Merge pull request #1158 from arcaneframework/dev/gg-simplify-usage-of-text-reader-writer-v2

Simplify usage of TextReader2 and TextWriter2

Author: grospelliergilles

arcane/src/arcane/std/BasicGenericReader.cc

@@ -27,8 +27,6 @@
 #include "arcane/core/ISerializedData.h"
 #include "arcane/core/XmlNodeList.h"
 
-#include "arcane/std/internal/TextReader2.h"
-
 /*---------------------------------------------------------------------------*/
 /*---------------------------------------------------------------------------*/
 
@@ -230,24 +228,25 @@ readItemGroup(const String& group_full_name, Int64Array& written_unique_ids,
     }
     return;
   }
+
   info(5) << "READ GROUP " << group_full_name;
   String filename = BasicReaderWriterCommon::_getBasicGroupFile(m_path, group_full_name, m_rank);
-  TextReader2 reader(filename);
+  std::ifstream reader(filename.localstr(), std::ios::in | std::ios::binary);
 
   {
     Integer nb_unique_id = 0;
-    reader.readIntegers(IntegerArrayView(1, &nb_unique_id));
+    binaryRead(reader,asWritableBytes(SmallSpan<Integer>(&nb_unique_id, 1)));
     info(5) << "NB_WRITTEN_UNIQUE_ID = " << nb_unique_id;
     written_unique_ids.resize(nb_unique_id);
-    reader.read(asWritableBytes(written_unique_ids.span()));
+    binaryRead(reader,asWritableBytes(written_unique_ids.span()));
   }
 
   {
     Integer nb_unique_id = 0;
-    reader.readIntegers(IntegerArrayView(1, &nb_unique_id));
+    binaryRead(reader,asWritableBytes(SmallSpan<Integer>(&nb_unique_id, 1)));
     info(5) << "NB_WANTED_UNIQUE_ID = " << nb_unique_id;
     wanted_unique_ids.resize(nb_unique_id);
-    reader.read(asWritableBytes(wanted_unique_ids.span()));
+    binaryRead(reader,asWritableBytes(wanted_unique_ids.span()));
   }
 }
 

arcane/src/arcane/std/BasicGenericWriter.cc

@@ -25,8 +25,6 @@
 #include "arcane/core/ISerializedData.h"
 #include "arcane/core/IRessourceMng.h"
 
-#include "arcane/std/internal/TextWriter2.h"
-
 /*---------------------------------------------------------------------------*/
 /*---------------------------------------------------------------------------*/
 
@@ -119,20 +117,20 @@ writeItemGroup(const String& group_full_name, SmallSpan<const Int64> written_uni
   }
 
   String filename = BasicReaderWriterCommon::_getBasicGroupFile(m_path, group_full_name, m_rank);
-  TextWriter2 writer(filename);
+  ofstream writer(filename.localstr(),std::ios::out | std::ios::binary);
 
   // Sauve la liste des unique_ids écrits
   {
     Integer nb_unique_id = written_unique_ids.size();
-    writer.write(asBytes(Span<const Int32>(&nb_unique_id, 1)));
-    writer.write(asBytes(written_unique_ids));
+    binaryWrite(writer,asBytes(Span<const Int32>(&nb_unique_id, 1)));
+    binaryWrite(writer,asBytes(written_unique_ids));
   }
 
   // Sauve la liste des unique_ids souhaités par ce sous-domaine
   {
     Integer nb_unique_id = wanted_unique_ids.size();
-    writer.write(asBytes(Span<const Int32>(&nb_unique_id, 1)));
-    writer.write(asBytes(wanted_unique_ids));
+    binaryWrite(writer,asBytes(Span<const Int32>(&nb_unique_id, 1)));
+    binaryWrite(writer,asBytes(wanted_unique_ids));
   }
 }
 

arcane/src/arcane/std/TextReader2.cc

@@ -19,6 +19,7 @@
 #include "arcane/utils/Ref.h"
 #include "arcane/utils/FatalErrorException.h"
 #include "arcane/utils/IDataCompressor.h"
+#include "arcane/utils/FixedArray.h"
 
 #include "arcane/core/ArcaneException.h"
 
@@ -103,28 +104,28 @@ void TextReader2::
 read(Span<std::byte> values)
 {
   Int64 nb_value = values.size();
-  _binaryRead(values.data(), nb_value);
+  _binaryRead(values);
   _checkStream("byte[]", nb_value);
 }
 
 /*---------------------------------------------------------------------------*/
 /*---------------------------------------------------------------------------*/
 
 void TextReader2::
-_binaryRead(void* values, Int64 len)
+_binaryRead(Span<std::byte> values)
 {
   std::istream& s = m_p->m_istream;
   IDataCompressor* d = m_p->m_data_compressor.get();
-  if (d && len > d->minCompressSize()) {
+  if (d && values.size() > d->minCompressSize()) {
     UniqueArray<std::byte> compressed_values;
-    Int64 compressed_size = 0;
-    s.read((char*)&compressed_size, sizeof(Int64));
-    compressed_values.resize(compressed_size);
-    s.read((char*)compressed_values.data(), compressed_size);
-    m_p->m_data_compressor->decompress(compressed_values, Span<std::byte>((std::byte*)values, len));
+    FixedArray<Int64, 1> compressed_size;
+    binaryRead(s, asWritableBytes(compressed_size.span()));
+    compressed_values.resize(compressed_size[0]);
+    binaryRead(s, asWritableBytes(compressed_values));
+    m_p->m_data_compressor->decompress(compressed_values, values);
   }
   else {
-    s.read((char*)values, len);
+    binaryRead(s, values);
   }
 }
 

arcane/src/arcane/std/TextWriter2.cc

@@ -49,16 +49,7 @@ TextWriter2::
 TextWriter2(const String& filename)
 : m_p(new Impl())
 {
-  open(filename);
-}
-
-/*---------------------------------------------------------------------------*/
-/*---------------------------------------------------------------------------*/
-
-TextWriter2::
-TextWriter2()
-: m_p(new Impl())
-{
+  _open(filename);
 }
 
 /*---------------------------------------------------------------------------*/
@@ -74,7 +65,7 @@ TextWriter2::
 /*---------------------------------------------------------------------------*/
 
 void TextWriter2::
-open(const String& filename)
+_open(const String& filename)
 {
   m_p->m_filename = filename;
   std::ios::openmode mode = std::ios::out | std::ios::binary;
@@ -90,7 +81,7 @@ open(const String& filename)
 void TextWriter2::
 write(Span<const std::byte> values)
 {
-  _binaryWrite(values.data(), values.size());
+  _binaryWrite(values);
 }
 
 /*---------------------------------------------------------------------------*/
@@ -120,22 +111,25 @@ fileOffset()
   return m_p->m_ostream.tellp();
 }
 
+/*---------------------------------------------------------------------------*/
+/*---------------------------------------------------------------------------*/
+
 void TextWriter2::
-_binaryWrite(const void* bytes, Int64 len)
+_binaryWrite(Span<const std::byte> values)
 {
   std::ostream& o = m_p->m_ostream;
   //cout << "** BINARY WRITE len=" << len << " deflater=" << m_data_compressor << '\n';
   IDataCompressor* d = m_p->m_data_compressor.get();
-  if (d && len > d->minCompressSize()) {
+  if (d && values.size() > d->minCompressSize()) {
     UniqueArray<std::byte> compressed_values;
-    m_p->m_data_compressor->compress(Span<const std::byte>((const std::byte*)bytes, len), compressed_values);
+    m_p->m_data_compressor->compress(values, compressed_values);
     Int64 compressed_size = compressed_values.largeSize();
-    o.write((const char*)&compressed_size, sizeof(Int64));
-    o.write((const char*)compressed_values.data(), compressed_size);
+    binaryWrite(o, asBytes(SmallSpan<Int64>(&compressed_size, 1)));
+    binaryWrite(o, compressed_values);
     //cout << "** BINARY WRITE len=" << len << " compressed_len=" << compressed_size << '\n';
   }
   else
-    o.write((const char*)bytes, len);
+    binaryWrite(o, values);
 }
 
 /*---------------------------------------------------------------------------*/

arcane/src/arcane/std/internal/TextReader2.h

@@ -65,7 +65,7 @@ class TextReader2
 
  private:
 
-  void _binaryRead(void* bytes, Int64 len);
+  void _binaryRead(Span<std::byte> values);
   void _checkStream(const char* type, Int64 nb_read_value);
 };
 

arcane/src/arcane/std/internal/TextWriter2.h

@@ -42,13 +42,11 @@ class TextWriter2
 
   explicit TextWriter2(const String& filename);
   TextWriter2(const TextWriter2& rhs) = delete;
-  TextWriter2();
   ~TextWriter2();
   TextWriter2& operator=(const TextWriter2& rhs) = delete;
 
  public:
 
-  void open(const String& filename);
   void write(Span<const std::byte> values);
 
  public:
@@ -65,7 +63,8 @@ class TextWriter2
 
  private:
 
-  void _binaryWrite(const void* bytes, Int64 len);
+  void _open(const String& filename);
+  void _binaryWrite(Span<const std::byte> values);
 };
 
 /*---------------------------------------------------------------------------*/