Changeset 1542

XIOS/trunk/arch/arch-GCC_LINUX.fcm

r983	r1542
7	7	%LINKER mpif90
8	8
9		%BASE_CFLAGS -~~ansi -w~~
	9	%BASE_CFLAGS -w -std=c++11
10	10	%PROD_CFLAGS -O3 -DBOOST_DISABLE_ASSERTS
11	11	%DEV_CFLAGS -g -O2

XIOS/trunk/arch/arch-X64_ADA.fcm

r591	r1542
7	7	%LINKER mpiifort -nofor-main
8	8
9		%BASE_CFLAGS -diag-disable 1125 -diag-disable 279
	9	%BASE_CFLAGS -std=c++11 -diag-disable 1125 -diag-disable 279
10	10	%PROD_CFLAGS -O3 -D BOOST_DISABLE_ASSERTS
11	11	%DEV_CFLAGS -g -traceback

XIOS/trunk/arch/arch-X64_CURIE.fcm

r1009	r1542
7	7	%LINKER mpif90 -nofor-main
8	8
9		%BASE_CFLAGS -diag-disable 1125 -diag-disable 279
	9	%BASE_CFLAGS -std=c++11 -diag-disable 1125 -diag-disable 279
10	10	%PROD_CFLAGS -O3 -D BOOST_DISABLE_ASSERTS
11	11	#%DEV_CFLAGS -g -traceback

XIOS/trunk/arch/arch-X64_CURIE_GCC.fcm

-                      r591
+                      r1542
 %LINKER         mpif90
 %BASE_CFLAGS    -w
+%BASE_CFLAGS    -std=c++11 -w
 %PROD_CFLAGS    -O3 -D BOOST_DISABLE_ASSERTS
 %DEV_CFLAGS     -g -O2
 %DEBUG_CFLAGS   -g
 %BASE_FFLAGS    -D__NONE__
+%BASE_FFLAGS    -D__NONE__ -ffree-line-length-none
 %PROD_FFLAGS    -O3
 %DEV_FFLAGS     -g -O2

XIOS/trunk/arch/arch-X64_CURIE_PGI.fcm

r591	r1542
7	7	%LINKER mpif90 -noswitcherror
8	8
9		%BASE_CFLAGS -D__NONE__
	9	%BASE_CFLAGS c++11 -D__NONE__
10	10	%PROD_CFLAGS -O3 -D BOOST_DISABLE_ASSERTS
11	11	%DEV_CFLAGS -g -O2

XIOS/trunk/arch/arch-X64_CURIE_VAMPIR.fcm

r591	r1542
6	6	%FCOMPILER vtf90 -vt:f90 mpif90 -vt:inst manual -DVTRACE
7	7	%LINKER vtf90 -vt:f90 mpif90 -vt:inst manual -nofor-main -DVTRACE
8		%BASE_CFLAGS -diag-disable 1125 -diag-disable 279
	8	%BASE_CFLAGS -std=c++11 -diag-disable 1125 -diag-disable 279
9	9	%PROD_CFLAGS -O3 -D BOOST_DISABLE_ASSERTS
10	10	%DEV_CFLAGS -g -traceback

XIOS/trunk/arch/arch-X64_IRENE.fcm

r1483	r1542
7	7	%LINKER mpif90 -nofor-main
8	8
9		%BASE_CFLAGS -~~diag-disable 1125 -diag-disable 279 -D BOOST_NO_CXX11_DEFAULTED_FUNCTIONS -D BOOST_NO_CXX11_DELETED_FUNCTIONS~~
	9	%BASE_CFLAGS -std=c++11 -diag-disable 1125 -diag-disable 279
10	10	%PROD_CFLAGS -O3 -D BOOST_DISABLE_ASSERTS
11	11	#%DEV_CFLAGS -g -traceback

XIOS/trunk/arch/arch-X64_OCCIGEN.fcm

r822	r1542
7	7	%LINKER mpif90 -nofor-main
8	8
9		%BASE_CFLAGS -diag-disable 1125 -diag-disable 279
	9	%BASE_CFLAGS -std=c++11 -diag-disable 1125 -diag-disable 279
10	10	%PROD_CFLAGS -O3 -D BOOST_DISABLE_ASSERTS
11	11	%DEV_CFLAGS -g -traceback

XIOS/trunk/arch/arch-X64_POINCARE.fcm

r804	r1542
7	7	%LINKER mpif90 -nofor-main
8	8
9		%BASE_CFLAGS -diag-disable 1125 -diag-disable 279
	9	%BASE_CFLAGS -std=c++11 -diag-disable 1125 -diag-disable 279
10	10	%PROD_CFLAGS -O3 -D BOOST_DISABLE_ASSERTS
11	11	%DEV_CFLAGS -g -traceback

XIOS/trunk/arch/arch-XC30_Cray.fcm

r591	r1542
19	19	%LINKER CC
20	20
21		%BASE_CFLAGS -DMPICH_SKIP_MPICXX -h msglevel_4 -h zero -h gnu
	21	%BASE_CFLAGS âhstd=c++11 -DMPICH_SKIP_MPICXX -h msglevel_4 -h zero -h gnu
22	22
23	23	## Only use -O3 if you can load module cce/8.3.7 or later

XIOS/trunk/src/array.hpp

r591	r1542
4	4	/// boost headers ///
5	5	#include <boost/cstdint.hpp>
6		~~#include <boost/shared_ptr.hpp>~~
7	6	#include <boost/multi_array.hpp>
8	7

XIOS/trunk/src/array_mac.hpp

r591	r1542
5	5
6	6	// Type Fortran
7		#define ARRAY(valuetype, numdims) ~~boost~~::shared_ptr<CArray<valuetype, numdims> >
	7	#define ARRAY(valuetype, numdims) std::shared_ptr<CArray<valuetype, numdims> >
8	8
9	9	#define ARRAY_ASSIGN(value, valuetype, numdims, extent)\

XIOS/trunk/src/client.cpp

r1243	r1542
314	314	if (!fb->is_open())
315	315	ERROR("void CClient::openStream(const StdString& fileName, const StdString& ext, std::filebuf* fb)",
316		<< std::endl << "Can not open <" << fileNameClient << "> file to write the client log(s).");
	316	<< std::endl << "Can not open <" << fileNameClient.str() << "> file to write the client log(s).");
317	317	}
318	318

XIOS/trunk/src/client_client_dht_template.hpp

-                      r941
+                      r1542
 #include "mpi.hpp"
 #include "policy.hpp"
 #include <boost/unordered_map.hpp>
+#include  <unordered_map>
 #include "dht_data_types.hpp"
 …
     typedef T InfoType;
     static const int infoTypeSize = sizeof(InfoType);
 //    typedef typename boost::unordered_map<InfoType, std::vector<size_t> > InfoType2IndexMap;
     typedef typename boost::unordered_map<size_t,InfoType> Index2InfoTypeMap;
     typedef typename boost::unordered_map<size_t,std::vector<InfoType> > Index2VectorInfoTypeMap;
+//    typedef typename std::unordered_map<InfoType, std::vector<size_t> > InfoType2IndexMap;
+    typedef typename std::unordered_map<size_t,InfoType> Index2InfoTypeMap;
+    typedef typename std::unordered_map<size_t,std::vector<InfoType> > Index2VectorInfoTypeMap;
   public:

XIOS/trunk/src/client_client_dht_template_impl.hpp

-                      r1158
+                      r1542
   size_t index;
   HashXIOS<size_t> hashGlobalIndex;
   boost::unordered_map<size_t,int> nbIndices;
+  std::unordered_map<size_t,int> nbIndices;
   nbIndices.rehash(std::ceil(ssize/nbIndices.max_load_factor()));
   for (int i = 0; i < ssize; ++i)
 …
+  }
   boost::unordered_map<int, size_t* > client2ClientIndex;
+  std::unordered_map<int, size_t* > client2ClientIndex;
   for (int idx = 0; idx < nbClient; ++idx)
+  {
 …
+  }
   boost::unordered_map<int, size_t* >::iterator itbIndex = client2ClientIndex.begin(), itIndex,
+  std::unordered_map<int, size_t* >::iterator itbIndex = client2ClientIndex.begin(), itIndex,
                                                 iteIndex = client2ClientIndex.end();
   for (itIndex = itbIndex; itIndex != iteIndex; ++itIndex)
 …
+  }
   boost::unordered_map<int,unsigned char*> client2ClientInfoOnReturn;
   boost::unordered_map<int,size_t*> client2ClientIndexOnReturn;
+  std::unordered_map<int,unsigned char*> client2ClientInfoOnReturn;
+  std::unordered_map<int,size_t*> client2ClientIndexOnReturn;
   currentIndex = 0;
   for (int idx = 0; idx < nbRecvClient; ++idx)
 …
   indexToInfoMappingLevel_.swap(indexToInfoMapping);
   if (0 != recvNbIndexCount) delete [] recvIndexBuff;
   for (boost::unordered_map<int,size_t*>::const_iterator it = client2ClientIndex.begin();
+  for (std::unordered_map<int,size_t*>::const_iterator it = client2ClientIndex.begin();
                                                         it != client2ClientIndex.end(); ++it)
       delete [] it->second;
 …
+  }
   for (boost::unordered_map<int,unsigned char*>::const_iterator it = client2ClientInfoOnReturn.begin();
+  for (std::unordered_map<int,unsigned char*>::const_iterator it = client2ClientInfoOnReturn.begin();
                                                                it != client2ClientInfoOnReturn.end(); ++it)
       delete [] it->second;
   for (boost::unordered_map<int,size_t*>::const_iterator it = client2ClientIndexOnReturn.begin();
+  for (std::unordered_map<int,size_t*>::const_iterator it = client2ClientIndexOnReturn.begin();
                                             it != client2ClientIndexOnReturn.end(); ++it)
       delete [] it->second;
 …
+  }
   boost::unordered_map<int, size_t*> client2ClientIndex;
   boost::unordered_map<int, unsigned char*> client2ClientInfo;
+  std::unordered_map<int, size_t*> client2ClientIndex;
+  std::unordered_map<int, unsigned char*> client2ClientInfo;
   for (int idx = 0; idx < nbClient; ++idx)
+  {
 …
+  }
   boost::unordered_map<int, size_t* >::iterator itbIndex = client2ClientIndex.begin(), itIndex,
+  std::unordered_map<int, size_t* >::iterator itbIndex = client2ClientIndex.begin(), itIndex,
                                                 iteIndex = client2ClientIndex.end();
   for (itIndex = itbIndex; itIndex != iteIndex; ++itIndex)
     sendIndexToClients(itIndex->first, itIndex->second, sendNbIndexBuff[itIndex->first-groupRankBegin], commLevel, request);
   boost::unordered_map<int, unsigned char*>::iterator itbInfo = client2ClientInfo.begin(), itInfo,
+  std::unordered_map<int, unsigned char*>::iterator itbInfo = client2ClientInfo.begin(), itInfo,
                                                       iteInfo = client2ClientInfo.end();
   for (itInfo = itbInfo; itInfo != iteInfo; ++itInfo)
 …
     delete [] recvInfoBuff;
+  }
   for (boost::unordered_map<int,unsigned char*>::const_iterator it = client2ClientInfo.begin();
+  for (std::unordered_map<int,unsigned char*>::const_iterator it = client2ClientInfo.begin();
                                                                it != client2ClientInfo.end(); ++it)
       delete [] it->second;
   for (boost::unordered_map<int,size_t*>::const_iterator it = client2ClientIndex.begin();
+  for (std::unordered_map<int,size_t*>::const_iterator it = client2ClientIndex.begin();
                                                         it != client2ClientIndex.end(); ++it)
       delete [] it->second;

XIOS/trunk/src/client_server_mapping.hpp

-                      r1336
+                      r1542
 #include "array_new.hpp"
 #include "mpi.hpp"
 #include <boost/unordered_map.hpp>
+#include <unordered_map>
 namespace xios {
 …
+{
 public:
   typedef boost::unordered_map<int, std::vector<size_t> > GlobalIndexMap;
+  typedef std::unordered_map<int, std::vector<size_t> > GlobalIndexMap;
   public:
     /** Default constructor */

XIOS/trunk/src/client_server_mapping_distributed.cpp

r1336	r1542
19	19	{
20	20
21		CClientServerMappingDistributed::CClientServerMappingDistributed(const ~~boost~~::unordered_map<size_t,int>& globalIndexOfServer,
	21	CClientServerMappingDistributed::CClientServerMappingDistributed(const std::unordered_map<size_t,int>& globalIndexOfServer,
22	22	const MPI_Comm& clientIntraComm, bool isDataDistributed)
23	23	: CClientServerMapping(), ccDHT_(0)

XIOS/trunk/src/client_server_mapping_distributed.hpp

-                      r1336
+                      r1542
 #include "array_new.hpp"
 #include "mpi.hpp"
 #include <boost/unordered_map.hpp>
+#include <unordered_map>
 #include "client_client_dht_template.hpp"
 …
   public:
     /** Default constructor */
     CClientServerMappingDistributed(const boost::unordered_map<size_t,int>& globalIndexOfServer,
+    CClientServerMappingDistributed(const std::unordered_map<size_t,int>& globalIndexOfServer,
                                     const MPI_Comm& clientIntraComm,
                                     bool isDataDistributed = true);

XIOS/trunk/src/data_output.cpp

r1158	r1542
87	87	{
88	88	CContext* context = CContext::getCurrent() ;
89		~~boost~~::shared_ptr<CCalendar> calendar = context->getCalendar();
	89	std::shared_ptr<CCalendar> calendar = context->getCalendar();
90	90
91	91	this->writeTimeAxis_(field, calendar);

XIOS/trunk/src/data_output.hpp

r1158	r1542
59	59	virtual void writeTimeDimension_(void) = 0;
60	60	virtual void writeTimeAxis_ (CField* field,
61		const shared_ptr<CCalendar> cal) = 0;
	61	const std::shared_ptr<CCalendar> cal) = 0;
62	62
63	63	/// PropriÃ©tÃ©s protÃ©gÃ©es ///

XIOS/trunk/src/distribution.hpp

-                      r1129
+                      r1542
 #include "xios_spl.hpp"
 #include "array_new.hpp"
 #include <boost/unordered_map.hpp>
+#include <unordered_map>
 namespace xios {
 …
+{
   public:
   typedef boost::unordered_map<size_t,int> GlobalLocalMap;
+  typedef std::unordered_map<size_t,int> GlobalLocalMap;
   public:

XIOS/trunk/src/filter/binary_arithmetic_filter.hpp

r642	r1542
5	5	#include <string>
6	6	#include "operator_expr.hpp"
	7	#include <unordered_map>
7	8
8	9	namespace xios

XIOS/trunk/src/filter/data_packet.hpp

-                      r643
+                      r1542
 #define __XIOS_CDataPacket__
 #include <boost/shared_ptr.hpp>
+#include <memory>
 #include "array_new.hpp"
 …
   }; // struct CDataPacket
   typedef boost::shared_ptr<CDataPacket> CDataPacketPtr;
   typedef boost::shared_ptr<const CDataPacket> CConstDataPacketPtr;
+  typedef std::shared_ptr<CDataPacket> CDataPacketPtr;
+  typedef std::shared_ptr<const CDataPacket> CConstDataPacketPtr;
 } // namespace xios

XIOS/trunk/src/filter/output_pin.cpp

-                      r1358
+                      r1542
   { /* Nothing to do */ }
   void COutputPin::connectOutput(boost::shared_ptr<CInputPin> inputPin, size_t inputSlot)
+  void COutputPin::connectOutput(std::shared_ptr<CInputPin> inputPin, size_t inputSlot)
+  {
     if (!inputPin)
 …
             "The packet cannot be null.");
     std::vector<std::pair<boost::shared_ptr<CInputPin>, size_t> >::iterator it, itEnd;
+    std::vector<std::pair<std::shared_ptr<CInputPin>, size_t> >::iterator it, itEnd;
     for (it = outputs.begin(), itEnd = outputs.end(); it != itEnd; ++it)
       it->first->setInput(it->second, packet);
 …
   bool COutputPin::mustAutoTrigger() const
+  {
     std::vector<std::pair<boost::shared_ptr<CInputPin>, size_t> >::const_iterator it, itEnd;
+    std::vector<std::pair<std::shared_ptr<CInputPin>, size_t> >::const_iterator it, itEnd;
     for (it = outputs.begin(), itEnd = outputs.end(); it != itEnd; ++it)
+    {
 …
   void COutputPin::setOutputTriggers()
+  {
     std::vector<std::pair<boost::shared_ptr<CInputPin>, size_t> >::iterator it, itEnd;
+    std::vector<std::pair<std::shared_ptr<CInputPin>, size_t> >::iterator it, itEnd;
     for (it = outputs.begin(), itEnd = outputs.end(); it != itEnd; ++it)
       it->first->setInputTrigger(it->second, this);
 …
   bool COutputPin::isDataExpected(const CDate& date) const
+  {
     std::vector<std::pair<boost::shared_ptr<CInputPin>, size_t> >::const_iterator it, itEnd;
+    std::vector<std::pair<std::shared_ptr<CInputPin>, size_t> >::const_iterator it, itEnd;
     for (it = outputs.begin(), itEnd = outputs.end(); it != itEnd; ++it)
+    {

XIOS/trunk/src/filter/output_pin.hpp

-                      r1358
+                      r1542
        * \param inputSlot the input slot number
        */
       void connectOutput(boost::shared_ptr<CInputPin> inputPin, size_t inputSlot);
+      void connectOutput(std::shared_ptr<CInputPin> inputPin, size_t inputSlot);
       /*!
 …
       //!< The list of connected filters and the corresponding slot numbers
       std::vector<std::pair<boost::shared_ptr<CInputPin>, size_t> > outputs;
+      std::vector<std::pair<std::shared_ptr<CInputPin>, size_t> > outputs;
       //! Output buffer, store the packets until the output is triggered

XIOS/trunk/src/filter/spatial_transform_filter.cpp

-                      r1474
+                      r1542
   { /* Nothing to do */ }
   std::pair<boost::shared_ptr<CSpatialTransformFilter>, boost::shared_ptr<CSpatialTransformFilter> >
+  std::pair<std::shared_ptr<CSpatialTransformFilter>, std::shared_ptr<CSpatialTransformFilter> >
   CSpatialTransformFilter::buildFilterGraph(CGarbageCollector& gc, CGrid* srcGrid, CGrid* destGrid, bool hasMissingValue, double missingValue)
+  {
     if (!srcGrid || !destGrid)
       ERROR("std::pair<boost::shared_ptr<CSpatialTransformFilter>, boost::shared_ptr<CSpatialTransformFilter> >"
+      ERROR("std::pair<std::shared_ptr<CSpatialTransformFilter>, std::shared_ptr<CSpatialTransformFilter> >"
             "buildFilterGraph(CGarbageCollector& gc, CGrid* srcGrid, CGrid* destGrid)",
             "Impossible to build the filter graph if either the source or the destination grid are null.");
     boost::shared_ptr<CSpatialTransformFilter> firstFilter, lastFilter;
+    std::shared_ptr<CSpatialTransformFilter> firstFilter, lastFilter;
     // Note that this loop goes from the last transformation to the first transformation
     do
 …
       for (it=algoList.begin();it!=algoList.end();++it)  if (it->second.first == TRANS_TEMPORAL_SPLITTING) isSpatialTemporal=true ;
       boost::shared_ptr<CSpatialTransformFilter> filter ;
       if( isSpatialTemporal) filter = boost::shared_ptr<CSpatialTransformFilter>(new CSpatialTemporalFilter(gc, engine, gridTransformation, defaultValue, inputCount));
       else filter = boost::shared_ptr<CSpatialTransformFilter>(new CSpatialTransformFilter(gc, engine, defaultValue, inputCount));
+      std::shared_ptr<CSpatialTransformFilter> filter ;
+      if( isSpatialTemporal) filter = std::shared_ptr<CSpatialTransformFilter>(new CSpatialTemporalFilter(gc, engine, gridTransformation, defaultValue, inputCount));
+      else filter = std::shared_ptr<CSpatialTransformFilter>(new CSpatialTransformFilter(gc, engine, defaultValue, inputCount));
 …
+  }
   std::map<CGridTransformation*, boost::shared_ptr<CSpatialTransformFilterEngine> > CSpatialTransformFilterEngine::engines;
+  std::map<CGridTransformation*, std::shared_ptr<CSpatialTransformFilterEngine> > CSpatialTransformFilterEngine::engines;
   CSpatialTransformFilterEngine* CSpatialTransformFilterEngine::get(CGridTransformation* gridTransformation)
 …
             "Impossible to get the requested engine, the grid transformation is invalid.");
     std::map<CGridTransformation*, boost::shared_ptr<CSpatialTransformFilterEngine> >::iterator it = engines.find(gridTransformation);
+    std::map<CGridTransformation*, std::shared_ptr<CSpatialTransformFilterEngine> >::iterator it = engines.find(gridTransformation);
     if (it == engines.end())
+    {
       boost::shared_ptr<CSpatialTransformFilterEngine> engine(new CSpatialTransformFilterEngine(gridTransformation));
+      std::shared_ptr<CSpatialTransformFilterEngine> engine(new CSpatialTransformFilterEngine(gridTransformation));
       it = engines.insert(std::make_pair(gridTransformation, engine)).first;
+    }

XIOS/trunk/src/filter/spatial_transform_filter.hpp

-                      r1275
+                      r1542
        * \return the first and the last filters of the filter graph
        */
       static std::pair<boost::shared_ptr<CSpatialTransformFilter>, boost::shared_ptr<CSpatialTransformFilter> >
+      static std::pair<std::shared_ptr<CSpatialTransformFilter>, std::shared_ptr<CSpatialTransformFilter> >
       buildFilterGraph(CGarbageCollector& gc, CGrid* srcGrid, CGrid* destGrid, bool hasMissingValue, double defaultValue);
 …
       //! The allocated engines
       static std::map<CGridTransformation*, boost::shared_ptr<CSpatialTransformFilterEngine> > engines;
+      static std::map<CGridTransformation*, std::shared_ptr<CSpatialTransformFilterEngine> > engines;
   }; // class CSpatialTransformFilterEngine
 } // namespace xios

XIOS/trunk/src/group_factory.hpp

-                      r591
+                      r1542
 #ifndef __XIOS_CGroupFactory__
 #define __XIOS_CGroupFactory__
-/// boost headers ///
-#include <boost/shared_ptr.hpp>
 /// XIOS headers ///
 …
          template <typename U>
             static void AddGroup(boost::shared_ptr<U> pgroup,
                                         boost::shared_ptr<U> cgroup);
+            static void AddGroup(std::shared_ptr<U> pgroup,
+                                        std::shared_ptr<U> cgroup);
          template <typename U>
             static void AddChild(boost::shared_ptr<U> group,
                                         boost::shared_ptr<typename U::RelChild> child);
+            static void AddChild(std::shared_ptr<U> group,
+                                        std::shared_ptr<typename U::RelChild> child);
          /// Accesseurs ///
 …
          template <typename U>
             static boost::shared_ptr<U>
                GetGroup(boost::shared_ptr<U> group, const StdString & id);
+            static std::shared_ptr<U>
+               GetGroup(std::shared_ptr<U> group, const StdString & id);
          template <typename U>
             static boost::shared_ptr<typename U::RelChild>
                GetChild(boost::shared_ptr<U> group, const StdString & id);
+            static std::shared_ptr<typename U::RelChild>
+               GetChild(std::shared_ptr<U> group, const StdString & id);
          template <typename U>
             static int GetGroupNum(boost::shared_ptr<U> group);
+            static int GetGroupNum(std::shared_ptr<U> group);
          template <typename U>
             static int GetGroupIdNum(boost::shared_ptr<U> group);
+            static int GetGroupIdNum(std::shared_ptr<U> group);
          template <typename U>
             static int GetChildNum(boost::shared_ptr<U> group);
+            static int GetChildNum(std::shared_ptr<U> group);
          template <typename U>
             static int GetChildIdNum(boost::shared_ptr<U> group);
+            static int GetChildIdNum(std::shared_ptr<U> group);
          /// Tests ///
          template <typename U>
             static bool HasGroup(boost::shared_ptr<U> group, const StdString & id);
+            static bool HasGroup(std::shared_ptr<U> group, const StdString & id);
          template <typename U>
             static bool HasChild(boost::shared_ptr<U> group, const StdString & id);
+            static bool HasChild(std::shared_ptr<U> group, const StdString & id);
          /// Instanciateur ///
          template <typename U>
             static boost::shared_ptr<U>
                CreateGroup(boost::shared_ptr<U> group, const StdString & id = StdString(""));
+            static std::shared_ptr<U>
+               CreateGroup(std::shared_ptr<U> group, const StdString & id = StdString(""));
          template <typename U>
             static boost::shared_ptr<typename U::RelChild>
                CreateChild(boost::shared_ptr<U> group, const StdString & id = StdString(""));
+            static std::shared_ptr<typename U::RelChild>
+               CreateChild(std::shared_ptr<U> group, const StdString & id = StdString(""));
       private :

XIOS/trunk/src/group_factory_decl.cpp

-                      r1457
+                      r1542
+{
 # define  macro(U) \
   template void CGroupFactory::AddGroup<U>(shared_ptr<U> pgroup,shared_ptr<U> cgroup); \
   template void CGroupFactory::AddChild<U>(shared_ptr<U> group, shared_ptr<U::RelChild> child); \
   template shared_ptr<U>  CGroupFactory::GetGroup<U>(shared_ptr<U> group, const StdString & id); \
   template shared_ptr<U::RelChild> CGroupFactory::GetChild<U>(shared_ptr<U> group, const StdString & id); \
   template int CGroupFactory::GetGroupNum<U>(shared_ptr<U> group); \
   template int CGroupFactory::GetGroupIdNum<U>(shared_ptr<U> group); \
   template int CGroupFactory::GetChildNum<U>(shared_ptr<U> group); \
   template int CGroupFactory::GetChildIdNum<U>(boost::shared_ptr<U> group); \
   template bool CGroupFactory::HasGroup<U>(shared_ptr<U> group, const StdString & id); \
   template bool CGroupFactory::HasChild<U>(boost::shared_ptr<U> group, const StdString & id); \
   template shared_ptr<U> CGroupFactory::CreateGroup<U>(shared_ptr<U> group, const StdString & id ); \
   template shared_ptr<U::RelChild>  CGroupFactory::CreateChild<U>(shared_ptr<U> group, const StdString & id);
+  template void CGroupFactory::AddGroup<U>(std::shared_ptr<U> pgroup, std::shared_ptr<U> cgroup); \
+  template void CGroupFactory::AddChild<U>(std::shared_ptr<U> group, std::shared_ptr<U::RelChild> child); \
+  template std::shared_ptr<U>  CGroupFactory::GetGroup<U>(std::shared_ptr<U> group, const StdString & id); \
+  template std::shared_ptr<U::RelChild> CGroupFactory::GetChild<U>( std::shared_ptr<U> group, const StdString & id); \
+  template int CGroupFactory::GetGroupNum<U>(std::shared_ptr<U> group); \
+  template int CGroupFactory::GetGroupIdNum<U>(std::shared_ptr<U> group); \
+  template int CGroupFactory::GetChildNum<U>(std::shared_ptr<U> group); \
+  template int CGroupFactory::GetChildIdNum<U>(std::shared_ptr<U> group); \
+  template bool CGroupFactory::HasGroup<U>(std::shared_ptr<U> group, const StdString & id); \
+  template bool CGroupFactory::HasChild<U>(std::shared_ptr<U> group, const StdString & id); \
+  template std::shared_ptr<U> CGroupFactory::CreateGroup<U>(std::shared_ptr<U> group, const StdString & id ); \
+  template std::shared_ptr<U::RelChild>  CGroupFactory::CreateChild<U>(std::shared_ptr<U> group, const StdString & id);
   macro(CFieldGroup)

XIOS/trunk/src/group_factory_impl.hpp

-                      r591
+                      r1542
    template <typename U>
       void CGroupFactory::AddGroup(boost::shared_ptr<U> pgroup,
                                    boost::shared_ptr<U> cgroup)
+      void CGroupFactory::AddGroup(std::shared_ptr<U> pgroup,
+                                   std::shared_ptr<U> cgroup)
+   {
       if (cgroup.get() == NULL || pgroup.get() == NULL )
          ERROR("CGroupFactory::AddGroup(boost::shared_ptr<U> pgroup, boost::shared_ptr<U> cgroup)",
+         ERROR("CGroupFactory::AddGroup(std::shared_ptr<U> pgroup, std::shared_ptr<U> cgroup)",
                << " pgroup or cgroup NULL !");
       if (!cgroup->hasId())
 …
    template <typename U>
       void CGroupFactory::AddChild(boost::shared_ptr<U> group,
                                    boost::shared_ptr<typename U::RelChild> child)
+      void CGroupFactory::AddChild(std::shared_ptr<U> group,
+                                   std::shared_ptr<typename U::RelChild> child)
+   {
       if (group.get() == NULL || child.get() == NULL )
          ERROR("CGroupFactory::AddGroup(boost::shared_ptr<U> pgroup, boost::shared_ptr<U> cgroup)",
+         ERROR("CGroupFactory::AddGroup(std::shared_ptr<U> pgroup, std::shared_ptr<U> cgroup)",
                << " pgroup or cgroup NULL !");
       if (!child->hasId())
 …
    template <typename U>
       boost::shared_ptr<U>
          CGroupFactory::CreateGroup(boost::shared_ptr<U> group, const StdString & id)
+      std::shared_ptr<U>
+         CGroupFactory::CreateGroup(std::shared_ptr<U> group, const StdString & id)
+   {
       CObjectFactory::SetCurrentContextId
 …
       if (id.size() == 0)
+      {
          boost::shared_ptr<U> value = CObjectFactory::CreateObject<U>(CObjectFactory::GenUId<U>());
+         std::shared_ptr<U> value = CObjectFactory::CreateObject<U>(CObjectFactory::GenUId<U>());
          group->groupList.insert(group->groupList.end(), value.get());
          group->groupMap.insert(std::make_pair(value->getId(), value.get()));
 …
       else
+      {
          boost::shared_ptr<U> value = CObjectFactory::CreateObject<U>(id);
+         std::shared_ptr<U> value = CObjectFactory::CreateObject<U>(id);
          group->groupList.insert(group->groupList.end(), value.get());
          group->groupMap.insert(std::make_pair(id, value.get()));
 …
    template <typename U>
       boost::shared_ptr<typename U::RelChild>
          CGroupFactory::CreateChild(boost::shared_ptr<U> group, const StdString & id)
+      std::shared_ptr<typename U::RelChild>
+         CGroupFactory::CreateChild(std::shared_ptr<U> group, const StdString & id)
+   {
       CObjectFactory::SetCurrentContextId
 …
       if (id.size() == 0)
+      {
          boost::shared_ptr<typename U::RelChild> value =
+         std::shared_ptr<typename U::RelChild> value =
                CObjectFactory::CreateObject<typename U::RelChild>();
          group->childList.insert(group->childList.end(), value.get());
 …
       else
+      {
          boost::shared_ptr<typename U::RelChild> value =
+         std::shared_ptr<typename U::RelChild> value =
                CObjectFactory::CreateObject<typename U::RelChild>(id);
          group->childList.insert(group->childList.end(), value.get());
 …
    template <typename U>
       bool CGroupFactory::HasGroup(boost::shared_ptr<U> group, const StdString & id)
+      bool CGroupFactory::HasGroup(std::shared_ptr<U> group, const StdString & id)
    {  return (group->groupMap.find(id) != group->groupMap.end()); }
    template <typename U>
       bool CGroupFactory::HasChild(boost::shared_ptr<U> group, const StdString & id)
+      bool CGroupFactory::HasChild(std::shared_ptr<U> group, const StdString & id)
    {  return (group->childMap.find(id) != group->childMap.end()); }
    template <typename U>
       int CGroupFactory::GetGroupNum(boost::shared_ptr<U> group)
+      int CGroupFactory::GetGroupNum(std::shared_ptr<U> group)
    { return (group->groupList.size()); }
    template <typename U>
       int CGroupFactory::GetGroupIdNum(boost::shared_ptr<U> group)
+      int CGroupFactory::GetGroupIdNum(std::shared_ptr<U> group)
    { return (group->groupMap.size()); }
    template <typename U>
       int CGroupFactory::GetChildNum(boost::shared_ptr<U> group)
+      int CGroupFactory::GetChildNum(std::shared_ptr<U> group)
    { return (group->childList.size()); }
    template <typename U>
       int CGroupFactory::GetChildIdNum(boost::shared_ptr<U> group)
+      int CGroupFactory::GetChildIdNum(std::shared_ptr<U> group)
    { return (group->childMap.size()); }
    template <typename U>
       boost::shared_ptr<U>
          CGroupFactory::GetGroup(boost::shared_ptr<U> group, const StdString & id)
+      std::shared_ptr<U>
+         CGroupFactory::GetGroup(std::shared_ptr<U> group, const StdString & id)
+   {
       if (!CGroupFactory::HasGroup<U>(group, id))
          ERROR("CGroupFactory::GetGroup(boost::shared_ptr<U> group, const StdString & id)",
+         ERROR("CGroupFactory::GetGroup(std::shared_ptr<U> group, const StdString & id)",
                << "[ id = " << id << ", U = " << U::GetName() << " ] "
                << " group is not referenced !");
 …
    template <typename U>
       boost::shared_ptr<typename U::RelChild>
          CGroupFactory::GetChild(boost::shared_ptr<U> group, const StdString & id)
+      std::shared_ptr<typename U::RelChild>
+         CGroupFactory::GetChild(std::shared_ptr<U> group, const StdString & id)
+   {
       if (!CGroupFactory::HasChild<U>(group, id))
          ERROR("CGroupFactory::GetChild(boost::shared_ptr<U> group, const StdString & id)",
+         ERROR("CGroupFactory::GetChild(std::shared_ptr<U> group, const StdString & id)",
                << "[ id = " << id << ", U = " << U::GetName() << " ] "
                << " child is not referenced !");

XIOS/trunk/src/group_template.hpp

-                      r1021
+                      r1542
          void solveRefInheritance(void);
 //         static bool has(const string & id);
 //         static boost::shared_ptr<V> get(const string& id) ;
 //         static boost::shared_ptr<V> create(const string& id=string("")) ;
+//         static std::shared_ptr<V> get(const string& id) ;
+//         static std::shared_ptr<V> create(const string& id=string("")) ;
          U* createChild(const string& id="") ;

XIOS/trunk/src/group_template_impl.hpp

-                      r1158
+                      r1542
 //   template <class U, class V, class W>
 //   boost::shared_ptr<V> CGroupTemplate<U, V, W>::get(const string& id)
+//   std::shared_ptr<V> CGroupTemplate<U, V, W>::get(const string& id)
 //   {
 //       return CObjectFactory::GetObject<V>(id) ;
 …
 //   template <class U, class V, class W>
 //   boost::shared_ptr<V> CGroupTemplate<U, V, W>::get()
+//   std::shared_ptr<V> CGroupTemplate<U, V, W>::get()
 //   {
 //       return CObjectFactory::GetObject<V>(this) ;
 …
 //   template <class U, class V, class W>
 //   boost::shared_ptr<V> CGroupTemplate<U, V, W>::create(const string& id)
+//   std::shared_ptr<V> CGroupTemplate<U, V, W>::create(const string& id)
 //   {
 //       return CObjectFactory::CreateObject<V>(id) ;

XIOS/trunk/src/interface/c/icaxis.cpp

r591	r1542
4	4
5	5	#include <boost/multi_array.hpp>
6		#include <~~boost/shared_ptr.hpp~~>
	6	#include <memory>
7	7
8	8	#include "xios.hpp"

XIOS/trunk/src/interface/c/iccalendar.cpp

-                      r704
+                      r1542
     CTimer::get("XIOS").resume();
     const xios::CContext* context = CContext::getCurrent();
     const boost::shared_ptr<xios::CCalendar> cal = context->getCalendar();
+    const std::shared_ptr<xios::CCalendar> cal = context->getCalendar();
     if (!cal)
       ERROR("void cxios_get_current_date(cxios_date* current_date_c)",
 …
+  {
     CTimer::get("XIOS").resume();
     const boost::shared_ptr<xios::CCalendar> cal = CContext::getCurrent()->getCalendar();
+    const std::shared_ptr<xios::CCalendar> cal = CContext::getCurrent()->getCalendar();
     if (!cal)
       ERROR("int cxios_get_year_length_in_seconds(int year)",
 …
+  {
     CTimer::get("XIOS").resume();
     const boost::shared_ptr<xios::CCalendar> cal = CContext::getCurrent()->getCalendar();
+    const std::shared_ptr<xios::CCalendar> cal = CContext::getCurrent()->getCalendar();
     if (!cal)
       ERROR("int cxios_get_day_length_in_seconds()",

XIOS/trunk/src/interface/c/iccalendar_wrapper.cpp

-                      r591
+                      r1542
 #include <boost/multi_array.hpp>
+#include <boost/shared_ptr.hpp>
+#include <memory>
 #include "xios.hpp"

XIOS/trunk/src/interface/c/iccompute_connectivity_domain.cpp

r934	r1542
4	4
5	5	#include <boost/multi_array.hpp>
6		~~#include <boost/shared_ptr.hpp>~~
7	6
8	7	#include "xios.hpp"

XIOS/trunk/src/interface/c/iccontext.cpp

-                      r591
+                      r1542
 #include <boost/multi_array.hpp>
+#include <boost/shared_ptr.hpp>
+#include <memory>
 #include "xios.hpp"

XIOS/trunk/src/interface/c/icdata.cpp

r1054	r1542
4	4
5	5	#include <boost/multi_array.hpp>
6		#include <~~boost/shared_ptr.hpp~~>
	6	#include <memory>
7	7	#include <string>
8	8	#include <cstring>

XIOS/trunk/src/interface/c/icdate.cpp

-                      r1472
+                      r1542
 #include <boost/multi_array.hpp>
-#include <boost/shared_ptr.hpp>
 #include "xios.hpp"
 …
   if (!context)
     ERROR(idFunc, << "Impossible to do calendar operations: no current context available.");
   const boost::shared_ptr<xios::CCalendar> cal = context->getCalendar();
+  const std::shared_ptr<xios::CCalendar> cal = context->getCalendar();
   if (!cal)
     ERROR(idFunc, << "Impossible to do calendar operations: no calendar was defined.");

XIOS/trunk/src/interface/c/icdomain.cpp

-                      r591
+                      r1542
 #include <boost/multi_array.hpp>
+#include <boost/shared_ptr.hpp>
+#include <memory>
 #include "xios.hpp"

XIOS/trunk/src/interface/c/icduplicate_scalar_to_axis.cpp

r1492	r1542
4	4
5	5	#include <boost/multi_array.hpp>
6		#include <~~boost/shared_ptr.hpp~~>
	6	#include <memory>
7	7
8	8	#include "xios.hpp"

XIOS/trunk/src/interface/c/icexpand_domain.cpp

-                      r981
+                      r1542
 #include <boost/multi_array.hpp>
+#include <boost/shared_ptr.hpp>
+#include <memory>
 #include "xios.hpp"

XIOS/trunk/src/interface/c/icextract_to_axis.cpp

r981	r1542
4	4
5	5	#include <boost/multi_array.hpp>
6		#include <~~boost/shared_ptr.hpp~~>
	6	#include <memory>
7	7
8	8	#include "xios.hpp"

XIOS/trunk/src/interface/c/icextract_to_scalar.cpp

r981	r1542
4	4
5	5	#include <boost/multi_array.hpp>
6		#include <~~boost/shared_ptr.hpp~~>
	6	#include <memory>
7	7
8	8	#include "xios.hpp"

XIOS/trunk/src/interface/c/icfield.cpp

-                      r1158
+                      r1542
 #include <boost/multi_array.hpp>
+#include <boost/shared_ptr.hpp>
+#include <memory>
 #include "xios.hpp"

XIOS/trunk/src/interface/c/icfile.cpp

r591	r1542
4	4
5	5	#include <boost/multi_array.hpp>
6		#include <~~boost/shared_ptr.hpp~~>
	6	#include <memory>
7	7
8	8	#include "xios.hpp"

XIOS/trunk/src/interface/c/icgenerate_rectilinear_domain.cpp

-                      r786
+                      r1542
 #include <boost/multi_array.hpp>
+#include <boost/shared_ptr.hpp>
+#include <memory>
 #include "xios.hpp"

XIOS/trunk/src/interface/c/icgrid.cpp

r591	r1542
4	4
5	5	#include <boost/multi_array.hpp>
6		~~#include <boost/shared_ptr.hpp>~~
7	6
8	7	#include "xios.hpp"

XIOS/trunk/src/interface/c/icinterpolate.cpp

r786	r1542
4	4
5	5	#include <boost/multi_array.hpp>
6		~~#include <boost/shared_ptr.hpp>~~
7	6
8	7	#include "xios.hpp"

XIOS/trunk/src/interface/c/icinverse_axis.cpp

-                      r786
+                      r1542
 #include <boost/multi_array.hpp>
+#include <boost/shared_ptr.hpp>
+#include <memory>
 #include "xios.hpp"

XIOS/trunk/src/interface/c/icreduce_axis_to_axis.cpp

-                      r1492
+                      r1542
 #include <boost/multi_array.hpp>
+#include <boost/shared_ptr.hpp>
+#include <memory>
 #include "xios.hpp"

XIOS/trunk/src/interface/c/icreduce_scalar_to_scalar.cpp

-                      r1492
+                      r1542
 #include <boost/multi_array.hpp>
+#include <boost/shared_ptr.hpp>
+#include <memory>
 #include "xios.hpp"

XIOS/trunk/src/interface/c/icreduce_to_axis.cpp

-                      r981
+                      r1542
 #include <boost/multi_array.hpp>
+#include <boost/shared_ptr.hpp>
+#include <memory>
 #include "xios.hpp"

XIOS/trunk/src/interface/c/icreduce_to_scalar.cpp

r981	r1542
4	4
5	5	#include <boost/multi_array.hpp>
6		~~#include <boost/shared_ptr.hpp>~~
7	6
8	7	#include "xios.hpp"

XIOS/trunk/src/interface/c/icreorder_domain.cpp

-                      r1492
+                      r1542
 #include <boost/multi_array.hpp>
+#include <boost/shared_ptr.hpp>
+#include <memory>
 #include "xios.hpp"

XIOS/trunk/src/interface/c/icscalar.cpp

r891	r1542
4	4
5	5	#include <boost/multi_array.hpp>
6		#include <~~boost/shared_ptr.hpp~~>
	6	#include <memory>
7	7
8	8	#include "xios.hpp"

XIOS/trunk/src/interface/c/ictemporal_splitting.cpp

-                      r1492
+                      r1542
 #include <boost/multi_array.hpp>
+#include <boost/shared_ptr.hpp>
+#include <memory>
 #include "xios.hpp"

XIOS/trunk/src/interface/c/icvariable.cpp

-                      r591
+                      r1542
 #include <boost/multi_array.hpp>
+#include <boost/shared_ptr.hpp>
+#include <memory>
 #include "xios.hpp"

XIOS/trunk/src/interface/c/icxml_tree.cpp

r981	r1542
4	4
5	5	#include <boost/multi_array.hpp>
6		#include <~~boost/shared_ptr.hpp~~>
	6	#include <memory>
7	7
8	8	#include "xios.hpp"

XIOS/trunk/src/interface/c/iczoom.cpp

-                      r786
+                      r1542
 #include <boost/multi_array.hpp>
+#include <boost/shared_ptr.hpp>
+#include <memory>
 #include "xios.hpp"

XIOS/trunk/src/interface/c_attr/icaxis_attr.cpp

r1492	r1542
4	4
5	5	#include <boost/multi_array.hpp>
6		#include <~~boost/shared_ptr.hpp~~>
	6	#include <memory>
7	7	#include "xios.hpp"
8	8	#include "attribute_template.hpp"

XIOS/trunk/src/interface/c_attr/icaxisgroup_attr.cpp

r1492	r1542
4	4
5	5	#include <boost/multi_array.hpp>
6		#include <~~boost/shared_ptr.hpp~~>
	6	#include <memory>
7	7	#include "xios.hpp"
8	8	#include "attribute_template.hpp"

XIOS/trunk/src/interface/c_attr/iccalendar_wrapper_attr.cpp

r1492	r1542
4	4
5	5	#include <boost/multi_array.hpp>
6		#include <~~boost/shared_ptr.hpp~~>
	6	#include <memory>
7	7	#include "xios.hpp"
8	8	#include "attribute_template.hpp"

XIOS/trunk/src/interface/c_attr/iccompute_connectivity_domain_attr.cpp

r934	r1542
4	4
5	5	#include <boost/multi_array.hpp>
6		#include <~~boost/shared_ptr.hpp~~>
	6	#include <memory>
7	7	#include "xios.hpp"
8	8	#include "attribute_template.hpp"

XIOS/trunk/src/interface/c_attr/iccontext_attr.cpp

r591	r1542
4	4
5	5	#include <boost/multi_array.hpp>
6		#include <~~boost/shared_ptr.hpp~~>
	6	#include <memory>
7	7	#include "xios.hpp"
8	8	#include "attribute_template.hpp"

XIOS/trunk/src/interface/c_attr/icdomain_attr.cpp

r1492	r1542
4	4
5	5	#include <boost/multi_array.hpp>
6		#include <~~boost/shared_ptr.hpp~~>
	6	#include <memory>
7	7	#include "xios.hpp"
8	8	#include "attribute_template.hpp"

XIOS/trunk/src/interface/c_attr/icdomaingroup_attr.cpp

r1492	r1542
4	4
5	5	#include <boost/multi_array.hpp>
6		#include <~~boost/shared_ptr.hpp~~>
	6	#include <memory>
7	7	#include "xios.hpp"
8	8	#include "attribute_template.hpp"

XIOS/trunk/src/interface/c_attr/icduplicate_scalar_to_axis_attr.cpp

r1492	r1542
4	4
5	5	#include <boost/multi_array.hpp>
6		#include <~~boost/shared_ptr.hpp~~>
	6	#include <memory>
7	7	#include "xios.hpp"
8	8	#include "attribute_template.hpp"

XIOS/trunk/src/interface/c_attr/icexpand_domain_attr.cpp

r1158	r1542
4	4
5	5	#include <boost/multi_array.hpp>
6		#include <~~boost/shared_ptr.hpp~~>
	6	#include <memory>
7	7	#include "xios.hpp"
8	8	#include "attribute_template.hpp"

XIOS/trunk/src/interface/c_attr/icextract_axis_to_scalar_attr.cpp

r981	r1542
4	4
5	5	#include <boost/multi_array.hpp>
6		#include <~~boost/shared_ptr.hpp~~>
	6	#include <memory>
7	7	#include "xios.hpp"
8	8	#include "attribute_template.hpp"

XIOS/trunk/src/interface/c_attr/icextract_domain_to_axis_attr.cpp

r981	r1542
4	4
5	5	#include <boost/multi_array.hpp>
6		#include <~~boost/shared_ptr.hpp~~>
	6	#include <memory>
7	7	#include "xios.hpp"
8	8	#include "attribute_template.hpp"

XIOS/trunk/src/interface/c_attr/icfield_attr.cpp

r1492	r1542
4	4
5	5	#include <boost/multi_array.hpp>
6		#include <~~boost/shared_ptr.hpp~~>
	6	#include <memory>
7	7	#include "xios.hpp"
8	8	#include "attribute_template.hpp"

XIOS/trunk/src/interface/c_attr/icfieldgroup_attr.cpp

r1492	r1542
4	4
5	5	#include <boost/multi_array.hpp>
6		#include <~~boost/shared_ptr.hpp~~>
	6	#include <memory>
7	7	#include "xios.hpp"
8	8	#include "attribute_template.hpp"

XIOS/trunk/src/interface/c_attr/icfile_attr.cpp

r1492	r1542
4	4
5	5	#include <boost/multi_array.hpp>
6		#include <~~boost/shared_ptr.hpp~~>
	6	#include <memory>
7	7	#include "xios.hpp"
8	8	#include "attribute_template.hpp"

XIOS/trunk/src/interface/c_attr/icfilegroup_attr.cpp

r1492	r1542
4	4
5	5	#include <boost/multi_array.hpp>
6		#include <~~boost/shared_ptr.hpp~~>
	6	#include <memory>
7	7	#include "xios.hpp"
8	8	#include "attribute_template.hpp"

XIOS/trunk/src/interface/c_attr/icgenerate_rectilinear_domain_attr.cpp

r786	r1542
4	4
5	5	#include <boost/multi_array.hpp>
6		#include <~~boost/shared_ptr.hpp~~>
	6	#include <memory>
7	7	#include "xios.hpp"
8	8	#include "attribute_template.hpp"

XIOS/trunk/src/interface/c_attr/icgrid_attr.cpp

r1492	r1542
4	4
5	5	#include <boost/multi_array.hpp>
6		#include <~~boost/shared_ptr.hpp~~>
	6	#include <memory>
7	7	#include "xios.hpp"
8	8	#include "attribute_template.hpp"

XIOS/trunk/src/interface/c_attr/icgridgroup_attr.cpp

r1492	r1542
4	4
5	5	#include <boost/multi_array.hpp>
6		#include <~~boost/shared_ptr.hpp~~>
	6	#include <memory>
7	7	#include "xios.hpp"
8	8	#include "attribute_template.hpp"

XIOS/trunk/src/interface/c_attr/icinterpolate_axis_attr.cpp

r891	r1542
4	4
5	5	#include <boost/multi_array.hpp>
6		#include <~~boost/shared_ptr.hpp~~>
	6	#include <memory>
7	7	#include "xios.hpp"
8	8	#include "attribute_template.hpp"

XIOS/trunk/src/interface/c_attr/icinterpolate_domain_attr.cpp

r1492	r1542
4	4
5	5	#include <boost/multi_array.hpp>
6		#include <~~boost/shared_ptr.hpp~~>
	6	#include <memory>
7	7	#include "xios.hpp"
8	8	#include "attribute_template.hpp"

XIOS/trunk/src/interface/c_attr/icinverse_axis_attr.cpp

r786	r1542
4	4
5	5	#include <boost/multi_array.hpp>
6		#include <~~boost/shared_ptr.hpp~~>
	6	#include <memory>
7	7	#include "xios.hpp"
8	8	#include "attribute_template.hpp"

XIOS/trunk/src/interface/c_attr/icreduce_axis_to_axis_attr.cpp

r1492	r1542
4	4
5	5	#include <boost/multi_array.hpp>
6		#include <~~boost/shared_ptr.hpp~~>
	6	#include <memory>
7	7	#include "xios.hpp"
8	8	#include "attribute_template.hpp"

XIOS/trunk/src/interface/c_attr/icreduce_axis_to_scalar_attr.cpp

r980	r1542
4	4
5	5	#include <boost/multi_array.hpp>
6		#include <~~boost/shared_ptr.hpp~~>
	6	#include <memory>
7	7	#include "xios.hpp"
8	8	#include "attribute_template.hpp"

XIOS/trunk/src/interface/c_attr/icreduce_domain_to_axis_attr.cpp

r1492	r1542
4	4
5	5	#include <boost/multi_array.hpp>
6		#include <~~boost/shared_ptr.hpp~~>
	6	#include <memory>
7	7	#include "xios.hpp"
8	8	#include "attribute_template.hpp"

XIOS/trunk/src/interface/c_attr/icreduce_domain_to_scalar_attr.cpp

r1492	r1542
4	4
5	5	#include <boost/multi_array.hpp>
6		#include <~~boost/shared_ptr.hpp~~>
	6	#include <memory>
7	7	#include "xios.hpp"
8	8	#include "attribute_template.hpp"

XIOS/trunk/src/interface/c_attr/icreduce_scalar_to_scalar_attr.cpp

r1492	r1542
4	4
5	5	#include <boost/multi_array.hpp>
6		#include <~~boost/shared_ptr.hpp~~>
	6	#include <memory>
7	7	#include "xios.hpp"
8	8	#include "attribute_template.hpp"

XIOS/trunk/src/interface/c_attr/icreorder_domain_attr.cpp

r1492	r1542
4	4
5	5	#include <boost/multi_array.hpp>
6		#include <~~boost/shared_ptr.hpp~~>
	6	#include <memory>
7	7	#include "xios.hpp"
8	8	#include "attribute_template.hpp"

XIOS/trunk/src/interface/c_attr/icscalar_attr.cpp

r1492	r1542
4	4
5	5	#include <boost/multi_array.hpp>
6		#include <~~boost/shared_ptr.hpp~~>
	6	#include <memory>
7	7	#include "xios.hpp"
8	8	#include "attribute_template.hpp"

XIOS/trunk/src/interface/c_attr/icscalargroup_attr.cpp

r1492	r1542
4	4
5	5	#include <boost/multi_array.hpp>
6		#include <~~boost/shared_ptr.hpp~~>
	6	#include <memory>
7	7	#include "xios.hpp"
8	8	#include "attribute_template.hpp"

XIOS/trunk/src/interface/c_attr/ictemporal_splitting_attr.cpp

r1492	r1542
4	4
5	5	#include <boost/multi_array.hpp>
6		#include <~~boost/shared_ptr.hpp~~>
	6	#include <memory>
7	7	#include "xios.hpp"
8	8	#include "attribute_template.hpp"

XIOS/trunk/src/interface/c_attr/icvariable_attr.cpp

r1158	r1542
4	4
5	5	#include <boost/multi_array.hpp>
6		#include <~~boost/shared_ptr.hpp~~>
	6	#include <memory>
7	7	#include "xios.hpp"
8	8	#include "attribute_template.hpp"

XIOS/trunk/src/interface/c_attr/icvariablegroup_attr.cpp

r1158	r1542
4	4
5	5	#include <boost/multi_array.hpp>
6		#include <~~boost/shared_ptr.hpp~~>
	6	#include <memory>
7	7	#include "xios.hpp"
8	8	#include "attribute_template.hpp"

XIOS/trunk/src/interface/c_attr/iczoom_axis_attr.cpp

r1201	r1542
4	4
5	5	#include <boost/multi_array.hpp>
6		#include <~~boost/shared_ptr.hpp~~>
	6	#include <memory>
7	7	#include "xios.hpp"
8	8	#include "attribute_template.hpp"

XIOS/trunk/src/interface/c_attr/iczoom_domain_attr.cpp

r787	r1542
4	4
5	5	#include <boost/multi_array.hpp>
6		#include <~~boost/shared_ptr.hpp~~>
	6	#include <memory>
7	7	#include "xios.hpp"
8	8	#include "attribute_template.hpp"

XIOS/trunk/src/io/nc4_data_output.cpp

r1509	r1542
2697	2697	void CNc4DataOutput::writeTimeAxis_
2698	2698	(CField* field,
2699		const ~~boost~~::shared_ptr<CCalendar> cal)
	2699	const std::shared_ptr<CCalendar> cal)
2700	2700	{
2701	2701	StdOStringStream oss;
…	…
2920	2920	msg.append(e.what());
2921	2921	ERROR("CNc4DataOutput::writeTimeAxis_ (CField* field, \
2922		const ~~boost~~::shared_ptr<CCalendar> cal)", << msg);
	2922	const std::shared_ptr<CCalendar> cal)", << msg);
2923	2923	}
2924	2924	}

XIOS/trunk/src/io/nc4_data_output.hpp

r1456	r1542
61	61	virtual void syncFile_ (void);
62	62	virtual void writeTimeAxis_ (CField* field,
63		const ~~boost~~::shared_ptr<CCalendar> cal);
	63	const std::shared_ptr<CCalendar> cal);
64	64
65	65	protected :

XIOS/trunk/src/node/axis.cpp

-                      r1421
+                      r1542
+     {
        // size estimation for sendDistributedValue
        boost::unordered_map<int, vector<size_t> >::const_iterator it, ite = indSrv_[client->serverSize].end();
+       std::unordered_map<int, vector<size_t> >::const_iterator it, ite = indSrv_[client->serverSize].end();
        for (it = indSrv_[client->serverSize].begin(); it != ite; ++it)
+       {
 …
         std::vector<int> serverZeroIndex;
         serverZeroIndex = serverDescription.computeServerGlobalIndexInRange(std::make_pair<size_t,size_t>(indexBegin, indexEnd), 0);
+        serverZeroIndex = serverDescription.computeServerGlobalIndexInRange(std::make_pair<size_t&,size_t&>(indexBegin, indexEnd), 0);
         std::list<int> serverZeroIndexLeader;
 …
     // we need to compute the local index on the server from its corresponding global index
     size_t nbWritten = 0, indGlo;
     boost::unordered_map<size_t,size_t>::const_iterator itb = globalLocalIndexMap_.begin(),
+    std::unordered_map<size_t,size_t>::const_iterator itb = globalLocalIndexMap_.begin(),
                                                         ite = globalLocalIndexMap_.end(), it;
     CArray<size_t,1>::const_iterator itSrvb = writtenGlobalIndex.begin(),
 …
+    {
       nbWritten = 0;
       boost::unordered_map<size_t,size_t>::const_iterator itb = globalLocalIndexMap_.begin(),
+      std::unordered_map<size_t,size_t>::const_iterator itb = globalLocalIndexMap_.begin(),
                                                           ite = globalLocalIndexMap_.end(), it;
       for (int i = 0; i < zoom_index.numElements(); ++i)
 …
     // {
     //   nbWritten = 0;
     //   boost::unordered_map<size_t,size_t> localGlobalIndexMap;
+    //   std::unordered_map<size_t,size_t> localGlobalIndexMap;
     //   for (itSrv = itSrvb; itSrv != itSrve; ++itSrv)
     //   {
 …
       CDistributionServer srvDist(server->intraCommSize, nBegin, nSize, nBeginGlobal, nGlob);
       const CArray<size_t,1>& writtenGlobalIndex  = srvDist.getGlobalIndex();
       boost::unordered_map<size_t,size_t>::const_iterator itb = globalLocalIndexMap_.begin(),
+      std::unordered_map<size_t,size_t>::const_iterator itb = globalLocalIndexMap_.begin(),
                                                           ite = globalLocalIndexMap_.end(), it;
       CArray<size_t,1>::const_iterator itSrvb = writtenGlobalIndex.begin(),
                                        itSrve = writtenGlobalIndex.end(), itSrv;
       boost::unordered_map<size_t,size_t> localGlobalIndexMap;
+      std::unordered_map<size_t,size_t> localGlobalIndexMap;
       for (itSrv = itSrvb; itSrv != itSrve; ++itSrv)
+      {
 …
+      }
       boost::unordered_map<int, std::vector<size_t> >::const_iterator it, iteMap;
+      std::unordered_map<int, std::vector<size_t> >::const_iterator it, iteMap;
       iteMap = indSrv_[nbServer].end();
       for (int k = 0; k < connectedServerRank_[nbServer].size(); ++k)

XIOS/trunk/src/node/axis.hpp

-                      r1371
+                      r1542
          bool isCompressible_;
          std::map<int, map<int,int> > nbSenders; // Mapping of number of communicating client to a server
          std::map<int, boost::unordered_map<int, vector<size_t> > > indSrv_; // Global index of each client sent to server
+         std::map<int, std::unordered_map<int, vector<size_t> > > indSrv_; // Global index of each client sent to server
          // std::map<int, vector<int> > indWrittenSrv_; // Global written index of each client sent to server
          boost::unordered_map<size_t,size_t> globalLocalIndexMap_;
+         std::unordered_map<size_t,size_t> globalLocalIndexMap_;
          std::vector<int> indexesToWrite;
          std::map<int,int> numberWrittenIndexes_, totalNumberWrittenIndexes_, offsetWrittenIndexes_;

XIOS/trunk/src/node/calendar_wrapper.cpp

-                      r1201
+                      r1542
   \return the calendar
   */
   boost::shared_ptr<CCalendar> CCalendarWrapper::getCalendar(bool checkValid /*= false*/) const
+  std::shared_ptr<CCalendar> CCalendarWrapper::getCalendar(bool checkValid /*= false*/) const
+  {
     if (checkValid && !this->calendar)
 …
 #define DECLARE_CALENDAR(MType, eType)                                     \
       if (type.getValue() == type_attr::eType)                             \
         calendar = boost::shared_ptr<CCalendar>(new C##MType##Calendar());
+        calendar = std::shared_ptr<CCalendar>(new C##MType##Calendar());
 #include "calendar_type.conf"
 #undef DECLARE_CALENDAR
 …
                 << "Both leap_year_drift and leap_year_month attributes are mandatory if you wish to use leap_year_drift_offset attribute.");
         boost::shared_ptr<CUserDefinedCalendar> userDefinedCalendar;
+        std::shared_ptr<CUserDefinedCalendar> userDefinedCalendar;
         if (year_length.isEmpty())
           userDefinedCalendar.reset(new CUserDefinedCalendar(day_length.getValue(), month_lengths.getValue()));

XIOS/trunk/src/node/calendar_wrapper.hpp

-                      r591
+                      r1542
     public :
       /// Accesseurs ///
       boost::shared_ptr<CCalendar> getCalendar(bool checkValid = false) const;
+      std::shared_ptr<CCalendar> getCalendar(bool checkValid = false) const;
       const CDate& getInitDate() const;
 …
     private:
       // Calendar of context
       boost::shared_ptr<CCalendar> calendar;
+      std::shared_ptr<CCalendar> calendar;
   }; // class CCalendarWrapper

XIOS/trunk/src/node/context.cpp

-                      r1489
+                      r1542
 namespace xios {
   shared_ptr<CContextGroup> CContext::root;
+  std::shared_ptr<CContextGroup> CContext::root;
    /// ////////////////////// DÃ©finitions ////////////////////// ///
 …
    CContextGroup* CContext::getRoot(void)
+   {
       if (root.get()==NULL) root=shared_ptr<CContextGroup>(new CContextGroup(xml::CXMLNode::GetRootName()));
+      if (root.get()==NULL) root=std::shared_ptr<CContextGroup>(new CContextGroup(xml::CXMLNode::GetRootName()));
       return root.get();
+   }
 …
    \return Calendar
    */
    boost::shared_ptr<CCalendar> CContext::getCalendar(void) const
+   std::shared_ptr<CCalendar> CContext::getCalendar(void) const
+   {
       return (this->calendar);
 …
    \param[in] newCalendar new calendar
    */
    void CContext::setCalendar(boost::shared_ptr<CCalendar> newCalendar)
+   void CContext::setCalendar(std::shared_ptr<CCalendar> newCalendar)
+   {
       this->calendar = newCalendar;
 …
      idServer_ = this->getId();
      idServer_ += "_server_";
      idServer_ += boost::lexical_cast<string>(i);
+     idServer_ += std::to_string(static_cast<unsigned long long>(i));
      return idServer_;
+   }

XIOS/trunk/src/node/context.hpp

-                      r1378
+                      r1542
 #include "declare_group.hpp"
-//#include "context_client.hpp"
-//#include "context_server.hpp"
 #include "data_output.hpp"
 #include "garbage_collector.hpp"
 …
          /// Mutateurs ///
          void setCalendar(boost::shared_ptr<CCalendar> newCalendar);
+         void setCalendar(std::shared_ptr<CCalendar> newCalendar);
          /// Accesseurs ///
          boost::shared_ptr<CCalendar>      getCalendar(void) const;
+         std::shared_ptr<CCalendar>      getCalendar(void) const;
       public :
 …
       public :
          // Calendar of context
          boost::shared_ptr<CCalendar>   calendar;
+         std::shared_ptr<CCalendar>   calendar;
          // List of all enabled files (files on which fields are written or read)
 …
          // Context root
          static shared_ptr<CContextGroup> root;
+         static std::shared_ptr<CContextGroup> root;
          // Determine context on client or not

XIOS/trunk/src/node/domain.cpp

-                      r1509
+                      r1542
+     }
      boost::unordered_map<int, vector<size_t> >::const_iterator itIndexEnd = indSrv_[client->serverSize].end();
+     std::unordered_map<int, vector<size_t> >::const_iterator itIndexEnd = indSrv_[client->serverSize].end();
      // std::map<int, std::vector<int> >::const_iterator itWrittenIndexEnd = indWrittenSrv_.end();
      for (size_t k = 0; k < connectedServerRank_[client->serverSize].size(); ++k)
+     {
        int rank = connectedServerRank_[client->serverSize][k];
        boost::unordered_map<int, std::vector<size_t> >::const_iterator it = indSrv_[client->serverSize].find(rank);
+       std::unordered_map<int, std::vector<size_t> >::const_iterator it = indSrv_[client->serverSize].find(rank);
        size_t idxCount = (it != itIndexEnd) ? it->second.size() : 0;
 …
            CServerDistributionDescription serverDescription(nGlobDomain, nbServer);
            std::vector<int> serverZeroIndex;
            if (isUnstructed_) serverZeroIndex = serverDescription.computeServerGlobalIndexInRange(std::make_pair<size_t,size_t>(indexBegin, indexEnd), 0);
            else serverZeroIndex = serverDescription.computeServerGlobalIndexInRange(std::make_pair<size_t,size_t>(indexBegin, indexEnd), 1);
+           if (isUnstructed_) serverZeroIndex = serverDescription.computeServerGlobalIndexInRange(std::make_pair<size_t&,size_t&>(indexBegin, indexEnd), 0);
+           else serverZeroIndex = serverDescription.computeServerGlobalIndexInRange(std::make_pair<size_t&,size_t&>(indexBegin, indexEnd), 1);
            std::list<int> serverZeroIndexLeader;
 …
       size_t nbWritten = 0, indGlo;
       boost::unordered_map<size_t,size_t>::const_iterator itb = globalLocalIndexMap_.begin(),
+      std::unordered_map<size_t,size_t>::const_iterator itb = globalLocalIndexMap_.begin(),
                                                           ite = globalLocalIndexMap_.end(), it;
       CArray<size_t,1>::const_iterator itSrvb = writtenGlobalIndex.begin(),
 …
       // {
       //   nbWritten = 0;
       //   boost::unordered_map<size_t,size_t> localGlobalIndexMap;
+      //   std::unordered_map<size_t,size_t> localGlobalIndexMap;
       //   for (itSrv = itSrvb; itSrv != itSrve; ++itSrv)
       //   {
 …
       const CArray<size_t,1>& writtenGlobalIndex  = srvDist.getGlobalIndex();
       boost::unordered_map<size_t,size_t>::const_iterator itb = globalLocalIndexMap_.begin(),
+      std::unordered_map<size_t,size_t>::const_iterator itb = globalLocalIndexMap_.begin(),
                                                           ite = globalLocalIndexMap_.end(), it;
       CArray<size_t,1>::const_iterator itSrvb = writtenGlobalIndex.begin(),
                                        itSrve = writtenGlobalIndex.end(), itSrv;
       boost::unordered_map<size_t,size_t> localGlobalIndexMap;
+      std::unordered_map<size_t,size_t> localGlobalIndexMap;
       for (itSrv = itSrvb; itSrv != itSrve; ++itSrv)
+      {
 …
       list<CArray<int,1> > list_indZoom, list_writtenInd, list_indGlob;
       boost::unordered_map<int, vector<size_t> >::const_iterator itIndex, iteIndex;
+      std::unordered_map<int, vector<size_t> >::const_iterator itIndex, iteIndex;
       iteIndex = indSrv_[serverSize].end();
       for (int k = 0; k < connectedServerRank_[serverSize].size(); ++k)
 …
       list<CArray<bool,1> > list_mask;
       boost::unordered_map<int, vector<size_t> >::const_iterator it, iteMap;
+      std::unordered_map<int, vector<size_t> >::const_iterator it, iteMap;
       iteMap = indSrv_[serverSize].end();
       for (int k = 0; k < connectedServerRank_[serverSize].size(); ++k)
 …
       list<CArray<double,1> > list_area;
       boost::unordered_map<int, vector<size_t> >::const_iterator it, iteMap;
+      std::unordered_map<int, vector<size_t> >::const_iterator it, iteMap;
       iteMap = indSrv_[serverSize].end();
       for (int k = 0; k < connectedServerRank_[serverSize].size(); ++k)
 …
       list<CArray<double,2> > list_boundslon, list_boundslat;
       boost::unordered_map<int, vector<size_t> >::const_iterator it, iteMap;
+      std::unordered_map<int, vector<size_t> >::const_iterator it, iteMap;
       iteMap = indSrv_[serverSize].end();
       for (int k = 0; k < connectedServerRank_[serverSize].size(); ++k)
 …
+      }
       boost::unordered_map<int, vector<size_t> >::const_iterator it, iteMap;
+      std::unordered_map<int, vector<size_t> >::const_iterator it, iteMap;
       iteMap = indSrv_[serverSize].end();
       for (int k = 0; k < connectedServerRank_[serverSize].size(); ++k)

XIOS/trunk/src/node/domain.hpp

-                      r1353
+                      r1542
 /** Global index of each client sent to server: map<serverSize, map<serverRank, indexes>> */
          std::map<int, boost::unordered_map<int, vector<size_t> > > indSrv_;
+         std::map<int, std::unordered_map<int, vector<size_t> > > indSrv_;
          // std::map<CContextClient*, std::map<int, vector<int> > > indWrittenSrv_; // Global written index of each client sent to server
          std::vector<int> indexesToWrite;
 …
          TransMapTypes transformationMap_;
          bool isUnstructed_;
          boost::unordered_map<size_t,size_t> globalLocalIndexMap_;
+         std::unordered_map<size_t,size_t> globalLocalIndexMap_;
        private:

XIOS/trunk/src/node/field.cpp

-                      r1524
+                      r1542
       // Gather all data from different clients
       recvDataSrv.resize(storeClient.numElements());
       recvFoperationSrv = boost::shared_ptr<func::CFunctor>(new func::CInstant(recvDataSrv));
+      recvFoperationSrv = std::shared_ptr<func::CFunctor>(new func::CInstant(recvDataSrv));
+    }
 …
    //----------------------------------------------------------------
    boost::shared_ptr<COutputPin> CField::getInstantDataFilter()
+   std::shared_ptr<COutputPin> CField::getInstantDataFilter()
+   {
      return instantDataFilter;
 …
               << "An operation must be defined for field \"" << getId() << "\".");
       boost::shared_ptr<func::CFunctor> functor;
+      std::shared_ptr<func::CFunctor> functor;
       CArray<double, 1> dummyData;
 …
+     {
         if (!instantDataFilter)
           instantDataFilter = clientSourceFilter = boost::shared_ptr<CSourceFilter>(new CSourceFilter(gc, grid,true));
+          instantDataFilter = clientSourceFilter = std::shared_ptr<CSourceFilter>(new CSourceFilter(gc, grid,true));
 …
          if (file && (file->mode.isEmpty() || file->mode == CFile::mode_attr::write))
+         {
            fileServerWriterFilter = boost::shared_ptr<CFileServerWriterFilter>(new CFileServerWriterFilter(gc, this));
+           fileServerWriterFilter = std::shared_ptr<CFileServerWriterFilter>(new CFileServerWriterFilter(gc, this));
            instantDataFilter->connectOutput(fileServerWriterFilter, 0);
+         }
 …
+     {
        if (!instantDataFilter)
          instantDataFilter = clientSourceFilter = boost::shared_ptr<CSourceFilter>(new CSourceFilter(gc, grid, true));
+         instantDataFilter = clientSourceFilter = std::shared_ptr<CSourceFilter>(new CSourceFilter(gc, grid, true));
              // If the field data is to be read by the client or/and written to a file
 …
          if (file && (file->mode.isEmpty() || file->mode == CFile::mode_attr::write))
+         {
            fileWriterFilter = boost::shared_ptr<CFileWriterFilter>(new CFileWriterFilter(gc, this));
+           fileWriterFilter = std::shared_ptr<CFileWriterFilter>(new CFileWriterFilter(gc, this));
            instantDataFilter->connectOutput(fileWriterFilter, 0);
+         }
 …
+         {
            boost::scoped_ptr<IFilterExprNode> expr(parseExpr(getExpression() + '\0'));
            boost::shared_ptr<COutputPin> filter = expr->reduce(gc, *this);
+           std::shared_ptr<COutputPin> filter = expr->reduce(gc, *this);
            // Check if a spatial transformation is needed
 …
              if (grid && grid != gridRef && grid->hasTransform())
+             {
                  std::pair<boost::shared_ptr<CFilter>, boost::shared_ptr<CFilter> > filters = CSpatialTransformFilter::buildFilterGraph(gc, gridRef, grid, detectMissingValues, defaultValue);
+                 std::pair<std::shared_ptr<CFilter>, std::shared_ptr<CFilter> > filters = CSpatialTransformFilter::buildFilterGraph(gc, gridRef, grid, detectMissingValues, defaultValue);
                filter->connectOutput(filters.first, 0);
 …
+         {
            checkTimeAttributes();
            instantDataFilter = serverSourceFilter = boost::shared_ptr<CSourceFilter>(new CSourceFilter(gc, grid, true, freq_offset, true,
+           instantDataFilter = serverSourceFilter = std::shared_ptr<CSourceFilter>(new CSourceFilter(gc, grid, true, freq_offset, true,
                                                                                                        detectMissingValues, defaultValue));
+         }
 …
+         {
             if (check_if_active.isEmpty()) check_if_active = false;
             instantDataFilter = clientSourceFilter = boost::shared_ptr<CSourceFilter>(new CSourceFilter(gc, grid, false, NoneDu, false,
+            instantDataFilter = clientSourceFilter = std::shared_ptr<CSourceFilter>(new CSourceFilter(gc, grid, false, NoneDu, false,
                                                                                                         detectMissingValues, defaultValue));
+         }
 …
          if (!read_access.isEmpty() && read_access)
+         {
            storeFilter = boost::shared_ptr<CStoreFilter>(new CStoreFilter(gc, CContext::getCurrent(), grid,
+           storeFilter = std::shared_ptr<CStoreFilter>(new CStoreFilter(gc, CContext::getCurrent(), grid,
                                                                           detectMissingValues, defaultValue));
            instantDataFilter->connectOutput(storeFilter, 0);
 …
          if (file && (file->mode.isEmpty() || file->mode == CFile::mode_attr::write))
+         {
            fileWriterFilter = boost::shared_ptr<CFileWriterFilter>(new CFileWriterFilter(gc, this));
+           fileWriterFilter = std::shared_ptr<CFileWriterFilter>(new CFileWriterFilter(gc, this));
            getTemporalDataFilter(gc, file->output_freq)->connectOutput(fileWriterFilter, 0);
+         }
 …
     * \return the output pin corresponding to the field reference
     */
    boost::shared_ptr<COutputPin> CField::getFieldReference(CGarbageCollector& gc)
+   std::shared_ptr<COutputPin> CField::getFieldReference(CGarbageCollector& gc)
+   {
      if (instantDataFilter || field_ref.isEmpty())
 …
      fieldRef->buildFilterGraph(gc, false);
      std::pair<boost::shared_ptr<CFilter>, boost::shared_ptr<CFilter> > filters;
+     std::pair<std::shared_ptr<CFilter>, std::shared_ptr<CFilter> > filters;
      // Check if a spatial transformation is needed
      if (grid && grid != fieldRef->grid && grid->hasTransform())
 …
+     }
      else
        filters.first = filters.second = boost::shared_ptr<CFilter>(new CPassThroughFilter(gc));
+       filters.first = filters.second = std::shared_ptr<CFilter>(new CPassThroughFilter(gc));
      fieldRef->getInstantDataFilter()->connectOutput(filters.first, 0);
 …
     * \return the output pin corresponding to a self reference
     */
    boost::shared_ptr<COutputPin> CField::getSelfReference(CGarbageCollector& gc)
+   std::shared_ptr<COutputPin> CField::getSelfReference(CGarbageCollector& gc)
+   {
      if (instantDataFilter || !hasExpression())
 …
+         {
            checkTimeAttributes();
            serverSourceFilter = boost::shared_ptr<CSourceFilter>(new CSourceFilter(gc, grid, true, freq_offset, true,
+           serverSourceFilter = std::shared_ptr<CSourceFilter>(new CSourceFilter(gc, grid, true, freq_offset, true,
                                                                                    detectMissingValues, defaultValue));
+         }
 …
+         {
            if (check_if_active.isEmpty()) check_if_active = false;
            clientSourceFilter = boost::shared_ptr<CSourceFilter>(new CSourceFilter(gc, grid, true, NoneDu, false,
+           clientSourceFilter = std::shared_ptr<CSourceFilter>(new CSourceFilter(gc, grid, true, NoneDu, false,
                                                                                    detectMissingValues, defaultValue));
+         }
 …
     * \return the output pin corresponding to the requested temporal filter
     */
    boost::shared_ptr<COutputPin> CField::getTemporalDataFilter(CGarbageCollector& gc, CDuration outFreq)
+   {
      std::map<CDuration, boost::shared_ptr<COutputPin> >::iterator it = temporalDataFilters.find(outFreq);
+   std::shared_ptr<COutputPin> CField::getTemporalDataFilter(CGarbageCollector& gc, CDuration outFreq)
+   {
+     std::map<CDuration, std::shared_ptr<COutputPin> >::iterator it = temporalDataFilters.find(outFreq);
      if (it == temporalDataFilters.end())
 …
        const bool detectMissingValues = (!detect_missing_value.isEmpty()  && detect_missing_value == true);
        boost::shared_ptr<CTemporalFilter> temporalFilter(new CTemporalFilter(gc, operation,
+       std::shared_ptr<CTemporalFilter> temporalFilter(new CTemporalFilter(gc, operation,
                                                                              CContext::getCurrent()->getCalendar()->getInitDate(),
                                                                              freq_op, freq_offset, outFreq, detectMissingValues));
 …
     */
    boost::shared_ptr<COutputPin> CField::getSelfTemporalDataFilter(CGarbageCollector& gc, CDuration outFreq)
+   std::shared_ptr<COutputPin> CField::getSelfTemporalDataFilter(CGarbageCollector& gc, CDuration outFreq)
+   {
      if (instantDataFilter || !hasExpression())
 …
        const bool detectMissingValues = (!detect_missing_value.isEmpty() && detect_missing_value == true);
        boost::shared_ptr<CTemporalFilter> temporalFilter(new CTemporalFilter(gc, operation,
+       std::shared_ptr<CTemporalFilter> temporalFilter(new CTemporalFilter(gc, operation,
                                                                              CContext::getCurrent()->getCalendar()->getInitDate(),
                                                                              freq_op, freq_offset, outFreq, detectMissingValues));

XIOS/trunk/src/node/field.hpp

-                      r1524
+                      r1542
          template <int N> void getData(CArray<double, N>& _data) const;
          boost::shared_ptr<COutputPin> getInstantDataFilter();
+         std::shared_ptr<COutputPin> getInstantDataFilter();
          /// Mutateur ///
 …
          boost::shared_ptr<COutputPin> getFieldReference(CGarbageCollector& gc);
          boost::shared_ptr<COutputPin> getSelfReference(CGarbageCollector& gc);
          boost::shared_ptr<COutputPin> getTemporalDataFilter(CGarbageCollector& gc, CDuration outFreq);
          boost::shared_ptr<COutputPin> getSelfTemporalDataFilter(CGarbageCollector& gc, CDuration outFreq);
+         std::shared_ptr<COutputPin> getFieldReference(CGarbageCollector& gc);
+         std::shared_ptr<COutputPin> getSelfReference(CGarbageCollector& gc);
+         std::shared_ptr<COutputPin> getTemporalDataFilter(CGarbageCollector& gc, CDuration outFreq);
+         std::shared_ptr<COutputPin> getSelfTemporalDataFilter(CGarbageCollector& gc, CDuration outFreq);
 //         virtual void fromBinary(StdIStream& is);
 …
          bool mustAutoTrigger;
          map<int,boost::shared_ptr<func::CFunctor> > foperation_srv;
+         map<int,std::shared_ptr<func::CFunctor> > foperation_srv;
          // map<int, CArray<double,1> > data_srv;
          CArray<double,1> recvDataSrv;
          boost::shared_ptr<func::CFunctor> recvFoperationSrv;
+         std::shared_ptr<func::CFunctor> recvFoperationSrv;
          string content;
 …
          //! The output pin of the filter providing the instant data for the field
          boost::shared_ptr<COutputPin> instantDataFilter;
+         std::shared_ptr<COutputPin> instantDataFilter;
          //! The output pin of the filters providing the result of the field's temporal operation
          std::map<CDuration, boost::shared_ptr<COutputPin>, DurationFakeLessComparator> temporalDataFilters;
+         std::map<CDuration, std::shared_ptr<COutputPin>, DurationFakeLessComparator> temporalDataFilters;
          //! The output pin of the filter providing the instant data for self references
          boost::shared_ptr<COutputPin> selfReferenceFilter;
+         std::shared_ptr<COutputPin> selfReferenceFilter;
          //! The source filter for data provided by the client
          boost::shared_ptr<CSourceFilter> clientSourceFilter;
+         std::shared_ptr<CSourceFilter> clientSourceFilter;
          //! The source filter for data provided by the server
          boost::shared_ptr<CSourceFilter> serverSourceFilter;
+         std::shared_ptr<CSourceFilter> serverSourceFilter;
          //! The terminal filter which stores the instant data
          boost::shared_ptr<CStoreFilter> storeFilter;
+         std::shared_ptr<CStoreFilter> storeFilter;
          //! The terminal filter which writes the data to file
          boost::shared_ptr<CFileWriterFilter> fileWriterFilter;
+         std::shared_ptr<CFileWriterFilter> fileWriterFilter;
          //! The terminal filter which writes data to file
          boost::shared_ptr<CFileServerWriterFilter> fileServerWriterFilter;
+         std::shared_ptr<CFileServerWriterFilter> fileServerWriterFilter;
    }; // class CField

XIOS/trunk/src/node/file.cpp

-                      r1516
+                      r1542
    \return data writer object.
    */
    boost::shared_ptr<CDataOutput> CFile::getDataOutput(void) const
+   std::shared_ptr<CDataOutput> CFile::getDataOutput(void) const
+   {
       return data_out;
 …
    \return data reader object.
    */
    boost::shared_ptr<CDataInput> CFile::getDataInput(void) const
+   std::shared_ptr<CDataInput> CFile::getDataInput(void) const
+   {
       return data_in;
 …
          if (isOpen) data_out->closeFile();
         data_out = shared_ptr<CDataOutput>(new CNc4DataOutput(this, oss.str(), append, useClassicFormat, useCFConvention,
+        data_out = std::shared_ptr<CDataOutput>(new CNc4DataOutput(this, oss.str(), append, useClassicFormat, useCFConvention,
                                                               fileComm, multifile, isCollective, time_counter_name));
         isOpen = true;
 …
       bool ugridConvention = !convention.isEmpty() ? (convention == convention_attr::UGRID) : false;
       if (time_counter_name.isEmpty())
         data_in = shared_ptr<CDataInput>(new CNc4DataInput(oss.str(), readComm, multifile, isCollective, readMetaDataPar, ugridConvention));
+        data_in = std::shared_ptr<CDataInput>(new CNc4DataInput(oss.str(), readComm, multifile, isCollective, readMetaDataPar, ugridConvention));
       else
         data_in = shared_ptr<CDataInput>(new CNc4DataInput(oss.str(), readComm, multifile, isCollective, readMetaDataPar, ugridConvention, time_counter_name));
+        data_in = std::shared_ptr<CDataInput>(new CNc4DataInput(oss.str(), readComm, multifile, isCollective, readMetaDataPar, ugridConvention, time_counter_name));
       isOpen = true;
+    }

XIOS/trunk/src/node/file.hpp

-                      r1494
+                      r1542
          /// Accesseurs ///
          const StdString getFileOutputName(void) const;
          boost::shared_ptr<CDataOutput> getDataOutput(void) const;
          boost::shared_ptr<CDataInput> getDataInput(void) const;
+         std::shared_ptr<CDataOutput> getDataOutput(void) const;
+         std::shared_ptr<CDataInput> getDataInput(void) const;
          CFieldGroup* getVirtualFieldGroup(void) const;
          CVariableGroup* getVirtualVariableGroup(void) const;
 …
          CFieldGroup* vFieldGroup;
          CVariableGroup* vVariableGroup;
          boost::shared_ptr<CDataOutput> data_out;
          boost::shared_ptr<CDataInput> data_in;
+         std::shared_ptr<CDataOutput> data_out;
+         std::shared_ptr<CDataInput> data_in;
          std::vector<CField*> enabledFields;

XIOS/trunk/src/node/grid.cpp

-                      r1397
+                      r1542
          // Compute mapping between client and server
          std::vector<boost::unordered_map<size_t,std::vector<int> > > indexServerOnElement;
+         std::vector<std::unordered_map<size_t,std::vector<int> > > indexServerOnElement;
          CServerDistributionDescription serverDistributionDescription(getGlobalDimension(), client->serverSize);
          std::vector<int> serverZeroIndex = serverDistributionDescription.computeServerGlobalByElement(indexServerOnElement,
 …
       \param [out] globalIndexOnServer global index of grid and its corresponding rank of server.
    */
    void CGrid::computeIndexByElement(const std::vector<boost::unordered_map<size_t,std::vector<int> > >& indexServerOnElement,
+   void CGrid::computeIndexByElement(const std::vector<std::unordered_map<size_t,std::vector<int> > >& indexServerOnElement,
                                      const CContextClient* client,
                                      CClientServerMapping::GlobalIndexMap& globalIndexOnServer)
 …
      std::vector<std::vector<bool> > elementOnServer(nbElement, std::vector<bool>(serverSize, false));
      std::vector<boost::unordered_map<int,std::vector<size_t> > > globalElementIndexOnServer(nbElement);
+     std::vector<std::unordered_map<int,std::vector<size_t> > > globalElementIndexOnServer(nbElement);
      CArray<int,1> nbIndexOnServer(serverSize); // Number of distributed global index held by each client for each server
      // Number of temporary distributed global index held by each client for each server
 …
+     {
        nbIndexOnServer = 0;
        const boost::unordered_map<size_t,std::vector<int> >& indexServerElement = indexServerOnElement[idx];
+       const std::unordered_map<size_t,std::vector<int> >& indexServerElement = indexServerOnElement[idx];
        const CArray<size_t,1>& globalIndexElementOnClient = globalIndexElement[idx];
        CClientClientDHTInt clientClientDHT(indexServerElement, client->intraComm);

XIOS/trunk/src/node/grid.hpp

r1422	r1542
288	288	void checkAttributesAfterTransformation();
289	289	void setTransformationAlgorithms();
290		void computeIndexByElement(const std::vector<~~boost~~::unordered_map<size_t,std::vector<int> > >& indexServerOnElement,
	290	void computeIndexByElement(const std::vector<std::unordered_map<size_t,std::vector<int> > >& indexServerOnElement,
291	291	const CContextClient* client,
292	292	CClientServerMapping::GlobalIndexMap& globalIndexOnServer);

XIOS/trunk/src/node/mesh.cpp

-                      r1507
+                      r1542
 #include "mesh.hpp"
+#include <boost/functional/hash.hpp>
+//#include <unordered_map>
 namespace xios {
 …
+    }
-///----------------------------------------------------------------
-/*!
- * \fn size_t CMesh::nodeIndex (double lon, double lat)
- * Returns its index if a node exists; otherwise adds the node and returns -1.
- * Precision check is implemented with two hash values for each dimension, longitude and latitude.
- * \param [in] lon Node longitude in degrees.
- * \param [in] lat Node latitude in degrees ranged from 0 to 360.
- * \return node index if a node exists; -1 otherwise
- */
-  size_t CMesh::nodeIndex (double lon, double lat)
+  {
-    double minBoundLon = 0. ;
-    double maxBoundLon = 360. ;
-    double minBoundLat = -90 ;
-    double maxBoundLat = 90 ;
-    double prec=1e-11 ;
-    double precLon=prec ;
-    double precLat=prec ;
-    size_t maxsize_t=numeric_limits<size_t>::max() ;
-    if ( (maxBoundLon-minBoundLon)/maxsize_t > precLon) precLon=(maxBoundLon-minBoundLon)/maxsize_t ;
-    if ( (maxBoundLat-minBoundLat)/maxsize_t > precLat) precLat=(maxBoundLat-minBoundLat)/maxsize_t ;
-    size_t iMinLon=0 ;
-    size_t iMaxLon=(maxBoundLon-minBoundLon)/precLon ;
-    size_t iMinLat=0 ;
-    size_t iMaxLat=(maxBoundLat-minBoundLat)/precLat ;
-    size_t hash0,hash1,hash2,hash3 ;
-    size_t lon0,lon1,lat0,lat1 ;
-    lon0=(lon-minBoundLon)/precLon ;
-    if ( ((lon0+1)*precLon + lon0*precLon)/2 > lon-minBoundLon)
+    {
-      if (lon0==iMinLon) lon1=iMaxLon ;
-      else lon1=lon0-1 ;
+    }
-    else
+    {
-      if (lon0==iMaxLon) lon1=iMinLon ;
-      else lon1=lon0+1 ;
+    }
-    lat0=(lat-minBoundLat)/precLat ;
-    if ( ((lat0+1)*precLat + lat0*precLat)/2 > lat-minBoundLat)
+    {
-      if (lat0==iMinLat) lat1=lat0 ;
-      else lat1=lat0-1 ;
+    }
-    else
+    {
-      if (lat0==iMaxLat) lat1=lat0 ;
-      else lat1=lat0+1 ;
+    }
-    hash0=hashPair(lon0,lat0) ;
-    hash1=hashPair(lon0,lat1) ;
-    hash2=hashPair(lon1,lat0) ;
-    hash3=hashPair(lon1,lat1) ;
-    boost::unordered_map<size_t, size_t>::iterator end = hashed_map_nodes.end() ;
-    size_t mapSize = hashed_map_nodes.size();
-    if (hashed_map_nodes.find(hash0)==end && hashed_map_nodes.find(hash1)==end && hashed_map_nodes.find(hash2)==end && hashed_map_nodes.find(hash3)==end)
+    {
-      hashed_map_nodes[hash0] = mapSize ;
-      hashed_map_nodes[hash1] = mapSize + 1;
-      hashed_map_nodes[hash2] = mapSize + 2;
-      hashed_map_nodes[hash3] = mapSize + 3;
-      return -1;
+    }
-    else
-      return ( (hashed_map_nodes[hash0]+1) / 4 );
-  } // nodeIndex()
 ///----------------------------------------------------------------
 /*!
 …
  * \param [in] bounds_lat Array of boundary latitudes. Its size depends on the element type.
  */
   void CMesh::createMesh(const CArray<double, 1>& lonvalue, const CArray<double, 1>& latvalue,
             const CArray<double, 2>& bounds_lon, const CArray<double, 2>& bounds_lat)
+  {
     int nvertex = (bounds_lon.numElements() == 0) ? 1 : bounds_lon.rows();
     if (nvertex == 1)
+    {
       nbNodes_ = lonvalue.numElements();
       node_lon.resizeAndPreserve(nbNodes_);
       node_lat.resizeAndPreserve(nbNodes_);
       for (int nn = 0; nn < nbNodes_; ++nn)
+      {
         if (map_nodes.find(make_pair (lonvalue(nn), latvalue(nn))) == map_nodes.end())
+        {
           map_nodes[make_pair (lonvalue(nn), latvalue(nn))] = nn ;
           node_lon(nn) = lonvalue(nn);
           node_lat(nn) = latvalue(nn);
+        }
+      }
+    }
     else if (nvertex == 2)
+    {
       nbEdges_ = bounds_lon.shape()[1];
       // Create nodes and edge_node connectivity
       node_lon.resizeAndPreserve(nbEdges_*nvertex); // Max possible number of nodes
       node_lat.resizeAndPreserve(nbEdges_*nvertex);
       edge_nodes.resizeAndPreserve(nvertex, nbEdges_);
       for (int ne = 0; ne < nbEdges_; ++ne)
+      {
         for (int nv = 0; nv < nvertex; ++nv)
+        {
           if (map_nodes.find(make_pair (bounds_lon(nv, ne), bounds_lat(nv ,ne))) == map_nodes.end())
+          {
             map_nodes[make_pair (bounds_lon(nv, ne), bounds_lat(nv, ne))] = nbNodes_ ;
             edge_nodes(nv,ne) = nbNodes_ ;
             node_lon(nbNodes_) = bounds_lon(nv, ne);
             node_lat(nbNodes_) = bounds_lat(nv, ne);
             ++nbNodes_ ;
+          }
           else
             edge_nodes(nv,ne) = map_nodes[make_pair (bounds_lon(nv, ne), bounds_lat(nv ,ne))];
+        }
+      }
       node_lon.resizeAndPreserve(nbNodes_);
       node_lat.resizeAndPreserve(nbNodes_);
       // Create edges
       edge_lon.resizeAndPreserve(nbEdges_);
       edge_lat.resizeAndPreserve(nbEdges_);
       for (int ne = 0; ne < nbEdges_; ++ne)
+      {
         if (map_edges.find(make_ordered_pair (edge_nodes(0,ne), edge_nodes(1,ne))) == map_edges.end())
+        {
           map_edges[make_ordered_pair ( edge_nodes(0,ne), edge_nodes(1,ne) )] = ne ;
           edge_lon(ne) = lonvalue(ne);
           edge_lat(ne) = latvalue(ne);
+        }
+      }
       edgesAreWritten = true;
+    }
     else
+    {
       nbFaces_ = bounds_lon.shape()[1];
       // Create nodes and face_node connectivity
       node_lon.resizeAndPreserve(nbFaces_*nvertex);  // Max possible number of nodes
       node_lat.resizeAndPreserve(nbFaces_*nvertex);
       face_nodes.resize(nvertex, nbFaces_);
       for (int nf = 0; nf < nbFaces_; ++nf)
+      {
         for (int nv = 0; nv < nvertex; ++nv)
+        {
           if (map_nodes.find(make_pair (bounds_lon(nv, nf), bounds_lat(nv ,nf))) == map_nodes.end())
+          {
             map_nodes[make_pair (bounds_lon(nv, nf), bounds_lat(nv, nf))] = nbNodes_ ;
             face_nodes(nv,nf) = nbNodes_ ;
             node_lon(nbNodes_) = bounds_lon(nv, nf);
             node_lat(nbNodes_) = bounds_lat(nv ,nf);
             ++nbNodes_ ;
+          }
           else
+          {
             face_nodes(nv,nf) = map_nodes[make_pair (bounds_lon(nv, nf), bounds_lat(nv ,nf))];
+          }
+        }
+      }
       node_lon.resizeAndPreserve(nbNodes_);
       node_lat.resizeAndPreserve(nbNodes_);
       // Create edges and edge_nodes connectivity
       edge_lon.resizeAndPreserve(nbFaces_*nvertex); // Max possible number of edges
       edge_lat.resizeAndPreserve(nbFaces_*nvertex);
       edge_nodes.resizeAndPreserve(2, nbFaces_*nvertex);
       edge_faces.resize(2, nbFaces_*nvertex);
       face_edges.resize(nvertex, nbFaces_);
       face_faces.resize(nvertex, nbFaces_);
       vector<int> countEdges(nbFaces_*nvertex);   // needed in case if edges have been already generated
       vector<int> countFaces(nbFaces_);
       countEdges.assign(nbFaces_*nvertex, 0);
       countFaces.assign(nbFaces_, 0);
       int edge;
       for (int nf = 0; nf < nbFaces_; ++nf)
+      {
         for (int nv1 = 0; nv1 < nvertex; ++nv1)
+        {
           int nv = 0;
           int nv2 = (nv1 < nvertex -1 ) ? (nv1 + 1) : (nv1 + 1 - nvertex); // cyclic rotation
           if (map_edges.find(make_ordered_pair (face_nodes(nv1,nf), face_nodes(nv2,nf))) == map_edges.end())
+          {
             map_edges[make_ordered_pair (face_nodes(nv1,nf), face_nodes(nv2,nf))] = nbEdges_ ;
             face_edges(nv1,nf) = map_edges[make_ordered_pair (face_nodes(nv1,nf), face_nodes(nv2,nf))];
             edge_faces(0,nbEdges_) = nf;
             edge_faces(1,nbEdges_) = -999;
             face_faces(nv1,nf) = 999999;
             edge_nodes(Range::all(),nbEdges_) = face_nodes(nv1,nf), face_nodes(nv2,nf);
             edge_lon(nbEdges_) = ( abs( node_lon(face_nodes(nv1,nf)) - node_lon(face_nodes(nv2,nf))) < 180.) ?
                         (( node_lon(face_nodes(nv1,nf)) + node_lon(face_nodes(nv2,nf))) * 0.5) :
                         (( node_lon(face_nodes(nv1,nf)) + node_lon(face_nodes(nv2,nf))) * 0.5 -180.);
             edge_lat(nbEdges_) = ( node_lat(face_nodes(nv1,nf)) + node_lat(face_nodes(nv2,nf)) ) * 0.5;
             ++nbEdges_;
+          }
           else
+          {
             edge = map_edges[make_ordered_pair (face_nodes(nv1,nf), face_nodes(nv2,nf))];
             face_edges(nv1,nf) = edge;
             if (edgesAreWritten)
+            {
               edge_faces(countEdges[edge], edge) = nf;
               if (countEdges[edge]==0)
+              {
                 face_faces(nv1,nf) = 999999;
+              }
               else
+              {
                 int face1 = nf; // = edge_faces(1,edge)
                 int face2 = edge_faces(0,edge);
                 face_faces(countFaces[face1], face1) =  face2;
                 face_faces(countFaces[face2], face2) =  face1;
                 ++(countFaces[face1]);
                 ++(countFaces[face2]);
+              }
+            }
             else
+            {
               edge_faces(1,edge) = nf;
               int face1 = nf; // = edge_faces(1,edge)
               int face2 = edge_faces(0,edge);
               face_faces(countFaces[face1], face1) =  face2;
               face_faces(countFaces[face2], face2) =  face1;
               ++(countFaces[face1]);
               ++(countFaces[face2]);
+            }
             ++(countEdges[edge]);
+          }
+        }
+      }
       edge_nodes.resizeAndPreserve(2, nbEdges_);
       edge_faces.resizeAndPreserve(2, nbEdges_);
       edge_lon.resizeAndPreserve(nbEdges_);
       edge_lat.resizeAndPreserve(nbEdges_);
       // Create faces
       face_lon.resize(nbFaces_);
       face_lat.resize(nbFaces_);
       face_lon = lonvalue;
       face_lat = latvalue;
       facesAreWritten = true;
     } // nvertex > 2
   } // createMesh()
+//  void CMesh::createMesh(const CArray<double, 1>& lonvalue, const CArray<double, 1>& latvalue,
+//            const CArray<double, 2>& bounds_lon, const CArray<double, 2>& bounds_lat)
+//  {
+//    int nvertex = (bounds_lon.numElements() == 0) ? 1 : bounds_lon.rows();
+//
+//    if (nvertex == 1)
+//    {
+//      nbNodes_ = lonvalue.numElements();
+//      node_lon.resizeAndPreserve(nbNodes_);
+//      node_lat.resizeAndPreserve(nbNodes_);
+//      for (int nn = 0; nn < nbNodes_; ++nn)
+//      {
+//        if (map_nodes.find(make_pair (lonvalue(nn), latvalue(nn))) == map_nodes.end())
+//        {
+//          map_nodes[make_pair (lonvalue(nn), latvalue(nn))] = nn ;
+//          node_lon(nn) = lonvalue(nn);
+//          node_lat(nn) = latvalue(nn);
+//        }
+//      }
+//    }
+//    else if (nvertex == 2)
+//    {
+//      nbEdges_ = bounds_lon.shape()[1];
+//
+//      // Create nodes and edge_node connectivity
+//      node_lon.resizeAndPreserve(nbEdges_*nvertex); // Max possible number of nodes
+//      node_lat.resizeAndPreserve(nbEdges_*nvertex);
+//      edge_nodes.resizeAndPreserve(nvertex, nbEdges_);
+//
+//      for (int ne = 0; ne < nbEdges_; ++ne)
+//      {
+//        for (int nv = 0; nv < nvertex; ++nv)
+//        {
+//          if (map_nodes.find(make_pair (bounds_lon(nv, ne), bounds_lat(nv ,ne))) == map_nodes.end())
+//          {
+//            map_nodes[make_pair (bounds_lon(nv, ne), bounds_lat(nv, ne))] = nbNodes_ ;
+//            edge_nodes(nv,ne) = nbNodes_ ;
+//            node_lon(nbNodes_) = bounds_lon(nv, ne);
+//            node_lat(nbNodes_) = bounds_lat(nv, ne);
+//            ++nbNodes_ ;
+//          }
+//          else
+//            edge_nodes(nv,ne) = map_nodes[make_pair (bounds_lon(nv, ne), bounds_lat(nv ,ne))];
+//        }
+//      }
+//      node_lon.resizeAndPreserve(nbNodes_);
+//      node_lat.resizeAndPreserve(nbNodes_);
+//
+//      // Create edges
+//      edge_lon.resizeAndPreserve(nbEdges_);
+//      edge_lat.resizeAndPreserve(nbEdges_);
+//
+//      for (int ne = 0; ne < nbEdges_; ++ne)
+//      {
+//        if (map_edges.find(make_ordered_pair (edge_nodes(0,ne), edge_nodes(1,ne))) == map_edges.end())
+//        {
+//          map_edges[make_ordered_pair ( edge_nodes(0,ne), edge_nodes(1,ne) )] = ne ;
+//          edge_lon(ne) = lonvalue(ne);
+//          edge_lat(ne) = latvalue(ne);
+//        }
+//
+//      }
+//      edgesAreWritten = true;
+//    }
+//    else
+//    {
+//      nbFaces_ = bounds_lon.shape()[1];
+//
+//      // Create nodes and face_node connectivity
+//      node_lon.resizeAndPreserve(nbFaces_*nvertex);  // Max possible number of nodes
+//      node_lat.resizeAndPreserve(nbFaces_*nvertex);
+//      face_nodes.resize(nvertex, nbFaces_);
+//
+//      for (int nf = 0; nf < nbFaces_; ++nf)
+//      {
+//        for (int nv = 0; nv < nvertex; ++nv)
+//        {
+//          if (map_nodes.find(make_pair (bounds_lon(nv, nf), bounds_lat(nv ,nf))) == map_nodes.end())
+//          {
+//            map_nodes[make_pair (bounds_lon(nv, nf), bounds_lat(nv, nf))] = nbNodes_ ;
+//            face_nodes(nv,nf) = nbNodes_ ;
+//            node_lon(nbNodes_) = bounds_lon(nv, nf);
+//            node_lat(nbNodes_) = bounds_lat(nv ,nf);
+//            ++nbNodes_ ;
+//          }
+//          else
+//          {
+//            face_nodes(nv,nf) = map_nodes[make_pair (bounds_lon(nv, nf), bounds_lat(nv ,nf))];
+//          }
+//        }
+//      }
+//      node_lon.resizeAndPreserve(nbNodes_);
+//      node_lat.resizeAndPreserve(nbNodes_);
+//
+//      // Create edges and edge_nodes connectivity
+//      edge_lon.resizeAndPreserve(nbFaces_*nvertex); // Max possible number of edges
+//      edge_lat.resizeAndPreserve(nbFaces_*nvertex);
+//      edge_nodes.resizeAndPreserve(2, nbFaces_*nvertex);
+//      edge_faces.resize(2, nbFaces_*nvertex);
+//      face_edges.resize(nvertex, nbFaces_);
+//      face_faces.resize(nvertex, nbFaces_);
+//
+//      vector<int> countEdges(nbFaces_*nvertex);   // needed in case if edges have been already generated
+//      vector<int> countFaces(nbFaces_);
+//      countEdges.assign(nbFaces_*nvertex, 0);
+//      countFaces.assign(nbFaces_, 0);
+//      int edge;
+//      for (int nf = 0; nf < nbFaces_; ++nf)
+//      {
+//        for (int nv1 = 0; nv1 < nvertex; ++nv1)
+//        {
+//          int nv = 0;
+//          int nv2 = (nv1 < nvertex -1 ) ? (nv1 + 1) : (nv1 + 1 - nvertex); // cyclic rotation
+//          if (map_edges.find(make_ordered_pair (face_nodes(nv1,nf), face_nodes(nv2,nf))) == map_edges.end())
+//          {
+//            map_edges[make_ordered_pair (face_nodes(nv1,nf), face_nodes(nv2,nf))] = nbEdges_ ;
+//            face_edges(nv1,nf) = map_edges[make_ordered_pair (face_nodes(nv1,nf), face_nodes(nv2,nf))];
+//            edge_faces(0,nbEdges_) = nf;
+//            edge_faces(1,nbEdges_) = -999;
+//            face_faces(nv1,nf) = 999999;
+//            edge_nodes(Range::all(),nbEdges_) = face_nodes(nv1,nf), face_nodes(nv2,nf);
+//            edge_lon(nbEdges_) = ( abs( node_lon(face_nodes(nv1,nf)) - node_lon(face_nodes(nv2,nf))) < 180.) ?
+//                        (( node_lon(face_nodes(nv1,nf)) + node_lon(face_nodes(nv2,nf))) * 0.5) :
+//                        (( node_lon(face_nodes(nv1,nf)) + node_lon(face_nodes(nv2,nf))) * 0.5 -180.);
+//            edge_lat(nbEdges_) = ( node_lat(face_nodes(nv1,nf)) + node_lat(face_nodes(nv2,nf)) ) * 0.5;
+//            ++nbEdges_;
+//          }
+//          else
+//          {
+//            edge = map_edges[make_ordered_pair (face_nodes(nv1,nf), face_nodes(nv2,nf))];
+//            face_edges(nv1,nf) = edge;
+//            if (edgesAreWritten)
+//            {
+//              edge_faces(countEdges[edge], edge) = nf;
+//              if (countEdges[edge]==0)
+//              {
+//                face_faces(nv1,nf) = 999999;
+//              }
+//              else
+//              {
+//                int face1 = nf; // = edge_faces(1,edge)
+//                int face2 = edge_faces(0,edge);
+//                face_faces(countFaces[face1], face1) =  face2;
+//                face_faces(countFaces[face2], face2) =  face1;
+//                ++(countFaces[face1]);
+//                ++(countFaces[face2]);
+//              }
+//            }
+//            else
+//            {
+//              edge_faces(1,edge) = nf;
+//              int face1 = nf; // = edge_faces(1,edge)
+//              int face2 = edge_faces(0,edge);
+//              face_faces(countFaces[face1], face1) =  face2;
+//              face_faces(countFaces[face2], face2) =  face1;
+//              ++(countFaces[face1]);
+//              ++(countFaces[face2]);
+//            }
+//            ++(countEdges[edge]);
+//          }
+//        }
+//      }
+//      edge_nodes.resizeAndPreserve(2, nbEdges_);
+//      edge_faces.resizeAndPreserve(2, nbEdges_);
+//      edge_lon.resizeAndPreserve(nbEdges_);
+//      edge_lat.resizeAndPreserve(nbEdges_);
+//
+//      // Create faces
+//      face_lon.resize(nbFaces_);
+//      face_lat.resize(nbFaces_);
+//      face_lon = lonvalue;
+//      face_lat = latvalue;
+//      facesAreWritten = true;
+//
+//    } // nvertex > 2
+//
+//  } // createMesh()
 ///----------------------------------------------------------------
 …
     // faceToFaces connectivity
     boost::unordered_map <int, int> mapFaces;  // mapFaces = < hash(face1, face2), hash> (the mapped value is irrelevant)
+    std::unordered_map <int, int> mapFaces;  // mapFaces = < hash(face1, face2), hash> (the mapped value is irrelevant)
     int maxNb = 20;                            // some assumption on the max possible number of neighboring cells
     faceToFaces.resize(maxNb, nbFaces);
 …
     CArray<double, 2> faceToNodes (nvertex, nbFaces);
     boost::unordered_map <pair<double,double>, int> mapNodes;
+    std::unordered_map <pairDouble, int, boost::hash<pairDouble> > mapNodes;
     for (int nf = 0; nf < nbFaces; ++nf)
 …
     // faceToFaces connectivity
     boost::unordered_map <pair<int,int>, int> mapEdges;
+    std::unordered_map <pairInt, int, boost::hash<pairInt> > mapEdges;
     faceToFaces.resize(nvertex, nbFaces);
     CArray<int, 2> edgeToFaces(2, nbFaces*nvertex); // max possible

XIOS/trunk/src/node/mesh.hpp

-                      r931
+                      r1542
     private:
+      typedef std::pair<double, double> pairDouble;
+      typedef std::pair<int, int> pairInt;
       int nbNodes_;
       int nbEdges_;
 …
       vector<size_t> createHashes (const double, const double);
-      size_t nodeIndex (double, double);                           // redundant in parallel version with epsilon precision
-      boost::unordered_map <size_t, size_t> hashed_map_nodes;      // redundant in parallel version with epsilon precision
-      boost::unordered_map <pair<double,double>, int> map_nodes;   // redundant in parallel version with epsilon precision
-      boost::unordered_map <pair<int,int>, int> map_edges;         // redundant in parallel version with epsilon precision
   };

XIOS/trunk/src/object_factory.hpp

-                      r769
+                      r1542
 #define __XIOS_CObjectFactory__
+/// boost headers ///
+#include <boost/shared_ptr.hpp>
+#include <memory>
 /// XIOS headers ///
 …
          template <typename U>
             static  boost::shared_ptr<U> GetObject(const StdString & id);
+            static  std::shared_ptr<U> GetObject(const StdString & id);
          template <typename U>
             static  boost::shared_ptr<U> GetObject(const StdString& context,const StdString & id);
+            static  std::shared_ptr<U> GetObject(const StdString& context,const StdString & id);
          template <typename U>
             static  boost::shared_ptr<U> GetObject(const U * const object);
+            static  std::shared_ptr<U> GetObject(const U * const object);
          template <typename U>
 …
          template <typename U>
             static  const std::vector<boost::shared_ptr<U> > &
+            static  const std::vector<std::shared_ptr<U> > &
                GetObjectVector(const StdString & context = CObjectFactory::GetCurrentContextId());
 …
          /// Instanciateur ///
          template <typename U>
             static  boost::shared_ptr<U> CreateObject(const StdString & id = StdString(""));
+            static  std::shared_ptr<U> CreateObject(const StdString & id = StdString(""));
          template <typename U> static const StdString& GetUIdBase(void);

XIOS/trunk/src/object_factory_decl.cpp

-                      r1457
+                      r1542
+{
 #define macro(U) \
   template shared_ptr<U> CObjectFactory::GetObject<U>(const StdString& id);  \
   template shared_ptr<U> CObjectFactory::GetObject<U>(const StdString& context,const StdString& id); \
   template shared_ptr<U> CObjectFactory::GetObject<U>(const U* const object); \
+  template std::shared_ptr<U> CObjectFactory::GetObject<U>(const StdString& id);  \
+  template std::shared_ptr<U> CObjectFactory::GetObject<U>(const StdString& context,const StdString& id); \
+  template std::shared_ptr<U> CObjectFactory::GetObject<U>(const U* const object); \
   template int CObjectFactory::GetObjectNum<U>(void); \
   template int CObjectFactory::GetObjectIdNum<U>(void); \
   template const std::vector<shared_ptr<U> >& CObjectFactory::GetObjectVector<U>(const StdString& context ); \
+  template const std::vector<std::shared_ptr<U> >& CObjectFactory::GetObjectVector<U>(const StdString& context ); \
   template bool CObjectFactory::HasObject<U>(const StdString& id); \
   template bool CObjectFactory::HasObject<U>(const StdString& context,const StdString& id); \
   template boost::shared_ptr<U> CObjectFactory::CreateObject<U>(const StdString& id ); \
+  template std::shared_ptr<U> CObjectFactory::CreateObject<U>(const StdString& id ); \
   template const StdString& CObjectFactory::GetUIdBase<U>(void); \
   template StdString CObjectFactory::GenUId<U>(void); \

XIOS/trunk/src/object_factory_impl.hpp

-                      r769
+                      r1542
    template <typename U>
       boost::shared_ptr<U> CObjectFactory::GetObject(const U * const object)
+      std::shared_ptr<U> CObjectFactory::GetObject(const U * const object)
+   {
       if (CurrContext.size() == 0)
          ERROR("CObjectFactory::GetObject(const U * const object)",
                << "please define current context id !");
       std::vector<boost::shared_ptr<U> > & vect =
+      std::vector<std::shared_ptr<U> > & vect =
                      U::AllVectObj[CObjectFactory::CurrContext];
       typename std::vector<boost::shared_ptr<U> >::const_iterator
+      typename std::vector<std::shared_ptr<U> >::const_iterator
          it = vect.begin(), end = vect.end();
       for (; it != end; it++)
+      {
          boost::shared_ptr<U> ptr = *it;
+         std::shared_ptr<U> ptr = *it;
          if (ptr.get() == object)
             return (ptr);
 …
                << "[type = " << U::GetName() << ", adress = " << object << "] "
                << "object was not found.");
       return (boost::shared_ptr<U>()); // jamais atteint
+      return (std::shared_ptr<U>()); // jamais atteint
+   }
    template <typename U>
       boost::shared_ptr<U> CObjectFactory::GetObject(const StdString & id)
+      std::shared_ptr<U> CObjectFactory::GetObject(const StdString & id)
+   {
       if (CurrContext.size() == 0)
 …
    template <typename U>
       boost::shared_ptr<U> CObjectFactory::GetObject(const StdString & context, const StdString & id)
+      std::shared_ptr<U> CObjectFactory::GetObject(const StdString & context, const StdString & id)
+   {
       if (!CObjectFactory::HasObject<U>(context,id))
 …
    template <typename U>
    boost::shared_ptr<U> CObjectFactory::CreateObject(const StdString& id)
+   std::shared_ptr<U> CObjectFactory::CreateObject(const StdString& id)
+   {
       if (CurrContext.empty())
 …
       else
+      {
          boost::shared_ptr<U> value(new U(id.empty() ? CObjectFactory::GenUId<U>() : id));
+         std::shared_ptr<U> value(new U(id.empty() ? CObjectFactory::GenUId<U>() : id));
          U::AllVectObj[CObjectFactory::CurrContext].insert(U::AllVectObj[CObjectFactory::CurrContext].end(), value);
 …
    template <typename U>
       const std::vector<boost::shared_ptr<U> > &
+      const std::vector<std::shared_ptr<U> > &
          CObjectFactory::GetObjectVector(const StdString & context)
+   {

XIOS/trunk/src/object_template.hpp

-                      r1330
+                      r1542
          /// Accesseur statique ///
          static std::vector<boost::shared_ptr<DerivedType> > &
+         static std::vector<std::shared_ptr<DerivedType> > &
             GetAllVectobject(const StdString & contextId);
 …
          static T* get(const string& contextId, const string& id) ;
          T* get(void) ;
          shared_ptr<T> getShared(void) ;
          static shared_ptr<T> getShared(const T* ptr) ;
+         std::shared_ptr<T> getShared(void) ;
+         static std::shared_ptr<T> getShared(const T* ptr) ;
          static T* create(const string& id=string("")) ;
 …
          static xios_map<StdString,
                 xios_map<StdString,
                 boost::shared_ptr<DerivedType> > > AllMapObj;
+                std::shared_ptr<DerivedType> > > AllMapObj;
          static xios_map<StdString,
                 std::vector<boost::shared_ptr<DerivedType> > > AllVectObj;
+                std::vector<std::shared_ptr<DerivedType> > > AllVectObj;
          static xios_map< StdString, long int > GenId ;

XIOS/trunk/src/object_template_impl.hpp

-                      r1330
+                      r1542
       xios_map<StdString,
       xios_map<StdString,
       boost::shared_ptr<T> > > CObjectTemplate<T>::AllMapObj;
+      std::shared_ptr<T> > > CObjectTemplate<T>::AllMapObj;
    template <class T>
       xios_map<StdString,
       std::vector<boost::shared_ptr<T> > > CObjectTemplate<T>::AllVectObj;
+      std::vector<std::shared_ptr<T> > > CObjectTemplate<T>::AllVectObj;
    template <class T>
 …
    template <class T>
       std::vector<boost::shared_ptr<T> > &
+      std::vector<std::shared_ptr<T> > &
          CObjectTemplate<T>::GetAllVectobject(const StdString & contextId)
+   {
 …
    template <typename T>
    shared_ptr<T> CObjectTemplate<T>::getShared(const T* ptr)
+   std::shared_ptr<T> CObjectTemplate<T>::getShared(const T* ptr)
+   {
      return CObjectFactory::GetObject<T>(ptr);
 …
    template <typename T>
    shared_ptr<T> CObjectTemplate<T>::getShared(void)
+   std::shared_ptr<T> CObjectTemplate<T>::getShared(void)
+   {
      return CObjectFactory::GetObject<T>((T*)this);
 …
    const vector<T*> CObjectTemplate<T>::getAll()
+   {
      const vector< shared_ptr<T> >& shared_vect= CObjectFactory::GetObjectVector<T>();
+     const vector< std::shared_ptr<T> >& shared_vect= CObjectFactory::GetObjectVector<T>();
      vector<T*> vect;
      typename vector<shared_ptr<T> >::const_iterator it;
+     typename vector<std::shared_ptr<T> >::const_iterator it;
      for(it=shared_vect.begin();it!=shared_vect.end();++it) vect.push_back(it->get());
      return vect;
 …
    const vector<T*> CObjectTemplate<T>::getAll(const string & id)
+   {
      const vector< shared_ptr<T> >& shared_vect= CObjectFactory::GetObjectVector<T>(id);
+     const vector< std::shared_ptr<T> >& shared_vect= CObjectFactory::GetObjectVector<T>(id);
      vector<T*> vect;
      typename vector<shared_ptr<T> >::const_iterator it;
+     typename vector<std::shared_ptr<T> >::const_iterator it;
      for(it=shared_vect.begin();it!=shared_vect.end();++it) vect.push_back(it->get());
      return vect;
 …
      oss << iendl;
      oss << "#include <boost/multi_array.hpp>" << iendl;
      oss << "#include <boost/shared_ptr.hpp>" << iendl;
+     oss << "#include <boostXXX/shared_ptr.hpp>" << iendl;
      oss << "#include \"xios.hpp\"" << iendl;
      oss << "#include \"attribute_template.hpp\"" << iendl;

XIOS/trunk/src/parse_expr/filter_expr_node.cpp

-                      r1158
+                      r1542
   { /* Nothing to do */ }
   boost::shared_ptr<COutputPin> CFilterFieldExprNode::reduce(CGarbageCollector& gc, CField& thisField) const
+  {
     boost::shared_ptr<COutputPin> outputPin;
+  std::shared_ptr<COutputPin> CFilterFieldExprNode::reduce(CGarbageCollector& gc, CField& thisField) const
+  {
+    std::shared_ptr<COutputPin> outputPin;
     if (fieldId == "this")
 …
       CField* field = CField::get(fieldId);
       if (field == &thisField)
         ERROR("boost::shared_ptr<COutputPin> CFilterFieldExprNode::reduce(CGarbageCollector& gc, CField& thisField) const",
+        ERROR("std::shared_ptr<COutputPin> CFilterFieldExprNode::reduce(CGarbageCollector& gc, CField& thisField) const",
               << "The field " << fieldId << " has an invalid reference to itself. "
               << "Use the keyword \"this\" if you want to reference the input data sent to this field.");
 …
+    }
     else
       ERROR("boost::shared_ptr<COutputPin> CFilterFieldExprNode::reduce(CGarbageCollector& gc, CField& thisField) const",
+      ERROR("std::shared_ptr<COutputPin> CFilterFieldExprNode::reduce(CGarbageCollector& gc, CField& thisField) const",
             << "The field " << fieldId << " does not exist.");
 …
   { /* Nothing to do */ }
   boost::shared_ptr<COutputPin> CFilterTemporalFieldExprNode::reduce(CGarbageCollector& gc, CField& thisField) const
+  {
     boost::shared_ptr<COutputPin> outputPin;
+  std::shared_ptr<COutputPin> CFilterTemporalFieldExprNode::reduce(CGarbageCollector& gc, CField& thisField) const
+  {
+    std::shared_ptr<COutputPin> outputPin;
     if (fieldId == "this")
 …
       CField* field = CField::get(fieldId);
       if (field == &thisField)
         ERROR("boost::shared_ptr<COutputPin> CFilterTemporalFieldExprNode::reduce(CGarbageCollector& gc, CField& thisField) const",
+        ERROR("std::shared_ptr<COutputPin> CFilterTemporalFieldExprNode::reduce(CGarbageCollector& gc, CField& thisField) const",
               << "The field " << fieldId << " has an invalid reference to itself. "
               << "Use the keyword \"this\" if you want to reference the input data sent to this field.");
 …
+    }
     else
       ERROR("boost::shared_ptr<COutputPin> CFilterTemporalFieldExprNode::reduce(CGarbageCollector& gc, CField& thisField) const",
+      ERROR("std::shared_ptr<COutputPin> CFilterTemporalFieldExprNode::reduce(CGarbageCollector& gc, CField& thisField) const",
             << "The field " << fieldId << " does not exist.");
 …
+  }
   boost::shared_ptr<COutputPin> CFilterUnaryOpExprNode::reduce(CGarbageCollector& gc, CField& thisField) const
+  {
     boost::shared_ptr<CUnaryArithmeticFilter> filter(new CUnaryArithmeticFilter(gc, opId));
+  std::shared_ptr<COutputPin> CFilterUnaryOpExprNode::reduce(CGarbageCollector& gc, CField& thisField) const
+  {
+    std::shared_ptr<CUnaryArithmeticFilter> filter(new CUnaryArithmeticFilter(gc, opId));
     child->reduce(gc, thisField)->connectOutput(filter, 0);
     return filter;
 …
+  }
   boost::shared_ptr<COutputPin> CFilterScalarFieldOpExprNode::reduce(CGarbageCollector& gc, CField& thisField) const
+  {
     boost::shared_ptr<CScalarFieldArithmeticFilter> filter(new CScalarFieldArithmeticFilter(gc, opId, child1->reduce()));
+  std::shared_ptr<COutputPin> CFilterScalarFieldOpExprNode::reduce(CGarbageCollector& gc, CField& thisField) const
+  {
+    std::shared_ptr<CScalarFieldArithmeticFilter> filter(new CScalarFieldArithmeticFilter(gc, opId, child1->reduce()));
     child2->reduce(gc, thisField)->connectOutput(filter, 0);
     return filter;
 …
+  }
   boost::shared_ptr<COutputPin> CFilterFieldScalarOpExprNode::reduce(CGarbageCollector& gc, CField& thisField) const
+  {
     boost::shared_ptr<CFieldScalarArithmeticFilter> filter(new CFieldScalarArithmeticFilter(gc, opId, child2->reduce()));
+  std::shared_ptr<COutputPin> CFilterFieldScalarOpExprNode::reduce(CGarbageCollector& gc, CField& thisField) const
+  {
+    std::shared_ptr<CFieldScalarArithmeticFilter> filter(new CFieldScalarArithmeticFilter(gc, opId, child2->reduce()));
     child1->reduce(gc, thisField)->connectOutput(filter, 0);
     return filter;
 …
+  }
   boost::shared_ptr<COutputPin> CFilterFieldFieldOpExprNode::reduce(CGarbageCollector& gc, CField& thisField) const
+  {
     boost::shared_ptr<CFieldFieldArithmeticFilter> filter(new CFieldFieldArithmeticFilter(gc, opId));
+  std::shared_ptr<COutputPin> CFilterFieldFieldOpExprNode::reduce(CGarbageCollector& gc, CField& thisField) const
+  {
+    std::shared_ptr<CFieldFieldArithmeticFilter> filter(new CFieldFieldArithmeticFilter(gc, opId));
     child1->reduce(gc, thisField)->connectOutput(filter, 0);
     child2->reduce(gc, thisField)->connectOutput(filter, 1);
 …
+  }
   boost::shared_ptr<COutputPin> CFilterScalarScalarFieldOpExprNode::reduce(CGarbageCollector& gc, CField& thisField) const
+  {
     boost::shared_ptr<CScalarScalarFieldArithmeticFilter> filter(new CScalarScalarFieldArithmeticFilter(gc, opId, child1->reduce(),child2->reduce()));
+  std::shared_ptr<COutputPin> CFilterScalarScalarFieldOpExprNode::reduce(CGarbageCollector& gc, CField& thisField) const
+  {
+    std::shared_ptr<CScalarScalarFieldArithmeticFilter> filter(new CScalarScalarFieldArithmeticFilter(gc, opId, child1->reduce(),child2->reduce()));
     child3->reduce(gc, thisField)->connectOutput(filter, 0);
     return filter;
 …
+  }
   boost::shared_ptr<COutputPin> CFilterScalarFieldScalarOpExprNode::reduce(CGarbageCollector& gc, CField& thisField) const
+  {
     boost::shared_ptr<CScalarFieldScalarArithmeticFilter> filter(new CScalarFieldScalarArithmeticFilter(gc, opId, child1->reduce(),child3->reduce()));
+  std::shared_ptr<COutputPin> CFilterScalarFieldScalarOpExprNode::reduce(CGarbageCollector& gc, CField& thisField) const
+  {
+    std::shared_ptr<CScalarFieldScalarArithmeticFilter> filter(new CScalarFieldScalarArithmeticFilter(gc, opId, child1->reduce(),child3->reduce()));
     child2->reduce(gc, thisField)->connectOutput(filter, 0);
     return filter;
 …
+  }
   boost::shared_ptr<COutputPin> CFilterScalarFieldFieldOpExprNode::reduce(CGarbageCollector& gc, CField& thisField) const
+  {
     boost::shared_ptr<CScalarFieldFieldArithmeticFilter> filter(new CScalarFieldFieldArithmeticFilter(gc, opId, child1->reduce()));
+  std::shared_ptr<COutputPin> CFilterScalarFieldFieldOpExprNode::reduce(CGarbageCollector& gc, CField& thisField) const
+  {
+    std::shared_ptr<CScalarFieldFieldArithmeticFilter> filter(new CScalarFieldFieldArithmeticFilter(gc, opId, child1->reduce()));
     child2->reduce(gc, thisField)->connectOutput(filter, 0);
     child3->reduce(gc, thisField)->connectOutput(filter, 1);
 …
+  }
   boost::shared_ptr<COutputPin> CFilterFieldScalarScalarOpExprNode::reduce(CGarbageCollector& gc, CField& thisField) const
+  {
     boost::shared_ptr<CFieldScalarScalarArithmeticFilter> filter(new CFieldScalarScalarArithmeticFilter(gc, opId, child2->reduce(),child3->reduce()));
+  std::shared_ptr<COutputPin> CFilterFieldScalarScalarOpExprNode::reduce(CGarbageCollector& gc, CField& thisField) const
+  {
+    std::shared_ptr<CFieldScalarScalarArithmeticFilter> filter(new CFieldScalarScalarArithmeticFilter(gc, opId, child2->reduce(),child3->reduce()));
     child1->reduce(gc, thisField)->connectOutput(filter, 0);
     return filter;
 …
+  }
   boost::shared_ptr<COutputPin> CFilterFieldScalarFieldOpExprNode::reduce(CGarbageCollector& gc, CField& thisField) const
+  {
     boost::shared_ptr<CFieldScalarFieldArithmeticFilter> filter(new CFieldScalarFieldArithmeticFilter(gc, opId, child2->reduce()));
+  std::shared_ptr<COutputPin> CFilterFieldScalarFieldOpExprNode::reduce(CGarbageCollector& gc, CField& thisField) const
+  {
+    std::shared_ptr<CFieldScalarFieldArithmeticFilter> filter(new CFieldScalarFieldArithmeticFilter(gc, opId, child2->reduce()));
     child1->reduce(gc, thisField)->connectOutput(filter, 0);
     child3->reduce(gc, thisField)->connectOutput(filter, 1);
 …
+  }
   boost::shared_ptr<COutputPin> CFilterFieldFieldScalarOpExprNode::reduce(CGarbageCollector& gc, CField& thisField) const
+  {
     boost::shared_ptr<CFieldFieldScalarArithmeticFilter> filter(new CFieldFieldScalarArithmeticFilter(gc, opId, child3->reduce()));
+  std::shared_ptr<COutputPin> CFilterFieldFieldScalarOpExprNode::reduce(CGarbageCollector& gc, CField& thisField) const
+  {
+    std::shared_ptr<CFieldFieldScalarArithmeticFilter> filter(new CFieldFieldScalarArithmeticFilter(gc, opId, child3->reduce()));
     child1->reduce(gc, thisField)->connectOutput(filter, 0);
     child2->reduce(gc, thisField)->connectOutput(filter, 1);
 …
+  }
   boost::shared_ptr<COutputPin> CFilterFieldFieldFieldOpExprNode::reduce(CGarbageCollector& gc, CField& thisField) const
+  {
     boost::shared_ptr<CFieldFieldFieldArithmeticFilter> filter(new CFieldFieldFieldArithmeticFilter(gc, opId));
+  std::shared_ptr<COutputPin> CFilterFieldFieldFieldOpExprNode::reduce(CGarbageCollector& gc, CField& thisField) const
+  {
+    std::shared_ptr<CFieldFieldFieldArithmeticFilter> filter(new CFieldFieldFieldArithmeticFilter(gc, opId));
     child1->reduce(gc, thisField)->connectOutput(filter, 0);
     child2->reduce(gc, thisField)->connectOutput(filter, 1);

XIOS/trunk/src/parse_expr/filter_expr_node.hpp

-                      r1158
+                      r1542
 #include <string>
-#include <boost/shared_ptr.hpp>
 #include <boost/smart_ptr/scoped_ptr.hpp>
 #include "scalar_expr_node.hpp"
 …
      * \return the output pin of the filter producing the result of the expression
      */
     virtual boost::shared_ptr<COutputPin> reduce(CGarbageCollector& gc, CField& thisField) const = 0;
+    virtual std::shared_ptr<COutputPin> reduce(CGarbageCollector& gc, CField& thisField) const = 0;
   };
 …
       CFilterFieldExprNode(const std::string& fieldId);
       virtual boost::shared_ptr<COutputPin> reduce(CGarbageCollector& gc, CField& thisField) const;
+      virtual std::shared_ptr<COutputPin> reduce(CGarbageCollector& gc, CField& thisField) const;
     private:
 …
       CFilterTemporalFieldExprNode(const std::string& fieldId);
       virtual boost::shared_ptr<COutputPin> reduce(CGarbageCollector& gc, CField& thisField) const;
+      virtual std::shared_ptr<COutputPin> reduce(CGarbageCollector& gc, CField& thisField) const;
     private:
 …
       CFilterUnaryOpExprNode(const std::string& opId, IFilterExprNode* child);
       virtual boost::shared_ptr<COutputPin> reduce(CGarbageCollector& gc, CField& thisField) const;
+      virtual std::shared_ptr<COutputPin> reduce(CGarbageCollector& gc, CField& thisField) const;
     private:
 …
       CFilterScalarFieldOpExprNode(IScalarExprNode* child1, const std::string& opId, IFilterExprNode* child2);
       virtual boost::shared_ptr<COutputPin> reduce(CGarbageCollector& gc, CField& thisField) const;
+      virtual std::shared_ptr<COutputPin> reduce(CGarbageCollector& gc, CField& thisField) const;
     private:
 …
       CFilterFieldScalarOpExprNode(IFilterExprNode* child1, const std::string& opId, IScalarExprNode* child2);
       virtual boost::shared_ptr<COutputPin> reduce(CGarbageCollector& gc, CField& thisField) const;
+      virtual std::shared_ptr<COutputPin> reduce(CGarbageCollector& gc, CField& thisField) const;
     private:
 …
       CFilterFieldFieldOpExprNode(IFilterExprNode* child1, const std::string& opId, IFilterExprNode* child2);
       virtual boost::shared_ptr<COutputPin> reduce(CGarbageCollector& gc, CField& thisField) const;
+      virtual std::shared_ptr<COutputPin> reduce(CGarbageCollector& gc, CField& thisField) const;
     private:
 …
       CFilterScalarScalarFieldOpExprNode(IScalarExprNode* child1, const std::string& opId, IScalarExprNode* child2, IFilterExprNode* child3);
       virtual boost::shared_ptr<COutputPin> reduce(CGarbageCollector& gc, CField& thisField) const;
+      virtual std::shared_ptr<COutputPin> reduce(CGarbageCollector& gc, CField& thisField) const;
     private:
 …
       CFilterScalarFieldScalarOpExprNode(IScalarExprNode* child1, const std::string& opId, IFilterExprNode* child2, IScalarExprNode* child3);
       virtual boost::shared_ptr<COutputPin> reduce(CGarbageCollector& gc, CField& thisField) const;
+      virtual std::shared_ptr<COutputPin> reduce(CGarbageCollector& gc, CField& thisField) const;
     private:
 …
       CFilterScalarFieldFieldOpExprNode(IScalarExprNode* child1, const std::string& opId, IFilterExprNode* child2, IFilterExprNode* child3);
       virtual boost::shared_ptr<COutputPin> reduce(CGarbageCollector& gc, CField& thisField) const;
+      virtual std::shared_ptr<COutputPin> reduce(CGarbageCollector& gc, CField& thisField) const;
     private:
 …
       CFilterFieldScalarScalarOpExprNode(IFilterExprNode* child1, const std::string& opId, IScalarExprNode* child2, IScalarExprNode* child3);
       virtual boost::shared_ptr<COutputPin> reduce(CGarbageCollector& gc, CField& thisField) const;
+      virtual std::shared_ptr<COutputPin> reduce(CGarbageCollector& gc, CField& thisField) const;
     private:
 …
       CFilterFieldScalarFieldOpExprNode(IFilterExprNode* child1, const std::string& opId, IScalarExprNode* child2, IFilterExprNode* child3);
       virtual boost::shared_ptr<COutputPin> reduce(CGarbageCollector& gc, CField& thisField) const;
+      virtual std::shared_ptr<COutputPin> reduce(CGarbageCollector& gc, CField& thisField) const;
     private:
 …
       CFilterFieldFieldScalarOpExprNode(IFilterExprNode* child1, const std::string& opId, IFilterExprNode* child2, IScalarExprNode* child3);
       virtual boost::shared_ptr<COutputPin> reduce(CGarbageCollector& gc, CField& thisField) const;
+      virtual std::shared_ptr<COutputPin> reduce(CGarbageCollector& gc, CField& thisField) const;
     private:
 …
       CFilterFieldFieldFieldOpExprNode(IFilterExprNode* child1, const std::string& opId, IFilterExprNode* child2, IFilterExprNode* child3);
       virtual boost::shared_ptr<COutputPin> reduce(CGarbageCollector& gc, CField& thisField) const;
+      virtual std::shared_ptr<COutputPin> reduce(CGarbageCollector& gc, CField& thisField) const;
     private:

XIOS/trunk/src/server.cpp

r1519	r1542
791	791	if (!fb->is_open())
792	792	ERROR("void CServer::openStream(const StdString& fileName, const StdString& ext, std::filebuf* fb)",
793		<< std::endl << "Can not open <" << fileNameClient << "> file to write the server log(s).");
	793	<< std::endl << "Can not open <" << fileNameClient.str() << "> file to write the server log(s).");
794	794	}
795	795

XIOS/trunk/src/server_distribution_description.cpp

-                      r1312
+                      r1542
   \param [in] positionDimensionDistributed dimension of server on which we make the cut.
 */
 std::vector<int> CServerDistributionDescription::computeServerGlobalByElement(std::vector<boost::unordered_map<size_t,std::vector<int> > >& indexServerOnElement,
+std::vector<int> CServerDistributionDescription::computeServerGlobalByElement(std::vector<std::unordered_map<size_t,std::vector<int> > >& indexServerOnElement,
                                                                               int clientRank,
                                                                               int clientSize,
 …
   Get global index calculated by computeServerGlobalIndexInRange
 */
 const boost::unordered_map<size_t,int>& CServerDistributionDescription::getGlobalIndexRange() const
+const std::unordered_map<size_t,int>& CServerDistributionDescription::getGlobalIndexRange() const
+{
   return globalIndex_;

XIOS/trunk/src/server_distribution_description.hpp

-                      r1258
+                      r1542
 #include "xios_spl.hpp"
 #include "array_new.hpp"
 #include <boost/unordered_map.hpp>
+#include <unordered_map>
 namespace xios
 …
     void computeServerDistribution(bool doComputeGlobalIndex = false, int positionDimensionDistributed = 1);
     std::vector<int> computeServerGlobalIndexInRange(const std::pair<size_t, size_t>& indexBeginEnd, int positionDimensionDistributed = 1);
     std::vector<int> computeServerGlobalByElement(std::vector<boost::unordered_map<size_t,std::vector<int> > >& indexServerOnElement,
+    std::vector<int> computeServerGlobalByElement(std::vector<std::unordered_map<size_t,std::vector<int> > >& indexServerOnElement,
                                                   int rank,
                                                   int clientSize,
 …
     std::vector<std::vector<int> > getServerDimensionSizes() const;
     const std::vector<CArray<size_t,1> >& getGlobalIndex() const;
     const boost::unordered_map<size_t,int>& getGlobalIndexRange() const;
+    const std::unordered_map<size_t,int>& getGlobalIndexRange() const;
     int getDimensionDistributed();
 …
     //!< In case we need only global index of one server with specific rank
     boost::unordered_map<size_t,int> globalIndex_;
+    std::unordered_map<size_t,int> globalIndex_;
     //!< Type of distribution on server side

XIOS/trunk/src/transformation/axis_algorithm_inverse.cpp

-                      r936
+                      r1542
+  }
   typedef boost::unordered_map<size_t, std::vector<double> > GlobalIndexMapFromSrcToDest;
+  typedef std::unordered_map<size_t, std::vector<double> > GlobalIndexMapFromSrcToDest;
   GlobalIndexMapFromSrcToDest globalIndexMapFromSrcToDest;
   TransformationIndexMap& transMap = this->transformationMapping_[0];
 …
   dhtIndexProcRank.computeIndexInfoMapping(globalSrcIndex);
   CClientClientDHTInt::Index2VectorInfoTypeMap& computedGlobalIndexOnProc = dhtIndexProcRank.getInfoIndexMap();
   boost::unordered_map<int, std::vector<size_t> > globalSrcIndexSendToProc;
+  std::unordered_map<int, std::vector<size_t> > globalSrcIndexSendToProc;
   for (int idx = 0; idx < localIndex; ++idx)
+  {
 …
+  }
   boost::unordered_map<int, std::vector<size_t> >::const_iterator itbIndex = globalSrcIndexSendToProc.begin(), itIndex,
+  std::unordered_map<int, std::vector<size_t> >::const_iterator itbIndex = globalSrcIndexSendToProc.begin(), itIndex,
                                                                   iteIndex = globalSrcIndexSendToProc.end();
   std::map<int,int> sendRankSizeMap,recvRankSizeMap;
 …
   std::vector<MPI_Request> requests;
   std::vector<MPI_Status> status;
   boost::unordered_map<int, unsigned long* > recvGlobalIndexSrc;
   boost::unordered_map<int, double* > sendValueToDest;
+  std::unordered_map<int, unsigned long* > recvGlobalIndexSrc;
+  std::unordered_map<int, double* > sendValueToDest;
   for (std::map<int,int>::const_iterator itRecv = recvRankSizeMap.begin(); itRecv != recvRankSizeMap.end(); ++itRecv)
+  {
 …
+  }
   boost::unordered_map<int, unsigned long* > sendGlobalIndexSrc;
   boost::unordered_map<int, double* > recvValueFromSrc;
+  std::unordered_map<int, unsigned long* > sendGlobalIndexSrc;
+  std::unordered_map<int, double* > recvValueFromSrc;
   for (itIndex = itbIndex; itIndex != iteIndex; ++itIndex)
+  {
 …
   delete [] recvSizeBuff;
   boost::unordered_map<int, double* >::const_iterator itChar;
+  std::unordered_map<int, double* >::const_iterator itChar;
   for (itChar = sendValueToDest.begin(); itChar != sendValueToDest.end(); ++itChar)
     delete [] itChar->second;
   for (itChar = recvValueFromSrc.begin(); itChar != recvValueFromSrc.end(); ++itChar)
     delete [] itChar->second;
   boost::unordered_map<int, unsigned long* >::const_iterator itLong;
+  std::unordered_map<int, unsigned long* >::const_iterator itLong;
   for (itLong = sendGlobalIndexSrc.begin(); itLong != sendGlobalIndexSrc.end(); ++itLong)
     delete [] itLong->second;

XIOS/trunk/src/transformation/domain_algorithm_interpolate.cpp

-                      r1480
+                      r1542
  */
 #include "domain_algorithm_interpolate.hpp"
 #include <boost/unordered_map.hpp>
+#include <unordered_map>
 #include "context.hpp"
 #include "context_client.hpp"
 …
   TransformationWeightMap& transWeight = this->transformationWeight_[0];
   boost::unordered_map<size_t,int> globalIndexOfDomainDest;
+  std::unordered_map<size_t,int> globalIndexOfDomainDest;
   int ni = domainDest_->ni.getValue();
   int nj = domainDest_->nj.getValue();

XIOS/trunk/src/transformation/generic_algorithm_transformation.cpp

-                      r1480
+                      r1542
   int nbClient = client->clientSize;
   typedef boost::unordered_map<int, std::vector<std::pair<int,double> > > SrcToDstMap;
+  typedef std::unordered_map<int, std::vector<std::pair<int,double> > > SrcToDstMap;
   int idx;
 …
         if (idx != elementPositionInGrid)
+        {
           boost::unordered_map<int,std::vector<size_t> >::iterator itb = globalElementIndexOnProc_[idx].begin(), it,
+          std::unordered_map<int,std::vector<size_t> >::iterator itb = globalElementIndexOnProc_[idx].begin(), it,
                                                                    ite = globalElementIndexOnProc_[idx].end();
           for (it = itb; it != ite; ++it) it->second.resize(1);
 …
         if (idx != elementPositionInGrid)
+        {
           boost::unordered_map<int,std::vector<size_t> >::iterator itb = globalElementIndexOnProc_[idx].begin(), it,
+          std::unordered_map<int,std::vector<size_t> >::iterator itb = globalElementIndexOnProc_[idx].begin(), it,
                                                                    ite = globalElementIndexOnProc_[idx].end();
           for (it = itb; it != ite; ++it) procOfNonTransformedElements_.insert(it->first);
 …
           set<int> tmpSet ;
           procList.swap(tmpSet) ;
           boost::unordered_map<int,std::vector<size_t> >::iterator itb = globalElementIndexOnProc_[idx].begin(), it,
+          std::unordered_map<int,std::vector<size_t> >::iterator itb = globalElementIndexOnProc_[idx].begin(), it,
                                                                    ite = globalElementIndexOnProc_[idx].end();
           for (it = itb; it != ite; ++it)
 …
     // Build mapping between global source element index and global destination element index.
     boost::unordered_map<int,std::vector<size_t> >().swap(globalElementIndexOnProc_[elementPositionInGrid]);
+    std::unordered_map<int,std::vector<size_t> >().swap(globalElementIndexOnProc_[elementPositionInGrid]);
     std::set<int> tmpCounter;
     itTransWeight = itbTransWeight;
 …
         if (idx != elementPositionInGrid)
+        {
           boost::unordered_map<int,std::vector<size_t> >::iterator itb = globalElementIndexOnProc_[idx].begin(), it,
+          std::unordered_map<int,std::vector<size_t> >::iterator itb = globalElementIndexOnProc_[idx].begin(), it,
                                                                    ite = globalElementIndexOnProc_[idx].end();
           for (it = itb; it != ite; ++it) it->second[0] = transPos(idxTrans);
 …
 void CGenericAlgorithmTransformation::computeGlobalGridIndexMapping(int elementPositionInGrid,
                                                                    const std::vector<int>& srcRank,
                                                                    boost::unordered_map<int, std::vector<std::pair<int,double> > >& src2DstMap,
+                                                                   std::unordered_map<int, std::vector<std::pair<int,double> > >& src2DstMap,
                                                                    CGrid* gridSrc,
                                                                    CGrid* gridDst,
                                                                    std::vector<boost::unordered_map<int,std::vector<size_t> > >& globalElementIndexOnProc,
+                                                                   std::vector<std::unordered_map<int,std::vector<size_t> > >& globalElementIndexOnProc,
                                                                    SourceDestinationIndexMap& globaIndexWeightFromSrcToDst)
+{
 …
       SourceDestinationIndexMap::iterator rankIt,rankIte ;
       boost::unordered_map<size_t, std::vector<std::pair<size_t,double> > >::iterator globalSrcIndexIt, globalSrcIndexIte ;
+      std::unordered_map<size_t, std::vector<std::pair<size_t,double> > >::iterator globalSrcIndexIt, globalSrcIndexIte ;
       std::vector<std::pair<size_t,double> >::iterator vectIt,vectIte ;
 …
                                                                  CScalar* scalarSrc,
                                                                  CArray<size_t,1>& destGlobalIndexPositionInGrid,
                                                                  boost::unordered_map<int,std::vector<size_t> >& globalScalarIndexOnProc)
+                                                                 std::unordered_map<int,std::vector<size_t> >& globalScalarIndexOnProc)
+{
   CContext* context = CContext::getCurrent();
 …
                                                                CAxis* axisSrc,
                                                                CArray<size_t,1>& destGlobalIndexPositionInGrid,
                                                                boost::unordered_map<int,std::vector<size_t> >& globalAxisIndexOnProc)
+                                                               std::unordered_map<int,std::vector<size_t> >& globalAxisIndexOnProc)
+{
   CContext* context = CContext::getCurrent();
 …
                                                                  CDomain* domainSrc,
                                                                  CArray<size_t,1>& destGlobalIndexPositionInGrid,
                                                                  boost::unordered_map<int,std::vector<size_t> >& globalDomainIndexOnProc)
+                                                                 std::unordered_map<int,std::vector<size_t> >& globalDomainIndexOnProc)
+{
   CContext* context = CContext::getCurrent();

XIOS/trunk/src/transformation/generic_algorithm_transformation.hpp

-                      r1420
+                      r1542
 public:
   // Mapping between global index map of DESTINATION and its local index with pair of global index of SOURCE and weights
   typedef boost::unordered_map<int, boost::unordered_map<size_t, std::vector<std::pair<size_t,double> > > > SourceDestinationIndexMap;
+  typedef std::unordered_map<int, std::unordered_map<size_t, std::vector<std::pair<size_t,double> > > > SourceDestinationIndexMap;
 protected:
   typedef boost::unordered_map<size_t,int> GlobalLocalMap;
+  typedef std::unordered_map<size_t,int> GlobalLocalMap;
 protected:
   typedef boost::unordered_map<int, std::vector<int> > TransformationIndexMap;
   typedef boost::unordered_map<int, std::vector<double> > TransformationWeightMap;
   typedef boost::unordered_map<int, std::vector<int> > TransformationPositionMap;
+  typedef std::unordered_map<int, std::vector<int> > TransformationIndexMap;
+  typedef std::unordered_map<int, std::vector<double> > TransformationWeightMap;
+  typedef std::unordered_map<int, std::vector<int> > TransformationPositionMap;
 public:
 …
   void computeGlobalGridIndexMapping(int elementPositionInGrid,
                                      const std::vector<int>& srcRank,
                                      boost::unordered_map<int, std::vector<std::pair<int,double> > >& src2DstMap,
+                                     std::unordered_map<int, std::vector<std::pair<int,double> > >& src2DstMap,
                                      CGrid* gridDst,
                                      CGrid* gridSrc,
                                      std::vector<boost::unordered_map<int,std::vector<size_t> > >& globalElementIndexOnProc,
+                                     std::vector<std::unordered_map<int,std::vector<size_t> > >& globalElementIndexOnProc,
                                      SourceDestinationIndexMap& globaIndexWeightFromSrcToDst);
 …
                                   CDomain* domainSrc,
                                   CArray<size_t,1>& destGlobalIndexPositionInGrid,
                                   boost::unordered_map<int,std::vector<size_t> >& globalDomainIndexOnProc);
+                                  std::unordered_map<int,std::vector<size_t> >& globalDomainIndexOnProc);
   void computeExchangeAxisIndex(CAxis* axisDst,
                                 CAxis* axisSrc,
                                 CArray<size_t,1>& destGlobalIndexPositionInGrid,
                                 boost::unordered_map<int,std::vector<size_t> >& globalAxisIndexOnProc);
+                                std::unordered_map<int,std::vector<size_t> >& globalAxisIndexOnProc);
   void computeExchangeScalarIndex(CScalar* scalarDst,
                                   CScalar* scalarSrc,
                                   CArray<size_t,1>& destGlobalIndexPositionInGrid,
                                   boost::unordered_map<int,std::vector<size_t> >& globalScalarIndexOnProc);
+                                  std::unordered_map<int,std::vector<size_t> >& globalScalarIndexOnProc);
   void computePositionElements(CGrid* dst, CGrid* src);
 …
   std::set<StdSize> indexElementSrc_;
   std::vector<boost::unordered_map<int,std::vector<size_t> > > globalElementIndexOnProc_;
+  std::vector<std::unordered_map<int,std::vector<size_t> > > globalElementIndexOnProc_;
   std::vector<int> procContainSrcElementIdx_;  // List of processes containing source index of transformed elements

XIOS/trunk/src/transformation/grid_transformation.cpp

-                      r1412
+                      r1542
 #include "mpi_tag.hpp"
 #include "grid.hpp"
 #include <boost/unordered_map.hpp>
+#include <unordered_map>
 #include "timer.hpp"
 …
   SourceDestinationIndexMap::const_iterator itbIndex = globaIndexWeightFromSrcToDst.begin(),
                                             iteIndex = globaIndexWeightFromSrcToDst.end(), itIndex;
   typedef boost::unordered_map<size_t, std::vector<std::pair<size_t,double> > > SendIndexMap;
+  typedef std::unordered_map<size_t, std::vector<std::pair<size_t,double> > > SendIndexMap;
   std::map<int,int> sendRankSizeMap,recvRankSizeMap;
   int connectedClient = globaIndexWeightFromSrcToDst.size();
 …
   std::vector<MPI_Request> requests;
   std::vector<MPI_Status> status;
   boost::unordered_map<int, unsigned char* > recvMaskDst;
   boost::unordered_map<int, unsigned long* > recvGlobalIndexSrc;
+  std::unordered_map<int, unsigned char* > recvMaskDst;
+  std::unordered_map<int, unsigned long* > recvGlobalIndexSrc;
   for (std::map<int,int>::const_iterator itRecv = recvRankSizeMap.begin(); itRecv != recvRankSizeMap.end(); ++itRecv)
+  {
 …
+  }
   boost::unordered_map<int, CArray<size_t,1> > globalIndexDst;
   boost::unordered_map<int, CArray<double,1> > weightDst;
   boost::unordered_map<int, unsigned char* > sendMaskDst;
   boost::unordered_map<int, unsigned long* > sendGlobalIndexSrc;
+  std::unordered_map<int, CArray<size_t,1> > globalIndexDst;
+  std::unordered_map<int, CArray<double,1> > weightDst;
+  std::unordered_map<int, unsigned char* > sendMaskDst;
+  std::unordered_map<int, unsigned long* > sendGlobalIndexSrc;
   for (itIndex = itbIndex; itIndex != iteIndex; ++itIndex)
+  {
 …
   delete [] recvSizeBuff;
   boost::unordered_map<int, unsigned char* >::const_iterator itChar;
+  std::unordered_map<int, unsigned char* >::const_iterator itChar;
   for (itChar = sendMaskDst.begin(); itChar != sendMaskDst.end(); ++itChar)
     delete [] itChar->second;
   for (itChar = recvMaskDst.begin(); itChar != recvMaskDst.end(); ++itChar)
     delete [] itChar->second;
   boost::unordered_map<int, unsigned long* >::const_iterator itLong;
+  std::unordered_map<int, unsigned long* >::const_iterator itLong;
   for (itLong = sendGlobalIndexSrc.begin(); itLong != sendGlobalIndexSrc.end(); ++itLong)
     delete [] itLong->second;

XIOS/trunk/src/xios_spl.hpp

-                      r1158
+                      r1542
 #include <string>
 #include <algorithm>
+#include <unordered_map>
+#include <memory>
 // standard C
 …
 /// boost headers ///
-#include <boost/unordered_map.hpp>
-#include <boost/shared_ptr.hpp>
 #include <boost/cast.hpp>
 /// Map ///

Context Navigation

Legend:

Download in other formats: