diff --git a/io/xml/src/TBufferXML.cxx b/io/xml/src/TBufferXML.cxx
index dd40d7634c9f6..69b60435380b6 100644
--- a/io/xml/src/TBufferXML.cxx
+++ b/io/xml/src/TBufferXML.cxx
@@ -41,7 +41,6 @@
 #include "TStreamer.h"
 #include "TStreamerInfoActions.h"
 #include "RZip.h"
-#include <string>
 
 #ifdef R__VISUAL_CPLUSPLUS
 #define FLong64    "%I64d"
@@ -1433,16 +1432,27 @@ void TBufferXML::BeforeIOoperation()
 //______________________________________________________________________________
 TClass* TBufferXML::ReadClass(const TClass*, UInt_t*)
 {
-   // suppressed function of TBuffer
+   // function to read class from buffer, used in old-style streamers
 
-   return 0;
+   const char* clname = 0;
+
+   if (VerifyItemNode(xmlio::Class)) {
+      clname = XmlReadValue(xmlio::Class);
+   }
+
+   if (gDebug>2) Info("ReadClass", "Try to read class %s", clname ? clname : "---");
+
+   return clname ? gROOT->GetClass(clname) : 0;
 }
 
 //______________________________________________________________________________
-void TBufferXML::WriteClass(const TClass*)
+void TBufferXML::WriteClass(const TClass* cl)
 {
-   // suppressed function of TBuffer
+   // function to write class into buffer, used in old-style streamers
+
+   if (gDebug>2) Info("WriteClass", "Try to write class %s", cl->GetName());
 
+   XmlWriteValue(cl->GetName(), xmlio::Class);
 }
 
 //______________________________________________________________________________
diff --git a/net/http/src/TBufferJSON.cxx b/net/http/src/TBufferJSON.cxx
index e61f07520fe2b..3262a8462bc3b 100644
--- a/net/http/src/TBufferJSON.cxx
+++ b/net/http/src/TBufferJSON.cxx
@@ -32,7 +32,6 @@
 #include "TBufferJSON.h"
 
 #include <typeinfo>
-#include <string>
 
 #include "Compression.h"
 
@@ -395,8 +394,7 @@ TString TBufferJSON::JsonWriteMember(const void *ptr, TDataMember *member,
          while (cnt >= 0) {
             if (indexes[cnt] >= member->GetMaxIndex(cnt)) {
                fOutBuffer.Append(" ]");
-               indexes[cnt] = 0;
-               cnt--;
+               indexes[cnt--] = 0;
                if (cnt >= 0) indexes[cnt]++;
                continue;
             }
@@ -417,8 +415,6 @@ TString TBufferJSON::JsonWriteMember(const void *ptr, TDataMember *member,
 
                fValue.Clear();
 
-               WriteFastArray((Int_t *)ptr + shift, len);
-
                switch (tid) {
                   case kChar_t:
                      WriteFastArray((Char_t *)ptr + shift, len);
@@ -485,8 +481,7 @@ TString TBufferJSON::JsonWriteMember(const void *ptr, TDataMember *member,
                }
 
                fOutBuffer.Append(fValue);
-               cnt--;
-               indexes[cnt]++;
+               indexes[--cnt]++;
             }
          }
 
@@ -798,39 +793,41 @@ void TBufferJSON::JsonWriteObject(const void *obj, const TClass *cl, Bool_t chec
          }
 
       } else {
-         // write like blob values, but skipping first element with size
-         // TODO: make special handling for std::map, should pack each each pair in separate object
          const char* separ = "[";
-         TString blob;
 
-         for (Int_t k=1;k<=stack->fValues.GetLast();k++) {
-            blob.Append(separ); separ = fArraySepar.Data();
-            blob.Append(stack->fValues.At(k)->GetName());
+         if (fValue.Length() > 0) {
+            stack->fValues.Add(new TObjString(fValue));
+            fValue.Clear();
          }
 
-         if (fValue.Length()>0) {
-            blob.Append(separ);
-            blob.Append(fValue);
+         Int_t size = TString(stack->fValues.At(0)->GetName()).Atoi();
+
+         if ((size*2 == stack->fValues.GetLast()) &&
+              ((special_kind==TClassEdit::kMap) || (special_kind==TClassEdit::kMultiMap))) {
+            // special handling for std::map. Create entries like { 'first' : key, 'second' : value }
+            for (Int_t k=1;k<stack->fValues.GetLast();k+=2) {
+               fValue.Append(separ); separ = fArraySepar.Data();
+               fValue.Append("{");
+               fValue.Append("\"first\"");
+               fValue.Append(fSemicolon);
+               fValue.Append(stack->fValues.At(k)->GetName());
+               fValue.Append(fArraySepar);
+               fValue.Append("\"second\"");
+               fValue.Append(fSemicolon);
+               fValue.Append(stack->fValues.At(k+1)->GetName());
+               fValue.Append("}");
+            }
+         } else {
+            // for most stl containers write just like blob, but skipping first element with size
+            for (Int_t k=1;k<=stack->fValues.GetLast();k++) {
+               fValue.Append(separ); separ = fArraySepar.Data();
+               fValue.Append(stack->fValues.At(k)->GetName());
+            }
          }
 
-         blob.Append("]");
+         fValue.Append("]");
          stack->fValues.Delete();
-         fValue = blob;
-      }
-
-      /*
-      switch(isstlcont) {
-         case TClassEdit::kVector : break;
-         case TClassEdit::kList   : break;
-         case TClassEdit::kDeque  : break;
-         case TClassEdit::kMap    : break;
-         case TClassEdit::kMultiMap : break;
-         case TClassEdit::kSet : break;
-         case TClassEdit::kMultiSet : break;
-         case TClassEdit::kBitSet : break;
-         default: break;
       }
-      */
    }
 
    if ((special_kind==0) &&
@@ -2130,8 +2127,30 @@ void TBufferJSON::WriteArrayDouble32(const Double_t *d, Int_t n,
             }                                                                \
             PerformPostProcessing(Stack(0), elem);                           \
          }                                                                   \
-      }                                                                      \
-      else {                                                                 \
+      } else                                                                 \
+      if ((elem!=0) && (elem->GetArrayDim()>1) && (elem->GetArrayLength()==n)) { \
+         TArrayI indexes(elem->GetArrayDim() - 1);                           \
+         indexes.Reset(0);                                                   \
+         Int_t cnt = 0;                                                      \
+         while (cnt >= 0) {                                                  \
+            if (indexes[cnt] >= elem->GetMaxIndex(cnt)) {                    \
+               fValue.Append("]");                                           \
+               indexes[cnt--] = 0;                                           \
+               if (cnt >= 0) indexes[cnt]++;                                 \
+               continue;                                                     \
+            }                                                                \
+            fValue.Append(indexes[cnt] == 0 ? "[" : fArraySepar.Data());     \
+            if (++cnt == indexes.GetSize()) {                                \
+               Int_t shift = 0;                                              \
+               for (Int_t k = 0; k < indexes.GetSize(); k++)                 \
+                  shift = shift * elem->GetMaxIndex(k) + indexes[k];         \
+               Int_t len = elem->GetMaxIndex(indexes.GetSize());             \
+               shift *= len;                                                 \
+               TJSONWriteArrayContent((vname+shift), len);                   \
+               indexes[--cnt]++;                                             \
+            }                                                                \
+         }                                                                   \
+      } else {                                                               \
          TJSONWriteArrayContent(vname, n);                                   \
       }                                                                      \
    }