Update pre-commit to fixed versions, run remod for ck_tile (#2895)

* Fix ruff linter errors

* Fix remod dos2unix command

* Clang format

* Ignore utility in remod

* Run remod

* Specify clang-format version in pre-commit

* Specify ruff version

* Include PoolKernelArgs in reference_pool

* Add calculate_total_elements to reference batched contraction

* Fix calculate_total_elements declaration

* Refactor remod pre-commit hook

* Fix Aquant tests

---------

Co-authored-by: Illia Silin <98187287+illsilin@users.noreply.github.com>

include/rapidjson/stream.h

@@ -69,34 +69,41 @@ concept Stream {
     For custom stream, this type can be specialized for other configuration.
     See TEST(Reader, CustomStringStream) in readertest.cpp for example.
 */
-template<typename Stream>
-struct StreamTraits {
+template <typename Stream>
+struct StreamTraits
+{
     //! Whether to make local copy of stream for optimization during parsing.
     /*!
         By default, for safety, streams do not use local copy optimization.
         Stream that can be copied fast should specialize this, like StreamTraits<StringStream>.
     */
-    enum { copyOptimization = 0 };
+    enum
+    {
+        copyOptimization = 0
+    };
 };
 
 //! Reserve n characters for writing to a stream.
-template<typename Stream>
-inline void PutReserve(Stream& stream, size_t count) {
+template <typename Stream>
+inline void PutReserve(Stream& stream, size_t count)
+{
     (void)stream;
     (void)count;
 }
 
 //! Write character to a stream, presuming buffer is reserved.
-template<typename Stream>
-inline void PutUnsafe(Stream& stream, typename Stream::Ch c) {
+template <typename Stream>
+inline void PutUnsafe(Stream& stream, typename Stream::Ch c)
+{
     stream.Put(c);
 }
 
 //! Put N copies of a character to a stream.
-template<typename Stream, typename Ch>
-inline void PutN(Stream& stream, Ch c, size_t n) {
+template <typename Stream, typename Ch>
+inline void PutN(Stream& stream, Ch c, size_t n)
+{
     PutReserve(stream, n);
-    for (size_t i = 0; i < n; i++)
+    for(size_t i = 0; i < n; i++)
         PutUnsafe(stream, c);
 }
 
@@ -111,15 +118,16 @@ inline void PutN(Stream& stream, Ch c, size_t n) {
 
 #if defined(_MSC_VER) && _MSC_VER <= 1800
 RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(4702)  // unreachable code
-RAPIDJSON_DIAG_OFF(4512)  // assignment operator could not be generated
+RAPIDJSON_DIAG_OFF(4702) // unreachable code
+RAPIDJSON_DIAG_OFF(4512) // assignment operator could not be generated
 #endif
 
-template <typename InputStream, typename Encoding = UTF8<> >
-class GenericStreamWrapper {
-public:
+template <typename InputStream, typename Encoding = UTF8<>>
+class GenericStreamWrapper
+{
+    public:
     typedef typename Encoding::Ch Ch;
-    GenericStreamWrapper(InputStream& is): is_(is) {}
+    GenericStreamWrapper(InputStream& is) : is_(is) {}
 
     Ch Peek() const { return is_.Peek(); }
     Ch Take() { return is_.Take(); }
@@ -136,7 +144,7 @@ public:
     UTFType GetType() const { return is_.GetType(); }
     bool HasBOM() const { return is_.HasBOM(); }
 
-protected:
+    protected:
     InputStream& is_;
 };
 
@@ -149,33 +157,46 @@ RAPIDJSON_DIAG_POP
 
 //! Read-only string stream.
 /*! \note implements Stream concept
-*/
+ */
 template <typename Encoding>
-struct GenericStringStream {
+struct GenericStringStream
+{
     typedef typename Encoding::Ch Ch;
 
-    GenericStringStream(const Ch *src) : src_(src), head_(src) {}
+    GenericStringStream(const Ch* src) : src_(src), head_(src) {}
 
     Ch Peek() const { return *src_; }
     Ch Take() { return *src_++; }
     size_t Tell() const { return static_cast<size_t>(src_ - head_); }
 
-    Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
+    Ch* PutBegin()
+    {
+        RAPIDJSON_ASSERT(false);
+        return 0;
+    }
     void Put(Ch) { RAPIDJSON_ASSERT(false); }
     void Flush() { RAPIDJSON_ASSERT(false); }
-    size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; }
+    size_t PutEnd(Ch*)
+    {
+        RAPIDJSON_ASSERT(false);
+        return 0;
+    }
 
-    const Ch* src_;     //!< Current read position.
-    const Ch* head_;    //!< Original head of the string.
+    const Ch* src_;  //!< Current read position.
+    const Ch* head_; //!< Original head of the string.
 };
 
 template <typename Encoding>
-struct StreamTraits<GenericStringStream<Encoding> > {
-    enum { copyOptimization = 1 };
+struct StreamTraits<GenericStringStream<Encoding>>
+{
+    enum
+    {
+        copyOptimization = 1
+    };
 };
 
 //! String stream with UTF8 encoding.
-typedef GenericStringStream<UTF8<> > StringStream;
+typedef GenericStringStream<UTF8<>> StringStream;
 
 ///////////////////////////////////////////////////////////////////////////////
 // InsituStringStream
@@ -185,10 +206,11 @@ typedef GenericStringStream<UTF8<> > StringStream;
     \note implements Stream concept
 */
 template <typename Encoding>
-struct GenericInsituStringStream {
+struct GenericInsituStringStream
+{
     typedef typename Encoding::Ch Ch;
 
-    GenericInsituStringStream(Ch *src) : src_(src), dst_(0), head_(src) {}
+    GenericInsituStringStream(Ch* src) : src_(src), dst_(0), head_(src) {}
 
     // Read
     Ch Peek() { return *src_; }
@@ -196,13 +218,22 @@ struct GenericInsituStringStream {
     size_t Tell() { return static_cast<size_t>(src_ - head_); }
 
     // Write
-    void Put(Ch c) { RAPIDJSON_ASSERT(dst_ != 0); *dst_++ = c; }
+    void Put(Ch c)
+    {
+        RAPIDJSON_ASSERT(dst_ != 0);
+        *dst_++ = c;
+    }
 
     Ch* PutBegin() { return dst_ = src_; }
     size_t PutEnd(Ch* begin) { return static_cast<size_t>(dst_ - begin); }
     void Flush() {}
 
-    Ch* Push(size_t count) { Ch* begin = dst_; dst_ += count; return begin; }
+    Ch* Push(size_t count)
+    {
+        Ch* begin = dst_;
+        dst_ += count;
+        return begin;
+    }
     void Pop(size_t count) { dst_ -= count; }
 
     Ch* src_;
@@ -211,12 +242,16 @@ struct GenericInsituStringStream {
 };
 
 template <typename Encoding>
-struct StreamTraits<GenericInsituStringStream<Encoding> > {
-    enum { copyOptimization = 1 };
+struct StreamTraits<GenericInsituStringStream<Encoding>>
+{
+    enum
+    {
+        copyOptimization = 1
+    };
 };
 
 //! Insitu string stream with UTF8 encoding.
-typedef GenericInsituStringStream<UTF8<> > InsituStringStream;
+typedef GenericInsituStringStream<UTF8<>> InsituStringStream;
 
 RAPIDJSON_NAMESPACE_END