From 3fd74cfc4c5a28402ac083002edc7b50657704ab Mon Sep 17 00:00:00 2001
From: Christian Zimmermann <christian.zimmermann@ur.de>
Date: Mon, 17 Sep 2018 11:06:24 +0200
Subject: [PATCH] some fixes

---
 src/include/map_range.h          | 14 ++++++++++++++
 src/include/ranges/x_to_string.h | 21 +++++++++++++++++++++
 src/include/type_operations.h    | 23 +++++++++++++++++++++++
 3 files changed, 58 insertions(+)

diff --git a/src/include/map_range.h b/src/include/map_range.h
index a3aea41..16d17e7 100644
--- a/src/include/map_range.h
+++ b/src/include/map_range.h
@@ -124,6 +124,9 @@ namespace MultiArrayTools
 	template <size_t N>
 	auto getPtr() const -> decltype( std::get<N>( mIPack ) )&;
 
+	template <size_t N>
+	size_t getBlockSize() const { return std::get<N>(mBlockSizes); }
+	
 	std::shared_ptr<OIType> outIndex() const;
 	
 	// raplace instances (in contrast to its analogon in ContainerIndex
@@ -262,6 +265,8 @@ namespace MultiArrayTools
 	virtual IndexType end() const final;
 
 	const MultiArray<size_t,ORType>& mapMultiplicity() const;
+	MultiArray<size_t,MapRange> explMapMultiplicity() const;
+
 	
 	template <class... ERanges>
 	auto cat(const std::shared_ptr<MapRange<ERanges...> >& erange)
@@ -762,6 +767,15 @@ namespace MultiArrayTools
     {
 	return mMapMult;
     }
+
+    template <class MapF, class... Ranges>
+    auto MapRange<MapF,Ranges...>::explMapMultiplicity() const
+	-> MultiArray<size_t,MapRange>
+    {
+	auto tmp = mMapMult;
+	return tmp.format( std::dynamic_pointer_cast<MapRange<MapF,Ranges...> >
+			   ( std::shared_ptr<RangeBase>( RB::mThis )) ); 
+    }
     
     template <class MapF, class... Ranges>
     template <class... ERanges>
diff --git a/src/include/ranges/x_to_string.h b/src/include/ranges/x_to_string.h
index 77722b2..d3e6ac2 100644
--- a/src/include/ranges/x_to_string.h
+++ b/src/include/ranges/x_to_string.h
@@ -9,6 +9,27 @@
 
 namespace MultiArrayHelper
 {
+    template <typename T>
+    inline std::string xToString(const T& x);
+
+
+    template <>
+    inline std::string xToString<char>(const char& x);
+
+    template <>
+    inline std::string xToString<std::string>(const std::string& x);
+
+    template <typename T>
+    inline std::string xToString(const std::vector<T>& x);
+
+    template <typename T, size_t N>
+    inline std::string xToString(const std::array<T,N>& x);
+
+    template <typename... Ts>
+    inline std::string xToString(const std::tuple<Ts...>& tp);
+
+    // TEMPLATE CODE
+
     template <typename T>
     inline std::string xToString(const T& x)
     {
diff --git a/src/include/type_operations.h b/src/include/type_operations.h
index 24e634b..6870dac 100644
--- a/src/include/type_operations.h
+++ b/src/include/type_operations.h
@@ -101,6 +101,29 @@ namespace MultiArrayTools
 	friend OperationClass;
     };
 
+    inline std::array<int,2>& operator+=(std::array<int,2>& a, const std::array<int,2>& b)
+    {
+	std::get<0>(a) += std::get<0>(b);
+	std::get<1>(a) += std::get<1>(b);
+	return a;
+    }
+    
+    inline std::array<int,3>& operator+=(std::array<int,3>& a, const std::array<int,3>& b)
+    {
+	std::get<0>(a) += std::get<0>(b);
+	std::get<1>(a) += std::get<1>(b);
+	std::get<2>(a) += std::get<2>(b);
+	return a;
+    }
+    
+    inline std::tuple<int,int,int>& operator+=(std::tuple<int,int,int>& a, const std::tuple<int,int,int>& b)
+    {
+	std::get<0>(a) += std::get<0>(b);
+	std::get<1>(a) += std::get<1>(b);
+	std::get<2>(a) += std::get<2>(b);
+	return a;
+    }
+
 } // namespace MultiArrayTools
 
 #endif