Restoring authorship annotation for <thegeorg@yandex-team.ru>. Commit 2 of 2.

35 files changed, 7014 insertions, 7014 deletions

diff --git a/contrib/libs/apache/avro/api/AvroParse.hh b/contrib/libs/apache/avro/api/AvroParse.hh
index 999ff86122..dd2b98c419 100644
--- a/contrib/libs/apache/avro/api/AvroParse.hh
+++ b/contrib/libs/apache/avro/api/AvroParse.hh
@@ -1,85 +1,85 @@
-/* 
- * Licensed to the Apache Software Foundation (ASF) under one 
- * or more contributor license agreements.  See the NOTICE file 
- * distributed with this work for additional information 
- * regarding copyright ownership.  The ASF licenses this file 
- * to you under the Apache License, Version 2.0 (the 
- * "License"); you may not use this file except in compliance 
- * with the License.  You may obtain a copy of the License at 
- * 
- *     https://www.apache.org/licenses/LICENSE-2.0 
- * 
- * Unless required by applicable law or agreed to in writing, software 
- * distributed under the License is distributed on an "AS IS" BASIS, 
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
- * See the License for the specific language governing permissions and 
- * limitations under the License. 
- */ 
- 
-#ifndef avro_AvroParse_hh__ 
-#define avro_AvroParse_hh__ 
- 
-#include "Config.hh" 
-#include "AvroTraits.hh" 
-#include "ResolvingReader.hh" 
- 
-/// \file 
-/// 
-/// Standalone parse functions for Avro types. 
- 
-namespace avro { 
- 
-/// The main parse entry point function.  Takes a parser (either validating or 
-/// plain) and the object that should receive the parsed data. 
- 
-template <typename Reader, typename T> 
-void parse(Reader &p, T& val) 
-{ 
-    parse(p, val, is_serializable<T>()); 
-} 
- 
-template <typename T> 
-void parse(ResolvingReader &p, T& val) 
-{ 
-    translatingParse(p, val, is_serializable<T>()); 
-} 
- 
-/// Type trait should be set to is_serializable in otherwise force the compiler to complain. 
- 
-template <typename Reader, typename T> 
-void parse(Reader &p, T& val, const std::false_type &) 
-{ 
-    static_assert(sizeof(T) == 0, "Not a valid type to parse"); 
-} 
- 
-template <typename Reader, typename T> 
-void translatingParse(Reader &p, T& val, const std::false_type &) 
-{ 
-    static_assert(sizeof(T) == 0, "Not a valid type to parse"); 
-} 
- 
-// @{ 
- 
-/// The remainder of the file includes default implementations for serializable types. 
- 
- 
-template <typename Reader, typename T> 
-void parse(Reader &p, T &val, const std::true_type &) { 
-    p.readValue(val); 
-} 
- 
-template <typename Reader> 
-void parse(Reader &p, std::vector<uint8_t> &val, const std::true_type &) { 
-    p.readBytes(val); 
-} 
- 
-template<typename T> 
-void translatingParse(ResolvingReader &p, T& val, const std::true_type &) { 
-    p.parse(val); 
-} 
- 
-// @} 
- 
-} // namespace avro 
- 
-#endif 
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef avro_AvroParse_hh__
+#define avro_AvroParse_hh__
+
+#include "Config.hh"
+#include "AvroTraits.hh"
+#include "ResolvingReader.hh"
+
+/// \file
+///
+/// Standalone parse functions for Avro types.
+
+namespace avro {
+
+/// The main parse entry point function.  Takes a parser (either validating or
+/// plain) and the object that should receive the parsed data.
+
+template <typename Reader, typename T>
+void parse(Reader &p, T& val)
+{
+    parse(p, val, is_serializable<T>());
+}
+
+template <typename T>
+void parse(ResolvingReader &p, T& val)
+{
+    translatingParse(p, val, is_serializable<T>());
+}
+
+/// Type trait should be set to is_serializable in otherwise force the compiler to complain.
+
+template <typename Reader, typename T>
+void parse(Reader &p, T& val, const std::false_type &)
+{
+    static_assert(sizeof(T) == 0, "Not a valid type to parse");
+}
+
+template <typename Reader, typename T>
+void translatingParse(Reader &p, T& val, const std::false_type &)
+{
+    static_assert(sizeof(T) == 0, "Not a valid type to parse");
+}
+
+// @{
+
+/// The remainder of the file includes default implementations for serializable types.
+
+
+template <typename Reader, typename T>
+void parse(Reader &p, T &val, const std::true_type &) {
+    p.readValue(val);
+}
+
+template <typename Reader>
+void parse(Reader &p, std::vector<uint8_t> &val, const std::true_type &) {
+    p.readBytes(val);
+}
+
+template<typename T>
+void translatingParse(ResolvingReader &p, T& val, const std::true_type &) {
+    p.parse(val);
+}
+
+// @}
+
+} // namespace avro
+
+#endif
diff --git a/contrib/libs/apache/avro/api/AvroSerialize.hh b/contrib/libs/apache/avro/api/AvroSerialize.hh
index 365e8ff648..9495940c9c 100644
--- a/contrib/libs/apache/avro/api/AvroSerialize.hh
+++ b/contrib/libs/apache/avro/api/AvroSerialize.hh
@@ -1,66 +1,66 @@
-/* 
- * Licensed to the Apache Software Foundation (ASF) under one 
- * or more contributor license agreements.  See the NOTICE file 
- * distributed with this work for additional information 
- * regarding copyright ownership.  The ASF licenses this file 
- * to you under the Apache License, Version 2.0 (the 
- * "License"); you may not use this file except in compliance 
- * with the License.  You may obtain a copy of the License at 
- * 
- *     https://www.apache.org/licenses/LICENSE-2.0 
- * 
- * Unless required by applicable law or agreed to in writing, software 
- * distributed under the License is distributed on an "AS IS" BASIS, 
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
- * See the License for the specific language governing permissions and 
- * limitations under the License. 
- */ 
- 
-#ifndef avro_AvroSerialize_hh__ 
-#define avro_AvroSerialize_hh__ 
- 
-#include "Config.hh" 
-#include "AvroTraits.hh" 
- 
-/// \file 
-/// 
-/// Standalone serialize functions for Avro types. 
- 
-namespace avro { 
- 
-/// The main serializer entry point function.  Takes a serializer (either validating or 
-/// plain) and the object that should be serialized. 
- 
-template <typename Writer, typename T> 
-void serialize(Writer &s, const T& val) 
-{ 
-    serialize(s, val, is_serializable<T>()); 
-} 
- 
-/// Type trait should be set to is_serializable in otherwise force the compiler to complain. 
- 
-template <typename Writer, typename T> 
-void serialize(Writer &s, const T& val, const std::false_type &) 
-{ 
-    static_assert(sizeof(T) == 0, "Not a valid type to serialize"); 
-} 
- 
-/// The remainder of the file includes default implementations for serializable types. 
- 
-// @{ 
- 
-template <typename Writer, typename T> 
-void serialize(Writer &s, T val, const std::true_type &) { 
-    s.writeValue(val); 
-} 
- 
-template <typename Writer> 
-void serialize(Writer &s, const std::vector<uint8_t> &val, const std::true_type &) { 
-    s.writeBytes(val.data(), val.size()); 
-} 
- 
-// @} 
- 
-} // namespace avro 
- 
-#endif 
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef avro_AvroSerialize_hh__
+#define avro_AvroSerialize_hh__
+
+#include "Config.hh"
+#include "AvroTraits.hh"
+
+/// \file
+///
+/// Standalone serialize functions for Avro types.
+
+namespace avro {
+
+/// The main serializer entry point function.  Takes a serializer (either validating or
+/// plain) and the object that should be serialized.
+
+template <typename Writer, typename T>
+void serialize(Writer &s, const T& val)
+{
+    serialize(s, val, is_serializable<T>());
+}
+
+/// Type trait should be set to is_serializable in otherwise force the compiler to complain.
+
+template <typename Writer, typename T>
+void serialize(Writer &s, const T& val, const std::false_type &)
+{
+    static_assert(sizeof(T) == 0, "Not a valid type to serialize");
+}
+
+/// The remainder of the file includes default implementations for serializable types.
+
+// @{
+
+template <typename Writer, typename T>
+void serialize(Writer &s, T val, const std::true_type &) {
+    s.writeValue(val);
+}
+
+template <typename Writer>
+void serialize(Writer &s, const std::vector<uint8_t> &val, const std::true_type &) {
+    s.writeBytes(val.data(), val.size());
+}
+
+// @}
+
+} // namespace avro
+
+#endif
diff --git a/contrib/libs/apache/avro/api/AvroTraits.hh b/contrib/libs/apache/avro/api/AvroTraits.hh
index d4d76efb2e..91e2130c76 100644
--- a/contrib/libs/apache/avro/api/AvroTraits.hh
+++ b/contrib/libs/apache/avro/api/AvroTraits.hh
@@ -1,116 +1,116 @@
-/* 
- * Licensed to the Apache Software Foundation (ASF) under one 
- * or more contributor license agreements.  See the NOTICE file 
- * distributed with this work for additional information 
- * regarding copyright ownership.  The ASF licenses this file 
- * to you under the Apache License, Version 2.0 (the 
- * "License"); you may not use this file except in compliance 
- * with the License.  You may obtain a copy of the License at 
- * 
- *     https://www.apache.org/licenses/LICENSE-2.0 
- * 
- * Unless required by applicable law or agreed to in writing, software 
- * distributed under the License is distributed on an "AS IS" BASIS, 
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
- * See the License for the specific language governing permissions and 
- * limitations under the License. 
- */ 
- 
-#ifndef avro_AvroTraits_hh__ 
-#define avro_AvroTraits_hh__ 
- 
-#include "Config.hh" 
-#include "Types.hh" 
-#include <stdint.h> 
-#include <type_traits> 
- 
-/** @file 
- * 
- * This header contains type traits and similar utilities used by the library. 
- */ 
-namespace avro { 
- 
-/** 
- * Define an is_serializable trait for types we can serialize natively. 
- * New types will need to define the trait as well. 
- */ 
-template <typename T> 
-struct is_serializable : public std::false_type{}; 
- 
-template <typename T> 
-struct is_promotable : public std::false_type{}; 
- 
-template <typename T> 
-struct type_to_avro { 
-    static const Type type = AVRO_NUM_TYPES; 
-}; 
- 
-/** 
- * Check if a \p T is a complete type i.e. it is defined as opposed to just 
- * declared. 
- * 
- * is_defined<T>::value will be true or false depending on whether T is a 
- * complete type or not respectively. 
- */ 
-template <class T> 
-struct is_defined { 
- 
-    typedef char yes[1]; 
- 
-    typedef char no[2]; 
- 
-    template <class U> static yes& test(char(*)[sizeof(U)]) { throw 0; }; 
- 
-    template <class U> static no& test(...) { throw 0; }; 
- 
-    static const bool value = sizeof(test<T>(0)) == sizeof(yes); 
-}; 
- 
-/** 
- * Similar to is_defined, but used to check if T is not defined. 
- * 
- * is_not_defined<T>::value will be true or false depending on whether T is an 
- * incomplete type or not respectively. 
- */ 
-template <class T> 
-struct is_not_defined { 
- 
-    typedef char yes[1]; 
- 
-    typedef char no[2]; 
- 
-    template <class U> static yes& test(char(*)[sizeof(U)]) { throw 0; }; 
- 
-    template <class U> static no& test(...) { throw 0; }; 
- 
-    static const bool value = sizeof(test<T>(0)) == sizeof(no); 
-}; 
- 
-#define DEFINE_PRIMITIVE(CTYPE, AVROTYPE) \ 
-template <> \ 
-struct is_serializable<CTYPE> : public std::true_type{}; \ 
-\ 
-template <> \ 
-struct type_to_avro<CTYPE> { \ 
-    static const Type type = AVROTYPE; \ 
-}; 
- 
-#define DEFINE_PROMOTABLE_PRIMITIVE(CTYPE, AVROTYPE) \ 
-template <> \ 
-struct is_promotable<CTYPE> : public std::true_type{}; \ 
-\ 
-DEFINE_PRIMITIVE(CTYPE, AVROTYPE) 
- 
-DEFINE_PROMOTABLE_PRIMITIVE(int32_t, AVRO_INT) 
-DEFINE_PROMOTABLE_PRIMITIVE(int64_t, AVRO_LONG) 
-DEFINE_PROMOTABLE_PRIMITIVE(float, AVRO_FLOAT) 
-DEFINE_PRIMITIVE(double, AVRO_DOUBLE) 
-DEFINE_PRIMITIVE(bool, AVRO_BOOL) 
-DEFINE_PRIMITIVE(Null, AVRO_NULL) 
-DEFINE_PRIMITIVE(std::string, AVRO_STRING) 
-DEFINE_PRIMITIVE(std::vector<uint8_t>, AVRO_BYTES) 
- 
- 
-} // namespace avro 
- 
-#endif 
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef avro_AvroTraits_hh__
+#define avro_AvroTraits_hh__
+
+#include "Config.hh"
+#include "Types.hh"
+#include <stdint.h>
+#include <type_traits>
+
+/** @file
+ *
+ * This header contains type traits and similar utilities used by the library.
+ */
+namespace avro {
+
+/**
+ * Define an is_serializable trait for types we can serialize natively.
+ * New types will need to define the trait as well.
+ */
+template <typename T>
+struct is_serializable : public std::false_type{};
+
+template <typename T>
+struct is_promotable : public std::false_type{};
+
+template <typename T>
+struct type_to_avro {
+    static const Type type = AVRO_NUM_TYPES;
+};
+
+/**
+ * Check if a \p T is a complete type i.e. it is defined as opposed to just
+ * declared.
+ *
+ * is_defined<T>::value will be true or false depending on whether T is a
+ * complete type or not respectively.
+ */
+template <class T>
+struct is_defined {
+
+    typedef char yes[1];
+
+    typedef char no[2];
+
+    template <class U> static yes& test(char(*)[sizeof(U)]) { throw 0; };
+
+    template <class U> static no& test(...) { throw 0; };
+
+    static const bool value = sizeof(test<T>(0)) == sizeof(yes);
+};
+
+/**
+ * Similar to is_defined, but used to check if T is not defined.
+ *
+ * is_not_defined<T>::value will be true or false depending on whether T is an
+ * incomplete type or not respectively.
+ */
+template <class T>
+struct is_not_defined {
+
+    typedef char yes[1];
+
+    typedef char no[2];
+
+    template <class U> static yes& test(char(*)[sizeof(U)]) { throw 0; };
+
+    template <class U> static no& test(...) { throw 0; };
+
+    static const bool value = sizeof(test<T>(0)) == sizeof(no);
+};
+
+#define DEFINE_PRIMITIVE(CTYPE, AVROTYPE) \
+template <> \
+struct is_serializable<CTYPE> : public std::true_type{}; \
+\
+template <> \
+struct type_to_avro<CTYPE> { \
+    static const Type type = AVROTYPE; \
+};
+
+#define DEFINE_PROMOTABLE_PRIMITIVE(CTYPE, AVROTYPE) \
+template <> \
+struct is_promotable<CTYPE> : public std::true_type{}; \
+\
+DEFINE_PRIMITIVE(CTYPE, AVROTYPE)
+
+DEFINE_PROMOTABLE_PRIMITIVE(int32_t, AVRO_INT)
+DEFINE_PROMOTABLE_PRIMITIVE(int64_t, AVRO_LONG)
+DEFINE_PROMOTABLE_PRIMITIVE(float, AVRO_FLOAT)
+DEFINE_PRIMITIVE(double, AVRO_DOUBLE)
+DEFINE_PRIMITIVE(bool, AVRO_BOOL)
+DEFINE_PRIMITIVE(Null, AVRO_NULL)
+DEFINE_PRIMITIVE(std::string, AVRO_STRING)
+DEFINE_PRIMITIVE(std::vector<uint8_t>, AVRO_BYTES)
+
+
+} // namespace avro
+
+#endif
diff --git a/contrib/libs/apache/avro/api/Compiler.hh b/contrib/libs/apache/avro/api/Compiler.hh
index 3df875cd16..892d60580d 100644
--- a/contrib/libs/apache/avro/api/Compiler.hh
+++ b/contrib/libs/apache/avro/api/Compiler.hh
@@ -1,63 +1,63 @@
-/* 
- * Licensed to the Apache Software Foundation (ASF) under one 
- * or more contributor license agreements.  See the NOTICE file 
- * distributed with this work for additional information 
- * regarding copyright ownership.  The ASF licenses this file 
- * to you under the Apache License, Version 2.0 (the 
- * "License"); you may not use this file except in compliance 
- * with the License.  You may obtain a copy of the License at 
- * 
- *     https://www.apache.org/licenses/LICENSE-2.0 
- * 
- * Unless required by applicable law or agreed to in writing, software 
- * distributed under the License is distributed on an "AS IS" BASIS, 
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
- * See the License for the specific language governing permissions and 
- * limitations under the License. 
- */ 
- 
-#ifndef avro_Compiler_hh__ 
-#define avro_Compiler_hh__ 
- 
-#include "Config.hh" 
-#include <stdint.h> 
-#include <istream> 
- 
-namespace avro { 
- 
-class AVRO_DECL InputStream; 
- 
-/// This class is used to implement an avro spec parser using a flex/bison 
-/// compiler.  In order for the lexer to be reentrant, this class provides a 
-/// lexer object for each parse.  The bison parser also uses this class to 
-/// build up an avro parse tree as the avro spec is parsed. 
- 
-class AVRO_DECL ValidSchema; 
- 
-/// Given a stream comtaining a JSON schema, compiles the schema to a 
-/// ValidSchema object.  Throws if the schema cannot be compiled to a valid 
-/// schema 
- 
-AVRO_DECL void compileJsonSchema(std::istream &is, ValidSchema &schema); 
- 
-/// Non-throwing version of compileJsonSchema. 
-/// 
-/// \return True if no error, false if error (with the error string set) 
-/// 
- 
-AVRO_DECL bool compileJsonSchema(std::istream &is, ValidSchema &schema, 
-    std::string &error); 
- 
-AVRO_DECL ValidSchema compileJsonSchemaFromStream(InputStream& is); 
- 
-AVRO_DECL ValidSchema compileJsonSchemaFromMemory(const uint8_t* input, size_t len); 
- 
-AVRO_DECL ValidSchema compileJsonSchemaFromString(const char* input); 
- 
-AVRO_DECL ValidSchema compileJsonSchemaFromString(const std::string& input); 
- 
-AVRO_DECL ValidSchema compileJsonSchemaFromFile(const char* filename); 
- 
-} // namespace avro 
- 
-#endif 
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef avro_Compiler_hh__
+#define avro_Compiler_hh__
+
+#include "Config.hh"
+#include <stdint.h>
+#include <istream>
+
+namespace avro {
+
+class AVRO_DECL InputStream;
+
+/// This class is used to implement an avro spec parser using a flex/bison
+/// compiler.  In order for the lexer to be reentrant, this class provides a
+/// lexer object for each parse.  The bison parser also uses this class to
+/// build up an avro parse tree as the avro spec is parsed.
+
+class AVRO_DECL ValidSchema;
+
+/// Given a stream comtaining a JSON schema, compiles the schema to a
+/// ValidSchema object.  Throws if the schema cannot be compiled to a valid
+/// schema
+
+AVRO_DECL void compileJsonSchema(std::istream &is, ValidSchema &schema);
+
+/// Non-throwing version of compileJsonSchema.
+///
+/// \return True if no error, false if error (with the error string set)
+///
+
+AVRO_DECL bool compileJsonSchema(std::istream &is, ValidSchema &schema,
+    std::string &error);
+
+AVRO_DECL ValidSchema compileJsonSchemaFromStream(InputStream& is);
+
+AVRO_DECL ValidSchema compileJsonSchemaFromMemory(const uint8_t* input, size_t len);
+
+AVRO_DECL ValidSchema compileJsonSchemaFromString(const char* input);
+
+AVRO_DECL ValidSchema compileJsonSchemaFromString(const std::string& input);
+
+AVRO_DECL ValidSchema compileJsonSchemaFromFile(const char* filename);
+
+} // namespace avro
+
+#endif
diff --git a/contrib/libs/apache/avro/api/Config.hh b/contrib/libs/apache/avro/api/Config.hh
index 6daa843e9c..69d36f2abe 100644
--- a/contrib/libs/apache/avro/api/Config.hh
+++ b/contrib/libs/apache/avro/api/Config.hh
@@ -1,45 +1,45 @@
-/* 
- * Licensed to the Apache Software Foundation (ASF) under one 
- * or more contributor license agreements.  See the NOTICE file 
- * distributed with this work for additional information 
- * regarding copyright ownership.  The ASF licenses this file 
- * to you under the Apache License, Version 2.0 (the 
- * "License"); you may not use this file except in compliance 
- * with the License.  You may obtain a copy of the License at 
- * 
- *     https://www.apache.org/licenses/LICENSE-2.0 
- * 
- * Unless required by applicable law or agreed to in writing, software 
- * distributed under the License is distributed on an "AS IS" BASIS, 
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
- * See the License for the specific language governing permissions and 
- * limitations under the License. 
- */ 
- 
-#ifndef avro_Config_hh 
-#define avro_Config_hh 
- 
-// Windows DLL suport 
- 
-#ifdef _WIN32 
-#pragma warning (disable: 4275 4251) 
- 
-#if defined(AVRO_DYN_LINK) 
-#ifdef AVRO_SOURCE 
-# define AVRO_DECL __declspec(dllexport) 
-#else 
-# define AVRO_DECL __declspec(dllimport) 
-#endif  // AVRO_SOURCE 
-#endif  // AVRO_DYN_LINK 
- 
-#include <intsafe.h> 
-typedef SSIZE_T ssize_t; 
- 
-#endif  // _WIN32 
- 
-#ifndef AVRO_DECL 
-#define AVRO_DECL 
-#endif 
- 
-#endif 
- 
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef avro_Config_hh
+#define avro_Config_hh
+
+// Windows DLL suport
+
+#ifdef _WIN32
+#pragma warning (disable: 4275 4251)
+
+#if defined(AVRO_DYN_LINK)
+#ifdef AVRO_SOURCE
+# define AVRO_DECL __declspec(dllexport)
+#else
+# define AVRO_DECL __declspec(dllimport)
+#endif  // AVRO_SOURCE
+#endif  // AVRO_DYN_LINK
+
+#include <intsafe.h>
+typedef SSIZE_T ssize_t;
+
+#endif  // _WIN32
+
+#ifndef AVRO_DECL
+#define AVRO_DECL
+#endif
+
+#endif
+
diff --git a/contrib/libs/apache/avro/api/DataFile.hh b/contrib/libs/apache/avro/api/DataFile.hh
index cc333d70ba..50169106b1 100644
--- a/contrib/libs/apache/avro/api/DataFile.hh
+++ b/contrib/libs/apache/avro/api/DataFile.hh
@@ -1,419 +1,419 @@
-/* 
- * Licensed to the Apache Software Foundation (ASF) under one 
- * or more contributor license agreements.  See the NOTICE file 
- * distributed with this work for additional information 
- * regarding copyright ownership.  The ASF licenses this file 
- * to you under the Apache License, Version 2.0 (the 
- * "License"); you may not use this file except in compliance 
- * with the License.  You may obtain a copy of the License at 
- * 
- *     https://www.apache.org/licenses/LICENSE-2.0 
- * 
- * Unless required by applicable law or agreed to in writing, software 
- * distributed under the License is distributed on an "AS IS" BASIS, 
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
- * See the License for the specific language governing permissions and 
- * limitations under the License. 
- */ 
- 
-#ifndef avro_DataFile_hh__ 
-#define avro_DataFile_hh__ 
- 
-#include "Config.hh" 
-#include "Encoder.hh" 
-#include "buffer/Buffer.hh" 
-#include "ValidSchema.hh" 
-#include "Specific.hh" 
-#include "Stream.hh" 
- 
-#include <map> 
-#include <string> 
-#include <vector> 
- 
-#include "array" 
-#include "boost/utility.hpp" 
-#include <boost/iostreams/filtering_stream.hpp> 
- 
-namespace avro { 
- 
-/** Specify type of compression to use when writing data files. */ 
-enum Codec { 
-  NULL_CODEC, 
-  DEFLATE_CODEC, 
- 
-#ifdef SNAPPY_CODEC_AVAILABLE 
-  SNAPPY_CODEC 
-#endif 
- 
-}; 
- 
-const int SyncSize = 16; 
-/** 
- * The sync value. 
- */ 
-typedef std::array<uint8_t, SyncSize> DataFileSync; 
- 
-/** 
- * Type-independent portion of DataFileWriter. 
- *  At any given point in time, at most one file can be written using 
- *  this object. 
- */ 
-class AVRO_DECL DataFileWriterBase : boost::noncopyable { 
-    const std::string filename_; 
-    const ValidSchema schema_; 
-    const EncoderPtr encoderPtr_; 
-    const size_t syncInterval_; 
-    Codec codec_; 
- 
-    std::unique_ptr<OutputStream> stream_; 
-    std::unique_ptr<OutputStream> buffer_; 
-    const DataFileSync sync_; 
-    int64_t objectCount_; 
- 
-    typedef std::map<std::string, std::vector<uint8_t> > Metadata; 
- 
-    Metadata metadata_; 
-    int64_t lastSync_; 
- 
-    static std::unique_ptr<OutputStream> makeStream(const char* filename); 
-    static DataFileSync makeSync(); 
- 
-    void writeHeader(); 
-    void setMetadata(const std::string& key, const std::string& value); 
- 
-    /** 
-     * Generates a sync marker in the file. 
-     */ 
-    void sync(); 
- 
-    /** 
-     * Shared constructor portion since we aren't using C++11 
-     */ 
-    void init(const ValidSchema &schema, size_t syncInterval, const Codec &codec); 
- 
-public: 
-    /** 
-     * Returns the current encoder for this writer. 
-     */ 
-    Encoder& encoder() const { return *encoderPtr_; } 
- 
-    /** 
-     * Returns true if the buffer has sufficient data for a sync to be 
-     * inserted. 
-     */ 
-    void syncIfNeeded(); 
- 
-    /** 
-     * Returns the byte offset (within the current file) of the start of the current block being written. 
-     */ 
-    uint64_t getCurrentBlockStart(); 
- 
-    /** 
-     * Increments the object count. 
-     */ 
-    void incr() { 
-        ++objectCount_; 
-    } 
-    /** 
-     * Constructs a data file writer with the given sync interval and name. 
-     */ 
-    DataFileWriterBase(const char* filename, const ValidSchema& schema, 
-        size_t syncInterval, Codec codec = NULL_CODEC); 
-    DataFileWriterBase(std::unique_ptr<OutputStream> outputStream, 
-                       const ValidSchema& schema, size_t syncInterval, Codec codec); 
- 
-    ~DataFileWriterBase(); 
-    /** 
-     * Closes the current file. Once closed this datafile object cannot be 
-     * used for writing any more. 
-     */ 
-    void close(); 
- 
-    /** 
-     * Returns the schema for this data file. 
-     */ 
-    const ValidSchema& schema() const { return schema_; } 
- 
-    /** 
-     * Flushes any unwritten data into the file. 
-     */ 
-    void flush(); 
-}; 
- 
-/** 
- *  An Avro datafile that can store objects of type T. 
- */ 
-template <typename T> 
-class DataFileWriter : boost::noncopyable { 
-    std::unique_ptr<DataFileWriterBase> base_; 
-public: 
-    /** 
-     * Constructs a new data file. 
-     */ 
-    DataFileWriter(const char* filename, const ValidSchema& schema, 
-        size_t syncInterval = 16 * 1024, Codec codec = NULL_CODEC) : 
-        base_(new DataFileWriterBase(filename, schema, syncInterval, codec)) { } 
- 
-    DataFileWriter(std::unique_ptr<OutputStream> outputStream, const ValidSchema& schema, 
-        size_t syncInterval = 16 * 1024, Codec codec = NULL_CODEC) : 
-        base_(new DataFileWriterBase(std::move(outputStream), schema, syncInterval, codec)) { } 
- 
-    /** 
-     * Writes the given piece of data into the file. 
-     */ 
-    void write(const T& datum) { 
-        base_->syncIfNeeded(); 
-        avro::encode(base_->encoder(), datum); 
-        base_->incr(); 
-    } 
- 
-    /** 
-     *  Returns the byte offset (within the current file) of the start of the current block being written. 
-     */ 
-    uint64_t getCurrentBlockStart() { return base_->getCurrentBlockStart(); } 
- 
- 
-    /** 
-     * Closes the current file. Once closed this datafile object cannot be 
-     * used for writing any more. 
-     */ 
-    void close() { base_->close(); } 
- 
-    /** 
-     * Returns the schema for this data file. 
-     */ 
-    const ValidSchema& schema() const { return base_->schema(); } 
- 
-    /** 
-     * Flushes any unwritten data into the file. 
-     */ 
-    void flush() { base_->flush(); } 
-}; 
- 
-/** 
- * The type independent portion of reader. 
- */ 
-class AVRO_DECL DataFileReaderBase : boost::noncopyable { 
-    const std::string filename_; 
-    const std::unique_ptr<InputStream> stream_; 
-    const DecoderPtr decoder_; 
-    int64_t objectCount_; 
-    bool eof_; 
-    Codec codec_; 
-    int64_t blockStart_; 
-    int64_t blockEnd_; 
- 
-    ValidSchema readerSchema_; 
-    ValidSchema dataSchema_; 
-    DecoderPtr dataDecoder_; 
-    std::unique_ptr<InputStream> dataStream_; 
-    typedef std::map<std::string, std::vector<uint8_t> > Metadata; 
- 
-    Metadata metadata_; 
-    DataFileSync sync_; 
- 
-    // for compressed buffer 
-    std::unique_ptr<boost::iostreams::filtering_istream> os_; 
-    std::vector<char> compressed_; 
-    std::string uncompressed; 
-    void readHeader(); 
- 
-    void readDataBlock(); 
-    void doSeek(int64_t position); 
-public: 
-    /** 
-     * Returns the current decoder for this reader. 
-     */ 
-    Decoder& decoder() { return *dataDecoder_; } 
- 
-    /** 
-     * Returns true if and only if there is more to read. 
-     */ 
-    bool hasMore(); 
- 
-    /** 
-     * Decrements the number of objects yet to read. 
-     */ 
-    void decr() { --objectCount_; } 
- 
-    /** 
-     * Constructs the reader for the given file and the reader is 
-     * expected to use the schema that is used with data. 
-     * This function should be called exactly once after constructing 
-     * the DataFileReaderBase object. 
-     */ 
-    DataFileReaderBase(const char* filename); 
- 
-    DataFileReaderBase(std::unique_ptr<InputStream> inputStream); 
- 
-    /** 
-     * Initializes the reader so that the reader and writer schemas 
-     * are the same. 
-     */ 
-    void init(); 
- 
-    /** 
-     * Initializes the reader to read objects according to the given 
-     * schema. This gives an opportunity for the reader to see the schema 
-     * in the data file before deciding the right schema to use for reading. 
-     * This must be called exactly once after constructing the 
-     * DataFileReaderBase object. 
-     */ 
-    void init(const ValidSchema& readerSchema); 
- 
-    /** 
-     * Returns the schema for this object. 
-     */ 
-    const ValidSchema& readerSchema() { return readerSchema_; } 
- 
-    /** 
-     * Returns the schema stored with the data file. 
-     */ 
-    const ValidSchema& dataSchema() { return dataSchema_; } 
- 
-    /** 
-     * Closes the reader. No further operation is possible on this reader. 
-     */ 
-    void close(); 
- 
-    /** 
-     * Move to a specific, known synchronization point, for example one returned 
-     * from tell() after sync(). 
-     */ 
-    void seek(int64_t position); 
- 
-    /** 
-     * Move to the next synchronization point after a position. To process a 
-     * range of file entries, call this with the starting position, then check 
-     * pastSync() with the end point before each use of decoder(). 
-     */ 
-    void sync(int64_t position); 
- 
-    /** 
-     * Return true if past the next synchronization point after a position. 
-     */ 
-    bool pastSync(int64_t position); 
- 
-    /** 
-     * Return the last synchronization point before our current position. 
-     */ 
-    int64_t previousSync(); 
-}; 
- 
-/** 
- * Reads the contents of data file one after another. 
- */ 
-template <typename T> 
-class DataFileReader : boost::noncopyable { 
-    std::unique_ptr<DataFileReaderBase> base_; 
-public: 
-    /** 
-     * Constructs the reader for the given file and the reader is 
-     * expected to use the given schema. 
-     */ 
-    DataFileReader(const char* filename, const ValidSchema& readerSchema) : 
-        base_(new DataFileReaderBase(filename)) { 
-        base_->init(readerSchema); 
-    } 
- 
-    DataFileReader(std::unique_ptr<InputStream> inputStream, const ValidSchema& readerSchema) : 
-        base_(new DataFileReaderBase(std::move(inputStream))) { 
-        base_->init(readerSchema); 
-    } 
- 
-    /** 
-     * Constructs the reader for the given file and the reader is 
-     * expected to use the schema that is used with data. 
-     */ 
-    DataFileReader(const char* filename) : 
-        base_(new DataFileReaderBase(filename)) { 
-        base_->init(); 
-    } 
- 
-    DataFileReader(std::unique_ptr<InputStream> inputStream) : 
-        base_(new DataFileReaderBase(std::move(inputStream))) { 
-        base_->init(); 
-    } 
- 
-    /** 
-     * Constructs a reader using the reader base. This form of constructor 
-     * allows the user to examine the schema of a given file and then 
-     * decide to use the right type of data to be deserialize. Without this 
-     * the user must know the type of data for the template _before_ 
-     * he knows the schema within the file. 
-     * The schema present in the data file will be used for reading 
-     * from this reader. 
-     */ 
-    DataFileReader(std::unique_ptr<DataFileReaderBase> base) : base_(std::move(base)) { 
-        base_->init(); 
-    } 
- 
-    /** 
-     * Constructs a reader using the reader base. This form of constructor 
-     * allows the user to examine the schema of a given file and then 
-     * decide to use the right type of data to be deserialize. Without this 
-     * the user must know the type of data for the template _before_ 
-     * he knows the schema within the file. 
-     * The argument readerSchema will be used for reading 
-     * from this reader. 
-     */ 
-    DataFileReader(std::unique_ptr<DataFileReaderBase> base, 
-        const ValidSchema& readerSchema) : base_(std::move(base)) { 
-        base_->init(readerSchema); 
-    } 
- 
-    /** 
-     * Reads the next entry from the data file. 
-     * \return true if an object has been successfully read into \p datum and 
-     * false if there are no more entries in the file. 
-     */ 
-    bool read(T& datum) { 
-        if (base_->hasMore()) { 
-            base_->decr(); 
-            avro::decode(base_->decoder(), datum); 
-            return true; 
-        } 
-        return false; 
-    } 
- 
-    /** 
-     * Returns the schema for this object. 
-     */ 
-    const ValidSchema& readerSchema() { return base_->readerSchema(); } 
- 
-    /** 
-     * Returns the schema stored with the data file. 
-     */ 
-    const ValidSchema& dataSchema() { return base_->dataSchema(); } 
- 
-    /** 
-     * Closes the reader. No further operation is possible on this reader. 
-     */ 
-    void close() { return base_->close(); } 
- 
-    /** 
-     * Move to a specific, known synchronization point, for example one returned 
-     * from previousSync(). 
-     */ 
-    void seek(int64_t position) { base_->seek(position); } 
- 
-    /** 
-     * Move to the next synchronization point after a position. To process a 
-     * range of file entries, call this with the starting position, then check 
-     * pastSync() with the end point before each call to read(). 
-     */ 
-    void sync(int64_t position) { base_->sync(position); } 
- 
-    /** 
-     * Return true if past the next synchronization point after a position. 
-     */ 
-    bool pastSync(int64_t position) { return base_->pastSync(position); } 
- 
-    /** 
-     * Return the last synchronization point before our current position. 
-     */ 
-    int64_t previousSync() { return base_->previousSync(); } 
-}; 
- 
-}   // namespace avro 
-#endif 
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef avro_DataFile_hh__
+#define avro_DataFile_hh__
+
+#include "Config.hh"
+#include "Encoder.hh"
+#include "buffer/Buffer.hh"
+#include "ValidSchema.hh"
+#include "Specific.hh"
+#include "Stream.hh"
+
+#include <map>
+#include <string>
+#include <vector>
+
+#include "array"
+#include "boost/utility.hpp"
+#include <boost/iostreams/filtering_stream.hpp>
+
+namespace avro {
+
+/** Specify type of compression to use when writing data files. */
+enum Codec {
+  NULL_CODEC,
+  DEFLATE_CODEC,
+
+#ifdef SNAPPY_CODEC_AVAILABLE
+  SNAPPY_CODEC
+#endif
+
+};
+
+const int SyncSize = 16;
+/**
+ * The sync value.
+ */
+typedef std::array<uint8_t, SyncSize> DataFileSync;
+
+/**
+ * Type-independent portion of DataFileWriter.
+ *  At any given point in time, at most one file can be written using
+ *  this object.
+ */
+class AVRO_DECL DataFileWriterBase : boost::noncopyable {
+    const std::string filename_;
+    const ValidSchema schema_;
+    const EncoderPtr encoderPtr_;
+    const size_t syncInterval_;
+    Codec codec_;
+
+    std::unique_ptr<OutputStream> stream_;
+    std::unique_ptr<OutputStream> buffer_;
+    const DataFileSync sync_;
+    int64_t objectCount_;
+
+    typedef std::map<std::string, std::vector<uint8_t> > Metadata;
+
+    Metadata metadata_;
+    int64_t lastSync_;
+
+    static std::unique_ptr<OutputStream> makeStream(const char* filename);
+    static DataFileSync makeSync();
+
+    void writeHeader();
+    void setMetadata(const std::string& key, const std::string& value);
+
+    /**
+     * Generates a sync marker in the file.
+     */
+    void sync();
+
+    /**
+     * Shared constructor portion since we aren't using C++11
+     */
+    void init(const ValidSchema &schema, size_t syncInterval, const Codec &codec);
+
+public:
+    /**
+     * Returns the current encoder for this writer.
+     */
+    Encoder& encoder() const { return *encoderPtr_; }
+
+    /**
+     * Returns true if the buffer has sufficient data for a sync to be
+     * inserted.
+     */
+    void syncIfNeeded();
+
+    /**
+     * Returns the byte offset (within the current file) of the start of the current block being written.
+     */
+    uint64_t getCurrentBlockStart();
+
+    /**
+     * Increments the object count.
+     */
+    void incr() {
+        ++objectCount_;
+    }
+    /**
+     * Constructs a data file writer with the given sync interval and name.
+     */
+    DataFileWriterBase(const char* filename, const ValidSchema& schema,
+        size_t syncInterval, Codec codec = NULL_CODEC);
+    DataFileWriterBase(std::unique_ptr<OutputStream> outputStream,
+                       const ValidSchema& schema, size_t syncInterval, Codec codec);
+
+    ~DataFileWriterBase();
+    /**
+     * Closes the current file. Once closed this datafile object cannot be
+     * used for writing any more.
+     */
+    void close();
+
+    /**
+     * Returns the schema for this data file.
+     */
+    const ValidSchema& schema() const { return schema_; }
+
+    /**
+     * Flushes any unwritten data into the file.
+     */
+    void flush();
+};
+
+/**
+ *  An Avro datafile that can store objects of type T.
+ */
+template <typename T>
+class DataFileWriter : boost::noncopyable {
+    std::unique_ptr<DataFileWriterBase> base_;
+public:
+    /**
+     * Constructs a new data file.
+     */
+    DataFileWriter(const char* filename, const ValidSchema& schema,
+        size_t syncInterval = 16 * 1024, Codec codec = NULL_CODEC) :
+        base_(new DataFileWriterBase(filename, schema, syncInterval, codec)) { }
+
+    DataFileWriter(std::unique_ptr<OutputStream> outputStream, const ValidSchema& schema,
+        size_t syncInterval = 16 * 1024, Codec codec = NULL_CODEC) :
+        base_(new DataFileWriterBase(std::move(outputStream), schema, syncInterval, codec)) { }
+
+    /**
+     * Writes the given piece of data into the file.
+     */
+    void write(const T& datum) {
+        base_->syncIfNeeded();
+        avro::encode(base_->encoder(), datum);
+        base_->incr();
+    }
+
+    /**
+     *  Returns the byte offset (within the current file) of the start of the current block being written.
+     */
+    uint64_t getCurrentBlockStart() { return base_->getCurrentBlockStart(); }
+
+
+    /**
+     * Closes the current file. Once closed this datafile object cannot be
+     * used for writing any more.
+     */
+    void close() { base_->close(); }
+
+    /**
+     * Returns the schema for this data file.
+     */
+    const ValidSchema& schema() const { return base_->schema(); }
+
+    /**
+     * Flushes any unwritten data into the file.
+     */
+    void flush() { base_->flush(); }
+};
+
+/**
+ * The type independent portion of reader.
+ */
+class AVRO_DECL DataFileReaderBase : boost::noncopyable {
+    const std::string filename_;
+    const std::unique_ptr<InputStream> stream_;
+    const DecoderPtr decoder_;
+    int64_t objectCount_;
+    bool eof_;
+    Codec codec_;
+    int64_t blockStart_;
+    int64_t blockEnd_;
+
+    ValidSchema readerSchema_;
+    ValidSchema dataSchema_;
+    DecoderPtr dataDecoder_;
+    std::unique_ptr<InputStream> dataStream_;
+    typedef std::map<std::string, std::vector<uint8_t> > Metadata;
+
+    Metadata metadata_;
+    DataFileSync sync_;
+
+    // for compressed buffer
+    std::unique_ptr<boost::iostreams::filtering_istream> os_;
+    std::vector<char> compressed_;
+    std::string uncompressed;
+    void readHeader();
+
+    void readDataBlock();
+    void doSeek(int64_t position);
+public:
+    /**
+     * Returns the current decoder for this reader.
+     */
+    Decoder& decoder() { return *dataDecoder_; }
+
+    /**
+     * Returns true if and only if there is more to read.
+     */
+    bool hasMore();
+
+    /**
+     * Decrements the number of objects yet to read.
+     */
+    void decr() { --objectCount_; }
+
+    /**
+     * Constructs the reader for the given file and the reader is
+     * expected to use the schema that is used with data.
+     * This function should be called exactly once after constructing
+     * the DataFileReaderBase object.
+     */
+    DataFileReaderBase(const char* filename);
+
+    DataFileReaderBase(std::unique_ptr<InputStream> inputStream);
+
+    /**
+     * Initializes the reader so that the reader and writer schemas
+     * are the same.
+     */
+    void init();
+
+    /**
+     * Initializes the reader to read objects according to the given
+     * schema. This gives an opportunity for the reader to see the schema
+     * in the data file before deciding the right schema to use for reading.
+     * This must be called exactly once after constructing the
+     * DataFileReaderBase object.
+     */
+    void init(const ValidSchema& readerSchema);
+
+    /**
+     * Returns the schema for this object.
+     */
+    const ValidSchema& readerSchema() { return readerSchema_; }
+
+    /**
+     * Returns the schema stored with the data file.
+     */
+    const ValidSchema& dataSchema() { return dataSchema_; }
+
+    /**
+     * Closes the reader. No further operation is possible on this reader.
+     */
+    void close();
+
+    /**
+     * Move to a specific, known synchronization point, for example one returned
+     * from tell() after sync().
+     */
+    void seek(int64_t position);
+
+    /**
+     * Move to the next synchronization point after a position. To process a
+     * range of file entries, call this with the starting position, then check
+     * pastSync() with the end point before each use of decoder().
+     */
+    void sync(int64_t position);
+
+    /**
+     * Return true if past the next synchronization point after a position.
+     */
+    bool pastSync(int64_t position);
+
+    /**
+     * Return the last synchronization point before our current position.
+     */
+    int64_t previousSync();
+};
+
+/**
+ * Reads the contents of data file one after another.
+ */
+template <typename T>
+class DataFileReader : boost::noncopyable {
+    std::unique_ptr<DataFileReaderBase> base_;
+public:
+    /**
+     * Constructs the reader for the given file and the reader is
+     * expected to use the given schema.
+     */
+    DataFileReader(const char* filename, const ValidSchema& readerSchema) :
+        base_(new DataFileReaderBase(filename)) {
+        base_->init(readerSchema);
+    }
+
+    DataFileReader(std::unique_ptr<InputStream> inputStream, const ValidSchema& readerSchema) :
+        base_(new DataFileReaderBase(std::move(inputStream))) {
+        base_->init(readerSchema);
+    }
+
+    /**
+     * Constructs the reader for the given file and the reader is
+     * expected to use the schema that is used with data.
+     */
+    DataFileReader(const char* filename) :
+        base_(new DataFileReaderBase(filename)) {
+        base_->init();
+    }
+
+    DataFileReader(std::unique_ptr<InputStream> inputStream) :
+        base_(new DataFileReaderBase(std::move(inputStream))) {
+        base_->init();
+    }
+
+    /**
+     * Constructs a reader using the reader base. This form of constructor
+     * allows the user to examine the schema of a given file and then
+     * decide to use the right type of data to be deserialize. Without this
+     * the user must know the type of data for the template _before_
+     * he knows the schema within the file.
+     * The schema present in the data file will be used for reading
+     * from this reader.
+     */
+    DataFileReader(std::unique_ptr<DataFileReaderBase> base) : base_(std::move(base)) {
+        base_->init();
+    }
+
+    /**
+     * Constructs a reader using the reader base. This form of constructor
+     * allows the user to examine the schema of a given file and then
+     * decide to use the right type of data to be deserialize. Without this
+     * the user must know the type of data for the template _before_
+     * he knows the schema within the file.
+     * The argument readerSchema will be used for reading
+     * from this reader.
+     */
+    DataFileReader(std::unique_ptr<DataFileReaderBase> base,
+        const ValidSchema& readerSchema) : base_(std::move(base)) {
+        base_->init(readerSchema);
+    }
+
+    /**
+     * Reads the next entry from the data file.
+     * \return true if an object has been successfully read into \p datum and
+     * false if there are no more entries in the file.
+     */
+    bool read(T& datum) {
+        if (base_->hasMore()) {
+            base_->decr();
+            avro::decode(base_->decoder(), datum);
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * Returns the schema for this object.
+     */
+    const ValidSchema& readerSchema() { return base_->readerSchema(); }
+
+    /**
+     * Returns the schema stored with the data file.
+     */
+    const ValidSchema& dataSchema() { return base_->dataSchema(); }
+
+    /**
+     * Closes the reader. No further operation is possible on this reader.
+     */
+    void close() { return base_->close(); }
+
+    /**
+     * Move to a specific, known synchronization point, for example one returned
+     * from previousSync().
+     */
+    void seek(int64_t position) { base_->seek(position); }
+
+    /**
+     * Move to the next synchronization point after a position. To process a
+     * range of file entries, call this with the starting position, then check
+     * pastSync() with the end point before each call to read().
+     */
+    void sync(int64_t position) { base_->sync(position); }
+
+    /**
+     * Return true if past the next synchronization point after a position.
+     */
+    bool pastSync(int64_t position) { return base_->pastSync(position); }
+
+    /**
+     * Return the last synchronization point before our current position.
+     */
+    int64_t previousSync() { return base_->previousSync(); }
+};
+
+}   // namespace avro
+#endif
diff --git a/contrib/libs/apache/avro/api/Decoder.hh b/contrib/libs/apache/avro/api/Decoder.hh
index c57fc05505..5356d79f32 100644
--- a/contrib/libs/apache/avro/api/Decoder.hh
+++ b/contrib/libs/apache/avro/api/Decoder.hh
@@ -1,226 +1,226 @@
-/* 
- * Licensed to the Apache Software Foundation (ASF) under one 
- * or more contributor license agreements.  See the NOTICE file 
- * distributed with this work for additional information 
- * regarding copyright ownership.  The ASF licenses this file 
- * to you under the Apache License, Version 2.0 (the 
- * "License"); you may not use this file except in compliance 
- * with the License.  You may obtain a copy of the License at 
- * 
- *     https://www.apache.org/licenses/LICENSE-2.0 
- * 
- * Unless required by applicable law or agreed to in writing, software 
- * distributed under the License is distributed on an "AS IS" BASIS, 
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
- * See the License for the specific language governing permissions and 
- * limitations under the License. 
- */ 
- 
-#ifndef avro_Decoder_hh__ 
-#define avro_Decoder_hh__ 
- 
-#include "Config.hh" 
-#include <stdint.h> 
-#include <string> 
-#include <vector> 
-#include <memory> 
- 
-#include "ValidSchema.hh" 
-#include "Stream.hh" 
- 
-/// \file 
-/// 
-/// Low level support for decoding avro values. 
-/// This class has two types of functions.  One type of functions support 
-/// decoding of leaf values (for example, decodeLong and 
-/// decodeString). These functions have analogs in Encoder. 
-/// 
-/// The other type of functions support decoding of maps and arrays. 
-/// These functions are arrayStart, startItem, and arrayEnd 
-/// (and similar functions for maps). 
- 
-namespace avro { 
- 
-/** 
- * Decoder is an interface implemented by every decoder capable 
- * of decoding Avro data. 
- */ 
-class AVRO_DECL Decoder { 
-public: 
-    virtual ~Decoder() { }; 
-    /// All future decoding will come from is, which should be valid 
-    /// until replaced by another call to init() or this Decoder is 
-    /// destructed. 
-    virtual void init(InputStream& is) = 0; 
- 
-    /// Decodes a null from the current stream. 
-    virtual void decodeNull() = 0; 
- 
-    /// Decodes a bool from the current stream 
-    virtual bool decodeBool() = 0; 
- 
-    /// Decodes a 32-bit int from the current stream. 
-    virtual int32_t decodeInt() = 0; 
- 
-    /// Decodes a 64-bit signed int from the current stream. 
-    virtual int64_t decodeLong() = 0; 
- 
-    /// Decodes a single-precision floating point number from current stream. 
-    virtual float decodeFloat() = 0; 
- 
-    /// Decodes a double-precision floating point number from current stream. 
-    virtual double decodeDouble() = 0; 
- 
-    /// Decodes a UTF-8 string from the current stream. 
-    std::string decodeString() { 
-        std::string result; 
-        decodeString(result); 
-        return result; 
-    } 
- 
-    /** 
-     * Decodes a UTF-8 string from the stream and assigns it to value. 
-     */ 
-    virtual void decodeString(std::string& value) = 0; 
- 
-    /// Skips a string on the current stream. 
-    virtual void skipString() = 0; 
- 
-    /// Decodes arbitray binary data from the current stream. 
-    std::vector<uint8_t> decodeBytes() { 
-        std::vector<uint8_t> result; 
-        decodeBytes(result); 
-        return result; 
-    } 
- 
-    /// Decodes arbitrary binary data from the current stream and puts it 
-    /// in value. 
-    virtual void decodeBytes(std::vector<uint8_t>& value) = 0; 
- 
-    /// Skips bytes on the current stream. 
-    virtual void skipBytes() = 0; 
- 
-    /** 
-     * Decodes fixed length binary from the current stream. 
-     * \param[in] n The size (byte count) of the fixed being read. 
-     * \return The fixed data that has been read. The size of the returned 
-     * vector is guaranteed to be equal to \p n. 
-     */ 
-    std::vector<uint8_t> decodeFixed(size_t n) { 
-        std::vector<uint8_t> result; 
-        decodeFixed(n, result); 
-        return result; 
-    } 
- 
-    /** 
-     * Decodes a fixed from the current stream. 
-     * \param[in] n The size (byte count) of the fixed being read. 
-     * \param[out] value The value that receives the fixed. The vector will 
-     * be size-adjusted based on the fixed's size. 
-     */ 
-    virtual void decodeFixed(size_t n, std::vector<uint8_t>& value) = 0; 
- 
-    /// Skips fixed length binary on the current stream. 
-    virtual void skipFixed(size_t n) = 0; 
- 
-    /// Decodes enum from the current stream. 
-    virtual size_t decodeEnum() = 0; 
- 
-    /// Start decoding an array. Returns the number of entries in first chunk. 
-    virtual size_t arrayStart() = 0; 
- 
-    /// Returns the number of entries in next chunk. 0 if last. 
-    virtual size_t arrayNext() = 0; 
- 
-    /// Tries to skip an array. If it can, it returns 0. Otherwise 
-    /// it returns the number of elements to be skipped. The client 
-    /// should skip the individual items. In such cases, skipArray 
-    /// is identical to arrayStart. 
-    virtual size_t skipArray() = 0; 
- 
-    /// Start decoding a map. Returns the number of entries in first chunk. 
-    virtual size_t mapStart() = 0; 
- 
-    /// Returns the number of entries in next chunk. 0 if last. 
-    virtual size_t mapNext() = 0; 
- 
-    /// Tries to skip a map. If it can, it returns 0. Otherwise 
-    /// it returns the number of elements to be skipped. The client 
-    /// should skip the individual items. In such cases, skipMap 
-    /// is identical to mapStart. 
-    virtual size_t skipMap() = 0; 
- 
-    /// Decodes a branch of a union. The actual value is to follow. 
-    virtual size_t decodeUnionIndex() = 0; 
- 
-    /// Drains any additional data at the end of the current entry in a stream. 
-    /// It also returns any unused bytes back to any underlying input stream. 
-    /// One situation this happens is when the reader's schema and 
-    /// the writer's schema are records but are different and the writer's 
-    /// record has more fields at the end of the record. 
-    /// Leaving such data unread is usually not a problem. If multiple 
-    /// records are stored consecutively in a stream (e.g. Avro data file) 
-    /// any attempt to read the next record will automatically skip 
-    /// those extra fields of the current record. It would still leave 
-    /// the extra fields at the end of the last record in the stream. 
-    /// This would mean that the stream is not in a good state. For example, 
-    /// if some non-avro information is stored at the end of the stream, 
-    /// the consumers of such data would see the bytes left behind 
-    /// by the avro decoder. Similar set of problems occur if the Decoder 
-    /// consumes more than what it should. 
-    virtual void drain() = 0; 
-}; 
- 
-/** 
- * Shared pointer to Decoder. 
- */ 
-typedef std::shared_ptr<Decoder> DecoderPtr; 
- 
-/** 
- * ResolvingDecoder is derived from \ref Decoder, with an additional 
- * function to obtain the field ordering of fields within a record. 
- */ 
-class AVRO_DECL ResolvingDecoder : public Decoder { 
-public: 
-    /// Returns the order of fields for records. 
-    /// The order of fields could be different from the order of their 
-    /// order in the schema because the writer's field order could 
-    /// be different. In order to avoid buffering and later use, 
-    /// we return the values in the writer's field order. 
-    virtual const std::vector<size_t>& fieldOrder() = 0; 
-}; 
- 
-/** 
- * Shared pointer to ResolvingDecoder. 
- */ 
-typedef std::shared_ptr<ResolvingDecoder> ResolvingDecoderPtr; 
-/** 
- *  Returns an decoder that can decode binary Avro standard. 
- */ 
-AVRO_DECL DecoderPtr binaryDecoder(); 
- 
-/** 
- *  Returns an decoder that validates sequence of calls to an underlying 
- *  Decoder against the given schema. 
- */ 
-AVRO_DECL DecoderPtr validatingDecoder(const ValidSchema& schema, 
-    const DecoderPtr& base); 
- 
-/** 
- *  Returns an decoder that can decode Avro standard for JSON. 
- */ 
-AVRO_DECL DecoderPtr jsonDecoder(const ValidSchema& schema); 
- 
-/** 
- *  Returns a decoder that decodes avro data from base written according to 
- *  writerSchema and resolves against readerSchema. 
- *  The client uses the decoder as if the data were written using readerSchema. 
- *  // FIXME: Handle out of order fields. 
- */ 
-AVRO_DECL ResolvingDecoderPtr resolvingDecoder(const ValidSchema& writer, 
-    const ValidSchema& reader, const DecoderPtr& base); 
- 
- 
-}   // namespace avro 
- 
-#endif 
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef avro_Decoder_hh__
+#define avro_Decoder_hh__
+
+#include "Config.hh"
+#include <stdint.h>
+#include <string>
+#include <vector>
+#include <memory>
+
+#include "ValidSchema.hh"
+#include "Stream.hh"
+
+/// \file
+///
+/// Low level support for decoding avro values.
+/// This class has two types of functions.  One type of functions support
+/// decoding of leaf values (for example, decodeLong and
+/// decodeString). These functions have analogs in Encoder.
+///
+/// The other type of functions support decoding of maps and arrays.
+/// These functions are arrayStart, startItem, and arrayEnd
+/// (and similar functions for maps).
+
+namespace avro {
+
+/**
+ * Decoder is an interface implemented by every decoder capable
+ * of decoding Avro data.
+ */
+class AVRO_DECL Decoder {
+public:
+    virtual ~Decoder() { };
+    /// All future decoding will come from is, which should be valid
+    /// until replaced by another call to init() or this Decoder is
+    /// destructed.
+    virtual void init(InputStream& is) = 0;
+
+    /// Decodes a null from the current stream.
+    virtual void decodeNull() = 0;
+
+    /// Decodes a bool from the current stream
+    virtual bool decodeBool() = 0;
+
+    /// Decodes a 32-bit int from the current stream.
+    virtual int32_t decodeInt() = 0;
+
+    /// Decodes a 64-bit signed int from the current stream.
+    virtual int64_t decodeLong() = 0;
+
+    /// Decodes a single-precision floating point number from current stream.
+    virtual float decodeFloat() = 0;
+
+    /// Decodes a double-precision floating point number from current stream.
+    virtual double decodeDouble() = 0;
+
+    /// Decodes a UTF-8 string from the current stream.
+    std::string decodeString() {
+        std::string result;
+        decodeString(result);
+        return result;
+    }
+
+    /**
+     * Decodes a UTF-8 string from the stream and assigns it to value.
+     */
+    virtual void decodeString(std::string& value) = 0;
+
+    /// Skips a string on the current stream.
+    virtual void skipString() = 0;
+
+    /// Decodes arbitray binary data from the current stream.
+    std::vector<uint8_t> decodeBytes() {
+        std::vector<uint8_t> result;
+        decodeBytes(result);
+        return result;
+    }
+
+    /// Decodes arbitrary binary data from the current stream and puts it
+    /// in value.
+    virtual void decodeBytes(std::vector<uint8_t>& value) = 0;
+
+    /// Skips bytes on the current stream.
+    virtual void skipBytes() = 0;
+
+    /**
+     * Decodes fixed length binary from the current stream.
+     * \param[in] n The size (byte count) of the fixed being read.
+     * \return The fixed data that has been read. The size of the returned
+     * vector is guaranteed to be equal to \p n.
+     */
+    std::vector<uint8_t> decodeFixed(size_t n) {
+        std::vector<uint8_t> result;
+        decodeFixed(n, result);
+        return result;
+    }
+
+    /**
+     * Decodes a fixed from the current stream.
+     * \param[in] n The size (byte count) of the fixed being read.
+     * \param[out] value The value that receives the fixed. The vector will
+     * be size-adjusted based on the fixed's size.
+     */
+    virtual void decodeFixed(size_t n, std::vector<uint8_t>& value) = 0;
+
+    /// Skips fixed length binary on the current stream.
+    virtual void skipFixed(size_t n) = 0;
+
+    /// Decodes enum from the current stream.
+    virtual size_t decodeEnum() = 0;
+
+    /// Start decoding an array. Returns the number of entries in first chunk.
+    virtual size_t arrayStart() = 0;
+
+    /// Returns the number of entries in next chunk. 0 if last.
+    virtual size_t arrayNext() = 0;
+
+    /// Tries to skip an array. If it can, it returns 0. Otherwise
+    /// it returns the number of elements to be skipped. The client
+    /// should skip the individual items. In such cases, skipArray
+    /// is identical to arrayStart.
+    virtual size_t skipArray() = 0;
+
+    /// Start decoding a map. Returns the number of entries in first chunk.
+    virtual size_t mapStart() = 0;
+
+    /// Returns the number of entries in next chunk. 0 if last.
+    virtual size_t mapNext() = 0;
+
+    /// Tries to skip a map. If it can, it returns 0. Otherwise
+    /// it returns the number of elements to be skipped. The client
+    /// should skip the individual items. In such cases, skipMap
+    /// is identical to mapStart.
+    virtual size_t skipMap() = 0;
+
+    /// Decodes a branch of a union. The actual value is to follow.
+    virtual size_t decodeUnionIndex() = 0;
+
+    /// Drains any additional data at the end of the current entry in a stream.
+    /// It also returns any unused bytes back to any underlying input stream.
+    /// One situation this happens is when the reader's schema and
+    /// the writer's schema are records but are different and the writer's
+    /// record has more fields at the end of the record.
+    /// Leaving such data unread is usually not a problem. If multiple
+    /// records are stored consecutively in a stream (e.g. Avro data file)
+    /// any attempt to read the next record will automatically skip
+    /// those extra fields of the current record. It would still leave
+    /// the extra fields at the end of the last record in the stream.
+    /// This would mean that the stream is not in a good state. For example,
+    /// if some non-avro information is stored at the end of the stream,
+    /// the consumers of such data would see the bytes left behind
+    /// by the avro decoder. Similar set of problems occur if the Decoder
+    /// consumes more than what it should.
+    virtual void drain() = 0;
+};
+
+/**
+ * Shared pointer to Decoder.
+ */
+typedef std::shared_ptr<Decoder> DecoderPtr;
+
+/**
+ * ResolvingDecoder is derived from \ref Decoder, with an additional
+ * function to obtain the field ordering of fields within a record.
+ */
+class AVRO_DECL ResolvingDecoder : public Decoder {
+public:
+    /// Returns the order of fields for records.
+    /// The order of fields could be different from the order of their
+    /// order in the schema because the writer's field order could
+    /// be different. In order to avoid buffering and later use,
+    /// we return the values in the writer's field order.
+    virtual const std::vector<size_t>& fieldOrder() = 0;
+};
+
+/**
+ * Shared pointer to ResolvingDecoder.
+ */
+typedef std::shared_ptr<ResolvingDecoder> ResolvingDecoderPtr;
+/**
+ *  Returns an decoder that can decode binary Avro standard.
+ */
+AVRO_DECL DecoderPtr binaryDecoder();
+
+/**
+ *  Returns an decoder that validates sequence of calls to an underlying
+ *  Decoder against the given schema.
+ */
+AVRO_DECL DecoderPtr validatingDecoder(const ValidSchema& schema,
+    const DecoderPtr& base);
+
+/**
+ *  Returns an decoder that can decode Avro standard for JSON.
+ */
+AVRO_DECL DecoderPtr jsonDecoder(const ValidSchema& schema);
+
+/**
+ *  Returns a decoder that decodes avro data from base written according to
+ *  writerSchema and resolves against readerSchema.
+ *  The client uses the decoder as if the data were written using readerSchema.
+ *  // FIXME: Handle out of order fields.
+ */
+AVRO_DECL ResolvingDecoderPtr resolvingDecoder(const ValidSchema& writer,
+    const ValidSchema& reader, const DecoderPtr& base);
+
+
+}   // namespace avro
+
+#endif
diff --git a/contrib/libs/apache/avro/api/Encoder.hh b/contrib/libs/apache/avro/api/Encoder.hh
index 0d1f198e76..7849e93458 100644
--- a/contrib/libs/apache/avro/api/Encoder.hh
+++ b/contrib/libs/apache/avro/api/Encoder.hh
@@ -1,173 +1,173 @@
-/* 
- * Licensed to the Apache Software Foundation (ASF) under one 
- * or more contributor license agreements.  See the NOTICE file 
- * distributed with this work for additional information 
- * regarding copyright ownership.  The ASF licenses this file 
- * to you under the Apache License, Version 2.0 (the 
- * "License"); you may not use this file except in compliance 
- * with the License.  You may obtain a copy of the License at 
- * 
- *     https://www.apache.org/licenses/LICENSE-2.0 
- * 
- * Unless required by applicable law or agreed to in writing, software 
- * distributed under the License is distributed on an "AS IS" BASIS, 
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
- * See the License for the specific language governing permissions and 
- * limitations under the License. 
- */ 
- 
-#ifndef avro_Encoder_hh__ 
-#define avro_Encoder_hh__ 
- 
-#include "Config.hh" 
-#include <stdint.h> 
-#include <string> 
-#include <vector> 
-#include <memory> 
- 
-#include "ValidSchema.hh" 
-#include "Stream.hh" 
- 
-/// \file 
-/// 
-/// Low level support for encoding avro values. 
-/// This class has two types of funtions.  One type of functions support 
-/// the writing of leaf values (for example, encodeLong and 
-/// encodeString).  These functions have analogs in Decoder. 
-/// 
-/// The other type of functions support the writing of maps and arrays. 
-/// These functions are arrayStart, startItem, and arrayEnd 
-/// (and similar functions for maps). 
-/// Some implementations of Encoder handle the 
-/// buffering required to break large maps and arrays into blocks, 
-/// which is necessary for applications that want to do streaming. 
- 
-namespace avro { 
- 
-/** 
- * The abstract base class for all Avro encoders. The implementations 
- * differ in the method of encoding (binary vresus JSON) or in capabilities 
- * such as ability to verify the order of invocation of different functions. 
- */ 
-class AVRO_DECL Encoder { 
-public: 
-    virtual ~Encoder() { }; 
-    /// All future encodings will go to os, which should be valid until 
-    /// it is reset with another call to init() or the encoder is 
-    /// destructed. 
-    virtual void init(OutputStream& os) = 0; 
- 
-    /// Flushes any data in internal buffers. 
-    virtual void flush() = 0; 
- 
-    /// Returns the number of bytes produced so far. 
-    /// For a meaningful value, do a flush() before invoking this function. 
-    virtual int64_t byteCount() const = 0; 
- 
-    /// Encodes a null to the current stream. 
-    virtual void encodeNull() = 0; 
- 
-    /// Encodes a bool to the current stream 
-    virtual void encodeBool(bool b) = 0; 
- 
-    /// Encodes a 32-bit int to the current stream. 
-    virtual void encodeInt(int32_t i) = 0; 
- 
-    /// Encodes a 64-bit signed int to the current stream. 
-    virtual void encodeLong(int64_t l) = 0; 
- 
-    /// Encodes a single-precision floating point number to the current stream. 
-    virtual void encodeFloat(float f) = 0; 
- 
-    /// Encodes a double-precision floating point number to the current stream. 
-    virtual void encodeDouble(double d) = 0; 
- 
-    /// Encodes a UTF-8 string to the current stream. 
-    virtual void encodeString(const std::string& s) = 0; 
- 
-    /** 
-     * Encodes aribtray binary data into tthe current stream as Avro "bytes" 
-     * data type. 
-     * \param bytes Where the data is 
-     * \param len Number of bytes at \p bytes. 
-     */ 
-    virtual void encodeBytes(const uint8_t *bytes, size_t len) = 0; 
- 
-    /** 
-     * Encodes aribtray binary data into tthe current stream as Avro "bytes" 
-     * data type. 
-     * \param bytes The data. 
-     */ 
-    void encodeBytes(const std::vector<uint8_t>& bytes) { 
-        uint8_t b = 0; 
-        encodeBytes(bytes.empty() ? &b : bytes.data(), bytes.size()); 
-    } 
- 
-    /// Encodes fixed length binary to the current stream. 
-    virtual void encodeFixed(const uint8_t *bytes, size_t len) = 0; 
- 
-    /** 
-     * Encodes an Avro data type Fixed. 
-     * \param bytes The fixed, the length of which is taken as the size 
-     * of fixed. 
-     */ 
-    void encodeFixed(const std::vector<uint8_t>& bytes) { 
-        encodeFixed(bytes.data(), bytes.size()); 
-    } 
- 
-    /// Encodes enum to the current stream. 
-    virtual void encodeEnum(size_t e) = 0; 
- 
-    /// Indicates that an array of items is being encoded. 
-    virtual void arrayStart() = 0; 
- 
-    /// Indicates that the current array of items have ended. 
-    virtual void arrayEnd() = 0; 
- 
-    /// Indicates that a map of items is being encoded. 
-    virtual void mapStart() = 0; 
- 
-    /// Indicates that the current map of items have ended. 
-    virtual void mapEnd() = 0; 
- 
-    /// Indicates that count number of items are to follow in the current array 
-    /// or map. 
-    virtual void setItemCount(size_t count) = 0; 
- 
-    /// Marks a beginning of an item in the current array or map. 
-    virtual void startItem() = 0; 
- 
-    /// Encodes a branch of a union. The actual value is to follow. 
-    virtual void encodeUnionIndex(size_t e) = 0; 
-}; 
- 
-/** 
- * Shared pointer to Encoder. 
- */ 
-typedef std::shared_ptr<Encoder> EncoderPtr; 
- 
-/** 
- *  Returns an encoder that can encode binary Avro standard. 
- */ 
-AVRO_DECL EncoderPtr binaryEncoder(); 
- 
-/** 
- *  Returns an encoder that validates sequence of calls to an underlying 
- *  Encoder against the given schema. 
- */ 
-AVRO_DECL EncoderPtr validatingEncoder(const ValidSchema& schema, 
-    const EncoderPtr& base); 
- 
-/** 
- *  Returns an encoder that encodes Avro standard for JSON. 
- */ 
-AVRO_DECL EncoderPtr jsonEncoder(const ValidSchema& schema); 
- 
-/** 
- *  Returns an encoder that encodes Avro standard for pretty printed JSON. 
- */ 
-AVRO_DECL EncoderPtr jsonPrettyEncoder(const ValidSchema& schema); 
- 
-}   // namespace avro 
- 
-#endif 
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef avro_Encoder_hh__
+#define avro_Encoder_hh__
+
+#include "Config.hh"
+#include <stdint.h>
+#include <string>
+#include <vector>
+#include <memory>
+
+#include "ValidSchema.hh"
+#include "Stream.hh"
+
+/// \file
+///
+/// Low level support for encoding avro values.
+/// This class has two types of funtions.  One type of functions support
+/// the writing of leaf values (for example, encodeLong and
+/// encodeString).  These functions have analogs in Decoder.
+///
+/// The other type of functions support the writing of maps and arrays.
+/// These functions are arrayStart, startItem, and arrayEnd
+/// (and similar functions for maps).
+/// Some implementations of Encoder handle the
+/// buffering required to break large maps and arrays into blocks,
+/// which is necessary for applications that want to do streaming.
+
+namespace avro {
+
+/**
+ * The abstract base class for all Avro encoders. The implementations
+ * differ in the method of encoding (binary vresus JSON) or in capabilities
+ * such as ability to verify the order of invocation of different functions.
+ */
+class AVRO_DECL Encoder {
+public:
+    virtual ~Encoder() { };
+    /// All future encodings will go to os, which should be valid until
+    /// it is reset with another call to init() or the encoder is
+    /// destructed.
+    virtual void init(OutputStream& os) = 0;
+
+    /// Flushes any data in internal buffers.
+    virtual void flush() = 0;
+
+    /// Returns the number of bytes produced so far.
+    /// For a meaningful value, do a flush() before invoking this function.
+    virtual int64_t byteCount() const = 0;
+
+    /// Encodes a null to the current stream.
+    virtual void encodeNull() = 0;
+
+    /// Encodes a bool to the current stream
+    virtual void encodeBool(bool b) = 0;
+
+    /// Encodes a 32-bit int to the current stream.
+    virtual void encodeInt(int32_t i) = 0;
+
+    /// Encodes a 64-bit signed int to the current stream.
+    virtual void encodeLong(int64_t l) = 0;
+
+    /// Encodes a single-precision floating point number to the current stream.
+    virtual void encodeFloat(float f) = 0;
+
+    /// Encodes a double-precision floating point number to the current stream.
+    virtual void encodeDouble(double d) = 0;
+
+    /// Encodes a UTF-8 string to the current stream.
+    virtual void encodeString(const std::string& s) = 0;
+
+    /**
+     * Encodes aribtray binary data into tthe current stream as Avro "bytes"
+     * data type.
+     * \param bytes Where the data is
+     * \param len Number of bytes at \p bytes.
+     */
+    virtual void encodeBytes(const uint8_t *bytes, size_t len) = 0;
+
+    /**
+     * Encodes aribtray binary data into tthe current stream as Avro "bytes"
+     * data type.
+     * \param bytes The data.
+     */
+    void encodeBytes(const std::vector<uint8_t>& bytes) {
+        uint8_t b = 0;
+        encodeBytes(bytes.empty() ? &b : bytes.data(), bytes.size());
+    }
+
+    /// Encodes fixed length binary to the current stream.
+    virtual void encodeFixed(const uint8_t *bytes, size_t len) = 0;
+
+    /**
+     * Encodes an Avro data type Fixed.
+     * \param bytes The fixed, the length of which is taken as the size
+     * of fixed.
+     */
+    void encodeFixed(const std::vector<uint8_t>& bytes) {
+        encodeFixed(bytes.data(), bytes.size());
+    }
+
+    /// Encodes enum to the current stream.
+    virtual void encodeEnum(size_t e) = 0;
+
+    /// Indicates that an array of items is being encoded.
+    virtual void arrayStart() = 0;
+
+    /// Indicates that the current array of items have ended.
+    virtual void arrayEnd() = 0;
+
+    /// Indicates that a map of items is being encoded.
+    virtual void mapStart() = 0;
+
+    /// Indicates that the current map of items have ended.
+    virtual void mapEnd() = 0;
+
+    /// Indicates that count number of items are to follow in the current array
+    /// or map.
+    virtual void setItemCount(size_t count) = 0;
+
+    /// Marks a beginning of an item in the current array or map.
+    virtual void startItem() = 0;
+
+    /// Encodes a branch of a union. The actual value is to follow.
+    virtual void encodeUnionIndex(size_t e) = 0;
+};
+
+/**
+ * Shared pointer to Encoder.
+ */
+typedef std::shared_ptr<Encoder> EncoderPtr;
+
+/**
+ *  Returns an encoder that can encode binary Avro standard.
+ */
+AVRO_DECL EncoderPtr binaryEncoder();
+
+/**
+ *  Returns an encoder that validates sequence of calls to an underlying
+ *  Encoder against the given schema.
+ */
+AVRO_DECL EncoderPtr validatingEncoder(const ValidSchema& schema,
+    const EncoderPtr& base);
+
+/**
+ *  Returns an encoder that encodes Avro standard for JSON.
+ */
+AVRO_DECL EncoderPtr jsonEncoder(const ValidSchema& schema);
+
+/**
+ *  Returns an encoder that encodes Avro standard for pretty printed JSON.
+ */
+AVRO_DECL EncoderPtr jsonPrettyEncoder(const ValidSchema& schema);
+
+}   // namespace avro
+
+#endif
diff --git a/contrib/libs/apache/avro/api/Exception.hh b/contrib/libs/apache/avro/api/Exception.hh
index 4bcf63daa5..7c5410f96b 100644
--- a/contrib/libs/apache/avro/api/Exception.hh
+++ b/contrib/libs/apache/avro/api/Exception.hh
@@ -1,46 +1,46 @@
-/* 
- * Licensed to the Apache Software Foundation (ASF) under one 
- * or more contributor license agreements.  See the NOTICE file 
- * distributed with this work for additional information 
- * regarding copyright ownership.  The ASF licenses this file 
- * to you under the Apache License, Version 2.0 (the 
- * "License"); you may not use this file except in compliance 
- * with the License.  You may obtain a copy of the License at 
- * 
- *     https://www.apache.org/licenses/LICENSE-2.0 
- * 
- * Unless required by applicable law or agreed to in writing, software 
- * distributed under the License is distributed on an "AS IS" BASIS, 
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
- * See the License for the specific language governing permissions and 
- * limitations under the License. 
- */ 
- 
-#ifndef avro_Exception_hh__ 
-#define avro_Exception_hh__ 
- 
-#include "Config.hh" 
-#include <stdexcept> 
-#include <boost/format.hpp> 
- 
-namespace avro { 
- 
-/// Wrapper for std::runtime_error that provides convenience constructor 
-/// for boost::format objects 
- 
-class AVRO_DECL Exception : public virtual std::runtime_error 
-{ 
-  public: 
- 
-    Exception(const std::string &msg) : 
-        std::runtime_error(msg) 
-    { } 
- 
-    Exception(const boost::format &msg) : 
-        std::runtime_error( boost::str(msg)) 
-    { } 
-}; 
- 
-} // namespace avro 
- 
-#endif 
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef avro_Exception_hh__
+#define avro_Exception_hh__
+
+#include "Config.hh"
+#include <stdexcept>
+#include <boost/format.hpp>
+
+namespace avro {
+
+/// Wrapper for std::runtime_error that provides convenience constructor
+/// for boost::format objects
+
+class AVRO_DECL Exception : public virtual std::runtime_error
+{
+  public:
+
+    Exception(const std::string &msg) :
+        std::runtime_error(msg)
+    { }
+
+    Exception(const boost::format &msg) :
+        std::runtime_error( boost::str(msg))
+    { }
+};
+
+} // namespace avro
+
+#endif
diff --git a/contrib/libs/apache/avro/api/Generic.hh b/contrib/libs/apache/avro/api/Generic.hh
index 12f8610f8d..e1b3a8290c 100644
--- a/contrib/libs/apache/avro/api/Generic.hh
+++ b/contrib/libs/apache/avro/api/Generic.hh
@@ -1,149 +1,149 @@
-/* 
- * Licensed to the Apache Software Foundation (ASF) under one 
- * or more contributor license agreements.  See the NOTICE file 
- * distributed with this work for additional information 
- * regarding copyright ownership.  The ASF licenses this file 
- * to you under the Apache License, Version 2.0 (the 
- * "License"); you may not use this file except in compliance 
- * with the License.  You may obtain a copy of the License at 
- * 
- *     https://www.apache.org/licenses/LICENSE-2.0 
- * 
- * Unless required by applicable law or agreed to in writing, software 
- * distributed under the License is distributed on an "AS IS" BASIS, 
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
- * See the License for the specific language governing permissions and 
- * limitations under the License. 
- */ 
- 
-#ifndef avro_Generic_hh__ 
-#define avro_Generic_hh__ 
- 
-#include <boost/utility.hpp> 
- 
-#include "Config.hh" 
-#include "Types.hh" 
-#include "Encoder.hh" 
-#include "Decoder.hh" 
-#include "GenericDatum.hh" 
- 
-namespace avro { 
-/** 
- * A utility class to read generic datum from decoders. 
- */ 
-class AVRO_DECL GenericReader : boost::noncopyable { 
-    const ValidSchema schema_; 
-    const bool isResolving_; 
-    const DecoderPtr decoder_; 
- 
-    static void read(GenericDatum& datum, Decoder& d, bool isResolving); 
-public: 
-    /** 
-     * Constructs a reader for the given schema using the given decoder. 
-     */ 
-    GenericReader(const ValidSchema& s, const DecoderPtr& decoder); 
- 
-    /** 
-     * Constructs a reader for the given reader's schema \c readerSchema 
-     * using the given 
-     * decoder which holds data matching writer's schema \c writerSchema. 
-     */ 
-    GenericReader(const ValidSchema& writerSchema, 
-        const ValidSchema& readerSchema, const DecoderPtr& decoder); 
- 
-    /** 
-     * Reads a value off the decoder. 
-     */ 
-    void read(GenericDatum& datum) const; 
- 
-    /** 
-     * Drains any residual bytes in the input stream (e.g. because 
-     * reader's schema has no use of them) and return unused bytes 
-     * back to the underlying input stream. 
-     */ 
-    void drain() { 
-        decoder_->drain(); 
-    } 
-    /** 
-     * Reads a generic datum from the stream, using the given schema. 
-     */ 
-    static void read(Decoder& d, GenericDatum& g); 
- 
-    /** 
-     * Reads a generic datum from the stream, using the given schema. 
-     */ 
-    static void read(Decoder& d, GenericDatum& g, const ValidSchema& s); 
-}; 
- 
- 
-/** 
- * A utility class to write generic datum to encoders. 
- */ 
-class AVRO_DECL GenericWriter : boost::noncopyable { 
-    const ValidSchema schema_; 
-    const EncoderPtr encoder_; 
- 
-    static void write(const GenericDatum& datum, Encoder& e); 
-public: 
-    /** 
-     * Constructs a writer for the given schema using the given encoder. 
-     */ 
-    GenericWriter(const ValidSchema& s, const EncoderPtr& encoder); 
- 
-    /** 
-     * Writes a value onto the encoder. 
-     */ 
-    void write(const GenericDatum& datum) const; 
- 
-    /** 
-     * Writes a generic datum on to the stream. 
-     */ 
-    static void write(Encoder& e, const GenericDatum& g); 
- 
-    /** 
-     * Writes a generic datum on to the stream, using the given schema. 
-     * Retained for backward compatibility. 
-     */ 
-    static void write(Encoder& e, const GenericDatum& g, const ValidSchema&) { 
-        write(e, g); 
-    } 
-}; 
- 
-template <typename T> struct codec_traits; 
- 
-/** 
- * Specialization of codec_traits for Generic datum along with its schema. 
- * This is maintained for compatibility with old code. Please use the 
- * cleaner codec_traits<GenericDatum> instead. 
- */ 
-template <> struct codec_traits<std::pair<ValidSchema, GenericDatum> > { 
-    /** Encodes */ 
-    static void encode(Encoder& e, 
-        const std::pair<ValidSchema, GenericDatum>& p) { 
-        GenericWriter::write(e, p.second, p.first); 
-    } 
- 
-    /** Decodes */ 
-    static void decode(Decoder& d, std::pair<ValidSchema, GenericDatum>& p) { 
-        GenericReader::read(d, p.second, p.first); 
-    } 
-}; 
- 
-/** 
- * Specialization of codec_traits for GenericDatum. 
- */ 
-template <> struct codec_traits<GenericDatum> { 
-    /** Encodes */ 
-    static void encode(Encoder& e, const GenericDatum& g) { 
-        GenericWriter::write(e, g); 
-    } 
- 
-    /** Decodes */ 
-    static void decode(Decoder& d, GenericDatum& g) { 
-        GenericReader::read(d, g); 
-    } 
-}; 
- 
-}   // namespace avro 
-#endif 
- 
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef avro_Generic_hh__
+#define avro_Generic_hh__
+
+#include <boost/utility.hpp>
+
+#include "Config.hh"
+#include "Types.hh"
+#include "Encoder.hh"
+#include "Decoder.hh"
+#include "GenericDatum.hh"
+
+namespace avro {
+/**
+ * A utility class to read generic datum from decoders.
+ */
+class AVRO_DECL GenericReader : boost::noncopyable {
+    const ValidSchema schema_;
+    const bool isResolving_;
+    const DecoderPtr decoder_;
+
+    static void read(GenericDatum& datum, Decoder& d, bool isResolving);
+public:
+    /**
+     * Constructs a reader for the given schema using the given decoder.
+     */
+    GenericReader(const ValidSchema& s, const DecoderPtr& decoder);
+
+    /**
+     * Constructs a reader for the given reader's schema \c readerSchema
+     * using the given
+     * decoder which holds data matching writer's schema \c writerSchema.
+     */
+    GenericReader(const ValidSchema& writerSchema,
+        const ValidSchema& readerSchema, const DecoderPtr& decoder);
+
+    /**
+     * Reads a value off the decoder.
+     */
+    void read(GenericDatum& datum) const;
+
+    /**
+     * Drains any residual bytes in the input stream (e.g. because
+     * reader's schema has no use of them) and return unused bytes
+     * back to the underlying input stream.
+     */
+    void drain() {
+        decoder_->drain();
+    }
+    /**
+     * Reads a generic datum from the stream, using the given schema.
+     */
+    static void read(Decoder& d, GenericDatum& g);
+
+    /**
+     * Reads a generic datum from the stream, using the given schema.
+     */
+    static void read(Decoder& d, GenericDatum& g, const ValidSchema& s);
+};
+
+
+/**
+ * A utility class to write generic datum to encoders.
+ */
+class AVRO_DECL GenericWriter : boost::noncopyable {
+    const ValidSchema schema_;
+    const EncoderPtr encoder_;
+
+    static void write(const GenericDatum& datum, Encoder& e);
+public:
+    /**
+     * Constructs a writer for the given schema using the given encoder.
+     */
+    GenericWriter(const ValidSchema& s, const EncoderPtr& encoder);
+
+    /**
+     * Writes a value onto the encoder.
+     */
+    void write(const GenericDatum& datum) const;
+
+    /**
+     * Writes a generic datum on to the stream.
+     */
+    static void write(Encoder& e, const GenericDatum& g);
+
+    /**
+     * Writes a generic datum on to the stream, using the given schema.
+     * Retained for backward compatibility.
+     */
+    static void write(Encoder& e, const GenericDatum& g, const ValidSchema&) {
+        write(e, g);
+    }
+};
+
+template <typename T> struct codec_traits;
+
+/**
+ * Specialization of codec_traits for Generic datum along with its schema.
+ * This is maintained for compatibility with old code. Please use the
+ * cleaner codec_traits<GenericDatum> instead.
+ */
+template <> struct codec_traits<std::pair<ValidSchema, GenericDatum> > {
+    /** Encodes */
+    static void encode(Encoder& e,
+        const std::pair<ValidSchema, GenericDatum>& p) {
+        GenericWriter::write(e, p.second, p.first);
+    }
+
+    /** Decodes */
+    static void decode(Decoder& d, std::pair<ValidSchema, GenericDatum>& p) {
+        GenericReader::read(d, p.second, p.first);
+    }
+};
+
+/**
+ * Specialization of codec_traits for GenericDatum.
+ */
+template <> struct codec_traits<GenericDatum> {
+    /** Encodes */
+    static void encode(Encoder& e, const GenericDatum& g) {
+        GenericWriter::write(e, g);
+    }
+
+    /** Decodes */
+    static void decode(Decoder& d, GenericDatum& g) {
+        GenericReader::read(d, g);
+    }
+};
+
+}   // namespace avro
+#endif
+
diff --git a/contrib/libs/apache/avro/api/GenericDatum.hh b/contrib/libs/apache/avro/api/GenericDatum.hh
index 15cd53becb..ac0e5e5e20 100644
--- a/contrib/libs/apache/avro/api/GenericDatum.hh
+++ b/contrib/libs/apache/avro/api/GenericDatum.hh
@@ -1,576 +1,576 @@
-/* 
- * Licensed to the Apache Software Foundation (ASF) under one 
- * or more contributor license agreements.  See the NOTICE file 
- * distributed with this work for additional information 
- * regarding copyright ownership.  The ASF licenses this file 
- * to you under the Apache License, Version 2.0 (the 
- * "License"); you may not use this file except in compliance 
- * with the License.  You may obtain a copy of the License at 
- * 
- *     https://www.apache.org/licenses/LICENSE-2.0 
- * 
- * Unless required by applicable law or agreed to in writing, software 
- * distributed under the License is distributed on an "AS IS" BASIS, 
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
- * See the License for the specific language governing permissions and 
- * limitations under the License. 
- */ 
- 
-#ifndef avro_GenericDatum_hh__ 
-#define avro_GenericDatum_hh__ 
- 
-#include <stdint.h> 
-#include <vector> 
-#include <map> 
-#include <string> 
- 
-#if __cplusplus >= 201703L 
-#include <any> 
-#else 
-#include "boost/any.hpp" 
-#endif 
- 
-#include "LogicalType.hh" 
-#include "Node.hh" 
-#include "ValidSchema.hh" 
- 
-namespace avro { 
- 
-/** 
- * Generic datum which can hold any Avro type. The datum has a type 
- * and a value. The type is one of the Avro data types. The C++ type for 
- * value corresponds to the Avro type. 
- * \li An Avro <tt>null</tt> corresponds to no C++ type. It is illegal to 
- * to try to access values for <tt>null</tt>. 
- * \li Avro <tt>boolean</tt> maps to C++ <tt>bool</tt> 
- * \li Avro <tt>int</tt> maps to C++ <tt>int32_t</tt>. 
- * \li Avro <tt>long</tt> maps to C++ <tt>int64_t</tt>. 
- * \li Avro <tt>float</tt> maps to C++ <tt>float</tt>. 
- * \li Avro <tt>double</tt> maps to C++ <tt>double</tt>. 
- * \li Avro <tt>string</tt> maps to C++ <tt>std::string</tt>. 
- * \li Avro <tt>bytes</tt> maps to C++ <tt>std::vector&lt;uint_t&gt;</tt>. 
- * \li Avro <tt>fixed</tt> maps to C++ class <tt>GenericFixed</tt>. 
- * \li Avro <tt>enum</tt> maps to C++ class <tt>GenericEnum</tt>. 
- * \li Avro <tt>array</tt> maps to C++ class <tt>GenericArray</tt>. 
- * \li Avro <tt>map</tt> maps to C++ class <tt>GenericMap</tt>. 
- * \li There is no C++ type corresponding to Avro <tt>union</tt>. The 
- * object should have the C++ type corresponing to one of the constituent 
- * types of the union. 
- * 
- */ 
-class AVRO_DECL GenericDatum { 
-protected: 
-    Type type_; 
-    LogicalType logicalType_; 
-#if __cplusplus >= 201703L 
-    std::any value_; 
-#else 
-    boost::any value_; 
-#endif 
- 
-    GenericDatum(Type t) 
-        : type_(t), logicalType_(LogicalType::NONE) { } 
- 
-    GenericDatum(Type t, LogicalType logicalType) 
-        : type_(t), logicalType_(logicalType) { } 
- 
-    template <typename T> 
-    GenericDatum(Type t, LogicalType logicalType, const T& v) 
-        : type_(t), logicalType_(logicalType), value_(v) { } 
- 
-    void init(const NodePtr& schema); 
-public: 
-    /** 
-     * The avro data type this datum holds. 
-     */ 
-    Type type() const; 
- 
-    /** 
-     * The avro logical type that augments the main data type this datum holds. 
-     */ 
-    LogicalType logicalType() const; 
- 
-    /** 
-     * Returns the value held by this datum. 
-     * T The type for the value. This must correspond to the 
-     * avro type returned by type(). 
-     */ 
-    template<typename T> const T& value() const; 
- 
-    /** 
-     * Returns the reference to the value held by this datum, which 
-     * can be used to change the contents. Please note that only 
-     * value can be changed, the data type of the value held cannot 
-     * be changed. 
-     * 
-     * T The type for the value. This must correspond to the 
-     * avro type returned by type(). 
-     */ 
-    template<typename T> T& value(); 
- 
-    /** 
-     * Returns true if and only if this datum is a union. 
-     */ 
-    bool isUnion() const { return type_ == AVRO_UNION; } 
- 
-    /** 
-     * Returns the index of the current branch, if this is a union. 
-     * \sa isUnion(). 
-     */ 
-    size_t unionBranch() const; 
- 
-    /** 
-     * Selects a new branch in the union if this is a union. 
-     * \sa isUnion(). 
-     */ 
-    void selectBranch(size_t branch); 
- 
-    /// Makes a new AVRO_NULL datum. 
-    GenericDatum() : type_(AVRO_NULL), logicalType_(LogicalType::NONE) { } 
- 
-    /// Makes a new AVRO_BOOL datum whose value is of type bool. 
-    GenericDatum(bool v) 
-        : type_(AVRO_BOOL), logicalType_(LogicalType::NONE), value_(v) { } 
- 
-    /// Makes a new AVRO_INT datum whose value is of type int32_t. 
-    GenericDatum(int32_t v) 
-        : type_(AVRO_INT), logicalType_(LogicalType::NONE), value_(v) { } 
- 
-    /// Makes a new AVRO_LONG datum whose value is of type int64_t. 
-    GenericDatum(int64_t v) 
-        : type_(AVRO_LONG), logicalType_(LogicalType::NONE), value_(v) { } 
- 
-    /// Makes a new AVRO_FLOAT datum whose value is of type float. 
-    GenericDatum(float v) 
-        : type_(AVRO_FLOAT), logicalType_(LogicalType::NONE), value_(v) { } 
- 
-    /// Makes a new AVRO_DOUBLE datum whose value is of type double. 
-    GenericDatum(double v) 
-        : type_(AVRO_DOUBLE), logicalType_(LogicalType::NONE), value_(v) { } 
- 
-    /// Makes a new AVRO_STRING datum whose value is of type std::string. 
-    GenericDatum(const std::string& v) 
-        : type_(AVRO_STRING), logicalType_(LogicalType::NONE), value_(v) { } 
- 
-    /// Makes a new AVRO_BYTES datum whose value is of type 
-    /// std::vector<uint8_t>. 
-    GenericDatum(const std::vector<uint8_t>& v) : 
-        type_(AVRO_BYTES), logicalType_(LogicalType::NONE), value_(v) { } 
- 
-    /** 
-     * Constructs a datum corresponding to the given avro type. 
-     * The value will the appropriate default corresponding to the 
-     * data type. 
-     * \param schema The schema that defines the avro type. 
-     */ 
-    GenericDatum(const NodePtr& schema); 
- 
-    /** 
-     * Constructs a datum corresponding to the given avro type and set 
-     * the value. 
-     * \param schema The schema that defines the avro type. 
-     * \param v The value for this type. 
-     */ 
-    template<typename T> 
-    GenericDatum(const NodePtr& schema, const T& v) : 
-        type_(schema->type()), logicalType_(schema->logicalType()) { 
-        init(schema); 
-#if __cplusplus >= 201703L 
-        *std::any_cast<T>(&value_) = v; 
-#else 
-        *boost::any_cast<T>(&value_) = v; 
-#endif 
-    } 
- 
-    /** 
-     * Constructs a datum corresponding to the given avro type. 
-     * The value will the appropriate default corresponding to the 
-     * data type. 
-     * \param schema The schema that defines the avro type. 
-     */ 
-    GenericDatum(const ValidSchema& schema); 
-}; 
- 
-/** 
- * The base class for all generic type for containers. 
- */ 
-class AVRO_DECL GenericContainer { 
-    NodePtr schema_; 
-    static void assertType(const NodePtr& schema, Type type); 
-protected: 
-    /** 
-     * Constructs a container corresponding to the given schema. 
-     */ 
-    GenericContainer(Type type, const NodePtr& s) : schema_(s) { 
-        assertType(s, type); 
-    } 
- 
-public: 
-    /// Returns the schema for this object 
-    const NodePtr& schema() const { 
-        return schema_; 
-    } 
-}; 
- 
-/** 
- * Generic container for unions. 
- */ 
-class AVRO_DECL GenericUnion : public GenericContainer { 
-    size_t curBranch_; 
-    GenericDatum datum_; 
- 
-public: 
-    /** 
-     * Constructs a generic union corresponding to the given schema \p schema, 
-     * and the given value. The schema should be of Avro type union 
-     * and the value should correspond to one of the branches of the union. 
-     */ 
-    GenericUnion(const NodePtr& schema) : 
-        GenericContainer(AVRO_UNION, schema), curBranch_(schema->leaves()) { 
-        selectBranch(0); 
-    } 
- 
-    /** 
-     * Returns the index of the current branch. 
-     */ 
-    size_t currentBranch() const { return curBranch_; } 
- 
-    /** 
-     * Selects a new branch. The type for the value is changed accordingly. 
-     * \param branch The index for the selected branch. 
-     */ 
-    void selectBranch(size_t branch) { 
-        if (curBranch_ != branch) { 
-            datum_ = GenericDatum(schema()->leafAt(branch)); 
-            curBranch_ = branch; 
-        } 
-    } 
- 
-    /** 
-     * Returns the datum corresponding to the currently selected branch 
-     * in this union. 
-     */ 
-    GenericDatum& datum() { 
-        return datum_; 
-    } 
- 
-    /** 
-     * Returns the datum corresponding to the currently selected branch 
-     * in this union. 
-     */ 
-    const GenericDatum& datum() const { 
-        return datum_; 
-    } 
-}; 
- 
-/** 
- * The generic container for Avro records. 
- */ 
-class AVRO_DECL GenericRecord : public GenericContainer { 
-    std::vector<GenericDatum> fields_; 
-public: 
-    /** 
-     * Constructs a generic record corresponding to the given schema \p schema, 
-     * which should be of Avro type record. 
-     */ 
-    GenericRecord(const NodePtr& schema); 
- 
-    /** 
-     * Returns the number of fields in the current record. 
-     */ 
-    size_t fieldCount() const { 
-        return fields_.size(); 
-    } 
- 
-    /** 
-     * Returns index of the field with the given name \p name 
-     */ 
-    size_t fieldIndex(const std::string& name) const { 
-        size_t index = 0; 
-        if (!schema()->nameIndex(name, index)) { 
-            throw Exception("Invalid field name: " + name); 
-        } 
-        return index; 
-    } 
- 
-    /** 
-     * Returns true if a field with the given name \p name is located in this r 
-     * false otherwise 
-     */ 
-    bool hasField(const std::string& name) const { 
-        size_t index = 0; 
-        return schema()->nameIndex(name, index); 
-    } 
- 
-    /** 
-     * Returns the field with the given name \p name. 
-     */ 
-    const GenericDatum& field(const std::string& name) const { 
-        return fieldAt(fieldIndex(name)); 
-    } 
- 
-    /** 
-     * Returns the reference to the field with the given name \p name, 
-     * which can be used to change the contents. 
-     */ 
-    GenericDatum& field(const std::string& name) { 
-        return fieldAt(fieldIndex(name)); 
-    } 
- 
-    /** 
-     * Returns the field at the given position \p pos. 
-     */ 
-    const GenericDatum& fieldAt(size_t pos) const { 
-        return fields_[pos]; 
-    } 
- 
-    /** 
-     * Returns the reference to the field at the given position \p pos, 
-     * which can be used to change the contents. 
-     */ 
-    GenericDatum& fieldAt(size_t pos) { 
-        return fields_[pos]; 
-    } 
- 
-    /** 
-     * Replaces the field at the given position \p pos with \p v. 
-     */ 
-    void setFieldAt(size_t pos, const GenericDatum& v) { 
-        // assertSameType(v, schema()->leafAt(pos)); 
-        fields_[pos] = v; 
-    } 
-}; 
- 
-/** 
- * The generic container for Avro arrays. 
- */ 
-class AVRO_DECL GenericArray : public GenericContainer { 
-public: 
-    /** 
-     * The contents type for the array. 
-     */ 
-    typedef std::vector<GenericDatum> Value; 
- 
-    /** 
-     * Constructs a generic array corresponding to the given schema \p schema, 
-     * which should be of Avro type array. 
-     */ 
-    GenericArray(const NodePtr& schema) : GenericContainer(AVRO_ARRAY, schema) { 
-    } 
- 
-    /** 
-     * Returns the contents of this array. 
-     */ 
-    const Value& value() const { 
-        return value_; 
-    } 
- 
-    /** 
-     * Returns the reference to the contents of this array. 
-     */ 
-    Value& value() { 
-        return value_; 
-    } 
-private: 
-    Value value_; 
-}; 
- 
-/** 
- * The generic container for Avro maps. 
- */ 
-class AVRO_DECL GenericMap : public GenericContainer { 
-public: 
-    /** 
-     * The contents type for the map. 
-     */ 
-    typedef std::vector<std::pair<std::string, GenericDatum> > Value; 
- 
-    /** 
-     * Constructs a generic map corresponding to the given schema \p schema, 
-     * which should be of Avro type map. 
-     */ 
-    GenericMap(const NodePtr& schema) : GenericContainer(AVRO_MAP, schema) { 
-    } 
- 
-    /** 
-     * Returns the contents of this map. 
-     */ 
-    const Value& value() const { 
-        return value_; 
-    } 
- 
-    /** 
-     * Returns the reference to the contents of this map. 
-     */ 
-    Value& value() { 
-        return value_; 
-    } 
-private: 
-    Value value_; 
-}; 
- 
-/** 
- * Generic container for Avro enum. 
- */ 
-class AVRO_DECL GenericEnum : public GenericContainer { 
-    size_t value_; 
- 
-    static size_t index(const NodePtr& schema, const std::string& symbol) { 
-        size_t result; 
-        if (schema->nameIndex(symbol, result)) { 
-            return result; 
-        } 
-        throw Exception("No such symbol"); 
-    } 
- 
-public: 
-    /** 
-     * Constructs a generic enum corresponding to the given schema \p schema, 
-     * which should be of Avro type enum. 
-     */ 
-    GenericEnum(const NodePtr& schema) : 
-        GenericContainer(AVRO_ENUM, schema), value_(0) { 
-    } 
- 
-    GenericEnum(const NodePtr& schema, const std::string& symbol) : 
-        GenericContainer(AVRO_ENUM, schema), value_(index(schema, symbol)) { 
-    } 
- 
-    /** 
-     * Returns the symbol corresponding to the cardinal \p n. If the 
-     * value for \p n is not within the limits an exception is thrown. 
-     */ 
-    const std::string& symbol(size_t n) { 
-        if (n < schema()->names()) { 
-            return schema()->nameAt(n); 
-        } 
-        throw Exception("Not as many symbols"); 
-    } 
- 
-    /** 
-     * Returns the cardinal for the given symbol \c symbol. If the symbol 
-     * is not defined for this enum and exception is thrown. 
-     */ 
-    size_t index(const std::string& symbol) const { 
-        return index(schema(), symbol); 
-    } 
- 
-    /** 
-     * Set the value for this enum corresponding to the given symbol \c symbol. 
-     */ 
-    size_t set(const std::string& symbol) { 
-        return value_ = index(symbol); 
-    } 
- 
-    /** 
-     * Set the value for this enum corresponding to the given cardinal \c n. 
-     */ 
-    void set(size_t n) { 
-        if (n < schema()->names()) { 
-            value_ = n; 
-            return; 
-        } 
-        throw Exception("Not as many symbols"); 
-    } 
- 
-    /** 
-     * Returns the cardinal for the current value of this enum. 
-     */ 
-    size_t value() const { 
-        return value_; 
-    } 
- 
-    /** 
-     * Returns the symbol for the current value of this enum. 
-     */ 
-    const std::string& symbol() const { 
-        return schema()->nameAt(value_); 
-    } 
-}; 
- 
-/** 
- * Generic container for Avro fixed. 
- */ 
-class AVRO_DECL GenericFixed : public GenericContainer { 
-    std::vector<uint8_t> value_; 
-public: 
-    /** 
-     * Constructs a generic enum corresponding to the given schema \p schema, 
-     * which should be of Avro type fixed. 
-     */ 
-    GenericFixed(const NodePtr& schema) : GenericContainer(AVRO_FIXED, schema) { 
-        value_.resize(schema->fixedSize()); 
-    } 
- 
-    GenericFixed(const NodePtr& schema, const std::vector<uint8_t>& v) : 
-        GenericContainer(AVRO_FIXED, schema), value_(v) { } 
- 
-    /** 
-     * Returns the contents of this fixed. 
-     */ 
-    const std::vector<uint8_t>& value() const { 
-        return value_; 
-    } 
- 
-    /** 
-     * Returns the reference to the contents of this fixed. 
-     */ 
-    std::vector<uint8_t>& value() { 
-        return value_; 
-    } 
-}; 
- 
-inline Type GenericDatum::type() const { 
-    return (type_ == AVRO_UNION) ? 
-#if __cplusplus >= 201703L 
-        std::any_cast<GenericUnion>(&value_)->datum().type() : 
-#else 
-        boost::any_cast<GenericUnion>(&value_)->datum().type() : 
-#endif 
-        type_; 
-} 
- 
-inline LogicalType GenericDatum::logicalType() const { 
-    return logicalType_; 
-} 
- 
-template<typename T> T& GenericDatum::value() { 
-    return (type_ == AVRO_UNION) ? 
-#if __cplusplus >= 201703L 
-        std::any_cast<GenericUnion>(&value_)->datum().value<T>() : 
-        *std::any_cast<T>(&value_); 
-#else 
-        boost::any_cast<GenericUnion>(&value_)->datum().value<T>() : 
-        *boost::any_cast<T>(&value_); 
-#endif 
-} 
- 
-template<typename T> const T& GenericDatum::value() const { 
-    return (type_ == AVRO_UNION) ? 
-#if __cplusplus >= 201703L 
-        std::any_cast<GenericUnion>(&value_)->datum().value<T>() : 
-        *std::any_cast<T>(&value_); 
-#else 
-        boost::any_cast<GenericUnion>(&value_)->datum().value<T>() : 
-        *boost::any_cast<T>(&value_); 
-#endif 
-} 
- 
-inline size_t GenericDatum::unionBranch() const { 
-#if __cplusplus >= 201703L 
-    return std::any_cast<GenericUnion>(&value_)->currentBranch(); 
-#else 
-    return boost::any_cast<GenericUnion>(&value_)->currentBranch(); 
-#endif 
-} 
- 
-inline void GenericDatum::selectBranch(size_t branch) { 
-#if __cplusplus >= 201703L 
-    std::any_cast<GenericUnion>(&value_)->selectBranch(branch); 
-#else 
-    boost::any_cast<GenericUnion>(&value_)->selectBranch(branch); 
-#endif 
-} 
- 
-}   // namespace avro 
-#endif // avro_GenericDatum_hh__ 
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef avro_GenericDatum_hh__
+#define avro_GenericDatum_hh__
+
+#include <stdint.h>
+#include <vector>
+#include <map>
+#include <string>
+
+#if __cplusplus >= 201703L
+#include <any>
+#else
+#include "boost/any.hpp"
+#endif
+
+#include "LogicalType.hh"
+#include "Node.hh"
+#include "ValidSchema.hh"
+
+namespace avro {
+
+/**
+ * Generic datum which can hold any Avro type. The datum has a type
+ * and a value. The type is one of the Avro data types. The C++ type for
+ * value corresponds to the Avro type.
+ * \li An Avro <tt>null</tt> corresponds to no C++ type. It is illegal to
+ * to try to access values for <tt>null</tt>.
+ * \li Avro <tt>boolean</tt> maps to C++ <tt>bool</tt>
+ * \li Avro <tt>int</tt> maps to C++ <tt>int32_t</tt>.
+ * \li Avro <tt>long</tt> maps to C++ <tt>int64_t</tt>.
+ * \li Avro <tt>float</tt> maps to C++ <tt>float</tt>.
+ * \li Avro <tt>double</tt> maps to C++ <tt>double</tt>.
+ * \li Avro <tt>string</tt> maps to C++ <tt>std::string</tt>.
+ * \li Avro <tt>bytes</tt> maps to C++ <tt>std::vector&lt;uint_t&gt;</tt>.
+ * \li Avro <tt>fixed</tt> maps to C++ class <tt>GenericFixed</tt>.
+ * \li Avro <tt>enum</tt> maps to C++ class <tt>GenericEnum</tt>.
+ * \li Avro <tt>array</tt> maps to C++ class <tt>GenericArray</tt>.
+ * \li Avro <tt>map</tt> maps to C++ class <tt>GenericMap</tt>.
+ * \li There is no C++ type corresponding to Avro <tt>union</tt>. The
+ * object should have the C++ type corresponing to one of the constituent
+ * types of the union.
+ *
+ */
+class AVRO_DECL GenericDatum {
+protected:
+    Type type_;
+    LogicalType logicalType_;
+#if __cplusplus >= 201703L
+    std::any value_;
+#else
+    boost::any value_;
+#endif
+
+    GenericDatum(Type t)
+        : type_(t), logicalType_(LogicalType::NONE) { }
+
+    GenericDatum(Type t, LogicalType logicalType)
+        : type_(t), logicalType_(logicalType) { }
+
+    template <typename T>
+    GenericDatum(Type t, LogicalType logicalType, const T& v)
+        : type_(t), logicalType_(logicalType), value_(v) { }
+
+    void init(const NodePtr& schema);
+public:
+    /**
+     * The avro data type this datum holds.
+     */
+    Type type() const;
+
+    /**
+     * The avro logical type that augments the main data type this datum holds.
+     */
+    LogicalType logicalType() const;
+
+    /**
+     * Returns the value held by this datum.
+     * T The type for the value. This must correspond to the
+     * avro type returned by type().
+     */
+    template<typename T> const T& value() const;
+
+    /**
+     * Returns the reference to the value held by this datum, which
+     * can be used to change the contents. Please note that only
+     * value can be changed, the data type of the value held cannot
+     * be changed.
+     *
+     * T The type for the value. This must correspond to the
+     * avro type returned by type().
+     */
+    template<typename T> T& value();
+
+    /**
+     * Returns true if and only if this datum is a union.
+     */
+    bool isUnion() const { return type_ == AVRO_UNION; }
+
+    /**
+     * Returns the index of the current branch, if this is a union.
+     * \sa isUnion().
+     */
+    size_t unionBranch() const;
+
+    /**
+     * Selects a new branch in the union if this is a union.
+     * \sa isUnion().
+     */
+    void selectBranch(size_t branch);
+
+    /// Makes a new AVRO_NULL datum.
+    GenericDatum() : type_(AVRO_NULL), logicalType_(LogicalType::NONE) { }
+
+    /// Makes a new AVRO_BOOL datum whose value is of type bool.
+    GenericDatum(bool v)
+        : type_(AVRO_BOOL), logicalType_(LogicalType::NONE), value_(v) { }
+
+    /// Makes a new AVRO_INT datum whose value is of type int32_t.
+    GenericDatum(int32_t v)
+        : type_(AVRO_INT), logicalType_(LogicalType::NONE), value_(v) { }
+
+    /// Makes a new AVRO_LONG datum whose value is of type int64_t.
+    GenericDatum(int64_t v)
+        : type_(AVRO_LONG), logicalType_(LogicalType::NONE), value_(v) { }
+
+    /// Makes a new AVRO_FLOAT datum whose value is of type float.
+    GenericDatum(float v)
+        : type_(AVRO_FLOAT), logicalType_(LogicalType::NONE), value_(v) { }
+
+    /// Makes a new AVRO_DOUBLE datum whose value is of type double.
+    GenericDatum(double v)
+        : type_(AVRO_DOUBLE), logicalType_(LogicalType::NONE), value_(v) { }
+
+    /// Makes a new AVRO_STRING datum whose value is of type std::string.
+    GenericDatum(const std::string& v)
+        : type_(AVRO_STRING), logicalType_(LogicalType::NONE), value_(v) { }
+
+    /// Makes a new AVRO_BYTES datum whose value is of type
+    /// std::vector<uint8_t>.
+    GenericDatum(const std::vector<uint8_t>& v) :
+        type_(AVRO_BYTES), logicalType_(LogicalType::NONE), value_(v) { }
+
+    /**
+     * Constructs a datum corresponding to the given avro type.
+     * The value will the appropriate default corresponding to the
+     * data type.
+     * \param schema The schema that defines the avro type.
+     */
+    GenericDatum(const NodePtr& schema);
+
+    /**
+     * Constructs a datum corresponding to the given avro type and set
+     * the value.
+     * \param schema The schema that defines the avro type.
+     * \param v The value for this type.
+     */
+    template<typename T>
+    GenericDatum(const NodePtr& schema, const T& v) :
+        type_(schema->type()), logicalType_(schema->logicalType()) {
+        init(schema);
+#if __cplusplus >= 201703L
+        *std::any_cast<T>(&value_) = v;
+#else
+        *boost::any_cast<T>(&value_) = v;
+#endif
+    }
+
+    /**
+     * Constructs a datum corresponding to the given avro type.
+     * The value will the appropriate default corresponding to the
+     * data type.
+     * \param schema The schema that defines the avro type.
+     */
+    GenericDatum(const ValidSchema& schema);
+};
+
+/**
+ * The base class for all generic type for containers.
+ */
+class AVRO_DECL GenericContainer {
+    NodePtr schema_;
+    static void assertType(const NodePtr& schema, Type type);
+protected:
+    /**
+     * Constructs a container corresponding to the given schema.
+     */
+    GenericContainer(Type type, const NodePtr& s) : schema_(s) {
+        assertType(s, type);
+    }
+
+public:
+    /// Returns the schema for this object
+    const NodePtr& schema() const {
+        return schema_;
+    }
+};
+
+/**
+ * Generic container for unions.
+ */
+class AVRO_DECL GenericUnion : public GenericContainer {
+    size_t curBranch_;
+    GenericDatum datum_;
+
+public:
+    /**
+     * Constructs a generic union corresponding to the given schema \p schema,
+     * and the given value. The schema should be of Avro type union
+     * and the value should correspond to one of the branches of the union.
+     */
+    GenericUnion(const NodePtr& schema) :
+        GenericContainer(AVRO_UNION, schema), curBranch_(schema->leaves()) {
+        selectBranch(0);
+    }
+
+    /**
+     * Returns the index of the current branch.
+     */
+    size_t currentBranch() const { return curBranch_; }
+
+    /**
+     * Selects a new branch. The type for the value is changed accordingly.
+     * \param branch The index for the selected branch.
+     */
+    void selectBranch(size_t branch) {
+        if (curBranch_ != branch) {
+            datum_ = GenericDatum(schema()->leafAt(branch));
+            curBranch_ = branch;
+        }
+    }
+
+    /**
+     * Returns the datum corresponding to the currently selected branch
+     * in this union.
+     */
+    GenericDatum& datum() {
+        return datum_;
+    }
+
+    /**
+     * Returns the datum corresponding to the currently selected branch
+     * in this union.
+     */
+    const GenericDatum& datum() const {
+        return datum_;
+    }
+};
+
+/**
+ * The generic container for Avro records.
+ */
+class AVRO_DECL GenericRecord : public GenericContainer {
+    std::vector<GenericDatum> fields_;
+public:
+    /**
+     * Constructs a generic record corresponding to the given schema \p schema,
+     * which should be of Avro type record.
+     */
+    GenericRecord(const NodePtr& schema);
+
+    /**
+     * Returns the number of fields in the current record.
+     */
+    size_t fieldCount() const {
+        return fields_.size();
+    }
+
+    /**
+     * Returns index of the field with the given name \p name
+     */
+    size_t fieldIndex(const std::string& name) const {
+        size_t index = 0;
+        if (!schema()->nameIndex(name, index)) {
+            throw Exception("Invalid field name: " + name);
+        }
+        return index;
+    }
+
+    /**
+     * Returns true if a field with the given name \p name is located in this r
+     * false otherwise
+     */
+    bool hasField(const std::string& name) const {
+        size_t index = 0;
+        return schema()->nameIndex(name, index);
+    }
+
+    /**
+     * Returns the field with the given name \p name.
+     */
+    const GenericDatum& field(const std::string& name) const {
+        return fieldAt(fieldIndex(name));
+    }
+
+    /**
+     * Returns the reference to the field with the given name \p name,
+     * which can be used to change the contents.
+     */
+    GenericDatum& field(const std::string& name) {
+        return fieldAt(fieldIndex(name));
+    }
+
+    /**
+     * Returns the field at the given position \p pos.
+     */
+    const GenericDatum& fieldAt(size_t pos) const {
+        return fields_[pos];
+    }
+
+    /**
+     * Returns the reference to the field at the given position \p pos,
+     * which can be used to change the contents.
+     */
+    GenericDatum& fieldAt(size_t pos) {
+        return fields_[pos];
+    }
+
+    /**
+     * Replaces the field at the given position \p pos with \p v.
+     */
+    void setFieldAt(size_t pos, const GenericDatum& v) {
+        // assertSameType(v, schema()->leafAt(pos));
+        fields_[pos] = v;
+    }
+};
+
+/**
+ * The generic container for Avro arrays.
+ */
+class AVRO_DECL GenericArray : public GenericContainer {
+public:
+    /**
+     * The contents type for the array.
+     */
+    typedef std::vector<GenericDatum> Value;
+
+    /**
+     * Constructs a generic array corresponding to the given schema \p schema,
+     * which should be of Avro type array.
+     */
+    GenericArray(const NodePtr& schema) : GenericContainer(AVRO_ARRAY, schema) {
+    }
+
+    /**
+     * Returns the contents of this array.
+     */
+    const Value& value() const {
+        return value_;
+    }
+
+    /**
+     * Returns the reference to the contents of this array.
+     */
+    Value& value() {
+        return value_;
+    }
+private:
+    Value value_;
+};
+
+/**
+ * The generic container for Avro maps.
+ */
+class AVRO_DECL GenericMap : public GenericContainer {
+public:
+    /**
+     * The contents type for the map.
+     */
+    typedef std::vector<std::pair<std::string, GenericDatum> > Value;
+
+    /**
+     * Constructs a generic map corresponding to the given schema \p schema,
+     * which should be of Avro type map.
+     */
+    GenericMap(const NodePtr& schema) : GenericContainer(AVRO_MAP, schema) {
+    }
+
+    /**
+     * Returns the contents of this map.
+     */
+    const Value& value() const {
+        return value_;
+    }
+
+    /**
+     * Returns the reference to the contents of this map.
+     */
+    Value& value() {
+        return value_;
+    }
+private:
+    Value value_;
+};
+
+/**
+ * Generic container for Avro enum.
+ */
+class AVRO_DECL GenericEnum : public GenericContainer {
+    size_t value_;
+
+    static size_t index(const NodePtr& schema, const std::string& symbol) {
+        size_t result;
+        if (schema->nameIndex(symbol, result)) {
+            return result;
+        }
+        throw Exception("No such symbol");
+    }
+
+public:
+    /**
+     * Constructs a generic enum corresponding to the given schema \p schema,
+     * which should be of Avro type enum.
+     */
+    GenericEnum(const NodePtr& schema) :
+        GenericContainer(AVRO_ENUM, schema), value_(0) {
+    }
+
+    GenericEnum(const NodePtr& schema, const std::string& symbol) :
+        GenericContainer(AVRO_ENUM, schema), value_(index(schema, symbol)) {
+    }
+
+    /**
+     * Returns the symbol corresponding to the cardinal \p n. If the
+     * value for \p n is not within the limits an exception is thrown.
+     */
+    const std::string& symbol(size_t n) {
+        if (n < schema()->names()) {
+            return schema()->nameAt(n);
+        }
+        throw Exception("Not as many symbols");
+    }
+
+    /**
+     * Returns the cardinal for the given symbol \c symbol. If the symbol
+     * is not defined for this enum and exception is thrown.
+     */
+    size_t index(const std::string& symbol) const {
+        return index(schema(), symbol);
+    }
+
+    /**
+     * Set the value for this enum corresponding to the given symbol \c symbol.
+     */
+    size_t set(const std::string& symbol) {
+        return value_ = index(symbol);
+    }
+
+    /**
+     * Set the value for this enum corresponding to the given cardinal \c n.
+     */
+    void set(size_t n) {
+        if (n < schema()->names()) {
+            value_ = n;
+            return;
+        }
+        throw Exception("Not as many symbols");
+    }
+
+    /**
+     * Returns the cardinal for the current value of this enum.
+     */
+    size_t value() const {
+        return value_;
+    }
+
+    /**
+     * Returns the symbol for the current value of this enum.
+     */
+    const std::string& symbol() const {
+        return schema()->nameAt(value_);
+    }
+};
+
+/**
+ * Generic container for Avro fixed.
+ */
+class AVRO_DECL GenericFixed : public GenericContainer {
+    std::vector<uint8_t> value_;
+public:
+    /**
+     * Constructs a generic enum corresponding to the given schema \p schema,
+     * which should be of Avro type fixed.
+     */
+    GenericFixed(const NodePtr& schema) : GenericContainer(AVRO_FIXED, schema) {
+        value_.resize(schema->fixedSize());
+    }
+
+    GenericFixed(const NodePtr& schema, const std::vector<uint8_t>& v) :
+        GenericContainer(AVRO_FIXED, schema), value_(v) { }
+
+    /**
+     * Returns the contents of this fixed.
+     */
+    const std::vector<uint8_t>& value() const {
+        return value_;
+    }
+
+    /**
+     * Returns the reference to the contents of this fixed.
+     */
+    std::vector<uint8_t>& value() {
+        return value_;
+    }
+};
+
+inline Type GenericDatum::type() const {
+    return (type_ == AVRO_UNION) ?
+#if __cplusplus >= 201703L
+        std::any_cast<GenericUnion>(&value_)->datum().type() :
+#else
+        boost::any_cast<GenericUnion>(&value_)->datum().type() :
+#endif
+        type_;
+}
+
+inline LogicalType GenericDatum::logicalType() const {
+    return logicalType_;
+}
+
+template<typename T> T& GenericDatum::value() {
+    return (type_ == AVRO_UNION) ?
+#if __cplusplus >= 201703L
+        std::any_cast<GenericUnion>(&value_)->datum().value<T>() :
+        *std::any_cast<T>(&value_);
+#else
+        boost::any_cast<GenericUnion>(&value_)->datum().value<T>() :
+        *boost::any_cast<T>(&value_);
+#endif
+}
+
+template<typename T> const T& GenericDatum::value() const {
+    return (type_ == AVRO_UNION) ?
+#if __cplusplus >= 201703L
+        std::any_cast<GenericUnion>(&value_)->datum().value<T>() :
+        *std::any_cast<T>(&value_);
+#else
+        boost::any_cast<GenericUnion>(&value_)->datum().value<T>() :
+        *boost::any_cast<T>(&value_);
+#endif
+}
+
+inline size_t GenericDatum::unionBranch() const {
+#if __cplusplus >= 201703L
+    return std::any_cast<GenericUnion>(&value_)->currentBranch();
+#else
+    return boost::any_cast<GenericUnion>(&value_)->currentBranch();
+#endif
+}
+
+inline void GenericDatum::selectBranch(size_t branch) {
+#if __cplusplus >= 201703L
+    std::any_cast<GenericUnion>(&value_)->selectBranch(branch);
+#else
+    boost::any_cast<GenericUnion>(&value_)->selectBranch(branch);
+#endif
+}
+
+}   // namespace avro
+#endif // avro_GenericDatum_hh__
diff --git a/contrib/libs/apache/avro/api/Layout.hh b/contrib/libs/apache/avro/api/Layout.hh
index 693bed1b42..ffd810c8b0 100644
--- a/contrib/libs/apache/avro/api/Layout.hh
+++ b/contrib/libs/apache/avro/api/Layout.hh
@@ -1,83 +1,83 @@
-/* 
- * Licensed to the Apache Software Foundation (ASF) under one 
- * or more contributor license agreements.  See the NOTICE file 
- * distributed with this work for additional information 
- * regarding copyright ownership.  The ASF licenses this file 
- * to you under the Apache License, Version 2.0 (the 
- * "License"); you may not use this file except in compliance 
- * with the License.  You may obtain a copy of the License at 
- * 
- *     https://www.apache.org/licenses/LICENSE-2.0 
- * 
- * Unless required by applicable law or agreed to in writing, software 
- * distributed under the License is distributed on an "AS IS" BASIS, 
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
- * See the License for the specific language governing permissions and 
- * limitations under the License. 
- */ 
- 
-#ifndef avro_Layout_hh__ 
-#define avro_Layout_hh__ 
- 
-#include <boost/noncopyable.hpp> 
-#include "Config.hh" 
- 
-/// \file Layout.hh 
-/// 
- 
-namespace avro { 
- 
-class AVRO_DECL Layout : private boost::noncopyable { 
- 
-  protected: 
- 
-    Layout(size_t offset = 0) : 
-        offset_(offset) 
-    {} 
- 
-  public: 
- 
-    size_t offset() const { 
-        return offset_; 
-    } 
- 
-    virtual ~Layout() {} 
- 
-  private: 
- 
-    const size_t offset_; 
-}; 
- 
-class AVRO_DECL PrimitiveLayout : public Layout { 
- 
-  public: 
- 
-    PrimitiveLayout(size_t offset = 0) : 
-        Layout(offset) 
-    {} 
-}; 
- 
-class AVRO_DECL CompoundLayout : public Layout { 
- 
-  public: 
- 
-    CompoundLayout(size_t offset = 0) : 
-        Layout(offset) 
-    {} 
- 
-    void add(std::unique_ptr<Layout> &layout) { 
-        layouts_.push_back(std::move(layout)); 
-    } 
- 
-    const Layout &at (size_t idx) const { 
-        return *layouts_.at(idx); 
-    } 
- 
-  private: 
- 
-    std::vector<std::unique_ptr<Layout> > layouts_; 
-}; 
- 
-} // namespace avro 
- 
-#endif 
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef avro_Layout_hh__
+#define avro_Layout_hh__
+
+#include <boost/noncopyable.hpp>
+#include "Config.hh"
+
+/// \file Layout.hh
+///
+
+namespace avro {
+
+class AVRO_DECL Layout : private boost::noncopyable {
+
+  protected:
+
+    Layout(size_t offset = 0) :
+        offset_(offset)
+    {}
+
+  public:
+
+    size_t offset() const {
+        return offset_;
+    }
+
+    virtual ~Layout() {}
+
+  private:
+
+    const size_t offset_;
+};
+
+class AVRO_DECL PrimitiveLayout : public Layout {
+
+  public:
+
+    PrimitiveLayout(size_t offset = 0) :
+        Layout(offset)
+    {}
+};
+
+class AVRO_DECL CompoundLayout : public Layout {
+
+  public:
+
+    CompoundLayout(size_t offset = 0) :
+        Layout(offset)
+    {}
+
+    void add(std::unique_ptr<Layout> &layout) {
+        layouts_.push_back(std::move(layout));
+    }
+
+    const Layout &at (size_t idx) const {
+        return *layouts_.at(idx);
+    }
+
+  private:
+
+    std::vector<std::unique_ptr<Layout> > layouts_;
+};
+
+} // namespace avro
+
+#endif
diff --git a/contrib/libs/apache/avro/api/LogicalType.hh b/contrib/libs/apache/avro/api/LogicalType.hh
index ba9d86db98..33972788fb 100644
--- a/contrib/libs/apache/avro/api/LogicalType.hh
+++ b/contrib/libs/apache/avro/api/LogicalType.hh
@@ -1,65 +1,65 @@
-/* 
- * Licensed to the Apache Software Foundation (ASF) under one 
- * or more contributor license agreements.  See the NOTICE file 
- * distributed with this work for additional information 
- * regarding copyright ownership.  The ASF licenses this file 
- * to you under the Apache License, Version 2.0 (the 
- * "License"); you may not use this file except in compliance 
- * with the License.  You may obtain a copy of the License at 
- * 
- *     https://www.apache.org/licenses/LICENSE-2.0 
- * 
- * Unless required by applicable law or agreed to in writing, software 
- * distributed under the License is distributed on an "AS IS" BASIS, 
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
- * See the License for the specific language governing permissions and 
- * limitations under the License. 
- */ 
- 
-#ifndef avro_LogicalType_hh__ 
-#define avro_LogicalType_hh__ 
- 
-#include <iostream> 
- 
-#include "Config.hh" 
- 
-namespace avro { 
- 
-class AVRO_DECL LogicalType { 
-  public: 
-    enum Type { 
-        NONE, 
-        DECIMAL, 
-        DATE, 
-        TIME_MILLIS, 
-        TIME_MICROS, 
-        TIMESTAMP_MILLIS, 
-        TIMESTAMP_MICROS, 
-        DURATION, 
-        UUID 
-    }; 
- 
-    explicit LogicalType(Type type); 
- 
-    Type type() const; 
- 
-    // Precision and scale can only be set for the DECIMAL logical type. 
-    // Precision must be positive and scale must be either positive or zero. The 
-    // setters will throw an exception if they are called on any type other 
-    // than DECIMAL. 
-    void setPrecision(int precision); 
-    int precision() const { return precision_; } 
-    void setScale(int scale); 
-    int scale() const { return scale_; } 
- 
-    void printJson(std::ostream& os) const; 
- 
-  private: 
-    Type type_; 
-    int precision_; 
-    int scale_; 
-}; 
- 
-}  // namespace avro 
- 
-#endif 
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef avro_LogicalType_hh__
+#define avro_LogicalType_hh__
+
+#include <iostream>
+
+#include "Config.hh"
+
+namespace avro {
+
+class AVRO_DECL LogicalType {
+  public:
+    enum Type {
+        NONE,
+        DECIMAL,
+        DATE,
+        TIME_MILLIS,
+        TIME_MICROS,
+        TIMESTAMP_MILLIS,
+        TIMESTAMP_MICROS,
+        DURATION,
+        UUID
+    };
+
+    explicit LogicalType(Type type);
+
+    Type type() const;
+
+    // Precision and scale can only be set for the DECIMAL logical type.
+    // Precision must be positive and scale must be either positive or zero. The
+    // setters will throw an exception if they are called on any type other
+    // than DECIMAL.
+    void setPrecision(int precision);
+    int precision() const { return precision_; }
+    void setScale(int scale);
+    int scale() const { return scale_; }
+
+    void printJson(std::ostream& os) const;
+
+  private:
+    Type type_;
+    int precision_;
+    int scale_;
+};
+
+}  // namespace avro
+
+#endif
diff --git a/contrib/libs/apache/avro/api/Node.hh b/contrib/libs/apache/avro/api/Node.hh
index b8bbf1d573..205b06f00e 100644
--- a/contrib/libs/apache/avro/api/Node.hh
+++ b/contrib/libs/apache/avro/api/Node.hh
@@ -1,211 +1,211 @@
-/* 
- * Licensed to the Apache Software Foundation (ASF) under one 
- * or more contributor license agreements.  See the NOTICE file 
- * distributed with this work for additional information 
- * regarding copyright ownership.  The ASF licenses this file 
- * to you under the Apache License, Version 2.0 (the 
- * "License"); you may not use this file except in compliance 
- * with the License.  You may obtain a copy of the License at 
- * 
- *     https://www.apache.org/licenses/LICENSE-2.0 
- * 
- * Unless required by applicable law or agreed to in writing, software 
- * distributed under the License is distributed on an "AS IS" BASIS, 
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
- * See the License for the specific language governing permissions and 
- * limitations under the License. 
- */ 
- 
-#ifndef avro_Node_hh__ 
-#define avro_Node_hh__ 
- 
-#include "Config.hh" 
- 
-#include <cassert> 
-#include <memory> 
-#include <boost/noncopyable.hpp> 
- 
-#include "Exception.hh" 
-#include "LogicalType.hh" 
-#include "Types.hh" 
-#include "SchemaResolution.hh" 
- 
-namespace avro { 
- 
-class Node; 
-class GenericDatum; 
- 
-typedef std::shared_ptr<Node> NodePtr; 
- 
-class AVRO_DECL Name { 
-    std::string ns_; 
-    std::string simpleName_; 
-public: 
-    Name() { } 
-    Name(const std::string& fullname); 
-    Name(const std::string& simpleName, const std::string& ns) : ns_(ns), simpleName_(simpleName) { check(); } 
- 
-    const std::string fullname() const; 
-    const std::string& ns() const { return ns_; } 
-    const std::string& simpleName() const { return simpleName_; } 
- 
-    void ns(const std::string& n) { ns_ = n; } 
-    void simpleName(const std::string& n) { simpleName_ = n; } 
-    void fullname(const std::string& n); 
- 
-    bool operator < (const Name& n) const; 
-    void check() const; 
-    bool operator == (const Name& n) const; 
-    bool operator != (const Name& n) const { return !((*this) == n); } 
-    void clear() { 
-        ns_.clear(); 
-        simpleName_.clear(); 
-    } 
-    operator std::string() const { 
-        return fullname(); 
-    } 
-}; 
- 
-inline 
-std::ostream& operator << (std::ostream& os, const Name& n) { 
-    return os << n.fullname(); 
-} 
- 
-/// Node is the building block for parse trees.  Each node represents an avro 
-/// type.  Compound types have leaf nodes that represent the types they are 
-/// composed of. 
-/// 
-/// The user does not use the Node object directly, they interface with Schema 
-/// objects. 
-/// 
-/// The Node object uses reference-counted pointers.  This is so that schemas 
-/// may be reused in other schemas, without needing to worry about memory 
-/// deallocation for nodes that are added to multiple schema parse trees. 
-/// 
-/// Node has minimal implementation, serving as an abstract base class for 
-/// different node types. 
-/// 
- 
-class AVRO_DECL Node : private boost::noncopyable 
-{ 
-  public: 
- 
-    Node(Type type) : 
-        type_(type), 
-        logicalType_(LogicalType::NONE), 
-        locked_(false) 
-    {} 
- 
-    virtual ~Node(); 
- 
-    Type type() const { 
-        return type_; 
-    } 
- 
-    LogicalType logicalType() const { 
-        return logicalType_; 
-    } 
- 
-    void setLogicalType(LogicalType logicalType); 
- 
-    void lock() { 
-        locked_ = true; 
-    } 
- 
-    bool locked() const { 
-        return locked_; 
-    } 
- 
-    virtual bool hasName() const = 0; 
- 
-    void setName(const Name &name) { 
-        checkLock(); 
-        checkName(name); 
-        doSetName(name); 
-    } 
-    virtual const Name &name() const = 0; 
- 
-    virtual const std::string &getDoc() const = 0; 
-    void setDoc(const std::string &doc) { 
-        checkLock(); 
-        doSetDoc(doc); 
-    } 
- 
-    void addLeaf(const NodePtr &newLeaf) { 
-        checkLock(); 
-        doAddLeaf(newLeaf); 
-    } 
-    virtual size_t leaves() const = 0; 
-    virtual const NodePtr& leafAt(int index) const = 0; 
-    virtual const GenericDatum& defaultValueAt(int index) { 
-        throw Exception(boost::format("No default value at: %1%") % index); 
-    } 
- 
-    void addName(const std::string &name) { 
-        checkLock(); 
-        checkName(name); 
-        doAddName(name); 
-    } 
-    virtual size_t names() const = 0; 
-    virtual const std::string &nameAt(int index) const = 0; 
-    virtual bool nameIndex(const std::string &name, size_t &index) const = 0; 
- 
-    void setFixedSize(int size) { 
-        checkLock(); 
-        doSetFixedSize(size); 
-    } 
-    virtual int fixedSize() const = 0; 
- 
-    virtual bool isValid() const = 0; 
- 
-    virtual SchemaResolution resolve(const Node &reader) const = 0; 
- 
-    virtual void printJson(std::ostream &os, int depth) const = 0; 
- 
-    virtual void printBasicInfo(std::ostream &os) const = 0; 
- 
-    virtual void setLeafToSymbolic(int index, const NodePtr &node) = 0; 
- 
-    // Serialize the default value GenericDatum g for the node contained 
-    // in a record node. 
-    virtual void printDefaultToJson(const GenericDatum& g, std::ostream &os, 
-                                    int depth) const = 0; 
- 
-  protected: 
- 
-    void checkLock() const { 
-        if(locked()) { 
-            throw Exception("Cannot modify locked schema"); 
-        } 
-    } 
- 
-    virtual void checkName(const Name &name) const { 
-        name.check(); 
-    } 
- 
-    virtual void doSetName(const Name &name) = 0; 
-    virtual void doSetDoc(const std::string &name) = 0; 
- 
-    virtual void doAddLeaf(const NodePtr &newLeaf) = 0; 
-    virtual void doAddName(const std::string &name) = 0; 
-    virtual void doSetFixedSize(int size) = 0; 
- 
-  private: 
- 
-    const Type type_; 
-    LogicalType logicalType_; 
-    bool locked_; 
-}; 
- 
-} // namespace avro 
- 
-namespace std { 
-inline std::ostream& operator<<(std::ostream& os, const avro::Node& n) 
-{ 
-    n.printJson(os, 0); 
-    return os; 
-} 
-} 
- 
- 
-#endif 
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef avro_Node_hh__
+#define avro_Node_hh__
+
+#include "Config.hh"
+
+#include <cassert>
+#include <memory>
+#include <boost/noncopyable.hpp>
+
+#include "Exception.hh"
+#include "LogicalType.hh"
+#include "Types.hh"
+#include "SchemaResolution.hh"
+
+namespace avro {
+
+class Node;
+class GenericDatum;
+
+typedef std::shared_ptr<Node> NodePtr;
+
+class AVRO_DECL Name {
+    std::string ns_;
+    std::string simpleName_;
+public:
+    Name() { }
+    Name(const std::string& fullname);
+    Name(const std::string& simpleName, const std::string& ns) : ns_(ns), simpleName_(simpleName) { check(); }
+
+    const std::string fullname() const;
+    const std::string& ns() const { return ns_; }
+    const std::string& simpleName() const { return simpleName_; }
+
+    void ns(const std::string& n) { ns_ = n; }
+    void simpleName(const std::string& n) { simpleName_ = n; }
+    void fullname(const std::string& n);
+
+    bool operator < (const Name& n) const;
+    void check() const;
+    bool operator == (const Name& n) const;
+    bool operator != (const Name& n) const { return !((*this) == n); }
+    void clear() {
+        ns_.clear();
+        simpleName_.clear();
+    }
+    operator std::string() const {
+        return fullname();
+    }
+};
+
+inline
+std::ostream& operator << (std::ostream& os, const Name& n) {
+    return os << n.fullname();
+}
+
+/// Node is the building block for parse trees.  Each node represents an avro
+/// type.  Compound types have leaf nodes that represent the types they are
+/// composed of.
+///
+/// The user does not use the Node object directly, they interface with Schema
+/// objects.
+///
+/// The Node object uses reference-counted pointers.  This is so that schemas
+/// may be reused in other schemas, without needing to worry about memory
+/// deallocation for nodes that are added to multiple schema parse trees.
+///
+/// Node has minimal implementation, serving as an abstract base class for
+/// different node types.
+///
+
+class AVRO_DECL Node : private boost::noncopyable
+{
+  public:
+
+    Node(Type type) :
+        type_(type),
+        logicalType_(LogicalType::NONE),
+        locked_(false)
+    {}
+
+    virtual ~Node();
+
+    Type type() const {
+        return type_;
+    }
+
+    LogicalType logicalType() const {
+        return logicalType_;
+    }
+
+    void setLogicalType(LogicalType logicalType);
+
+    void lock() {
+        locked_ = true;
+    }
+
+    bool locked() const {
+        return locked_;
+    }
+
+    virtual bool hasName() const = 0;
+
+    void setName(const Name &name) {
+        checkLock();
+        checkName(name);
+        doSetName(name);
+    }
+    virtual const Name &name() const = 0;
+
+    virtual const std::string &getDoc() const = 0;
+    void setDoc(const std::string &doc) {
+        checkLock();
+        doSetDoc(doc);
+    }
+
+    void addLeaf(const NodePtr &newLeaf) {
+        checkLock();
+        doAddLeaf(newLeaf);
+    }
+    virtual size_t leaves() const = 0;
+    virtual const NodePtr& leafAt(int index) const = 0;
+    virtual const GenericDatum& defaultValueAt(int index) {
+        throw Exception(boost::format("No default value at: %1%") % index);
+    }
+
+    void addName(const std::string &name) {
+        checkLock();
+        checkName(name);
+        doAddName(name);
+    }
+    virtual size_t names() const = 0;
+    virtual const std::string &nameAt(int index) const = 0;
+    virtual bool nameIndex(const std::string &name, size_t &index) const = 0;
+
+    void setFixedSize(int size) {
+        checkLock();
+        doSetFixedSize(size);
+    }
+    virtual int fixedSize() const = 0;
+
+    virtual bool isValid() const = 0;
+
+    virtual SchemaResolution resolve(const Node &reader) const = 0;
+
+    virtual void printJson(std::ostream &os, int depth) const = 0;
+
+    virtual void printBasicInfo(std::ostream &os) const = 0;
+
+    virtual void setLeafToSymbolic(int index, const NodePtr &node) = 0;
+
+    // Serialize the default value GenericDatum g for the node contained
+    // in a record node.
+    virtual void printDefaultToJson(const GenericDatum& g, std::ostream &os,
+                                    int depth) const = 0;
+
+  protected:
+
+    void checkLock() const {
+        if(locked()) {
+            throw Exception("Cannot modify locked schema");
+        }
+    }
+
+    virtual void checkName(const Name &name) const {
+        name.check();
+    }
+
+    virtual void doSetName(const Name &name) = 0;
+    virtual void doSetDoc(const std::string &name) = 0;
+
+    virtual void doAddLeaf(const NodePtr &newLeaf) = 0;
+    virtual void doAddName(const std::string &name) = 0;
+    virtual void doSetFixedSize(int size) = 0;
+
+  private:
+
+    const Type type_;
+    LogicalType logicalType_;
+    bool locked_;
+};
+
+} // namespace avro
+
+namespace std {
+inline std::ostream& operator<<(std::ostream& os, const avro::Node& n)
+{
+    n.printJson(os, 0);
+    return os;
+}
+}
+
+
+#endif
diff --git a/contrib/libs/apache/avro/api/NodeConcepts.hh b/contrib/libs/apache/avro/api/NodeConcepts.hh
index 36d4f413f1..e914d925b6 100644
--- a/contrib/libs/apache/avro/api/NodeConcepts.hh
+++ b/contrib/libs/apache/avro/api/NodeConcepts.hh
@@ -1,224 +1,224 @@
-/* 
- * Licensed to the Apache Software Foundation (ASF) under one 
- * or more contributor license agreements.  See the NOTICE file 
- * distributed with this work for additional information 
- * regarding copyright ownership.  The ASF licenses this file 
- * to you under the Apache License, Version 2.0 (the 
- * "License"); you may not use this file except in compliance 
- * with the License.  You may obtain a copy of the License at 
- * 
- *     https://www.apache.org/licenses/LICENSE-2.0 
- * 
- * Unless required by applicable law or agreed to in writing, software 
- * distributed under the License is distributed on an "AS IS" BASIS, 
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
- * See the License for the specific language governing permissions and 
- * limitations under the License. 
- */ 
- 
-#ifndef avro_NodeConcepts_hh__ 
-#define avro_NodeConcepts_hh__ 
- 
-#include "Config.hh" 
- 
-#include <vector> 
-#include <map> 
-#include "Exception.hh" 
- 
-namespace avro { 
- 
- 
-/// 
-/// The concept classes are used to simplify NodeImpl.  Since different types 
-/// of avro types carry different attributes, such as names, or field names for 
-/// record members.  Using the concept class of NoAttribute vs Attribute, the 
-/// NodeImpl object can enable/disable the attribute, but the code is the same 
-/// in either case. 
-/// 
-/// Furthermore, attributes may have different types, for example, most 
-/// attributes are strings, but fixed types have a size attribute, which is 
-/// integer. 
-/// 
-/// Since compound types are composed of other types, the leaf attribute 
-/// concepts extend a NodeImpl to include leaf nodes, and attributes for leaf 
-/// nodes, which are used to build parse trees. 
-/// 
-/// 
- 
-namespace concepts { 
- 
-template <typename Attribute> 
-struct NoAttribute 
-{ 
-    static const bool hasAttribute = false; 
- 
-    size_t size() const { 
-        return 0; 
-    } 
- 
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef avro_NodeConcepts_hh__
+#define avro_NodeConcepts_hh__
+
+#include "Config.hh"
+
+#include <vector>
+#include <map>
+#include "Exception.hh"
+
+namespace avro {
+
+
+///
+/// The concept classes are used to simplify NodeImpl.  Since different types
+/// of avro types carry different attributes, such as names, or field names for
+/// record members.  Using the concept class of NoAttribute vs Attribute, the
+/// NodeImpl object can enable/disable the attribute, but the code is the same
+/// in either case.
+///
+/// Furthermore, attributes may have different types, for example, most
+/// attributes are strings, but fixed types have a size attribute, which is
+/// integer.
+///
+/// Since compound types are composed of other types, the leaf attribute
+/// concepts extend a NodeImpl to include leaf nodes, and attributes for leaf
+/// nodes, which are used to build parse trees.
+///
+///
+
+namespace concepts {
+
+template <typename Attribute>
+struct NoAttribute
+{
+    static const bool hasAttribute = false;
+
+    size_t size() const {
+        return 0;
+    }
+
     void add( const Attribute &) {
-        // There must be an add function for the generic NodeImpl, but the 
-        // Node APIs ensure that it is never called, the throw here is 
-        // just in case 
-        throw Exception("This type does not have attribute"); 
-    } 
- 
+        // There must be an add function for the generic NodeImpl, but the
+        // Node APIs ensure that it is never called, the throw here is
+        // just in case
+        throw Exception("This type does not have attribute");
+    }
+
     const Attribute &get(size_t = 0) const {
-        // There must be an get function for the generic NodeImpl, but the 
-        // Node APIs ensure that it is never called, the throw here is 
-        // just in case 
-        throw Exception("This type does not have attribute"); 
-        // even though this code is unreachable the compiler requires it 
-        static const Attribute empty = Attribute(); 
-        return empty; 
-    } 
- 
+        // There must be an get function for the generic NodeImpl, but the
+        // Node APIs ensure that it is never called, the throw here is
+        // just in case
+        throw Exception("This type does not have attribute");
+        // even though this code is unreachable the compiler requires it
+        static const Attribute empty = Attribute();
+        return empty;
+    }
+
     Attribute &get(size_t = 0) {
-        // There must be an get function for the generic NodeImpl, but the 
-        // Node APIs ensure that it is never called, the throw here is 
-        // just in case 
-        throw Exception("This type does not have attribute"); 
-    } 
- 
-}; 
- 
-template<typename Attribute> 
-struct SingleAttribute 
-{ 
-    static const bool hasAttribute = true; 
- 
-    SingleAttribute() : attr_() 
-    { } 
- 
-    SingleAttribute(const Attribute& a) : attr_(a) { } 
-    // copy constructing from another single attribute is allowed 
-    SingleAttribute(const SingleAttribute<Attribute> &rhs) : 
-        attr_(rhs.attr_) 
-    { } 
- 
-    // copy constructing from a no attribute is allowed 
+        // There must be an get function for the generic NodeImpl, but the
+        // Node APIs ensure that it is never called, the throw here is
+        // just in case
+        throw Exception("This type does not have attribute");
+    }
+
+};
+
+template<typename Attribute>
+struct SingleAttribute
+{
+    static const bool hasAttribute = true;
+
+    SingleAttribute() : attr_()
+    { }
+
+    SingleAttribute(const Attribute& a) : attr_(a) { }
+    // copy constructing from another single attribute is allowed
+    SingleAttribute(const SingleAttribute<Attribute> &rhs) :
+        attr_(rhs.attr_)
+    { }
+
+    // copy constructing from a no attribute is allowed
     SingleAttribute(const NoAttribute<Attribute> &) :
-        attr_() 
-    { } 
- 
-    size_t size() const { 
-        return 1; 
-    } 
- 
-    void add(const Attribute &attr) { 
-        attr_ = attr; 
-    } 
- 
-    const Attribute &get(size_t index = 0) const { 
-        if (index != 0) { 
-            throw Exception("SingleAttribute has only 1 value"); 
-        } 
-        return attr_; 
-    } 
- 
-    Attribute &get(size_t index = 0) { 
-        if (index != 0) { 
-            throw Exception("SingleAttribute has only 1 value"); 
-        } 
-        return attr_; 
-    } 
- 
-private: 
-    template<typename T> friend struct MultiAttribute; 
-    Attribute attr_; 
-}; 
- 
-template<typename Attribute> 
-struct MultiAttribute 
-{ 
-    static const bool hasAttribute = true; 
- 
-    MultiAttribute() 
-    { } 
- 
-    // copy constructing from another single attribute is allowed, it 
-    // pushes the attribute 
-    MultiAttribute(const SingleAttribute<Attribute> &rhs) 
-    { 
-        // since map is the only type that does this we know it's 
-        // final size will be two, so reserve 
-        attrs_.reserve(2); 
-        attrs_.push_back(rhs.attr_); 
-    } 
- 
-    MultiAttribute(const MultiAttribute<Attribute> &rhs)  : 
-        attrs_(rhs.attrs_) 
-    { } 
- 
+        attr_()
+    { }
+
+    size_t size() const {
+        return 1;
+    }
+
+    void add(const Attribute &attr) {
+        attr_ = attr;
+    }
+
+    const Attribute &get(size_t index = 0) const {
+        if (index != 0) {
+            throw Exception("SingleAttribute has only 1 value");
+        }
+        return attr_;
+    }
+
+    Attribute &get(size_t index = 0) {
+        if (index != 0) {
+            throw Exception("SingleAttribute has only 1 value");
+        }
+        return attr_;
+    }
+
+private:
+    template<typename T> friend struct MultiAttribute;
+    Attribute attr_;
+};
+
+template<typename Attribute>
+struct MultiAttribute
+{
+    static const bool hasAttribute = true;
+
+    MultiAttribute()
+    { }
+
+    // copy constructing from another single attribute is allowed, it
+    // pushes the attribute
+    MultiAttribute(const SingleAttribute<Attribute> &rhs)
+    {
+        // since map is the only type that does this we know it's
+        // final size will be two, so reserve
+        attrs_.reserve(2);
+        attrs_.push_back(rhs.attr_);
+    }
+
+    MultiAttribute(const MultiAttribute<Attribute> &rhs)  :
+        attrs_(rhs.attrs_)
+    { }
+
     MultiAttribute(const NoAttribute<Attribute> &)
-    {} 
- 
-    size_t size() const { 
-        return attrs_.size(); 
-    } 
- 
-    void add(const Attribute &attr) { 
-        attrs_.push_back(attr); 
-    } 
- 
-    const Attribute &get(size_t index = 0) const { 
-        return attrs_.at(index); 
-    } 
- 
-    Attribute &get(size_t index) { 
-        return attrs_.at(index); 
-    } 
- 
-  private: 
- 
-    std::vector<Attribute> attrs_; 
-}; 
- 
- 
-template<typename T> 
-struct NameIndexConcept { 
- 
+    {}
+
+    size_t size() const {
+        return attrs_.size();
+    }
+
+    void add(const Attribute &attr) {
+        attrs_.push_back(attr);
+    }
+
+    const Attribute &get(size_t index = 0) const {
+        return attrs_.at(index);
+    }
+
+    Attribute &get(size_t index) {
+        return attrs_.at(index);
+    }
+
+  private:
+
+    std::vector<Attribute> attrs_;
+};
+
+
+template<typename T>
+struct NameIndexConcept {
+
     bool lookup(const std::string &, size_t &) const {
-        throw Exception("Name index does not exist"); 
-        return 0; 
-    } 
- 
+        throw Exception("Name index does not exist");
+        return 0;
+    }
+
     bool add(const::std::string &, size_t) {
-        throw Exception("Name index does not exist"); 
-        return false; 
-    } 
-}; 
- 
-template<> 
-struct NameIndexConcept < MultiAttribute<std::string> > 
-{ 
-    typedef std::map<std::string, size_t> IndexMap; 
- 
-    bool lookup(const std::string &name, size_t &index) const { 
-        IndexMap::const_iterator iter = map_.find(name); 
-        if(iter == map_.end()) { 
-            return false; 
-        } 
-        index = iter->second; 
-        return true; 
-    } 
- 
-    bool add(const::std::string &name, size_t index) { 
-        bool added = false; 
-        IndexMap::iterator lb = map_.lower_bound(name); 
-        if(lb == map_.end() || map_.key_comp()(name, lb->first)) { 
-            map_.insert(lb, IndexMap::value_type(name, index)); 
-            added = true; 
-        } 
-        return added; 
-    } 
- 
-  private: 
- 
-    IndexMap map_; 
-}; 
- 
-} // namespace concepts 
-} // namespace avro 
- 
-#endif 
+        throw Exception("Name index does not exist");
+        return false;
+    }
+};
+
+template<>
+struct NameIndexConcept < MultiAttribute<std::string> >
+{
+    typedef std::map<std::string, size_t> IndexMap;
+
+    bool lookup(const std::string &name, size_t &index) const {
+        IndexMap::const_iterator iter = map_.find(name);
+        if(iter == map_.end()) {
+            return false;
+        }
+        index = iter->second;
+        return true;
+    }
+
+    bool add(const::std::string &name, size_t index) {
+        bool added = false;
+        IndexMap::iterator lb = map_.lower_bound(name);
+        if(lb == map_.end() || map_.key_comp()(name, lb->first)) {
+            map_.insert(lb, IndexMap::value_type(name, index));
+            added = true;
+        }
+        return added;
+    }
+
+  private:
+
+    IndexMap map_;
+};
+
+} // namespace concepts
+} // namespace avro
+
+#endif
diff --git a/contrib/libs/apache/avro/api/NodeImpl.hh b/contrib/libs/apache/avro/api/NodeImpl.hh
index f0f1cd9def..debce720a6 100644
--- a/contrib/libs/apache/avro/api/NodeImpl.hh
+++ b/contrib/libs/apache/avro/api/NodeImpl.hh
@@ -1,619 +1,619 @@
-/* 
- * Licensed to the Apache Software Foundation (ASF) under one 
- * or more contributor license agreements.  See the NOTICE file 
- * distributed with this work for additional information 
- * regarding copyright ownership.  The ASF licenses this file 
- * to you under the Apache License, Version 2.0 (the 
- * "License"); you may not use this file except in compliance 
- * with the License.  You may obtain a copy of the License at 
- * 
- *     https://www.apache.org/licenses/LICENSE-2.0 
- * 
- * Unless required by applicable law or agreed to in writing, software 
- * distributed under the License is distributed on an "AS IS" BASIS, 
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
- * See the License for the specific language governing permissions and 
- * limitations under the License. 
- */ 
- 
-#ifndef avro_NodeImpl_hh__ 
-#define avro_NodeImpl_hh__ 
- 
-#include "Config.hh" 
-#include "GenericDatum.hh" 
- 
-#include <limits> 
-#include <set> 
-#include <iomanip> 
-#include <iostream> 
-#include <sstream> 
-#include <memory> 
- 
-#include "Node.hh" 
-#include "NodeConcepts.hh" 
- 
-namespace avro { 
- 
-/// Implementation details for Node.  NodeImpl represents all the avro types, 
-/// whose properties are enabled and disabled by selecting concept classes. 
- 
-template 
-< 
-    class NameConcept, 
-    class LeavesConcept, 
-    class LeafNamesConcept, 
-    class SizeConcept 
-> 
-class NodeImpl : public Node 
-{ 
- 
-  protected: 
- 
-    NodeImpl(Type type) : 
-        Node(type), 
-        nameAttribute_(), 
-        docAttribute_(), 
-        leafAttributes_(), 
-        leafNameAttributes_(), 
-        sizeAttribute_() 
-    { } 
- 
-    NodeImpl(Type type, 
-             const NameConcept &name, 
-             const LeavesConcept &leaves, 
-             const LeafNamesConcept &leafNames, 
-             const SizeConcept &size) : 
-        Node(type), 
-        nameAttribute_(name), 
-        docAttribute_(), 
-        leafAttributes_(leaves), 
-        leafNameAttributes_(leafNames), 
-        sizeAttribute_(size) 
-    { } 
- 
-    // Ctor with "doc" 
-    NodeImpl(Type type, 
-             const NameConcept &name, 
-             const concepts::SingleAttribute<std::string> &doc, 
-             const LeavesConcept &leaves, 
-             const LeafNamesConcept &leafNames, 
-             const SizeConcept &size) : 
-        Node(type), 
-        nameAttribute_(name), 
-        docAttribute_(doc), 
-        leafAttributes_(leaves), 
-        leafNameAttributes_(leafNames), 
-        sizeAttribute_(size) 
-    {} 
- 
-    void swap(NodeImpl& impl) { 
-        std::swap(nameAttribute_, impl.nameAttribute_); 
-        std::swap(docAttribute_, impl.docAttribute_); 
-        std::swap(leafAttributes_, impl.leafAttributes_); 
-        std::swap(leafNameAttributes_, impl.leafNameAttributes_); 
-        std::swap(sizeAttribute_, impl.sizeAttribute_); 
-        std::swap(nameIndex_, impl.nameIndex_); 
-    } 
- 
-    bool hasName() const { 
-        // e.g.: true for single and multiattributes, false for noattributes. 
-        return NameConcept::hasAttribute; 
-    } 
- 
-    void doSetName(const Name &name) { 
-        nameAttribute_.add(name); 
-    } 
- 
-    const Name &name() const { 
-        return nameAttribute_.get(); 
-    } 
- 
-    void doSetDoc(const std::string &doc) { 
-      docAttribute_.add(doc); 
-    } 
- 
-    const std::string &getDoc() const { 
-      return docAttribute_.get(); 
-    } 
- 
-    void doAddLeaf(const NodePtr &newLeaf) { 
-        leafAttributes_.add(newLeaf); 
-    } 
- 
-    size_t leaves() const { 
-        return leafAttributes_.size(); 
-    } 
- 
-    const NodePtr &leafAt(int index) const { 
-        return leafAttributes_.get(index); 
-    } 
- 
-    void doAddName(const std::string &name) { 
-        if (! nameIndex_.add(name, leafNameAttributes_.size())) { 
-            throw Exception(boost::format("Cannot add duplicate name: %1%") % name); 
-        } 
-        leafNameAttributes_.add(name); 
-    } 
- 
-    size_t names() const { 
-        return leafNameAttributes_.size(); 
-    } 
- 
-    const std::string &nameAt(int index) const { 
-        return leafNameAttributes_.get(index); 
-    } 
- 
-    bool nameIndex(const std::string &name, size_t &index) const { 
-        return nameIndex_.lookup(name, index); 
-    } 
- 
-    void doSetFixedSize(int size) { 
-        sizeAttribute_.add(size); 
-    } 
- 
-    int fixedSize() const { 
-        return sizeAttribute_.get(); 
-    } 
- 
-    virtual bool isValid() const = 0; 
- 
-    void printBasicInfo(std::ostream &os) const; 
- 
-    void setLeafToSymbolic(int index, const NodePtr &node); 
- 
-    SchemaResolution furtherResolution(const Node &reader) const { 
-        SchemaResolution match = RESOLVE_NO_MATCH; 
- 
-        if (reader.type() == AVRO_SYMBOLIC) { 
- 
-            // resolve the symbolic type, and check again 
-            const NodePtr &node = reader.leafAt(0); 
-            match = resolve(*node); 
-        } 
-        else if(reader.type() == AVRO_UNION) { 
- 
-            // in this case, need to see if there is an exact match for the 
-            // writer's type, or if not, the first one that can be promoted to a 
-            // match 
- 
-            for(size_t i= 0; i < reader.leaves(); ++i)  { 
- 
-                const NodePtr &node = reader.leafAt(i); 
-                SchemaResolution thisMatch = resolve(*node); 
- 
-                // if matched then the search is done 
-                if(thisMatch == RESOLVE_MATCH) { 
-                    match = thisMatch; 
-                    break; 
-                } 
- 
-                // thisMatch is either no match, or promotable, this will set match to 
-                // promotable if it hasn't been set already 
-                if (match == RESOLVE_NO_MATCH) { 
-                    match = thisMatch; 
-                } 
-            } 
-        } 
- 
-        return match; 
-    } 
- 
-    NameConcept nameAttribute_; 
- 
-    // Rem: NameConcept type is HasName (= SingleAttribute<Name>), we use std::string instead 
-    concepts::SingleAttribute<std::string> docAttribute_; /** Doc used to compare schemas */ 
- 
-    LeavesConcept leafAttributes_; 
-    LeafNamesConcept leafNameAttributes_; 
-    SizeConcept sizeAttribute_; 
-    concepts::NameIndexConcept<LeafNamesConcept> nameIndex_; 
-}; 
- 
-typedef concepts::NoAttribute<Name>     NoName; 
-typedef concepts::SingleAttribute<Name> HasName; 
- 
-typedef concepts::SingleAttribute<std::string> HasDoc; 
- 
-typedef concepts::NoAttribute<NodePtr>      NoLeaves; 
-typedef concepts::SingleAttribute<NodePtr>  SingleLeaf; 
-typedef concepts::MultiAttribute<NodePtr>   MultiLeaves; 
- 
-typedef concepts::NoAttribute<std::string>     NoLeafNames; 
-typedef concepts::MultiAttribute<std::string>  LeafNames; 
- 
-typedef concepts::NoAttribute<int>     NoSize; 
-typedef concepts::SingleAttribute<int> HasSize; 
- 
-typedef NodeImpl< NoName,  NoLeaves,    NoLeafNames,  NoSize  > NodeImplPrimitive; 
-typedef NodeImpl< HasName, NoLeaves,    NoLeafNames,  NoSize  > NodeImplSymbolic; 
- 
-typedef NodeImpl< HasName, MultiLeaves, LeafNames,    NoSize  > NodeImplRecord; 
-typedef NodeImpl< HasName, NoLeaves,    LeafNames,    NoSize  > NodeImplEnum; 
-typedef NodeImpl< NoName,  SingleLeaf,  NoLeafNames,  NoSize  > NodeImplArray; 
-typedef NodeImpl< NoName,  MultiLeaves, NoLeafNames,  NoSize  > NodeImplMap; 
-typedef NodeImpl< NoName,  MultiLeaves, NoLeafNames,  NoSize  > NodeImplUnion; 
-typedef NodeImpl< HasName, NoLeaves,    NoLeafNames,  HasSize > NodeImplFixed; 
- 
-class AVRO_DECL NodePrimitive : public NodeImplPrimitive 
-{ 
-  public: 
- 
-    explicit NodePrimitive(Type type) : 
-        NodeImplPrimitive(type) 
-    { } 
- 
-    SchemaResolution resolve(const Node &reader)  const; 
- 
-    void printJson(std::ostream &os, int depth) const; 
- 
-    bool isValid() const { 
-        return true; 
-    } 
- 
-    void printDefaultToJson(const GenericDatum& g, std::ostream &os, int depth) const; 
-}; 
- 
-class AVRO_DECL NodeSymbolic : public NodeImplSymbolic 
-{ 
-    typedef std::weak_ptr<Node> NodeWeakPtr; 
- 
-  public: 
- 
-    NodeSymbolic() : 
-        NodeImplSymbolic(AVRO_SYMBOLIC) 
-    { } 
- 
-    explicit NodeSymbolic(const HasName &name) : 
-        NodeImplSymbolic(AVRO_SYMBOLIC, name, NoLeaves(), NoLeafNames(), NoSize()) 
-    { } 
- 
-    NodeSymbolic(const HasName &name, const NodePtr n) : 
-        NodeImplSymbolic(AVRO_SYMBOLIC, name, NoLeaves(), NoLeafNames(), NoSize()), actualNode_(n) 
-    { } 
-    SchemaResolution resolve(const Node &reader)  const; 
- 
-    void printJson(std::ostream &os, int depth) const; 
- 
-    bool isValid() const { 
-        return (nameAttribute_.size() == 1); 
-    } 
- 
-    void printDefaultToJson(const GenericDatum& g, std::ostream &os, int depth) const; 
- 
-    bool isSet() const { 
-         return (actualNode_.lock() != 0); 
-    } 
- 
-    NodePtr getNode() const { 
-        NodePtr node = actualNode_.lock(); 
-        if(!node) { 
-            throw Exception(boost::format("Could not follow symbol %1%") % name()); 
-        } 
-        return node; 
-    } 
- 
-    void setNode(const NodePtr &node) { 
-        actualNode_ = node; 
-    } 
- 
-  protected: 
- 
-    NodeWeakPtr actualNode_; 
- 
-}; 
- 
-class AVRO_DECL NodeRecord : public NodeImplRecord { 
-    std::vector<GenericDatum> defaultValues; 
-public: 
-    NodeRecord() : NodeImplRecord(AVRO_RECORD) { } 
-    NodeRecord(const HasName &name, const MultiLeaves &fields, 
-        const LeafNames &fieldsNames, 
-        const std::vector<GenericDatum>& dv) : 
-        NodeImplRecord(AVRO_RECORD, name, fields, fieldsNames, NoSize()), 
-        defaultValues(dv) { 
-        for (size_t i = 0; i < leafNameAttributes_.size(); ++i) { 
-            if (!nameIndex_.add(leafNameAttributes_.get(i), i)) { 
-                throw Exception(boost::format( 
-                    "Cannot add duplicate field: %1%") % 
-                    leafNameAttributes_.get(i)); 
-            } 
-        } 
-    } 
- 
-    NodeRecord(const HasName &name, const HasDoc &doc, const MultiLeaves &fields, 
-        const LeafNames &fieldsNames, 
-        const std::vector<GenericDatum> &dv) : 
-        NodeImplRecord(AVRO_RECORD, name, doc, fields, fieldsNames, NoSize()), 
-        defaultValues(dv) { 
-        for (size_t i = 0; i < leafNameAttributes_.size(); ++i) { 
-            if (!nameIndex_.add(leafNameAttributes_.get(i), i)) { 
-                throw Exception(boost::format( 
-                    "Cannot add duplicate field: %1%") % 
-                    leafNameAttributes_.get(i)); 
-            } 
-        } 
-    } 
- 
-    void swap(NodeRecord& r) { 
-        NodeImplRecord::swap(r); 
-        defaultValues.swap(r.defaultValues); 
-    } 
- 
-    SchemaResolution resolve(const Node &reader)  const; 
- 
-    void printJson(std::ostream &os, int depth) const; 
- 
-    bool isValid() const { 
-        return ((nameAttribute_.size() == 1) && 
-            (leafAttributes_.size() == leafNameAttributes_.size())); 
-    } 
- 
-    const GenericDatum& defaultValueAt(int index) { 
-        return defaultValues[index]; 
-    } 
- 
-    void printDefaultToJson(const GenericDatum& g, std::ostream &os, int depth) const; 
-}; 
- 
-class AVRO_DECL NodeEnum : public NodeImplEnum 
-{ 
-  public: 
- 
-    NodeEnum() : 
-        NodeImplEnum(AVRO_ENUM) 
-    { } 
- 
-    NodeEnum(const HasName &name, const LeafNames &symbols) : 
-        NodeImplEnum(AVRO_ENUM, name, NoLeaves(), symbols, NoSize()) 
-    { 
-        for(size_t i=0; i < leafNameAttributes_.size(); ++i) { 
-            if(!nameIndex_.add(leafNameAttributes_.get(i), i)) { 
-                 throw Exception(boost::format("Cannot add duplicate enum: %1%") % leafNameAttributes_.get(i)); 
-            } 
-        } 
-    } 
- 
-    SchemaResolution resolve(const Node &reader)  const; 
- 
-    void printJson(std::ostream &os, int depth) const; 
- 
-    bool isValid() const { 
-        return ( 
-                (nameAttribute_.size() == 1) && 
-                (leafNameAttributes_.size() > 0) 
-               ); 
-    } 
- 
-    void printDefaultToJson(const GenericDatum& g, std::ostream &os, int depth) const; 
-}; 
- 
-class AVRO_DECL NodeArray : public NodeImplArray 
-{ 
-  public: 
- 
-    NodeArray() : 
-        NodeImplArray(AVRO_ARRAY) 
-    { } 
- 
-    explicit NodeArray(const SingleLeaf &items) : 
-        NodeImplArray(AVRO_ARRAY, NoName(), items, NoLeafNames(), NoSize()) 
-    { } 
- 
-    SchemaResolution resolve(const Node &reader)  const; 
- 
-    void printJson(std::ostream &os, int depth) const; 
- 
-    bool isValid() const { 
-        return (leafAttributes_.size() == 1); 
-    } 
- 
-    void printDefaultToJson(const GenericDatum& g, std::ostream &os, int depth) const; 
-}; 
- 
-class AVRO_DECL NodeMap : public NodeImplMap 
-{ 
-  public: 
- 
-    NodeMap() : 
-        NodeImplMap(AVRO_MAP) 
-    { 
-         NodePtr key(new NodePrimitive(AVRO_STRING)); 
-         doAddLeaf(key); 
-    } 
- 
-    explicit NodeMap(const SingleLeaf &values) : 
-        NodeImplMap(AVRO_MAP, NoName(), values, NoLeafNames(), NoSize()) 
-    { 
-        // need to add the key for the map too 
-        NodePtr key(new NodePrimitive(AVRO_STRING)); 
-        doAddLeaf(key); 
- 
-        // key goes before value 
-        std::swap(leafAttributes_.get(0), leafAttributes_.get(1)); 
-    } 
- 
-    SchemaResolution resolve(const Node &reader)  const; 
- 
-    void printJson(std::ostream &os, int depth) const; 
- 
-    bool isValid() const { 
-        return (leafAttributes_.size() == 2); 
-    } 
- 
-    void printDefaultToJson(const GenericDatum& g, std::ostream &os, int depth) const; 
-}; 
- 
-class AVRO_DECL NodeUnion : public NodeImplUnion 
-{ 
-  public: 
- 
-    NodeUnion() : 
-        NodeImplUnion(AVRO_UNION) 
-    { } 
- 
-    explicit NodeUnion(const MultiLeaves &types) : 
-        NodeImplUnion(AVRO_UNION, NoName(), types, NoLeafNames(), NoSize()) 
-    { } 
- 
-    SchemaResolution resolve(const Node &reader)  const; 
- 
-    void printJson(std::ostream &os, int depth) const; 
- 
-    bool isValid() const { 
-        std::set<std::string> seen; 
-        if (leafAttributes_.size() >= 1) { 
-            for (size_t i = 0; i < leafAttributes_.size(); ++i) { 
-                std::string name; 
-                const NodePtr& n = leafAttributes_.get(i); 
-                switch (n->type()) { 
-                case AVRO_STRING: 
-                    name = "string"; 
-                    break; 
-                case AVRO_BYTES: 
-                    name = "bytes"; 
-                    break; 
-                case AVRO_INT: 
-                    name = "int"; 
-                    break; 
-                case AVRO_LONG: 
-                    name = "long"; 
-                    break; 
-                case AVRO_FLOAT: 
-                    name = "float"; 
-                    break; 
-                case AVRO_DOUBLE: 
-                    name = "double"; 
-                    break; 
-                case AVRO_BOOL: 
-                    name = "bool"; 
-                    break; 
-                case AVRO_NULL: 
-                    name = "null"; 
-                    break; 
-                case AVRO_ARRAY: 
-                    name = "array"; 
-                    break; 
-                case AVRO_MAP: 
-                    name = "map"; 
-                    break; 
-                case AVRO_RECORD: 
-                case AVRO_ENUM: 
-                case AVRO_UNION: 
-                case AVRO_FIXED: 
-                case AVRO_SYMBOLIC: 
-                    name = n->name().fullname(); 
-                    break; 
-                default: 
-                    return false; 
-                } 
-                if (seen.find(name) != seen.end()) { 
-                    return false; 
-                } 
-                seen.insert(name); 
-            } 
-            return true; 
-        } 
-        return false; 
-    } 
- 
-    void printDefaultToJson(const GenericDatum& g, std::ostream &os, int depth) const; 
-}; 
- 
-class AVRO_DECL NodeFixed : public NodeImplFixed 
-{ 
-  public: 
- 
-    NodeFixed() : 
-        NodeImplFixed(AVRO_FIXED) 
-    { } 
- 
-    NodeFixed(const HasName &name, const HasSize &size) : 
-        NodeImplFixed(AVRO_FIXED, name, NoLeaves(), NoLeafNames(), size) 
-    { } 
- 
-    SchemaResolution resolve(const Node &reader)  const; 
- 
-    void printJson(std::ostream &os, int depth) const; 
- 
-    bool isValid() const { 
-        return ( 
-                (nameAttribute_.size() == 1) && 
-                (sizeAttribute_.size() == 1) 
-               ); 
-    } 
- 
-    void printDefaultToJson(const GenericDatum& g, std::ostream &os, int depth) const; 
-}; 
- 
-template < class A, class B, class C, class D > 
-inline void 
-NodeImpl<A,B,C,D>::setLeafToSymbolic(int index, const NodePtr &node) 
-{ 
-    if(!B::hasAttribute) { 
-        throw Exception("Cannot change leaf node for nonexistent leaf"); 
-    } 
- 
-    NodePtr &replaceNode = const_cast<NodePtr &>(leafAttributes_.get(index)); 
-    if(replaceNode->name() != node->name()) { 
-        throw Exception("Symbolic name does not match the name of the schema it references"); 
-    } 
- 
-    NodePtr symbol(new NodeSymbolic); 
-    NodeSymbolic *ptr = static_cast<NodeSymbolic *> (symbol.get()); 
- 
-    ptr->setName(node->name()); 
-    ptr->setNode(node); 
-    replaceNode.swap(symbol); 
-} 
- 
-template < class A, class B, class C, class D > 
-inline void 
-NodeImpl<A,B,C,D>::printBasicInfo(std::ostream &os) const 
-{ 
-    os << type(); 
-    if(hasName()) { 
-        os << ' ' << nameAttribute_.get(); 
-    } 
- 
-    if(D::hasAttribute) { 
-        os << " " << sizeAttribute_.get(); 
-    } 
-    os << '\n'; 
-    int count = leaves(); 
-    count = count ? count : names(); 
-    for(int i= 0; i < count; ++i) { 
-        if( C::hasAttribute ) { 
-            os << "name " << nameAt(i) << '\n'; 
-        } 
-        if( type() != AVRO_SYMBOLIC && leafAttributes_.hasAttribute) { 
-            leafAt(i)->printBasicInfo(os); 
-        } 
-    } 
-    if(isCompound(type())) { 
-        os << "end " << type() << '\n'; 
-    } 
-} 
- 
- 
-inline NodePtr resolveSymbol(const NodePtr &node) 
-{ 
-    if(node->type() != AVRO_SYMBOLIC) { 
-        throw Exception("Only symbolic nodes may be resolved"); 
-    } 
-    std::shared_ptr<NodeSymbolic> symNode = std::static_pointer_cast<NodeSymbolic>(node); 
-    return symNode->getNode(); 
-} 
- 
-template< typename T > 
-inline std::string intToHex(T i) 
-{ 
-  std::stringstream stream; 
-  stream << "\\u" 
-         << std::setfill('0') << std::setw(sizeof(T)) 
-         << std::hex << i; 
-  return stream.str(); 
-} 
- 
-} // namespace avro 
- 
-#endif 
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef avro_NodeImpl_hh__
+#define avro_NodeImpl_hh__
+
+#include "Config.hh"
+#include "GenericDatum.hh"
+
+#include <limits>
+#include <set>
+#include <iomanip>
+#include <iostream>
+#include <sstream>
+#include <memory>
+
+#include "Node.hh"
+#include "NodeConcepts.hh"
+
+namespace avro {
+
+/// Implementation details for Node.  NodeImpl represents all the avro types,
+/// whose properties are enabled and disabled by selecting concept classes.
+
+template
+<
+    class NameConcept,
+    class LeavesConcept,
+    class LeafNamesConcept,
+    class SizeConcept
+>
+class NodeImpl : public Node
+{
+
+  protected:
+
+    NodeImpl(Type type) :
+        Node(type),
+        nameAttribute_(),
+        docAttribute_(),
+        leafAttributes_(),
+        leafNameAttributes_(),
+        sizeAttribute_()
+    { }
+
+    NodeImpl(Type type,
+             const NameConcept &name,
+             const LeavesConcept &leaves,
+             const LeafNamesConcept &leafNames,
+             const SizeConcept &size) :
+        Node(type),
+        nameAttribute_(name),
+        docAttribute_(),
+        leafAttributes_(leaves),
+        leafNameAttributes_(leafNames),
+        sizeAttribute_(size)
+    { }
+
+    // Ctor with "doc"
+    NodeImpl(Type type,
+             const NameConcept &name,
+             const concepts::SingleAttribute<std::string> &doc,
+             const LeavesConcept &leaves,
+             const LeafNamesConcept &leafNames,
+             const SizeConcept &size) :
+        Node(type),
+        nameAttribute_(name),
+        docAttribute_(doc),
+        leafAttributes_(leaves),
+        leafNameAttributes_(leafNames),
+        sizeAttribute_(size)
+    {}
+
+    void swap(NodeImpl& impl) {
+        std::swap(nameAttribute_, impl.nameAttribute_);
+        std::swap(docAttribute_, impl.docAttribute_);
+        std::swap(leafAttributes_, impl.leafAttributes_);
+        std::swap(leafNameAttributes_, impl.leafNameAttributes_);
+        std::swap(sizeAttribute_, impl.sizeAttribute_);
+        std::swap(nameIndex_, impl.nameIndex_);
+    }
+
+    bool hasName() const {
+        // e.g.: true for single and multiattributes, false for noattributes.
+        return NameConcept::hasAttribute;
+    }
+
+    void doSetName(const Name &name) {
+        nameAttribute_.add(name);
+    }
+
+    const Name &name() const {
+        return nameAttribute_.get();
+    }
+
+    void doSetDoc(const std::string &doc) {
+      docAttribute_.add(doc);
+    }
+
+    const std::string &getDoc() const {
+      return docAttribute_.get();
+    }
+
+    void doAddLeaf(const NodePtr &newLeaf) {
+        leafAttributes_.add(newLeaf);
+    }
+
+    size_t leaves() const {
+        return leafAttributes_.size();
+    }
+
+    const NodePtr &leafAt(int index) const {
+        return leafAttributes_.get(index);
+    }
+
+    void doAddName(const std::string &name) {
+        if (! nameIndex_.add(name, leafNameAttributes_.size())) {
+            throw Exception(boost::format("Cannot add duplicate name: %1%") % name);
+        }
+        leafNameAttributes_.add(name);
+    }
+
+    size_t names() const {
+        return leafNameAttributes_.size();
+    }
+
+    const std::string &nameAt(int index) const {
+        return leafNameAttributes_.get(index);
+    }
+
+    bool nameIndex(const std::string &name, size_t &index) const {
+        return nameIndex_.lookup(name, index);
+    }
+
+    void doSetFixedSize(int size) {
+        sizeAttribute_.add(size);
+    }
+
+    int fixedSize() const {
+        return sizeAttribute_.get();
+    }
+
+    virtual bool isValid() const = 0;
+
+    void printBasicInfo(std::ostream &os) const;
+
+    void setLeafToSymbolic(int index, const NodePtr &node);
+
+    SchemaResolution furtherResolution(const Node &reader) const {
+        SchemaResolution match = RESOLVE_NO_MATCH;
+
+        if (reader.type() == AVRO_SYMBOLIC) {
+
+            // resolve the symbolic type, and check again
+            const NodePtr &node = reader.leafAt(0);
+            match = resolve(*node);
+        }
+        else if(reader.type() == AVRO_UNION) {
+
+            // in this case, need to see if there is an exact match for the
+            // writer's type, or if not, the first one that can be promoted to a
+            // match
+
+            for(size_t i= 0; i < reader.leaves(); ++i)  {
+
+                const NodePtr &node = reader.leafAt(i);
+                SchemaResolution thisMatch = resolve(*node);
+
+                // if matched then the search is done
+                if(thisMatch == RESOLVE_MATCH) {
+                    match = thisMatch;
+                    break;
+                }
+
+                // thisMatch is either no match, or promotable, this will set match to
+                // promotable if it hasn't been set already
+                if (match == RESOLVE_NO_MATCH) {
+                    match = thisMatch;
+                }
+            }
+        }
+
+        return match;
+    }
+
+    NameConcept nameAttribute_;
+
+    // Rem: NameConcept type is HasName (= SingleAttribute<Name>), we use std::string instead
+    concepts::SingleAttribute<std::string> docAttribute_; /** Doc used to compare schemas */
+
+    LeavesConcept leafAttributes_;
+    LeafNamesConcept leafNameAttributes_;
+    SizeConcept sizeAttribute_;
+    concepts::NameIndexConcept<LeafNamesConcept> nameIndex_;
+};
+
+typedef concepts::NoAttribute<Name>     NoName;
+typedef concepts::SingleAttribute<Name> HasName;
+
+typedef concepts::SingleAttribute<std::string> HasDoc;
+
+typedef concepts::NoAttribute<NodePtr>      NoLeaves;
+typedef concepts::SingleAttribute<NodePtr>  SingleLeaf;
+typedef concepts::MultiAttribute<NodePtr>   MultiLeaves;
+
+typedef concepts::NoAttribute<std::string>     NoLeafNames;
+typedef concepts::MultiAttribute<std::string>  LeafNames;
+
+typedef concepts::NoAttribute<int>     NoSize;
+typedef concepts::SingleAttribute<int> HasSize;
+
+typedef NodeImpl< NoName,  NoLeaves,    NoLeafNames,  NoSize  > NodeImplPrimitive;
+typedef NodeImpl< HasName, NoLeaves,    NoLeafNames,  NoSize  > NodeImplSymbolic;
+
+typedef NodeImpl< HasName, MultiLeaves, LeafNames,    NoSize  > NodeImplRecord;
+typedef NodeImpl< HasName, NoLeaves,    LeafNames,    NoSize  > NodeImplEnum;
+typedef NodeImpl< NoName,  SingleLeaf,  NoLeafNames,  NoSize  > NodeImplArray;
+typedef NodeImpl< NoName,  MultiLeaves, NoLeafNames,  NoSize  > NodeImplMap;
+typedef NodeImpl< NoName,  MultiLeaves, NoLeafNames,  NoSize  > NodeImplUnion;
+typedef NodeImpl< HasName, NoLeaves,    NoLeafNames,  HasSize > NodeImplFixed;
+
+class AVRO_DECL NodePrimitive : public NodeImplPrimitive
+{
+  public:
+
+    explicit NodePrimitive(Type type) :
+        NodeImplPrimitive(type)
+    { }
+
+    SchemaResolution resolve(const Node &reader)  const;
+
+    void printJson(std::ostream &os, int depth) const;
+
+    bool isValid() const {
+        return true;
+    }
+
+    void printDefaultToJson(const GenericDatum& g, std::ostream &os, int depth) const;
+};
+
+class AVRO_DECL NodeSymbolic : public NodeImplSymbolic
+{
+    typedef std::weak_ptr<Node> NodeWeakPtr;
+
+  public:
+
+    NodeSymbolic() :
+        NodeImplSymbolic(AVRO_SYMBOLIC)
+    { }
+
+    explicit NodeSymbolic(const HasName &name) :
+        NodeImplSymbolic(AVRO_SYMBOLIC, name, NoLeaves(), NoLeafNames(), NoSize())
+    { }
+
+    NodeSymbolic(const HasName &name, const NodePtr n) :
+        NodeImplSymbolic(AVRO_SYMBOLIC, name, NoLeaves(), NoLeafNames(), NoSize()), actualNode_(n)
+    { }
+    SchemaResolution resolve(const Node &reader)  const;
+
+    void printJson(std::ostream &os, int depth) const;
+
+    bool isValid() const {
+        return (nameAttribute_.size() == 1);
+    }
+
+    void printDefaultToJson(const GenericDatum& g, std::ostream &os, int depth) const;
+
+    bool isSet() const {
+         return (actualNode_.lock() != 0);
+    }
+
+    NodePtr getNode() const {
+        NodePtr node = actualNode_.lock();
+        if(!node) {
+            throw Exception(boost::format("Could not follow symbol %1%") % name());
+        }
+        return node;
+    }
+
+    void setNode(const NodePtr &node) {
+        actualNode_ = node;
+    }
+
+  protected:
+
+    NodeWeakPtr actualNode_;
+
+};
+
+class AVRO_DECL NodeRecord : public NodeImplRecord {
+    std::vector<GenericDatum> defaultValues;
+public:
+    NodeRecord() : NodeImplRecord(AVRO_RECORD) { }
+    NodeRecord(const HasName &name, const MultiLeaves &fields,
+        const LeafNames &fieldsNames,
+        const std::vector<GenericDatum>& dv) :
+        NodeImplRecord(AVRO_RECORD, name, fields, fieldsNames, NoSize()),
+        defaultValues(dv) {
+        for (size_t i = 0; i < leafNameAttributes_.size(); ++i) {
+            if (!nameIndex_.add(leafNameAttributes_.get(i), i)) {
+                throw Exception(boost::format(
+                    "Cannot add duplicate field: %1%") %
+                    leafNameAttributes_.get(i));
+            }
+        }
+    }
+
+    NodeRecord(const HasName &name, const HasDoc &doc, const MultiLeaves &fields,
+        const LeafNames &fieldsNames,
+        const std::vector<GenericDatum> &dv) :
+        NodeImplRecord(AVRO_RECORD, name, doc, fields, fieldsNames, NoSize()),
+        defaultValues(dv) {
+        for (size_t i = 0; i < leafNameAttributes_.size(); ++i) {
+            if (!nameIndex_.add(leafNameAttributes_.get(i), i)) {
+                throw Exception(boost::format(
+                    "Cannot add duplicate field: %1%") %
+                    leafNameAttributes_.get(i));
+            }
+        }
+    }
+
+    void swap(NodeRecord& r) {
+        NodeImplRecord::swap(r);
+        defaultValues.swap(r.defaultValues);
+    }
+
+    SchemaResolution resolve(const Node &reader)  const;
+
+    void printJson(std::ostream &os, int depth) const;
+
+    bool isValid() const {
+        return ((nameAttribute_.size() == 1) &&
+            (leafAttributes_.size() == leafNameAttributes_.size()));
+    }
+
+    const GenericDatum& defaultValueAt(int index) {
+        return defaultValues[index];
+    }
+
+    void printDefaultToJson(const GenericDatum& g, std::ostream &os, int depth) const;
+};
+
+class AVRO_DECL NodeEnum : public NodeImplEnum
+{
+  public:
+
+    NodeEnum() :
+        NodeImplEnum(AVRO_ENUM)
+    { }
+
+    NodeEnum(const HasName &name, const LeafNames &symbols) :
+        NodeImplEnum(AVRO_ENUM, name, NoLeaves(), symbols, NoSize())
+    {
+        for(size_t i=0; i < leafNameAttributes_.size(); ++i) {
+            if(!nameIndex_.add(leafNameAttributes_.get(i), i)) {
+                 throw Exception(boost::format("Cannot add duplicate enum: %1%") % leafNameAttributes_.get(i));
+            }
+        }
+    }
+
+    SchemaResolution resolve(const Node &reader)  const;
+
+    void printJson(std::ostream &os, int depth) const;
+
+    bool isValid() const {
+        return (
+                (nameAttribute_.size() == 1) &&
+                (leafNameAttributes_.size() > 0)
+               );
+    }
+
+    void printDefaultToJson(const GenericDatum& g, std::ostream &os, int depth) const;
+};
+
+class AVRO_DECL NodeArray : public NodeImplArray
+{
+  public:
+
+    NodeArray() :
+        NodeImplArray(AVRO_ARRAY)
+    { }
+
+    explicit NodeArray(const SingleLeaf &items) :
+        NodeImplArray(AVRO_ARRAY, NoName(), items, NoLeafNames(), NoSize())
+    { }
+
+    SchemaResolution resolve(const Node &reader)  const;
+
+    void printJson(std::ostream &os, int depth) const;
+
+    bool isValid() const {
+        return (leafAttributes_.size() == 1);
+    }
+
+    void printDefaultToJson(const GenericDatum& g, std::ostream &os, int depth) const;
+};
+
+class AVRO_DECL NodeMap : public NodeImplMap
+{
+  public:
+
+    NodeMap() :
+        NodeImplMap(AVRO_MAP)
+    {
+         NodePtr key(new NodePrimitive(AVRO_STRING));
+         doAddLeaf(key);
+    }
+
+    explicit NodeMap(const SingleLeaf &values) :
+        NodeImplMap(AVRO_MAP, NoName(), values, NoLeafNames(), NoSize())
+    {
+        // need to add the key for the map too
+        NodePtr key(new NodePrimitive(AVRO_STRING));
+        doAddLeaf(key);
+
+        // key goes before value
+        std::swap(leafAttributes_.get(0), leafAttributes_.get(1));
+    }
+
+    SchemaResolution resolve(const Node &reader)  const;
+
+    void printJson(std::ostream &os, int depth) const;
+
+    bool isValid() const {
+        return (leafAttributes_.size() == 2);
+    }
+
+    void printDefaultToJson(const GenericDatum& g, std::ostream &os, int depth) const;
+};
+
+class AVRO_DECL NodeUnion : public NodeImplUnion
+{
+  public:
+
+    NodeUnion() :
+        NodeImplUnion(AVRO_UNION)
+    { }
+
+    explicit NodeUnion(const MultiLeaves &types) :
+        NodeImplUnion(AVRO_UNION, NoName(), types, NoLeafNames(), NoSize())
+    { }
+
+    SchemaResolution resolve(const Node &reader)  const;
+
+    void printJson(std::ostream &os, int depth) const;
+
+    bool isValid() const {
+        std::set<std::string> seen;
+        if (leafAttributes_.size() >= 1) {
+            for (size_t i = 0; i < leafAttributes_.size(); ++i) {
+                std::string name;
+                const NodePtr& n = leafAttributes_.get(i);
+                switch (n->type()) {
+                case AVRO_STRING:
+                    name = "string";
+                    break;
+                case AVRO_BYTES:
+                    name = "bytes";
+                    break;
+                case AVRO_INT:
+                    name = "int";
+                    break;
+                case AVRO_LONG:
+                    name = "long";
+                    break;
+                case AVRO_FLOAT:
+                    name = "float";
+                    break;
+                case AVRO_DOUBLE:
+                    name = "double";
+                    break;
+                case AVRO_BOOL:
+                    name = "bool";
+                    break;
+                case AVRO_NULL:
+                    name = "null";
+                    break;
+                case AVRO_ARRAY:
+                    name = "array";
+                    break;
+                case AVRO_MAP:
+                    name = "map";
+                    break;
+                case AVRO_RECORD:
+                case AVRO_ENUM:
+                case AVRO_UNION:
+                case AVRO_FIXED:
+                case AVRO_SYMBOLIC:
+                    name = n->name().fullname();
+                    break;
+                default:
+                    return false;
+                }
+                if (seen.find(name) != seen.end()) {
+                    return false;
+                }
+                seen.insert(name);
+            }
+            return true;
+        }
+        return false;
+    }
+
+    void printDefaultToJson(const GenericDatum& g, std::ostream &os, int depth) const;
+};
+
+class AVRO_DECL NodeFixed : public NodeImplFixed
+{
+  public:
+
+    NodeFixed() :
+        NodeImplFixed(AVRO_FIXED)
+    { }
+
+    NodeFixed(const HasName &name, const HasSize &size) :
+        NodeImplFixed(AVRO_FIXED, name, NoLeaves(), NoLeafNames(), size)
+    { }
+
+    SchemaResolution resolve(const Node &reader)  const;
+
+    void printJson(std::ostream &os, int depth) const;
+
+    bool isValid() const {
+        return (
+                (nameAttribute_.size() == 1) &&
+                (sizeAttribute_.size() == 1)
+               );
+    }
+
+    void printDefaultToJson(const GenericDatum& g, std::ostream &os, int depth) const;
+};
+
+template < class A, class B, class C, class D >
+inline void
+NodeImpl<A,B,C,D>::setLeafToSymbolic(int index, const NodePtr &node)
+{
+    if(!B::hasAttribute) {
+        throw Exception("Cannot change leaf node for nonexistent leaf");
+    }
+
+    NodePtr &replaceNode = const_cast<NodePtr &>(leafAttributes_.get(index));
+    if(replaceNode->name() != node->name()) {
+        throw Exception("Symbolic name does not match the name of the schema it references");
+    }
+
+    NodePtr symbol(new NodeSymbolic);
+    NodeSymbolic *ptr = static_cast<NodeSymbolic *> (symbol.get());
+
+    ptr->setName(node->name());
+    ptr->setNode(node);
+    replaceNode.swap(symbol);
+}
+
+template < class A, class B, class C, class D >
+inline void
+NodeImpl<A,B,C,D>::printBasicInfo(std::ostream &os) const
+{
+    os << type();
+    if(hasName()) {
+        os << ' ' << nameAttribute_.get();
+    }
+
+    if(D::hasAttribute) {
+        os << " " << sizeAttribute_.get();
+    }
+    os << '\n';
+    int count = leaves();
+    count = count ? count : names();
+    for(int i= 0; i < count; ++i) {
+        if( C::hasAttribute ) {
+            os << "name " << nameAt(i) << '\n';
+        }
+        if( type() != AVRO_SYMBOLIC && leafAttributes_.hasAttribute) {
+            leafAt(i)->printBasicInfo(os);
+        }
+    }
+    if(isCompound(type())) {
+        os << "end " << type() << '\n';
+    }
+}
+
+
+inline NodePtr resolveSymbol(const NodePtr &node)
+{
+    if(node->type() != AVRO_SYMBOLIC) {
+        throw Exception("Only symbolic nodes may be resolved");
+    }
+    std::shared_ptr<NodeSymbolic> symNode = std::static_pointer_cast<NodeSymbolic>(node);
+    return symNode->getNode();
+}
+
+template< typename T >
+inline std::string intToHex(T i)
+{
+  std::stringstream stream;
+  stream << "\\u"
+         << std::setfill('0') << std::setw(sizeof(T))
+         << std::hex << i;
+  return stream.str();
+}
+
+} // namespace avro
+
+#endif
diff --git a/contrib/libs/apache/avro/api/Parser.hh b/contrib/libs/apache/avro/api/Parser.hh
index 3ba6af65e3..fdf28fb0d5 100644
--- a/contrib/libs/apache/avro/api/Parser.hh
+++ b/contrib/libs/apache/avro/api/Parser.hh
@@ -1,151 +1,151 @@
-/* 
- * Licensed to the Apache Software Foundation (ASF) under one 
- * or more contributor license agreements.  See the NOTICE file 
- * distributed with this work for additional information 
- * regarding copyright ownership.  The ASF licenses this file 
- * to you under the Apache License, Version 2.0 (the 
- * "License"); you may not use this file except in compliance 
- * with the License.  You may obtain a copy of the License at 
- * 
- *     https://www.apache.org/licenses/LICENSE-2.0 
- * 
- * Unless required by applicable law or agreed to in writing, software 
- * distributed under the License is distributed on an "AS IS" BASIS, 
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
- * See the License for the specific language governing permissions and 
- * limitations under the License. 
- */ 
- 
-#ifndef avro_Parser_hh__ 
-#define avro_Parser_hh__ 
- 
-#include "Config.hh" 
-#include "Reader.hh" 
- 
-#include <array> 
- 
-namespace avro { 
- 
-/// 
-/// Class that wraps a reader or ValidatingReade with an interface that uses 
-/// explicit get* names instead of getValue 
-/// 
- 
-template<class Reader> 
-class Parser : private boost::noncopyable 
-{ 
- 
-  public: 
- 
-    // Constructor only works with Writer 
-    explicit Parser(const InputBuffer &in) : 
-        reader_(in) 
-    {} 
- 
-    /// Constructor only works with ValidatingWriter 
-    Parser(const ValidSchema &schema, const InputBuffer &in) : 
-        reader_(schema, in) 
-    {} 
- 
-    void readNull() { 
-        Null null; 
-        reader_.readValue(null); 
-    } 
- 
-    bool readBool() { 
-        bool val; 
-        reader_.readValue(val); 
-        return val; 
-    } 
- 
-    int32_t readInt() { 
-        int32_t val; 
-        reader_.readValue(val); 
-        return val; 
-    } 
- 
-    int64_t readLong() { 
-        int64_t val; 
-        reader_.readValue(val); 
-        return val; 
-    } 
- 
-    float readFloat() { 
-        float val; 
-        reader_.readValue(val); 
-        return val; 
-    } 
- 
-    double readDouble() { 
-        double val; 
-        reader_.readValue(val); 
-        return val; 
-    } 
- 
-    void readString(std::string &val) { 
-        reader_.readValue(val); 
-    } 
- 
-    void readBytes(std::vector<uint8_t> &val) { 
-        reader_.readBytes(val); 
-    } 
- 
-    template <size_t N> 
-    void readFixed(uint8_t (&val)[N]) { 
-        reader_.readFixed(val); 
-    } 
- 
-    template<size_t N> 
-    void readFixed(std::array<uint8_t, N> &val) { 
-        reader_.readFixed(val); 
-    } 
- 
-    void readRecord() { 
-        reader_.readRecord(); 
-    } 
- 
-    void readRecordEnd() { 
-        reader_.readRecordEnd(); 
-    } 
- 
-    int64_t readArrayBlockSize() { 
-        return reader_.readArrayBlockSize(); 
-    } 
- 
-    int64_t readUnion() { 
-        return reader_.readUnion(); 
-    } 
- 
-    int64_t readEnum() { 
-        return reader_.readEnum(); 
-    } 
- 
-    int64_t readMapBlockSize() { 
-        return reader_.readMapBlockSize(); 
-    } 
- 
-  private: 
- 
-    friend Type nextType(Parser<ValidatingReader> &p); 
-    friend bool currentRecordName(Parser<ValidatingReader> &p, std::string &name); 
-    friend bool nextFieldName(Parser<ValidatingReader> &p, std::string &name); 
- 
-    Reader reader_; 
- 
-}; 
- 
-inline Type nextType(Parser<ValidatingReader> &p) { 
-    return p.reader_.nextType(); 
-} 
- 
-inline bool currentRecordName(Parser<ValidatingReader> &p, std::string &name) { 
-    return p.reader_.currentRecordName(name); 
-} 
- 
-inline bool nextFieldName(Parser<ValidatingReader> &p, std::string &name) { 
-    return p.reader_.nextFieldName(name); 
-} 
- 
-} // namespace avro 
- 
-#endif 
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef avro_Parser_hh__
+#define avro_Parser_hh__
+
+#include "Config.hh"
+#include "Reader.hh"
+
+#include <array>
+
+namespace avro {
+
+///
+/// Class that wraps a reader or ValidatingReade with an interface that uses
+/// explicit get* names instead of getValue
+///
+
+template<class Reader>
+class Parser : private boost::noncopyable
+{
+
+  public:
+
+    // Constructor only works with Writer
+    explicit Parser(const InputBuffer &in) :
+        reader_(in)
+    {}
+
+    /// Constructor only works with ValidatingWriter
+    Parser(const ValidSchema &schema, const InputBuffer &in) :
+        reader_(schema, in)
+    {}
+
+    void readNull() {
+        Null null;
+        reader_.readValue(null);
+    }
+
+    bool readBool() {
+        bool val;
+        reader_.readValue(val);
+        return val;
+    }
+
+    int32_t readInt() {
+        int32_t val;
+        reader_.readValue(val);
+        return val;
+    }
+
+    int64_t readLong() {
+        int64_t val;
+        reader_.readValue(val);
+        return val;
+    }
+
+    float readFloat() {
+        float val;
+        reader_.readValue(val);
+        return val;
+    }
+
+    double readDouble() {
+        double val;
+        reader_.readValue(val);
+        return val;
+    }
+
+    void readString(std::string &val) {
+        reader_.readValue(val);
+    }
+
+    void readBytes(std::vector<uint8_t> &val) {
+        reader_.readBytes(val);
+    }
+
+    template <size_t N>
+    void readFixed(uint8_t (&val)[N]) {
+        reader_.readFixed(val);
+    }
+
+    template<size_t N>
+    void readFixed(std::array<uint8_t, N> &val) {
+        reader_.readFixed(val);
+    }
+
+    void readRecord() {
+        reader_.readRecord();
+    }
+
+    void readRecordEnd() {
+        reader_.readRecordEnd();
+    }
+
+    int64_t readArrayBlockSize() {
+        return reader_.readArrayBlockSize();
+    }
+
+    int64_t readUnion() {
+        return reader_.readUnion();
+    }
+
+    int64_t readEnum() {
+        return reader_.readEnum();
+    }
+
+    int64_t readMapBlockSize() {
+        return reader_.readMapBlockSize();
+    }
+
+  private:
+
+    friend Type nextType(Parser<ValidatingReader> &p);
+    friend bool currentRecordName(Parser<ValidatingReader> &p, std::string &name);
+    friend bool nextFieldName(Parser<ValidatingReader> &p, std::string &name);
+
+    Reader reader_;
+
+};
+
+inline Type nextType(Parser<ValidatingReader> &p) {
+    return p.reader_.nextType();
+}
+
+inline bool currentRecordName(Parser<ValidatingReader> &p, std::string &name) {
+    return p.reader_.currentRecordName(name);
+}
+
+inline bool nextFieldName(Parser<ValidatingReader> &p, std::string &name) {
+    return p.reader_.nextFieldName(name);
+}
+
+} // namespace avro
+
+#endif
diff --git a/contrib/libs/apache/avro/api/Reader.hh b/contrib/libs/apache/avro/api/Reader.hh
index 26488145a2..4f514fbbe9 100644
--- a/contrib/libs/apache/avro/api/Reader.hh
+++ b/contrib/libs/apache/avro/api/Reader.hh
@@ -1,209 +1,209 @@
-/* 
- * Licensed to the Apache Software Foundation (ASF) under one 
- * or more contributor license agreements.  See the NOTICE file 
- * distributed with this work for additional information 
- * regarding copyright ownership.  The ASF licenses this file 
- * to you under the Apache License, Version 2.0 (the 
- * "License"); you may not use this file except in compliance 
- * with the License.  You may obtain a copy of the License at 
- * 
- *     https://www.apache.org/licenses/LICENSE-2.0 
- * 
- * Unless required by applicable law or agreed to in writing, software 
- * distributed under the License is distributed on an "AS IS" BASIS, 
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
- * See the License for the specific language governing permissions and 
- * limitations under the License. 
- */ 
- 
-#ifndef avro_Reader_hh__ 
-#define avro_Reader_hh__ 
- 
-#include <stdint.h> 
-#include <vector> 
-#include <array> 
-#include <boost/noncopyable.hpp> 
- 
-#include "Config.hh" 
-#include "Zigzag.hh" 
-#include "Types.hh" 
-#include "Validator.hh" 
-#include "buffer/BufferReader.hh" 
- 
-namespace avro { 
- 
-/// 
-/// Parses from an avro encoding to the requested type.  Assumes the next item 
-/// in the avro binary data is the expected type. 
-/// 
- 
-template<class ValidatorType> 
-class ReaderImpl : private boost::noncopyable 
-{ 
- 
-  public: 
- 
-    explicit ReaderImpl(const InputBuffer &buffer) : 
-        reader_(buffer) 
-    {} 
- 
-    ReaderImpl(const ValidSchema &schema, const InputBuffer &buffer) : 
-        validator_(schema), 
-        reader_(buffer) 
-    {} 
- 
-    void readValue(Null &) { 
-        validator_.checkTypeExpected(AVRO_NULL); 
-    } 
- 
-    void readValue(bool &val) { 
-        validator_.checkTypeExpected(AVRO_BOOL); 
-        uint8_t ival = 0; 
-        reader_.read(ival); 
-        val = (ival != 0); 
-    } 
- 
-    void readValue(int32_t &val) { 
-        validator_.checkTypeExpected(AVRO_INT); 
-        uint32_t encoded = static_cast<uint32_t>(readVarInt()); 
-        val = decodeZigzag32(encoded); 
-    } 
- 
-    void readValue(int64_t &val) { 
-        validator_.checkTypeExpected(AVRO_LONG); 
-        uint64_t encoded = readVarInt(); 
-        val = decodeZigzag64(encoded); 
-    } 
- 
-    void readValue(float &val) { 
-        validator_.checkTypeExpected(AVRO_FLOAT); 
-        union { 
-            float f; 
-            uint32_t i; 
-        } v; 
-        reader_.read(v.i); 
-        val = v.f; 
-    } 
- 
-    void readValue(double &val) { 
-        validator_.checkTypeExpected(AVRO_DOUBLE); 
-        union { 
-            double d; 
-            uint64_t i; 
-        } v; 
-        reader_.read(v.i); 
-        val = v.d; 
-    } 
- 
-    void readValue(std::string &val) { 
-        validator_.checkTypeExpected(AVRO_STRING); 
-        size_t size = static_cast<size_t>(readSize()); 
-        reader_.read(val, size); 
-    } 
- 
-    void readBytes(std::vector<uint8_t> &val) { 
-        validator_.checkTypeExpected(AVRO_BYTES); 
-        size_t size = static_cast<size_t>(readSize()); 
-        val.resize(size); 
-        reader_.read(reinterpret_cast<char *>(val.data()), size); 
-    } 
- 
-    void readFixed(uint8_t *val, size_t size) { 
-        validator_.checkFixedSizeExpected(size); 
-        reader_.read(reinterpret_cast<char *>(val), size); 
-    } 
- 
-    template <size_t N> 
-    void readFixed(uint8_t (&val)[N]) { 
-        this->readFixed(val, N); 
-    } 
- 
-    template <size_t N> 
-    void readFixed(std::array<uint8_t, N> &val) { 
-        this->readFixed(val.data(), N); 
-    } 
- 
-    void readRecord() { 
-        validator_.checkTypeExpected(AVRO_RECORD); 
-        validator_.checkTypeExpected(AVRO_LONG); 
-        validator_.setCount(1); 
-    } 
- 
-    void readRecordEnd() { 
-        validator_.checkTypeExpected(AVRO_RECORD); 
-        validator_.checkTypeExpected(AVRO_LONG); 
-        validator_.setCount(0); 
-    } 
- 
-    int64_t readArrayBlockSize() { 
-        validator_.checkTypeExpected(AVRO_ARRAY); 
-        return readCount(); 
-    } 
- 
-    int64_t readUnion() { 
-        validator_.checkTypeExpected(AVRO_UNION); 
-        return readCount(); 
-    } 
- 
-    int64_t readEnum() { 
-        validator_.checkTypeExpected(AVRO_ENUM); 
-        return readCount(); 
-    } 
- 
-    int64_t readMapBlockSize() { 
-        validator_.checkTypeExpected(AVRO_MAP); 
-        return readCount(); 
-    } 
- 
-    Type nextType() const { 
-        return validator_.nextTypeExpected(); 
-    } 
- 
-    bool currentRecordName(std::string &name) const { 
-        return validator_.getCurrentRecordName(name); 
-    } 
- 
-    bool nextFieldName(std::string &name) const { 
-        return validator_.getNextFieldName(name); 
-    } 
- 
-  private: 
- 
-    uint64_t readVarInt() { 
-        uint64_t encoded = 0; 
-        uint8_t val = 0; 
-        int shift = 0; 
-        do { 
-            reader_.read(val); 
-            uint64_t newbits = static_cast<uint64_t>(val & 0x7f) << shift; 
-            encoded |= newbits; 
-            shift += 7; 
-        } while (val & 0x80); 
- 
-        return encoded; 
-    } 
- 
-    int64_t readSize() { 
-        uint64_t encoded = readVarInt(); 
-        int64_t size = decodeZigzag64(encoded); 
-        return size; 
-    } 
- 
-    int64_t readCount() { 
-        validator_.checkTypeExpected(AVRO_LONG); 
-        int64_t count = readSize(); 
-        validator_.setCount(count); 
-        return count; 
-    } 
- 
-    ValidatorType validator_; 
-    BufferReader  reader_; 
- 
-}; 
- 
-typedef ReaderImpl<NullValidator> Reader; 
-typedef ReaderImpl<Validator> ValidatingReader; 
- 
-} // namespace avro 
- 
-#endif 
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef avro_Reader_hh__
+#define avro_Reader_hh__
+
+#include <stdint.h>
+#include <vector>
+#include <array>
+#include <boost/noncopyable.hpp>
+
+#include "Config.hh"
+#include "Zigzag.hh"
+#include "Types.hh"
+#include "Validator.hh"
+#include "buffer/BufferReader.hh"
+
+namespace avro {
+
+///
+/// Parses from an avro encoding to the requested type.  Assumes the next item
+/// in the avro binary data is the expected type.
+///
+
+template<class ValidatorType>
+class ReaderImpl : private boost::noncopyable
+{
+
+  public:
+
+    explicit ReaderImpl(const InputBuffer &buffer) :
+        reader_(buffer)
+    {}
+
+    ReaderImpl(const ValidSchema &schema, const InputBuffer &buffer) :
+        validator_(schema),
+        reader_(buffer)
+    {}
+
+    void readValue(Null &) {
+        validator_.checkTypeExpected(AVRO_NULL);
+    }
+
+    void readValue(bool &val) {
+        validator_.checkTypeExpected(AVRO_BOOL);
+        uint8_t ival = 0;
+        reader_.read(ival);
+        val = (ival != 0);
+    }
+
+    void readValue(int32_t &val) {
+        validator_.checkTypeExpected(AVRO_INT);
+        uint32_t encoded = static_cast<uint32_t>(readVarInt());
+        val = decodeZigzag32(encoded);
+    }
+
+    void readValue(int64_t &val) {
+        validator_.checkTypeExpected(AVRO_LONG);
+        uint64_t encoded = readVarInt();
+        val = decodeZigzag64(encoded);
+    }
+
+    void readValue(float &val) {
+        validator_.checkTypeExpected(AVRO_FLOAT);
+        union {
+            float f;
+            uint32_t i;
+        } v;
+        reader_.read(v.i);
+        val = v.f;
+    }
+
+    void readValue(double &val) {
+        validator_.checkTypeExpected(AVRO_DOUBLE);
+        union {
+            double d;
+            uint64_t i;
+        } v;
+        reader_.read(v.i);
+        val = v.d;
+    }
+
+    void readValue(std::string &val) {
+        validator_.checkTypeExpected(AVRO_STRING);
+        size_t size = static_cast<size_t>(readSize());
+        reader_.read(val, size);
+    }
+
+    void readBytes(std::vector<uint8_t> &val) {
+        validator_.checkTypeExpected(AVRO_BYTES);
+        size_t size = static_cast<size_t>(readSize());
+        val.resize(size);
+        reader_.read(reinterpret_cast<char *>(val.data()), size);
+    }
+
+    void readFixed(uint8_t *val, size_t size) {
+        validator_.checkFixedSizeExpected(size);
+        reader_.read(reinterpret_cast<char *>(val), size);
+    }
+
+    template <size_t N>
+    void readFixed(uint8_t (&val)[N]) {
+        this->readFixed(val, N);
+    }
+
+    template <size_t N>
+    void readFixed(std::array<uint8_t, N> &val) {
+        this->readFixed(val.data(), N);
+    }
+
+    void readRecord() {
+        validator_.checkTypeExpected(AVRO_RECORD);
+        validator_.checkTypeExpected(AVRO_LONG);
+        validator_.setCount(1);
+    }
+
+    void readRecordEnd() {
+        validator_.checkTypeExpected(AVRO_RECORD);
+        validator_.checkTypeExpected(AVRO_LONG);
+        validator_.setCount(0);
+    }
+
+    int64_t readArrayBlockSize() {
+        validator_.checkTypeExpected(AVRO_ARRAY);
+        return readCount();
+    }
+
+    int64_t readUnion() {
+        validator_.checkTypeExpected(AVRO_UNION);
+        return readCount();
+    }
+
+    int64_t readEnum() {
+        validator_.checkTypeExpected(AVRO_ENUM);
+        return readCount();
+    }
+
+    int64_t readMapBlockSize() {
+        validator_.checkTypeExpected(AVRO_MAP);
+        return readCount();
+    }
+
+    Type nextType() const {
+        return validator_.nextTypeExpected();
+    }
+
+    bool currentRecordName(std::string &name) const {
+        return validator_.getCurrentRecordName(name);
+    }
+
+    bool nextFieldName(std::string &name) const {
+        return validator_.getNextFieldName(name);
+    }
+
+  private:
+
+    uint64_t readVarInt() {
+        uint64_t encoded = 0;
+        uint8_t val = 0;
+        int shift = 0;
+        do {
+            reader_.read(val);
+            uint64_t newbits = static_cast<uint64_t>(val & 0x7f) << shift;
+            encoded |= newbits;
+            shift += 7;
+        } while (val & 0x80);
+
+        return encoded;
+    }
+
+    int64_t readSize() {
+        uint64_t encoded = readVarInt();
+        int64_t size = decodeZigzag64(encoded);
+        return size;
+    }
+
+    int64_t readCount() {
+        validator_.checkTypeExpected(AVRO_LONG);
+        int64_t count = readSize();
+        validator_.setCount(count);
+        return count;
+    }
+
+    ValidatorType validator_;
+    BufferReader  reader_;
+
+};
+
+typedef ReaderImpl<NullValidator> Reader;
+typedef ReaderImpl<Validator> ValidatingReader;
+
+} // namespace avro
+
+#endif
diff --git a/contrib/libs/apache/avro/api/Resolver.hh b/contrib/libs/apache/avro/api/Resolver.hh
index 91c6de1cb7..a0ffcbeac7 100644
--- a/contrib/libs/apache/avro/api/Resolver.hh
+++ b/contrib/libs/apache/avro/api/Resolver.hh
@@ -1,57 +1,57 @@
-/* 
- * Licensed to the Apache Software Foundation (ASF) under one 
- * or more contributor license agreements.  See the NOTICE file 
- * distributed with this work for additional information 
- * regarding copyright ownership.  The ASF licenses this file 
- * to you under the Apache License, Version 2.0 (the 
- * "License"); you may not use this file except in compliance 
- * with the License.  You may obtain a copy of the License at 
- * 
- *     https://www.apache.org/licenses/LICENSE-2.0 
- * 
- * Unless required by applicable law or agreed to in writing, software 
- * distributed under the License is distributed on an "AS IS" BASIS, 
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
- * See the License for the specific language governing permissions and 
- * limitations under the License. 
- */ 
- 
-#ifndef avro_Resolver_hh__ 
-#define avro_Resolver_hh__ 
- 
-#include <memory> 
-#include <boost/noncopyable.hpp> 
-#include <stdint.h> 
- 
-#include "Config.hh" 
-#include "Reader.hh" 
- 
-/// \file Resolver.hh 
-/// 
- 
-namespace avro { 
- 
-class ValidSchema; 
-class Layout; 
- 
-class AVRO_DECL Resolver : private boost::noncopyable 
-{ 
- 
-  public: 
- 
-    virtual void parse(Reader &reader, uint8_t *address) const = 0; 
-    virtual ~Resolver() {} 
- 
-}; 
- 
-std::unique_ptr<Resolver> constructResolver( 
-        const ValidSchema &rwriterSchema, 
-        const ValidSchema &readerSchema, 
-        const Layout &readerLayout 
-    ); 
- 
- 
- 
-} // namespace avro 
- 
-#endif 
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef avro_Resolver_hh__
+#define avro_Resolver_hh__
+
+#include <memory>
+#include <boost/noncopyable.hpp>
+#include <stdint.h>
+
+#include "Config.hh"
+#include "Reader.hh"
+
+/// \file Resolver.hh
+///
+
+namespace avro {
+
+class ValidSchema;
+class Layout;
+
+class AVRO_DECL Resolver : private boost::noncopyable
+{
+
+  public:
+
+    virtual void parse(Reader &reader, uint8_t *address) const = 0;
+    virtual ~Resolver() {}
+
+};
+
+std::unique_ptr<Resolver> constructResolver(
+        const ValidSchema &rwriterSchema,
+        const ValidSchema &readerSchema,
+        const Layout &readerLayout
+    );
+
+
+
+} // namespace avro
+
+#endif
diff --git a/contrib/libs/apache/avro/api/ResolverSchema.hh b/contrib/libs/apache/avro/api/ResolverSchema.hh
index f9420cdfa5..9048a22b9a 100644
--- a/contrib/libs/apache/avro/api/ResolverSchema.hh
+++ b/contrib/libs/apache/avro/api/ResolverSchema.hh
@@ -1,56 +1,56 @@
-/* 
- * Licensed to the Apache Software Foundation (ASF) under one 
- * or more contributor license agreements.  See the NOTICE file 
- * distributed with this work for additional information 
- * regarding copyright ownership.  The ASF licenses this file 
- * to you under the Apache License, Version 2.0 (the 
- * "License"); you may not use this file except in compliance 
- * with the License.  You may obtain a copy of the License at 
- * 
- *     https://www.apache.org/licenses/LICENSE-2.0 
- * 
- * Unless required by applicable law or agreed to in writing, software 
- * distributed under the License is distributed on an "AS IS" BASIS, 
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
- * See the License for the specific language governing permissions and 
- * limitations under the License. 
- */ 
- 
-#ifndef avro_ResolverSchema_hh__ 
-#define avro_ResolverSchema_hh__ 
- 
-#include <boost/noncopyable.hpp> 
-#include <stdint.h> 
-#include <memory> 
- 
-#include "Config.hh" 
-#include "Reader.hh" 
- 
-/// \file ResolverSchema.hh 
-/// 
- 
-namespace avro { 
- 
-class ValidSchema; 
-class Layout; 
-class Resolver; 
- 
-class AVRO_DECL ResolverSchema { 
- 
-  public: 
- 
-    ResolverSchema(const ValidSchema &writer, const ValidSchema &reader, const Layout &readerLayout); 
- 
-  private: 
- 
-    friend class ResolvingReader; 
- 
-    void parse(Reader &reader, uint8_t *address); 
- 
-    std::shared_ptr<Resolver> resolver_; 
- 
-}; 
- 
-} // namespace avro 
- 
-#endif 
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef avro_ResolverSchema_hh__
+#define avro_ResolverSchema_hh__
+
+#include <boost/noncopyable.hpp>
+#include <stdint.h>
+#include <memory>
+
+#include "Config.hh"
+#include "Reader.hh"
+
+/// \file ResolverSchema.hh
+///
+
+namespace avro {
+
+class ValidSchema;
+class Layout;
+class Resolver;
+
+class AVRO_DECL ResolverSchema {
+
+  public:
+
+    ResolverSchema(const ValidSchema &writer, const ValidSchema &reader, const Layout &readerLayout);
+
+  private:
+
+    friend class ResolvingReader;
+
+    void parse(Reader &reader, uint8_t *address);
+
+    std::shared_ptr<Resolver> resolver_;
+
+};
+
+} // namespace avro
+
+#endif
diff --git a/contrib/libs/apache/avro/api/ResolvingReader.hh b/contrib/libs/apache/avro/api/ResolvingReader.hh
index 7588e5e08d..806e64da56 100644
--- a/contrib/libs/apache/avro/api/ResolvingReader.hh
+++ b/contrib/libs/apache/avro/api/ResolvingReader.hh
@@ -1,54 +1,54 @@
-/* 
- * Licensed to the Apache Software Foundation (ASF) under one 
- * or more contributor license agreements.  See the NOTICE file 
- * distributed with this work for additional information 
- * regarding copyright ownership.  The ASF licenses this file 
- * to you under the Apache License, Version 2.0 (the 
- * "License"); you may not use this file except in compliance 
- * with the License.  You may obtain a copy of the License at 
- * 
- *     https://www.apache.org/licenses/LICENSE-2.0 
- * 
- * Unless required by applicable law or agreed to in writing, software 
- * distributed under the License is distributed on an "AS IS" BASIS, 
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
- * See the License for the specific language governing permissions and 
- * limitations under the License. 
- */ 
- 
-#ifndef avro_ResolvingReader_hh__ 
-#define avro_ResolvingReader_hh__ 
- 
-#include <stdint.h> 
-#include <boost/noncopyable.hpp> 
- 
-#include "Config.hh" 
-#include "ResolverSchema.hh" 
-#include "Reader.hh" 
- 
-namespace avro { 
- 
-class AVRO_DECL ResolvingReader : private boost::noncopyable 
-{ 
- 
-  public: 
- 
-    ResolvingReader(const ResolverSchema &schema, const InputBuffer &in) : 
-        reader_(in), 
-        schema_(schema) 
-    {} 
- 
-    template<typename T> 
-    void parse(T &object) { 
-        schema_.parse(reader_, reinterpret_cast<uint8_t *>(&object)); 
-    } 
- 
-  private: 
- 
-    Reader reader_; 
-    ResolverSchema schema_; 
-}; 
- 
-} // namespace avro 
- 
-#endif 
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef avro_ResolvingReader_hh__
+#define avro_ResolvingReader_hh__
+
+#include <stdint.h>
+#include <boost/noncopyable.hpp>
+
+#include "Config.hh"
+#include "ResolverSchema.hh"
+#include "Reader.hh"
+
+namespace avro {
+
+class AVRO_DECL ResolvingReader : private boost::noncopyable
+{
+
+  public:
+
+    ResolvingReader(const ResolverSchema &schema, const InputBuffer &in) :
+        reader_(in),
+        schema_(schema)
+    {}
+
+    template<typename T>
+    void parse(T &object) {
+        schema_.parse(reader_, reinterpret_cast<uint8_t *>(&object));
+    }
+
+  private:
+
+    Reader reader_;
+    ResolverSchema schema_;
+};
+
+} // namespace avro
+
+#endif
diff --git a/contrib/libs/apache/avro/api/Schema.hh b/contrib/libs/apache/avro/api/Schema.hh
index ee0e79c6eb..b8ad92c825 100644
--- a/contrib/libs/apache/avro/api/Schema.hh
+++ b/contrib/libs/apache/avro/api/Schema.hh
@@ -1,146 +1,146 @@
-/* 
- * Licensed to the Apache Software Foundation (ASF) under one 
- * or more contributor license agreements.  See the NOTICE file 
- * distributed with this work for additional information 
- * regarding copyright ownership.  The ASF licenses this file 
- * to you under the Apache License, Version 2.0 (the 
- * "License"); you may not use this file except in compliance 
- * with the License.  You may obtain a copy of the License at 
- * 
- *     https://www.apache.org/licenses/LICENSE-2.0 
- * 
- * Unless required by applicable law or agreed to in writing, software 
- * distributed under the License is distributed on an "AS IS" BASIS, 
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
- * See the License for the specific language governing permissions and 
- * limitations under the License. 
- */ 
- 
-#ifndef avro_Schema_hh__ 
-#define avro_Schema_hh__ 
- 
-#include "Config.hh" 
-#include "NodeImpl.hh" 
-#include <string> 
- 
-/// \file 
-/// 
-/// Schemas for representing all the avro types.  The compound schema objects 
-/// allow composition from other schemas. 
-/// 
- 
-namespace avro { 
- 
- 
-/// The root Schema object is a base class.  Nobody constructs this class directly. 
- 
-class AVRO_DECL Schema { 
-public: 
- 
-    virtual ~Schema(); 
- 
-    Type type() const { 
-        return node_->type(); 
-    } 
- 
-    const NodePtr &root() const { 
-        return node_; 
-    } 
- 
-    NodePtr &root() { 
-        return node_; 
-    } 
- 
-  protected: 
-    Schema(); 
-    explicit Schema(const NodePtr &node); 
-    explicit Schema(Node *node); 
- 
-    NodePtr node_; 
-}; 
- 
-class AVRO_DECL NullSchema : public Schema { 
-public: 
-    NullSchema(): Schema(new NodePrimitive(AVRO_NULL)) {} 
-}; 
- 
-class AVRO_DECL BoolSchema : public Schema { 
-public: 
-    BoolSchema(): Schema(new NodePrimitive(AVRO_BOOL)) {} 
-}; 
- 
-class AVRO_DECL IntSchema : public Schema { 
-public: 
-    IntSchema(): Schema(new NodePrimitive(AVRO_INT)) {} 
-}; 
- 
-class AVRO_DECL LongSchema : public Schema { 
-public: 
-    LongSchema(): Schema(new NodePrimitive(AVRO_LONG)) {} 
-}; 
- 
-class AVRO_DECL FloatSchema : public Schema { 
-public: 
-    FloatSchema(): Schema(new NodePrimitive(AVRO_FLOAT)) {} 
-}; 
- 
-class AVRO_DECL DoubleSchema : public Schema { 
-public: 
-    DoubleSchema(): Schema(new NodePrimitive(AVRO_DOUBLE)) {} 
-}; 
- 
-class AVRO_DECL StringSchema : public Schema { 
-public: 
-    StringSchema(): Schema(new NodePrimitive(AVRO_STRING)) {} 
-}; 
- 
-class AVRO_DECL BytesSchema : public Schema { 
-public: 
-    BytesSchema(): Schema(new NodePrimitive(AVRO_BYTES)) {} 
-}; 
- 
-class AVRO_DECL RecordSchema : public Schema { 
-public: 
-    RecordSchema(const std::string &name); 
-    void addField(const std::string &name, const Schema &fieldSchema); 
- 
-    std::string getDoc() const; 
-    void setDoc(const std::string &); 
-}; 
- 
-class AVRO_DECL EnumSchema : public Schema { 
-public: 
-    EnumSchema(const std::string &name); 
-    void addSymbol(const std::string &symbol); 
-}; 
- 
-class AVRO_DECL ArraySchema : public Schema { 
-public: 
-    ArraySchema(const Schema &itemsSchema); 
-    ArraySchema(const ArraySchema &itemsSchema); 
-}; 
- 
-class AVRO_DECL MapSchema : public Schema { 
-public: 
-    MapSchema(const Schema &valuesSchema); 
-    MapSchema(const MapSchema &itemsSchema); 
-}; 
- 
-class AVRO_DECL UnionSchema : public Schema { 
-public: 
-    UnionSchema(); 
-    void addType(const Schema &typeSchema); 
-}; 
- 
-class AVRO_DECL FixedSchema : public Schema { 
-public: 
-    FixedSchema(int size, const std::string &name); 
-}; 
- 
-class AVRO_DECL SymbolicSchema : public Schema { 
-public: 
-    SymbolicSchema(const Name& name, const NodePtr& link); 
-}; 
-} // namespace avro 
- 
-#endif 
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef avro_Schema_hh__
+#define avro_Schema_hh__
+
+#include "Config.hh"
+#include "NodeImpl.hh"
+#include <string>
+
+/// \file
+///
+/// Schemas for representing all the avro types.  The compound schema objects
+/// allow composition from other schemas.
+///
+
+namespace avro {
+
+
+/// The root Schema object is a base class.  Nobody constructs this class directly.
+
+class AVRO_DECL Schema {
+public:
+
+    virtual ~Schema();
+
+    Type type() const {
+        return node_->type();
+    }
+
+    const NodePtr &root() const {
+        return node_;
+    }
+
+    NodePtr &root() {
+        return node_;
+    }
+
+  protected:
+    Schema();
+    explicit Schema(const NodePtr &node);
+    explicit Schema(Node *node);
+
+    NodePtr node_;
+};
+
+class AVRO_DECL NullSchema : public Schema {
+public:
+    NullSchema(): Schema(new NodePrimitive(AVRO_NULL)) {}
+};
+
+class AVRO_DECL BoolSchema : public Schema {
+public:
+    BoolSchema(): Schema(new NodePrimitive(AVRO_BOOL)) {}
+};
+
+class AVRO_DECL IntSchema : public Schema {
+public:
+    IntSchema(): Schema(new NodePrimitive(AVRO_INT)) {}
+};
+
+class AVRO_DECL LongSchema : public Schema {
+public:
+    LongSchema(): Schema(new NodePrimitive(AVRO_LONG)) {}
+};
+
+class AVRO_DECL FloatSchema : public Schema {
+public:
+    FloatSchema(): Schema(new NodePrimitive(AVRO_FLOAT)) {}
+};
+
+class AVRO_DECL DoubleSchema : public Schema {
+public:
+    DoubleSchema(): Schema(new NodePrimitive(AVRO_DOUBLE)) {}
+};
+
+class AVRO_DECL StringSchema : public Schema {
+public:
+    StringSchema(): Schema(new NodePrimitive(AVRO_STRING)) {}
+};
+
+class AVRO_DECL BytesSchema : public Schema {
+public:
+    BytesSchema(): Schema(new NodePrimitive(AVRO_BYTES)) {}
+};
+
+class AVRO_DECL RecordSchema : public Schema {
+public:
+    RecordSchema(const std::string &name);
+    void addField(const std::string &name, const Schema &fieldSchema);
+
+    std::string getDoc() const;
+    void setDoc(const std::string &);
+};
+
+class AVRO_DECL EnumSchema : public Schema {
+public:
+    EnumSchema(const std::string &name);
+    void addSymbol(const std::string &symbol);
+};
+
+class AVRO_DECL ArraySchema : public Schema {
+public:
+    ArraySchema(const Schema &itemsSchema);
+    ArraySchema(const ArraySchema &itemsSchema);
+};
+
+class AVRO_DECL MapSchema : public Schema {
+public:
+    MapSchema(const Schema &valuesSchema);
+    MapSchema(const MapSchema &itemsSchema);
+};
+
+class AVRO_DECL UnionSchema : public Schema {
+public:
+    UnionSchema();
+    void addType(const Schema &typeSchema);
+};
+
+class AVRO_DECL FixedSchema : public Schema {
+public:
+    FixedSchema(int size, const std::string &name);
+};
+
+class AVRO_DECL SymbolicSchema : public Schema {
+public:
+    SymbolicSchema(const Name& name, const NodePtr& link);
+};
+} // namespace avro
+
+#endif
diff --git a/contrib/libs/apache/avro/api/SchemaResolution.hh b/contrib/libs/apache/avro/api/SchemaResolution.hh
index c3a39e1237..765347d9de 100644
--- a/contrib/libs/apache/avro/api/SchemaResolution.hh
+++ b/contrib/libs/apache/avro/api/SchemaResolution.hh
@@ -1,55 +1,55 @@
-/* 
- * Licensed to the Apache Software Foundation (ASF) under one 
- * or more contributor license agreements.  See the NOTICE file 
- * distributed with this work for additional information 
- * regarding copyright ownership.  The ASF licenses this file 
- * to you under the Apache License, Version 2.0 (the 
- * "License"); you may not use this file except in compliance 
- * with the License.  You may obtain a copy of the License at 
- * 
- *     https://www.apache.org/licenses/LICENSE-2.0 
- * 
- * Unless required by applicable law or agreed to in writing, software 
- * distributed under the License is distributed on an "AS IS" BASIS, 
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
- * See the License for the specific language governing permissions and 
- * limitations under the License. 
- */ 
- 
-#ifndef avro_SchemaResolution_hh__ 
-#define avro_SchemaResolution_hh__ 
- 
-#include "Config.hh" 
- 
-namespace avro { 
- 
- 
-enum SchemaResolution { 
- 
-    /// The schemas definitely do not match 
- 
-    RESOLVE_NO_MATCH, 
- 
-    /// The schemas match at a cursory level 
-    /// 
-    /// For records and enums, this means the name is the same, but it does not 
-    /// necessarily mean that every symbol or field is an exact match. 
- 
-    RESOLVE_MATCH, 
- 
-    /// For primitives, the matching may occur if the type is promotable.  This means that the 
-    /// writer matches reader if the writer's type is promoted the specified type. 
- 
-    //@{ 
- 
-    RESOLVE_PROMOTABLE_TO_LONG, 
-    RESOLVE_PROMOTABLE_TO_FLOAT, 
-    RESOLVE_PROMOTABLE_TO_DOUBLE, 
- 
-    //@} 
- 
-}; 
- 
-} // namespace avro 
- 
-#endif 
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef avro_SchemaResolution_hh__
+#define avro_SchemaResolution_hh__
+
+#include "Config.hh"
+
+namespace avro {
+
+
+enum SchemaResolution {
+
+    /// The schemas definitely do not match
+
+    RESOLVE_NO_MATCH,
+
+    /// The schemas match at a cursory level
+    ///
+    /// For records and enums, this means the name is the same, but it does not
+    /// necessarily mean that every symbol or field is an exact match.
+
+    RESOLVE_MATCH,
+
+    /// For primitives, the matching may occur if the type is promotable.  This means that the
+    /// writer matches reader if the writer's type is promoted the specified type.
+
+    //@{
+
+    RESOLVE_PROMOTABLE_TO_LONG,
+    RESOLVE_PROMOTABLE_TO_FLOAT,
+    RESOLVE_PROMOTABLE_TO_DOUBLE,
+
+    //@}
+
+};
+
+} // namespace avro
+
+#endif
diff --git a/contrib/libs/apache/avro/api/Serializer.hh b/contrib/libs/apache/avro/api/Serializer.hh
index 3cc15b5a95..15a8878586 100644
--- a/contrib/libs/apache/avro/api/Serializer.hh
+++ b/contrib/libs/apache/avro/api/Serializer.hh
@@ -1,135 +1,135 @@
-/* 
- * Licensed to the Apache Software Foundation (ASF) under one 
- * or more contributor license agreements.  See the NOTICE file 
- * distributed with this work for additional information 
- * regarding copyright ownership.  The ASF licenses this file 
- * to you under the Apache License, Version 2.0 (the 
- * "License"); you may not use this file except in compliance 
- * with the License.  You may obtain a copy of the License at 
- * 
- *     https://www.apache.org/licenses/LICENSE-2.0 
- * 
- * Unless required by applicable law or agreed to in writing, software 
- * distributed under the License is distributed on an "AS IS" BASIS, 
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
- * See the License for the specific language governing permissions and 
- * limitations under the License. 
- */ 
- 
-#ifndef avro_Serializer_hh__ 
-#define avro_Serializer_hh__ 
- 
-#include <array> 
-#include <boost/noncopyable.hpp> 
- 
-#include "Config.hh" 
-#include "Writer.hh" 
- 
-namespace avro { 
- 
-/// Class that wraps a Writer or ValidatingWriter with an interface that uses 
-/// explicit write* names instead of writeValue 
- 
-template<class Writer> 
-class Serializer : private boost::noncopyable 
-{ 
- 
-  public: 
- 
-    /// Constructor only works with Writer 
-    explicit Serializer() : 
-        writer_() 
-    {} 
- 
-    /// Constructor only works with ValidatingWriter 
-    Serializer(const ValidSchema &schema) : 
-        writer_(schema) 
-    {} 
- 
-    void writeNull() { 
-        writer_.writeValue(Null()); 
-    } 
- 
-    void writeBool(bool val) { 
-        writer_.writeValue(val); 
-    } 
- 
-    void writeInt(int32_t val) { 
-        writer_.writeValue(val); 
-    } 
- 
-    void writeLong(int64_t val) { 
-        writer_.writeValue(val); 
-    } 
- 
-    void writeFloat(float val) { 
-        writer_.writeValue(val); 
-    } 
- 
-    void writeDouble(double val) { 
-        writer_.writeValue(val); 
-    } 
- 
-    void writeBytes(const void *val, size_t size) { 
-        writer_.writeBytes(val); 
-    } 
- 
-    template <size_t N> 
-    void writeFixed(const uint8_t (&val)[N]) { 
-        writer_.writeFixed(val); 
-    } 
- 
-    template <size_t N> 
-    void writeFixed(const std::array<uint8_t, N> &val) { 
-        writer_.writeFixed(val); 
-    } 
- 
-    void writeString(const std::string &val) { 
-        writer_.writeValue(val); 
-    } 
- 
-    void writeRecord() { 
-        writer_.writeRecord(); 
-    } 
- 
-    void writeRecordEnd() { 
-        writer_.writeRecordEnd(); 
-    } 
- 
-    void writeArrayBlock(int64_t size) { 
-        writer_.writeArrayBlock(size); 
-    } 
- 
-    void writeArrayEnd() { 
-        writer_.writeArrayEnd(); 
-    } 
- 
-    void writeMapBlock(int64_t size) { 
-        writer_.writeMapBlock(size); 
-    } 
- 
-    void writeMapEnd() { 
-        writer_.writeMapEnd(); 
-    } 
- 
-    void writeUnion(int64_t choice) { 
-        writer_.writeUnion(choice); 
-    } 
- 
-    void writeEnum(int64_t choice) { 
-        writer_.writeEnum(choice); 
-    } 
- 
-    InputBuffer buffer() const { 
-        return writer_.buffer(); 
-    } 
- 
-  private: 
- 
-    Writer writer_; 
- 
-}; 
- 
-} // namespace avro 
- 
-#endif 
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef avro_Serializer_hh__
+#define avro_Serializer_hh__
+
+#include <array>
+#include <boost/noncopyable.hpp>
+
+#include "Config.hh"
+#include "Writer.hh"
+
+namespace avro {
+
+/// Class that wraps a Writer or ValidatingWriter with an interface that uses
+/// explicit write* names instead of writeValue
+
+template<class Writer>
+class Serializer : private boost::noncopyable
+{
+
+  public:
+
+    /// Constructor only works with Writer
+    explicit Serializer() :
+        writer_()
+    {}
+
+    /// Constructor only works with ValidatingWriter
+    Serializer(const ValidSchema &schema) :
+        writer_(schema)
+    {}
+
+    void writeNull() {
+        writer_.writeValue(Null());
+    }
+
+    void writeBool(bool val) {
+        writer_.writeValue(val);
+    }
+
+    void writeInt(int32_t val) {
+        writer_.writeValue(val);
+    }
+
+    void writeLong(int64_t val) {
+        writer_.writeValue(val);
+    }
+
+    void writeFloat(float val) {
+        writer_.writeValue(val);
+    }
+
+    void writeDouble(double val) {
+        writer_.writeValue(val);
+    }
+
+    void writeBytes(const void *val, size_t size) {
+        writer_.writeBytes(val);
+    }
+
+    template <size_t N>
+    void writeFixed(const uint8_t (&val)[N]) {
+        writer_.writeFixed(val);
+    }
+
+    template <size_t N>
+    void writeFixed(const std::array<uint8_t, N> &val) {
+        writer_.writeFixed(val);
+    }
+
+    void writeString(const std::string &val) {
+        writer_.writeValue(val);
+    }
+
+    void writeRecord() {
+        writer_.writeRecord();
+    }
+
+    void writeRecordEnd() {
+        writer_.writeRecordEnd();
+    }
+
+    void writeArrayBlock(int64_t size) {
+        writer_.writeArrayBlock(size);
+    }
+
+    void writeArrayEnd() {
+        writer_.writeArrayEnd();
+    }
+
+    void writeMapBlock(int64_t size) {
+        writer_.writeMapBlock(size);
+    }
+
+    void writeMapEnd() {
+        writer_.writeMapEnd();
+    }
+
+    void writeUnion(int64_t choice) {
+        writer_.writeUnion(choice);
+    }
+
+    void writeEnum(int64_t choice) {
+        writer_.writeEnum(choice);
+    }
+
+    InputBuffer buffer() const {
+        return writer_.buffer();
+    }
+
+  private:
+
+    Writer writer_;
+
+};
+
+} // namespace avro
+
+#endif
diff --git a/contrib/libs/apache/avro/api/Specific.hh b/contrib/libs/apache/avro/api/Specific.hh
index 8572ffae48..53741be480 100644
--- a/contrib/libs/apache/avro/api/Specific.hh
+++ b/contrib/libs/apache/avro/api/Specific.hh
@@ -1,348 +1,348 @@
-/* 
- * Licensed to the Apache Software Foundation (ASF) under one 
- * or more contributor license agreements.  See the NOTICE file 
- * distributed with this work for additional information 
- * regarding copyright ownership.  The ASF licenses this file 
- * to you under the Apache License, Version 2.0 (the 
- * "License"); you may not use this file except in compliance 
- * with the License.  You may obtain a copy of the License at 
- * 
- *     https://www.apache.org/licenses/LICENSE-2.0 
- * 
- * Unless required by applicable law or agreed to in writing, software 
- * distributed under the License is distributed on an "AS IS" BASIS, 
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
- * See the License for the specific language governing permissions and 
- * limitations under the License. 
- */ 
- 
-#ifndef avro_Codec_hh__ 
-#define avro_Codec_hh__ 
- 
-#include <string> 
-#include <vector> 
-#include <map> 
-#include <algorithm> 
-#include "array" 
- 
-#include "boost/blank.hpp" 
- 
-#include "AvroTraits.hh" 
-#include "Config.hh" 
-#include "Encoder.hh" 
-#include "Decoder.hh" 
- 
-/** 
- * A bunch of templates and specializations for encoding and decoding 
- * specific types. 
- * 
- * Primitive AVRO types BOOLEAN, INT, LONG, FLOAT, DOUBLE, STRING and BYTES 
- * get decoded to and encoded from C++ types bool, int32_t, int64_t, float, 
- * double, std::string and std::vector<uint8_t> respectively. In addition, 
- * std::vector<T> for aribtrary type T gets encoded as an Avro array of T. 
- * Similarly, std::map<std::string, T> for arbitrary type T gets encoded 
- * as an Avro map with value type T. 
- * 
- * Users can have their custom types encoded/decoded by specializing 
- * avro::codec_traits class for their types. 
- */ 
-namespace avro { 
- 
-typedef boost::blank null; 
- 
-template <typename T> void encode(Encoder& e, const T& t); 
-template <typename T> void decode(Decoder& d, T& t); 
- 
-/** 
- * Codec_traits tells avro how to encode and decode an object of given type. 
- * 
- * The class is expected to have two static methods: 
- * \li static void encode(Encoder& e, const T& value); 
- * \li static void decode(Decoder& e, T& value); 
- * The default is empty. 
- */ 
-template <typename T> 
-struct codec_traits; 
- 
-/** 
- * codec_traits for Avro boolean. 
- */ 
-template <> struct codec_traits<bool> { 
-    /** 
-     * Encodes a given value. 
-     */ 
-    static void encode(Encoder& e, bool b) { 
-        e.encodeBool(b); 
-    } 
- 
-    /** 
-     * Decodes into a given value. 
-     */ 
-    static void decode(Decoder& d, bool& b) { 
-        b = d.decodeBool(); 
-    } 
-}; 
- 
-/** 
- * codec_traits for Avro int. 
- */ 
-template <> struct codec_traits<int32_t> { 
-    /** 
-     * Encodes a given value. 
-     */ 
-    static void encode(Encoder& e, int32_t i) { 
-        e.encodeInt(i); 
-    } 
- 
-    /** 
-     * Decodes into a given value. 
-     */ 
-    static void decode(Decoder& d, int32_t& i) { 
-        i = d.decodeInt(); 
-    } 
-}; 
- 
-/** 
- * codec_traits for Avro long. 
- */ 
-template <> struct codec_traits<int64_t> { 
-    /** 
-     * Encodes a given value. 
-     */ 
-    static void encode(Encoder& e, int64_t l) { 
-        e.encodeLong(l); 
-    } 
- 
-    /** 
-     * Decodes into a given value. 
-     */ 
-    static void decode(Decoder& d, int64_t& l) { 
-        l = d.decodeLong(); 
-    } 
-}; 
- 
-/** 
- * codec_traits for Avro float. 
- */ 
-template <> struct codec_traits<float> { 
-    /** 
-     * Encodes a given value. 
-     */ 
-    static void encode(Encoder& e, float f) { 
-        e.encodeFloat(f); 
-    } 
- 
-    /** 
-     * Decodes into a given value. 
-     */ 
-    static void decode(Decoder& d, float& f) { 
-        f = d.decodeFloat(); 
-    } 
-}; 
- 
-/** 
- * codec_traits for Avro double. 
- */ 
-template <> struct codec_traits<double> { 
-    /** 
-     * Encodes a given value. 
-     */ 
-    static void encode(Encoder& e, double d) { 
-        e.encodeDouble(d); 
-    } 
- 
-    /** 
-     * Decodes into a given value. 
-     */ 
-    static void decode(Decoder& d, double& dbl) { 
-        dbl = d.decodeDouble(); 
-    } 
-}; 
- 
-/** 
- * codec_traits for Avro string. 
- */ 
-template <> struct codec_traits<std::string> { 
-    /** 
-     * Encodes a given value. 
-     */ 
-    static void encode(Encoder& e, const std::string& s) { 
-        e.encodeString(s); 
-    } 
- 
-    /** 
-     * Decodes into a given value. 
-     */ 
-    static void decode(Decoder& d, std::string& s) { 
-        s = d.decodeString(); 
-    } 
-}; 
- 
-/** 
- * codec_traits for Avro bytes. 
- */ 
-template <> struct codec_traits<std::vector<uint8_t> > { 
-    /** 
-     * Encodes a given value. 
-     */ 
-    static void encode(Encoder& e, const std::vector<uint8_t>& b) { 
-        e.encodeBytes(b); 
-    } 
- 
-    /** 
-     * Decodes into a given value. 
-     */ 
-    static void decode(Decoder& d, std::vector<uint8_t>& s) { 
-        d.decodeBytes(s); 
-    } 
-}; 
- 
-/** 
- * codec_traits for Avro fixed. 
- */ 
-template <size_t N> struct codec_traits<std::array<uint8_t, N> > { 
-    /** 
-     * Encodes a given value. 
-     */ 
-    static void encode(Encoder& e, const std::array<uint8_t, N>& b) { 
-        e.encodeFixed(b.data(), N); 
-    } 
- 
-    /** 
-     * Decodes into a given value. 
-     */ 
-    static void decode(Decoder& d, std::array<uint8_t, N>& s) { 
-        std::vector<uint8_t> v(N); 
-        d.decodeFixed(N, v); 
-        std::copy(v.data(), v.data() + N, s.data()); 
-    } 
-}; 
- 
-/** 
- * codec_traits for Avro arrays. 
- */ 
-template <typename T> struct codec_traits<std::vector<T> > { 
-    /** 
-     * Encodes a given value. 
-     */ 
-    static void encode(Encoder& e, const std::vector<T>& b) { 
-        e.arrayStart(); 
-        if (! b.empty()) { 
-            e.setItemCount(b.size()); 
-            for (typename std::vector<T>::const_iterator it = b.begin(); 
-                it != b.end(); ++it) { 
-                e.startItem(); 
-                avro::encode(e, *it); 
-            } 
-        } 
-        e.arrayEnd(); 
-    } 
- 
-    /** 
-     * Decodes into a given value. 
-     */ 
-    static void decode(Decoder& d, std::vector<T>& s) { 
-        s.clear(); 
-        for (size_t n = d.arrayStart(); n != 0; n = d.arrayNext()) { 
-            for (size_t i = 0; i < n; ++i) { 
-                T t; 
-                avro::decode(d, t); 
-                s.push_back(std::move(t)); 
-            } 
-        } 
-    } 
-}; 
- 
-typedef codec_traits<std::vector<bool>::const_reference> bool_codec_traits; 
- 
-template <> struct codec_traits<std::conditional<avro::is_not_defined<bool_codec_traits>::value, 
-         std::vector<bool>::const_reference, void>::type> { 
-   /** 
-    * Encodes a given value. 
-    */ 
-    static void encode(Encoder& e, std::vector<bool>::const_reference b) { 
-        e.encodeBool(b); 
-    } 
-}; 
- 
-/** 
- * codec_traits for Avro maps. 
- */ 
-template <typename T> struct codec_traits<std::map<std::string, T> > { 
-    /** 
-     * Encodes a given value. 
-     */ 
-    static void encode(Encoder& e, const std::map<std::string, T>& b) { 
-        e.mapStart(); 
-        if (! b.empty()) { 
-            e.setItemCount(b.size()); 
-            for (typename std::map<std::string, T>::const_iterator 
-                it = b.begin(); 
-                it != b.end(); ++it) { 
-                e.startItem(); 
-                avro::encode(e, it->first); 
-                avro::encode(e, it->second); 
-            } 
-        } 
-        e.mapEnd(); 
-    } 
- 
-    /** 
-     * Decodes into a given value. 
-     */ 
-    static void decode(Decoder& d, std::map<std::string, T>& s) { 
-        s.clear(); 
-        for (size_t n = d.mapStart(); n != 0; n = d.mapNext()) { 
-            for (size_t i = 0; i < n; ++i) { 
-                std::string k; 
-                avro::decode(d, k); 
-                T& t = s[std::move(k)]; 
-                avro::decode(d, t); 
-            } 
-        } 
-    } 
-}; 
- 
-/** 
-* codec_traits for Avro null. 
-*/ 
-template <> struct codec_traits<avro::null> { 
-	/** 
-	* Encodes a given value. 
-	*/ 
-	static void encode(Encoder& e, const avro::null&) { 
-		e.encodeNull(); 
-	} 
- 
-	/** 
-	* Decodes into a given value. 
-	*/ 
-	static void decode(Decoder& d, avro::null&) { 
-		d.decodeNull(); 
-	} 
-}; 
- 
- 
- 
-/** 
- * Generic encoder function that makes use of the codec_traits. 
- */ 
-template <typename T> 
-void encode(Encoder& e, const T& t) { 
-    codec_traits<T>::encode(e, t); 
-} 
- 
-/** 
- * Generic decoder function that makes use of the codec_traits. 
- */ 
-template <typename T> 
-void decode(Decoder& d, T& t) { 
-    codec_traits<T>::decode(d, t); 
-} 
- 
-}   // namespace avro 
- 
-#endif // avro_Codec_hh__ 
- 
- 
- 
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef avro_Codec_hh__
+#define avro_Codec_hh__
+
+#include <string>
+#include <vector>
+#include <map>
+#include <algorithm>
+#include "array"
+
+#include "boost/blank.hpp"
+
+#include "AvroTraits.hh"
+#include "Config.hh"
+#include "Encoder.hh"
+#include "Decoder.hh"
+
+/**
+ * A bunch of templates and specializations for encoding and decoding
+ * specific types.
+ *
+ * Primitive AVRO types BOOLEAN, INT, LONG, FLOAT, DOUBLE, STRING and BYTES
+ * get decoded to and encoded from C++ types bool, int32_t, int64_t, float,
+ * double, std::string and std::vector<uint8_t> respectively. In addition,
+ * std::vector<T> for aribtrary type T gets encoded as an Avro array of T.
+ * Similarly, std::map<std::string, T> for arbitrary type T gets encoded
+ * as an Avro map with value type T.
+ *
+ * Users can have their custom types encoded/decoded by specializing
+ * avro::codec_traits class for their types.
+ */
+namespace avro {
+
+typedef boost::blank null;
+
+template <typename T> void encode(Encoder& e, const T& t);
+template <typename T> void decode(Decoder& d, T& t);
+
+/**
+ * Codec_traits tells avro how to encode and decode an object of given type.
+ *
+ * The class is expected to have two static methods:
+ * \li static void encode(Encoder& e, const T& value);
+ * \li static void decode(Decoder& e, T& value);
+ * The default is empty.
+ */
+template <typename T>
+struct codec_traits;
+
+/**
+ * codec_traits for Avro boolean.
+ */
+template <> struct codec_traits<bool> {
+    /**
+     * Encodes a given value.
+     */
+    static void encode(Encoder& e, bool b) {
+        e.encodeBool(b);
+    }
+
+    /**
+     * Decodes into a given value.
+     */
+    static void decode(Decoder& d, bool& b) {
+        b = d.decodeBool();
+    }
+};
+
+/**
+ * codec_traits for Avro int.
+ */
+template <> struct codec_traits<int32_t> {
+    /**
+     * Encodes a given value.
+     */
+    static void encode(Encoder& e, int32_t i) {
+        e.encodeInt(i);
+    }
+
+    /**
+     * Decodes into a given value.
+     */
+    static void decode(Decoder& d, int32_t& i) {
+        i = d.decodeInt();
+    }
+};
+
+/**
+ * codec_traits for Avro long.
+ */
+template <> struct codec_traits<int64_t> {
+    /**
+     * Encodes a given value.
+     */
+    static void encode(Encoder& e, int64_t l) {
+        e.encodeLong(l);
+    }
+
+    /**
+     * Decodes into a given value.
+     */
+    static void decode(Decoder& d, int64_t& l) {
+        l = d.decodeLong();
+    }
+};
+
+/**
+ * codec_traits for Avro float.
+ */
+template <> struct codec_traits<float> {
+    /**
+     * Encodes a given value.
+     */
+    static void encode(Encoder& e, float f) {
+        e.encodeFloat(f);
+    }
+
+    /**
+     * Decodes into a given value.
+     */
+    static void decode(Decoder& d, float& f) {
+        f = d.decodeFloat();
+    }
+};
+
+/**
+ * codec_traits for Avro double.
+ */
+template <> struct codec_traits<double> {
+    /**
+     * Encodes a given value.
+     */
+    static void encode(Encoder& e, double d) {
+        e.encodeDouble(d);
+    }
+
+    /**
+     * Decodes into a given value.
+     */
+    static void decode(Decoder& d, double& dbl) {
+        dbl = d.decodeDouble();
+    }
+};
+
+/**
+ * codec_traits for Avro string.
+ */
+template <> struct codec_traits<std::string> {
+    /**
+     * Encodes a given value.
+     */
+    static void encode(Encoder& e, const std::string& s) {
+        e.encodeString(s);
+    }
+
+    /**
+     * Decodes into a given value.
+     */
+    static void decode(Decoder& d, std::string& s) {
+        s = d.decodeString();
+    }
+};
+
+/**
+ * codec_traits for Avro bytes.
+ */
+template <> struct codec_traits<std::vector<uint8_t> > {
+    /**
+     * Encodes a given value.
+     */
+    static void encode(Encoder& e, const std::vector<uint8_t>& b) {
+        e.encodeBytes(b);
+    }
+
+    /**
+     * Decodes into a given value.
+     */
+    static void decode(Decoder& d, std::vector<uint8_t>& s) {
+        d.decodeBytes(s);
+    }
+};
+
+/**
+ * codec_traits for Avro fixed.
+ */
+template <size_t N> struct codec_traits<std::array<uint8_t, N> > {
+    /**
+     * Encodes a given value.
+     */
+    static void encode(Encoder& e, const std::array<uint8_t, N>& b) {
+        e.encodeFixed(b.data(), N);
+    }
+
+    /**
+     * Decodes into a given value.
+     */
+    static void decode(Decoder& d, std::array<uint8_t, N>& s) {
+        std::vector<uint8_t> v(N);
+        d.decodeFixed(N, v);
+        std::copy(v.data(), v.data() + N, s.data());
+    }
+};
+
+/**
+ * codec_traits for Avro arrays.
+ */
+template <typename T> struct codec_traits<std::vector<T> > {
+    /**
+     * Encodes a given value.
+     */
+    static void encode(Encoder& e, const std::vector<T>& b) {
+        e.arrayStart();
+        if (! b.empty()) {
+            e.setItemCount(b.size());
+            for (typename std::vector<T>::const_iterator it = b.begin();
+                it != b.end(); ++it) {
+                e.startItem();
+                avro::encode(e, *it);
+            }
+        }
+        e.arrayEnd();
+    }
+
+    /**
+     * Decodes into a given value.
+     */
+    static void decode(Decoder& d, std::vector<T>& s) {
+        s.clear();
+        for (size_t n = d.arrayStart(); n != 0; n = d.arrayNext()) {
+            for (size_t i = 0; i < n; ++i) {
+                T t;
+                avro::decode(d, t);
+                s.push_back(std::move(t));
+            }
+        }
+    }
+};
+
+typedef codec_traits<std::vector<bool>::const_reference> bool_codec_traits;
+
+template <> struct codec_traits<std::conditional<avro::is_not_defined<bool_codec_traits>::value,
+         std::vector<bool>::const_reference, void>::type> {
+   /**
+    * Encodes a given value.
+    */
+    static void encode(Encoder& e, std::vector<bool>::const_reference b) {
+        e.encodeBool(b);
+    }
+};
+
+/**
+ * codec_traits for Avro maps.
+ */
+template <typename T> struct codec_traits<std::map<std::string, T> > {
+    /**
+     * Encodes a given value.
+     */
+    static void encode(Encoder& e, const std::map<std::string, T>& b) {
+        e.mapStart();
+        if (! b.empty()) {
+            e.setItemCount(b.size());
+            for (typename std::map<std::string, T>::const_iterator
+                it = b.begin();
+                it != b.end(); ++it) {
+                e.startItem();
+                avro::encode(e, it->first);
+                avro::encode(e, it->second);
+            }
+        }
+        e.mapEnd();
+    }
+
+    /**
+     * Decodes into a given value.
+     */
+    static void decode(Decoder& d, std::map<std::string, T>& s) {
+        s.clear();
+        for (size_t n = d.mapStart(); n != 0; n = d.mapNext()) {
+            for (size_t i = 0; i < n; ++i) {
+                std::string k;
+                avro::decode(d, k);
+                T& t = s[std::move(k)];
+                avro::decode(d, t);
+            }
+        }
+    }
+};
+
+/**
+* codec_traits for Avro null.
+*/
+template <> struct codec_traits<avro::null> {
+	/**
+	* Encodes a given value.
+	*/
+	static void encode(Encoder& e, const avro::null&) {
+		e.encodeNull();
+	}
+
+	/**
+	* Decodes into a given value.
+	*/
+	static void decode(Decoder& d, avro::null&) {
+		d.decodeNull();
+	}
+};
+
+
+
+/**
+ * Generic encoder function that makes use of the codec_traits.
+ */
+template <typename T>
+void encode(Encoder& e, const T& t) {
+    codec_traits<T>::encode(e, t);
+}
+
+/**
+ * Generic decoder function that makes use of the codec_traits.
+ */
+template <typename T>
+void decode(Decoder& d, T& t) {
+    codec_traits<T>::decode(d, t);
+}
+
+}   // namespace avro
+
+#endif // avro_Codec_hh__
+
+
+
diff --git a/contrib/libs/apache/avro/api/Stream.hh b/contrib/libs/apache/avro/api/Stream.hh
index 6693fd5c24..508cb03980 100644
--- a/contrib/libs/apache/avro/api/Stream.hh
+++ b/contrib/libs/apache/avro/api/Stream.hh
@@ -1,483 +1,483 @@
-/* 
- * Licensed to the Apache Software Foundation (ASF) under one 
- * or more contributor license agreements.  See the NOTICE file 
- * distributed with this work for additional information 
- * regarding copyright ownership.  The ASF licenses this file 
- * to you under the Apache License, Version 2.0 (the 
- * "License"); you may not use this file except in compliance 
- * with the License.  You may obtain a copy of the License at 
- * 
- *     https://www.apache.org/licenses/LICENSE-2.0 
- * 
- * Unless required by applicable law or agreed to in writing, software 
- * distributed under the License is distributed on an "AS IS" BASIS, 
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
- * See the License for the specific language governing permissions and 
- * limitations under the License. 
- */ 
- 
-#ifndef avro_Stream_hh__ 
-#define avro_Stream_hh__ 
- 
-#include <memory> 
-#include <string.h> 
-#include <stdint.h> 
- 
-#include "boost/utility.hpp" 
- 
-#include "Config.hh" 
-#include "Exception.hh" 
- 
-namespace avro { 
- 
-/** 
- * A no-copy input stream. 
- */ 
-class AVRO_DECL InputStream : boost::noncopyable { 
-protected: 
- 
-    /** 
-     * An empty constuctor. 
-     */ 
-    InputStream() { } 
- 
-public: 
-    /** 
-     * Destructor. 
-     */ 
-    virtual ~InputStream() { } 
- 
-    /** 
-     * Returns some of available data. 
-     * 
-     * Returns true if some data is available, false if no more data is 
-     * available or an error has occurred. 
-     */ 
-    virtual bool next(const uint8_t** data, size_t* len) = 0; 
- 
-    /** 
-     * "Returns" back some of the data to the stream. The returned 
-     * data must be less than what was obtained in the last call to 
-     * next(). 
-     */ 
-    virtual void backup(size_t len) = 0; 
- 
-    /** 
-     * Skips number of bytes specified by len. 
-     */ 
-    virtual void skip(size_t len) = 0; 
- 
-    /** 
-     * Returns the number of bytes read from this stream so far. 
-     * All the bytes made available through next are considered 
-     * to be used unless, retutned back using backup. 
-     */ 
-    virtual size_t byteCount() const = 0; 
-}; 
- 
-typedef std::unique_ptr<InputStream> InputStreamPtr; 
- 
-/** 
- * An InputStream which also supports seeking to a specific offset. 
- */ 
-class AVRO_DECL SeekableInputStream : public InputStream { 
-protected: 
- 
-    /** 
-     * An empty constuctor. 
-     */ 
-    SeekableInputStream() { } 
- 
-public: 
-    /** 
-     * Destructor. 
-     */ 
-    virtual ~SeekableInputStream() { } 
- 
-    /** 
-     * Seek to a specific position in the stream. This may invalidate pointers 
-     * returned from next(). This will also reset byteCount() to the given 
-     * position. 
-     */ 
-    virtual void seek(int64_t position) = 0; 
-}; 
- 
-typedef std::unique_ptr<SeekableInputStream> SeekableInputStreamPtr; 
- 
-/** 
- * A no-copy output stream. 
- */ 
-class AVRO_DECL OutputStream : boost::noncopyable { 
-protected: 
- 
-    /** 
-     * An empty constuctor. 
-     */ 
-    OutputStream() { } 
-public: 
- 
-    /** 
-     * Destructor. 
-     */ 
-    virtual ~OutputStream() { } 
- 
-    /** 
-     * Returns a buffer that can be written into. 
-     * On successful return, data has the pointer to the buffer 
-     * and len has the number of bytes available at data. 
-     */ 
-    virtual bool next(uint8_t** data, size_t* len) = 0; 
- 
-    /** 
-     * "Returns" back to the stream some of the buffer obtained 
-     * from in the last call to next(). 
-     */ 
-    virtual void backup(size_t len) = 0; 
- 
-    /** 
-     * Number of bytes written so far into this stream. The whole buffer 
-     * returned by next() is assumed to be written unless some of 
-     * it was retutned using backup(). 
-     */ 
-    virtual uint64_t byteCount() const = 0; 
- 
-    /** 
-     * Flushes any data remaining in the buffer to the stream's underlying 
-     * store, if any. 
-     */ 
-    virtual void flush() = 0; 
-}; 
- 
-typedef std::unique_ptr<OutputStream> OutputStreamPtr; 
- 
-/** 
- * Returns a new OutputStream, which grows in memory chunks of specified size. 
- */ 
-AVRO_DECL OutputStreamPtr memoryOutputStream(size_t chunkSize = 4 * 1024); 
- 
-/** 
- * Returns a new InputStream, with the data from the given byte array. 
- * It does not copy the data, the byte array should remain valid 
- * until the InputStream is used. 
- */ 
-AVRO_DECL InputStreamPtr memoryInputStream(const uint8_t* data, size_t len); 
- 
-/** 
- * Returns a new InputStream with the contents written into an 
- * outputstream. The output stream must have been returned by 
- * an earlier call to memoryOutputStream(). The contents for the new 
- * input stream are the snapshot of the outputstream. One can construct 
- * any number of memory input stream from a single memory output stream. 
- */ 
-AVRO_DECL InputStreamPtr memoryInputStream(const OutputStream& source); 
- 
-/** 
- * Returns the contents written so far into the output stream, which should 
- * be a memory output stream. That is it must have been returned by a pervious 
- * call to memoryOutputStream(). 
- */ 
-AVRO_DECL std::shared_ptr<std::vector<uint8_t> > snapshot(const OutputStream& source); 
- 
-/** 
- * Returns a new OutputStream whose contents would be stored in a file. 
- * Data is written in chunks of given buffer size. 
- * 
- * If there is a file with the given name, it is truncated and overwritten. 
- * If there is no file with the given name, it is created. 
- */ 
-AVRO_DECL OutputStreamPtr fileOutputStream(const char* filename, 
-    size_t bufferSize = 8 * 1024); 
- 
-/** 
- * Returns a new InputStream whose contents come from the given file. 
- * Data is read in chunks of given buffer size. 
- */ 
-AVRO_DECL InputStreamPtr fileInputStream( 
-    const char *filename, size_t bufferSize = 8 * 1024); 
-AVRO_DECL SeekableInputStreamPtr fileSeekableInputStream( 
-    const char *filename, size_t bufferSize = 8 * 1024); 
- 
-/** 
- * Returns a new OutputStream whose contents will be sent to the given 
- * std::ostream. The std::ostream object should outlive the returned 
- * OutputStream. 
- */ 
-AVRO_DECL OutputStreamPtr ostreamOutputStream(std::ostream& os, 
-    size_t bufferSize = 8 * 1024); 
- 
-/** 
- * Returns a new InputStream whose contents come from the given 
- * std::istream. The std::istream object should outlive the returned 
- * InputStream. 
- */ 
-AVRO_DECL InputStreamPtr istreamInputStream( 
-    std::istream &in, size_t bufferSize = 8 * 1024); 
- 
-/** 
- * Returns a new InputStream whose contents come from the given 
- * std::istream. Use this instead of istreamInputStream if 
- * the istream does not support seekg (e.g. compressed streams). 
- * The returned InputStream would read off bytes instead of seeking. 
- * Of, course it has a performance penalty when reading instead of seeking; 
- * So, use this only when seekg does not work. 
- * The std::istream object should outlive the returned 
- * InputStream. 
- */ 
-AVRO_DECL InputStreamPtr nonSeekableIstreamInputStream( 
-    std::istream& is, size_t bufferSize = 8 * 1024); 
- 
- 
-/** A convenience class for reading from an InputStream */ 
-struct StreamReader { 
-    /** 
-     * The underlying input stream. 
-     */ 
-    InputStream* in_; 
- 
-    /** 
-     * The next location to read from. 
-     */ 
-    const uint8_t* next_; 
- 
-    /** 
-     * One past the last valid location. 
-     */ 
-    const uint8_t* end_; 
- 
-    /** 
-     * Constructs an empty reader. 
-     */ 
-    StreamReader() : in_(0), next_(0), end_(0) { } 
- 
-    /** 
-     * Constructs a reader with the given underlying stream. 
-     */ 
-    StreamReader(InputStream& in) : in_(0), next_(0), end_(0) { reset(in); } 
- 
-    /** 
-     * Replaces the current input stream with the given one after backing up 
-     * the original one if required. 
-     */ 
-    void reset(InputStream& is) { 
-        if (in_ != 0 && end_ != next_) { 
-            in_->backup(end_ - next_); 
-        } 
-        in_ = &is; 
-        next_ = end_ = 0; 
-    } 
- 
-    /** 
-     * Read just one byte from the underlying stream. If there are no 
-     * more data, throws an exception. 
-     */ 
-    uint8_t read() { 
-        if (next_ == end_) { 
-            more(); 
-        } 
-        return *next_++; 
-    } 
- 
-    /** 
-     * Reads the given number of bytes from the underlying stream. 
-     * If there are not that many bytes, throws an exception. 
-     */ 
-    void readBytes(uint8_t* b, size_t n) { 
-        while (n > 0) { 
-            if (next_ == end_) { 
-                more(); 
-            } 
-            size_t q = end_ - next_; 
-            if (q > n) { 
-                q = n; 
-            } 
-            ::memcpy(b, next_, q); 
-            next_ += q; 
-            b += q; 
-            n -= q; 
-        } 
-    } 
- 
-    /** 
-     * Skips the given number of bytes. Of there are not so that many 
-     * bytes, throws an exception. 
-     */ 
-    void skipBytes(size_t n) { 
-        if (n > static_cast<size_t>(end_ - next_)) { 
-            n -= end_ - next_; 
-            next_ = end_; 
-            in_->skip(n); 
-        } else { 
-            next_ += n; 
-        } 
-    } 
- 
-    /** 
-     * Get as many byes from the underlying stream as possible in a single 
-     * chunk. 
-     * \return true if some data could be obtained. False is no more 
-     * data is available on the stream. 
-     */ 
-    bool fill() { 
-        size_t n = 0; 
-        while (in_->next(&next_, &n)) { 
-            if (n != 0) { 
-                end_ = next_ + n; 
-                return true; 
-            } 
-        } 
-        return false; 
-    } 
- 
-    /** 
-     * Tries to get more data and if it cannot, throws an exception. 
-     */ 
-    void more() { 
-        if (! fill()) { 
-            throw Exception("EOF reached"); 
-        } 
-    } 
- 
-    /** 
-     * Returns true if and only if the end of stream is not reached. 
-     */ 
-    bool hasMore() { 
-        return (next_ == end_) ? fill() : true; 
-    } 
- 
-    /** 
-     * Returns unused bytes back to the underlying stream. 
-     * If unRead is true the last byte read is also pushed back. 
-     */ 
-    void drain(bool unRead) { 
-        if (unRead) { 
-            --next_; 
-        } 
-        in_->backup(end_ - next_); 
-        end_ = next_; 
-    } 
-}; 
- 
-/** 
- * A convinience class to write data into an OutputStream. 
- */ 
-struct StreamWriter { 
-    /** 
-     * The underlying output stream for this writer. 
-     */ 
-    OutputStream* out_; 
- 
-    /** 
-     * The next location to write to. 
-     */ 
-    uint8_t* next_; 
- 
-    /** 
-     * One past the last location one can write to. 
-     */ 
-    uint8_t* end_; 
- 
-    /** 
-     * Constructs a writer with no underlying stream. 
-     */ 
-    StreamWriter() : out_(0), next_(0), end_(0) { } 
- 
-    /** 
-     * Constructs a new writer with the given underlying stream. 
-     */ 
-    StreamWriter(OutputStream& out) : out_(0), next_(0), end_(0) { reset(out); } 
- 
-    /** 
-     * Replaces the current underlying stream with a new one. 
-     * If required, it backs up unused bytes in the previous stream. 
-     */ 
-    void reset(OutputStream& os) { 
-        if (out_ != 0 && end_ != next_) { 
-            out_->backup(end_ - next_); 
-        } 
-        out_ = &os; 
-        next_ = end_; 
-    } 
- 
-    /** 
-     * Writes a single byte. 
-     */ 
-    void write(uint8_t c) { 
-        if (next_ == end_) { 
-            more(); 
-        } 
-        *next_++ = c; 
-    } 
- 
-    /** 
-     * Writes the specified number of bytes starting at \p b. 
-     */ 
-    void writeBytes(const uint8_t* b, size_t n) { 
-        while (n > 0) { 
-            if (next_ == end_) { 
-                more(); 
-            } 
-            size_t q = end_ - next_; 
-            if (q > n) { 
-                q = n; 
-            } 
-            ::memcpy(next_, b, q); 
-            next_ += q; 
-            b += q; 
-            n -= q; 
-        } 
-    } 
- 
-    /** 
-     * backs up upto the currently written data and flushes the 
-     * underlying stream. 
-     */ 
-    void flush() { 
-        if (next_ != end_) { 
-            out_->backup(end_ - next_); 
-            next_ = end_; 
-        } 
-        out_->flush(); 
-    } 
- 
-    /** 
-     * Return the number of bytes written so far. For a meaningful 
-     * result, call this after a flush(). 
-     */ 
-    int64_t byteCount() const { 
-        return out_->byteCount(); 
-    } 
- 
-    /** 
-     * Gets more space to write to. Throws an exception it cannot. 
-     */ 
-    void more() { 
-        size_t n = 0; 
-        while (out_->next(&next_, &n)) { 
-            if (n != 0) { 
-                end_ = next_ + n; 
-                return; 
-            } 
-        } 
-        throw Exception("EOF reached"); 
-    } 
-}; 
- 
-/** 
- * A convenience function to copy all the contents of an input stream into 
- * an output stream. 
- */ 
-inline void copy(InputStream& in, OutputStream& out) 
-{ 
-    const uint8_t *p = 0; 
-    size_t n = 0; 
-    StreamWriter w(out); 
-    while (in.next(&p, &n)) { 
-        w.writeBytes(p, n); 
-    } 
-    w.flush(); 
-} 
- 
-}   // namespace avro 
-#endif 
- 
- 
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef avro_Stream_hh__
+#define avro_Stream_hh__
+
+#include <memory>
+#include <string.h>
+#include <stdint.h>
+
+#include "boost/utility.hpp"
+
+#include "Config.hh"
+#include "Exception.hh"
+
+namespace avro {
+
+/**
+ * A no-copy input stream.
+ */
+class AVRO_DECL InputStream : boost::noncopyable {
+protected:
+
+    /**
+     * An empty constuctor.
+     */
+    InputStream() { }
+
+public:
+    /**
+     * Destructor.
+     */
+    virtual ~InputStream() { }
+
+    /**
+     * Returns some of available data.
+     *
+     * Returns true if some data is available, false if no more data is
+     * available or an error has occurred.
+     */
+    virtual bool next(const uint8_t** data, size_t* len) = 0;
+
+    /**
+     * "Returns" back some of the data to the stream. The returned
+     * data must be less than what was obtained in the last call to
+     * next().
+     */
+    virtual void backup(size_t len) = 0;
+
+    /**
+     * Skips number of bytes specified by len.
+     */
+    virtual void skip(size_t len) = 0;
+
+    /**
+     * Returns the number of bytes read from this stream so far.
+     * All the bytes made available through next are considered
+     * to be used unless, retutned back using backup.
+     */
+    virtual size_t byteCount() const = 0;
+};
+
+typedef std::unique_ptr<InputStream> InputStreamPtr;
+
+/**
+ * An InputStream which also supports seeking to a specific offset.
+ */
+class AVRO_DECL SeekableInputStream : public InputStream {
+protected:
+
+    /**
+     * An empty constuctor.
+     */
+    SeekableInputStream() { }
+
+public:
+    /**
+     * Destructor.
+     */
+    virtual ~SeekableInputStream() { }
+
+    /**
+     * Seek to a specific position in the stream. This may invalidate pointers
+     * returned from next(). This will also reset byteCount() to the given
+     * position.
+     */
+    virtual void seek(int64_t position) = 0;
+};
+
+typedef std::unique_ptr<SeekableInputStream> SeekableInputStreamPtr;
+
+/**
+ * A no-copy output stream.
+ */
+class AVRO_DECL OutputStream : boost::noncopyable {
+protected:
+
+    /**
+     * An empty constuctor.
+     */
+    OutputStream() { }
+public:
+
+    /**
+     * Destructor.
+     */
+    virtual ~OutputStream() { }
+
+    /**
+     * Returns a buffer that can be written into.
+     * On successful return, data has the pointer to the buffer
+     * and len has the number of bytes available at data.
+     */
+    virtual bool next(uint8_t** data, size_t* len) = 0;
+
+    /**
+     * "Returns" back to the stream some of the buffer obtained
+     * from in the last call to next().
+     */
+    virtual void backup(size_t len) = 0;
+
+    /**
+     * Number of bytes written so far into this stream. The whole buffer
+     * returned by next() is assumed to be written unless some of
+     * it was retutned using backup().
+     */
+    virtual uint64_t byteCount() const = 0;
+
+    /**
+     * Flushes any data remaining in the buffer to the stream's underlying
+     * store, if any.
+     */
+    virtual void flush() = 0;
+};
+
+typedef std::unique_ptr<OutputStream> OutputStreamPtr;
+
+/**
+ * Returns a new OutputStream, which grows in memory chunks of specified size.
+ */
+AVRO_DECL OutputStreamPtr memoryOutputStream(size_t chunkSize = 4 * 1024);
+
+/**
+ * Returns a new InputStream, with the data from the given byte array.
+ * It does not copy the data, the byte array should remain valid
+ * until the InputStream is used.
+ */
+AVRO_DECL InputStreamPtr memoryInputStream(const uint8_t* data, size_t len);
+
+/**
+ * Returns a new InputStream with the contents written into an
+ * outputstream. The output stream must have been returned by
+ * an earlier call to memoryOutputStream(). The contents for the new
+ * input stream are the snapshot of the outputstream. One can construct
+ * any number of memory input stream from a single memory output stream.
+ */
+AVRO_DECL InputStreamPtr memoryInputStream(const OutputStream& source);
+
+/**
+ * Returns the contents written so far into the output stream, which should
+ * be a memory output stream. That is it must have been returned by a pervious
+ * call to memoryOutputStream().
+ */
+AVRO_DECL std::shared_ptr<std::vector<uint8_t> > snapshot(const OutputStream& source);
+
+/**
+ * Returns a new OutputStream whose contents would be stored in a file.
+ * Data is written in chunks of given buffer size.
+ *
+ * If there is a file with the given name, it is truncated and overwritten.
+ * If there is no file with the given name, it is created.
+ */
+AVRO_DECL OutputStreamPtr fileOutputStream(const char* filename,
+    size_t bufferSize = 8 * 1024);
+
+/**
+ * Returns a new InputStream whose contents come from the given file.
+ * Data is read in chunks of given buffer size.
+ */
+AVRO_DECL InputStreamPtr fileInputStream(
+    const char *filename, size_t bufferSize = 8 * 1024);
+AVRO_DECL SeekableInputStreamPtr fileSeekableInputStream(
+    const char *filename, size_t bufferSize = 8 * 1024);
+
+/**
+ * Returns a new OutputStream whose contents will be sent to the given
+ * std::ostream. The std::ostream object should outlive the returned
+ * OutputStream.
+ */
+AVRO_DECL OutputStreamPtr ostreamOutputStream(std::ostream& os,
+    size_t bufferSize = 8 * 1024);
+
+/**
+ * Returns a new InputStream whose contents come from the given
+ * std::istream. The std::istream object should outlive the returned
+ * InputStream.
+ */
+AVRO_DECL InputStreamPtr istreamInputStream(
+    std::istream &in, size_t bufferSize = 8 * 1024);
+
+/**
+ * Returns a new InputStream whose contents come from the given
+ * std::istream. Use this instead of istreamInputStream if
+ * the istream does not support seekg (e.g. compressed streams).
+ * The returned InputStream would read off bytes instead of seeking.
+ * Of, course it has a performance penalty when reading instead of seeking;
+ * So, use this only when seekg does not work.
+ * The std::istream object should outlive the returned
+ * InputStream.
+ */
+AVRO_DECL InputStreamPtr nonSeekableIstreamInputStream(
+    std::istream& is, size_t bufferSize = 8 * 1024);
+
+
+/** A convenience class for reading from an InputStream */
+struct StreamReader {
+    /**
+     * The underlying input stream.
+     */
+    InputStream* in_;
+
+    /**
+     * The next location to read from.
+     */
+    const uint8_t* next_;
+
+    /**
+     * One past the last valid location.
+     */
+    const uint8_t* end_;
+
+    /**
+     * Constructs an empty reader.
+     */
+    StreamReader() : in_(0), next_(0), end_(0) { }
+
+    /**
+     * Constructs a reader with the given underlying stream.
+     */
+    StreamReader(InputStream& in) : in_(0), next_(0), end_(0) { reset(in); }
+
+    /**
+     * Replaces the current input stream with the given one after backing up
+     * the original one if required.
+     */
+    void reset(InputStream& is) {
+        if (in_ != 0 && end_ != next_) {
+            in_->backup(end_ - next_);
+        }
+        in_ = &is;
+        next_ = end_ = 0;
+    }
+
+    /**
+     * Read just one byte from the underlying stream. If there are no
+     * more data, throws an exception.
+     */
+    uint8_t read() {
+        if (next_ == end_) {
+            more();
+        }
+        return *next_++;
+    }
+
+    /**
+     * Reads the given number of bytes from the underlying stream.
+     * If there are not that many bytes, throws an exception.
+     */
+    void readBytes(uint8_t* b, size_t n) {
+        while (n > 0) {
+            if (next_ == end_) {
+                more();
+            }
+            size_t q = end_ - next_;
+            if (q > n) {
+                q = n;
+            }
+            ::memcpy(b, next_, q);
+            next_ += q;
+            b += q;
+            n -= q;
+        }
+    }
+
+    /**
+     * Skips the given number of bytes. Of there are not so that many
+     * bytes, throws an exception.
+     */
+    void skipBytes(size_t n) {
+        if (n > static_cast<size_t>(end_ - next_)) {
+            n -= end_ - next_;
+            next_ = end_;
+            in_->skip(n);
+        } else {
+            next_ += n;
+        }
+    }
+
+    /**
+     * Get as many byes from the underlying stream as possible in a single
+     * chunk.
+     * \return true if some data could be obtained. False is no more
+     * data is available on the stream.
+     */
+    bool fill() {
+        size_t n = 0;
+        while (in_->next(&next_, &n)) {
+            if (n != 0) {
+                end_ = next_ + n;
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Tries to get more data and if it cannot, throws an exception.
+     */
+    void more() {
+        if (! fill()) {
+            throw Exception("EOF reached");
+        }
+    }
+
+    /**
+     * Returns true if and only if the end of stream is not reached.
+     */
+    bool hasMore() {
+        return (next_ == end_) ? fill() : true;
+    }
+
+    /**
+     * Returns unused bytes back to the underlying stream.
+     * If unRead is true the last byte read is also pushed back.
+     */
+    void drain(bool unRead) {
+        if (unRead) {
+            --next_;
+        }
+        in_->backup(end_ - next_);
+        end_ = next_;
+    }
+};
+
+/**
+ * A convinience class to write data into an OutputStream.
+ */
+struct StreamWriter {
+    /**
+     * The underlying output stream for this writer.
+     */
+    OutputStream* out_;
+
+    /**
+     * The next location to write to.
+     */
+    uint8_t* next_;
+
+    /**
+     * One past the last location one can write to.
+     */
+    uint8_t* end_;
+
+    /**
+     * Constructs a writer with no underlying stream.
+     */
+    StreamWriter() : out_(0), next_(0), end_(0) { }
+
+    /**
+     * Constructs a new writer with the given underlying stream.
+     */
+    StreamWriter(OutputStream& out) : out_(0), next_(0), end_(0) { reset(out); }
+
+    /**
+     * Replaces the current underlying stream with a new one.
+     * If required, it backs up unused bytes in the previous stream.
+     */
+    void reset(OutputStream& os) {
+        if (out_ != 0 && end_ != next_) {
+            out_->backup(end_ - next_);
+        }
+        out_ = &os;
+        next_ = end_;
+    }
+
+    /**
+     * Writes a single byte.
+     */
+    void write(uint8_t c) {
+        if (next_ == end_) {
+            more();
+        }
+        *next_++ = c;
+    }
+
+    /**
+     * Writes the specified number of bytes starting at \p b.
+     */
+    void writeBytes(const uint8_t* b, size_t n) {
+        while (n > 0) {
+            if (next_ == end_) {
+                more();
+            }
+            size_t q = end_ - next_;
+            if (q > n) {
+                q = n;
+            }
+            ::memcpy(next_, b, q);
+            next_ += q;
+            b += q;
+            n -= q;
+        }
+    }
+
+    /**
+     * backs up upto the currently written data and flushes the
+     * underlying stream.
+     */
+    void flush() {
+        if (next_ != end_) {
+            out_->backup(end_ - next_);
+            next_ = end_;
+        }
+        out_->flush();
+    }
+
+    /**
+     * Return the number of bytes written so far. For a meaningful
+     * result, call this after a flush().
+     */
+    int64_t byteCount() const {
+        return out_->byteCount();
+    }
+
+    /**
+     * Gets more space to write to. Throws an exception it cannot.
+     */
+    void more() {
+        size_t n = 0;
+        while (out_->next(&next_, &n)) {
+            if (n != 0) {
+                end_ = next_ + n;
+                return;
+            }
+        }
+        throw Exception("EOF reached");
+    }
+};
+
+/**
+ * A convenience function to copy all the contents of an input stream into
+ * an output stream.
+ */
+inline void copy(InputStream& in, OutputStream& out)
+{
+    const uint8_t *p = 0;
+    size_t n = 0;
+    StreamWriter w(out);
+    while (in.next(&p, &n)) {
+        w.writeBytes(p, n);
+    }
+    w.flush();
+}
+
+}   // namespace avro
+#endif
+
+
diff --git a/contrib/libs/apache/avro/api/Types.hh b/contrib/libs/apache/avro/api/Types.hh
index a72647c483..f42399e96b 100644
--- a/contrib/libs/apache/avro/api/Types.hh
+++ b/contrib/libs/apache/avro/api/Types.hh
@@ -1,114 +1,114 @@
-/* 
- * Licensed to the Apache Software Foundation (ASF) under one 
- * or more contributor license agreements.  See the NOTICE file 
- * distributed with this work for additional information 
- * regarding copyright ownership.  The ASF licenses this file 
- * to you under the Apache License, Version 2.0 (the 
- * "License"); you may not use this file except in compliance 
- * with the License.  You may obtain a copy of the License at 
- * 
- *     https://www.apache.org/licenses/LICENSE-2.0 
- * 
- * Unless required by applicable law or agreed to in writing, software 
- * distributed under the License is distributed on an "AS IS" BASIS, 
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
- * See the License for the specific language governing permissions and 
- * limitations under the License. 
- */ 
- 
-#ifndef avro_Types_hh__ 
-#define avro_Types_hh__ 
- 
-#include <iostream> 
- 
-#include "Config.hh" 
- 
-namespace avro { 
- 
-/** 
- * The "type" for the schema. 
- */ 
-enum Type { 
- 
-    AVRO_STRING,    /*!< String */ 
-    AVRO_BYTES,     /*!< Sequence of variable length bytes data */ 
-    AVRO_INT,       /*!< 32-bit integer */ 
-    AVRO_LONG,      /*!< 64-bit integer */ 
-    AVRO_FLOAT,     /*!< Floating point number */ 
-    AVRO_DOUBLE,    /*!< Double precision floating point number */ 
-    AVRO_BOOL,      /*!< Boolean value */ 
-    AVRO_NULL,      /*!< Null */ 
- 
-    AVRO_RECORD,    /*!< Record, a sequence of fields */ 
-    AVRO_ENUM,      /*!< Enumeration */ 
-    AVRO_ARRAY,     /*!< Homogeneous array of some specific type */ 
-    AVRO_MAP,       /*!< Homogeneous map from string to some specific type */ 
-    AVRO_UNION,     /*!< Union of one or more types */ 
-    AVRO_FIXED,     /*!< Fixed number of bytes */ 
- 
-    AVRO_NUM_TYPES, /*!< Marker */ 
- 
-    // The following is a pseudo-type used in implementation 
- 
-    AVRO_SYMBOLIC = AVRO_NUM_TYPES, /*!< User internally to avoid circular references. */ 
-    AVRO_UNKNOWN  = -1 /*!< Used internally. */ 
- 
-}; 
- 
-/** 
- * Returns true if and only if the given type is a primitive. 
- * Primitive types are: string, bytes, int, long, float, double, boolean 
- * and null 
- */ 
-inline bool isPrimitive(Type t) { 
-    return (t >= AVRO_STRING) && (t < AVRO_RECORD); 
-} 
- 
-/** 
- * Returns true if and only if the given type is a non primitive valid type. 
- * Primitive types are: string, bytes, int, long, float, double, boolean 
- * and null 
- */ 
-inline bool isCompound(Type t) { 
-    return (t>= AVRO_RECORD) && (t < AVRO_NUM_TYPES); 
-} 
- 
-/** 
- * Returns true if and only if the given type is a valid avro type. 
- */ 
-inline bool isAvroType(Type t) { 
-    return (t >= AVRO_STRING) && (t < AVRO_NUM_TYPES); 
-} 
- 
-/** 
- * Returns true if and only if the given type is within the valid range 
- * of enumeration. 
- */ 
-inline bool isAvroTypeOrPseudoType(Type t) { 
-    return (t >= AVRO_STRING) && (t <= AVRO_NUM_TYPES); 
-} 
- 
-/** 
- * Converts the given type into a string. Useful for generating messages. 
- */ 
-AVRO_DECL const std::string& toString(Type type); 
- 
-/** 
- * Writes a string form of the given type into the given ostream. 
- */ 
-AVRO_DECL std::ostream &operator<< (std::ostream &os, avro::Type type); 
- 
-/// define a type to identify Null in template functions 
-struct AVRO_DECL Null { }; 
- 
-/** 
- * Writes schema for null \p null type to \p os. 
- * \param os The ostream to write to. 
- * \param null The value to be written. 
- */ 
-std::ostream& operator<< (std::ostream &os, const Null &null); 
- 
-} // namespace avro 
- 
- 
-#endif 
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef avro_Types_hh__
+#define avro_Types_hh__
+
+#include <iostream>
+
+#include "Config.hh"
+
+namespace avro {
+
+/**
+ * The "type" for the schema.
+ */
+enum Type {
+
+    AVRO_STRING,    /*!< String */
+    AVRO_BYTES,     /*!< Sequence of variable length bytes data */
+    AVRO_INT,       /*!< 32-bit integer */
+    AVRO_LONG,      /*!< 64-bit integer */
+    AVRO_FLOAT,     /*!< Floating point number */
+    AVRO_DOUBLE,    /*!< Double precision floating point number */
+    AVRO_BOOL,      /*!< Boolean value */
+    AVRO_NULL,      /*!< Null */
+
+    AVRO_RECORD,    /*!< Record, a sequence of fields */
+    AVRO_ENUM,      /*!< Enumeration */
+    AVRO_ARRAY,     /*!< Homogeneous array of some specific type */
+    AVRO_MAP,       /*!< Homogeneous map from string to some specific type */
+    AVRO_UNION,     /*!< Union of one or more types */
+    AVRO_FIXED,     /*!< Fixed number of bytes */
+
+    AVRO_NUM_TYPES, /*!< Marker */
+
+    // The following is a pseudo-type used in implementation
+
+    AVRO_SYMBOLIC = AVRO_NUM_TYPES, /*!< User internally to avoid circular references. */
+    AVRO_UNKNOWN  = -1 /*!< Used internally. */
+
+};
+
+/**
+ * Returns true if and only if the given type is a primitive.
+ * Primitive types are: string, bytes, int, long, float, double, boolean
+ * and null
+ */
+inline bool isPrimitive(Type t) {
+    return (t >= AVRO_STRING) && (t < AVRO_RECORD);
+}
+
+/**
+ * Returns true if and only if the given type is a non primitive valid type.
+ * Primitive types are: string, bytes, int, long, float, double, boolean
+ * and null
+ */
+inline bool isCompound(Type t) {
+    return (t>= AVRO_RECORD) && (t < AVRO_NUM_TYPES);
+}
+
+/**
+ * Returns true if and only if the given type is a valid avro type.
+ */
+inline bool isAvroType(Type t) {
+    return (t >= AVRO_STRING) && (t < AVRO_NUM_TYPES);
+}
+
+/**
+ * Returns true if and only if the given type is within the valid range
+ * of enumeration.
+ */
+inline bool isAvroTypeOrPseudoType(Type t) {
+    return (t >= AVRO_STRING) && (t <= AVRO_NUM_TYPES);
+}
+
+/**
+ * Converts the given type into a string. Useful for generating messages.
+ */
+AVRO_DECL const std::string& toString(Type type);
+
+/**
+ * Writes a string form of the given type into the given ostream.
+ */
+AVRO_DECL std::ostream &operator<< (std::ostream &os, avro::Type type);
+
+/// define a type to identify Null in template functions
+struct AVRO_DECL Null { };
+
+/**
+ * Writes schema for null \p null type to \p os.
+ * \param os The ostream to write to.
+ * \param null The value to be written.
+ */
+std::ostream& operator<< (std::ostream &os, const Null &null);
+
+} // namespace avro
+
+
+#endif
diff --git a/contrib/libs/apache/avro/api/ValidSchema.hh b/contrib/libs/apache/avro/api/ValidSchema.hh
index eeff4ef610..7b0ec28bed 100644
--- a/contrib/libs/apache/avro/api/ValidSchema.hh
+++ b/contrib/libs/apache/avro/api/ValidSchema.hh
@@ -1,66 +1,66 @@
-/* 
- * Licensed to the Apache Software Foundation (ASF) under one 
- * or more contributor license agreements.  See the NOTICE file 
- * distributed with this work for additional information 
- * regarding copyright ownership.  The ASF licenses this file 
- * to you under the Apache License, Version 2.0 (the 
- * "License"); you may not use this file except in compliance 
- * with the License.  You may obtain a copy of the License at 
- * 
- *     https://www.apache.org/licenses/LICENSE-2.0 
- * 
- * Unless required by applicable law or agreed to in writing, software 
- * distributed under the License is distributed on an "AS IS" BASIS, 
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
- * See the License for the specific language governing permissions and 
- * limitations under the License. 
- */ 
- 
-#ifndef avro_ValidSchema_hh__ 
-#define avro_ValidSchema_hh__ 
- 
-#include "Config.hh" 
-#include "Node.hh" 
- 
-namespace avro { 
- 
-class AVRO_DECL Schema; 
- 
-/// A ValidSchema is basically a non-mutable Schema that has passed some 
-/// minimum of sanity checks.  Once validated, any Schema that is part of 
-/// this ValidSchema is considered locked, and cannot be modified (an attempt 
-/// to modify a locked Schema will throw).  Also, as it is validated, any 
-/// recursive duplications of schemas are replaced with symbolic links to the 
-/// original. 
-/// 
-/// Once a Schema is converted to a valid schema it can be used in validating 
-/// parsers/serializers, converted to a json schema, etc. 
-/// 
- 
-class AVRO_DECL ValidSchema { 
-public: 
-    explicit ValidSchema(const NodePtr &root); 
-    explicit ValidSchema(const Schema &schema); 
-    ValidSchema(); 
- 
-    void setSchema(const Schema &schema); 
- 
-    const NodePtr &root() const { 
-        return root_; 
-    } 
- 
-    void toJson(std::ostream &os) const; 
-    std::string toJson(bool prettyPrint = true) const; 
- 
-    void toFlatList(std::ostream &os) const; 
- 
-  protected: 
-    NodePtr root_; 
- 
-  private: 
-    static std::string compactSchema(const std::string &schema); 
-}; 
- 
-} // namespace avro 
- 
-#endif 
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef avro_ValidSchema_hh__
+#define avro_ValidSchema_hh__
+
+#include "Config.hh"
+#include "Node.hh"
+
+namespace avro {
+
+class AVRO_DECL Schema;
+
+/// A ValidSchema is basically a non-mutable Schema that has passed some
+/// minimum of sanity checks.  Once validated, any Schema that is part of
+/// this ValidSchema is considered locked, and cannot be modified (an attempt
+/// to modify a locked Schema will throw).  Also, as it is validated, any
+/// recursive duplications of schemas are replaced with symbolic links to the
+/// original.
+///
+/// Once a Schema is converted to a valid schema it can be used in validating
+/// parsers/serializers, converted to a json schema, etc.
+///
+
+class AVRO_DECL ValidSchema {
+public:
+    explicit ValidSchema(const NodePtr &root);
+    explicit ValidSchema(const Schema &schema);
+    ValidSchema();
+
+    void setSchema(const Schema &schema);
+
+    const NodePtr &root() const {
+        return root_;
+    }
+
+    void toJson(std::ostream &os) const;
+    std::string toJson(bool prettyPrint = true) const;
+
+    void toFlatList(std::ostream &os) const;
+
+  protected:
+    NodePtr root_;
+
+  private:
+    static std::string compactSchema(const std::string &schema);
+};
+
+} // namespace avro
+
+#endif
diff --git a/contrib/libs/apache/avro/api/Validator.hh b/contrib/libs/apache/avro/api/Validator.hh
index 8000f6fd22..3f542d611a 100644
--- a/contrib/libs/apache/avro/api/Validator.hh
+++ b/contrib/libs/apache/avro/api/Validator.hh
@@ -1,161 +1,161 @@
-/* 
- * Licensed to the Apache Software Foundation (ASF) under one 
- * or more contributor license agreements.  See the NOTICE file 
- * distributed with this work for additional information 
- * regarding copyright ownership.  The ASF licenses this file 
- * to you under the Apache License, Version 2.0 (the 
- * "License"); you may not use this file except in compliance 
- * with the License.  You may obtain a copy of the License at 
- * 
- *     https://www.apache.org/licenses/LICENSE-2.0 
- * 
- * Unless required by applicable law or agreed to in writing, software 
- * distributed under the License is distributed on an "AS IS" BASIS, 
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
- * See the License for the specific language governing permissions and 
- * limitations under the License. 
- */ 
- 
-#ifndef avro_Validating_hh__ 
-#define avro_Validating_hh__ 
- 
-#include <boost/noncopyable.hpp> 
-#include <vector> 
-#include <stdint.h> 
- 
-#include "Config.hh" 
-#include "Types.hh" 
-#include "ValidSchema.hh" 
- 
-namespace avro { 
- 
-class AVRO_DECL NullValidator : private boost::noncopyable 
-{ 
-  public: 
- 
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef avro_Validating_hh__
+#define avro_Validating_hh__
+
+#include <boost/noncopyable.hpp>
+#include <vector>
+#include <stdint.h>
+
+#include "Config.hh"
+#include "Types.hh"
+#include "ValidSchema.hh"
+
+namespace avro {
+
+class AVRO_DECL NullValidator : private boost::noncopyable
+{
+  public:
+
     explicit NullValidator(const ValidSchema &) {}
-    NullValidator() {} 
- 
+    NullValidator() {}
+
     void setCount(int64_t) {}
- 
+
     bool typeIsExpected(Type) const {
-        return true; 
-    } 
- 
-    Type nextTypeExpected() const { 
-        return AVRO_UNKNOWN; 
-    } 
- 
-    int nextSizeExpected() const { 
-        return 0; 
-    } 
- 
+        return true;
+    }
+
+    Type nextTypeExpected() const {
+        return AVRO_UNKNOWN;
+    }
+
+    int nextSizeExpected() const {
+        return 0;
+    }
+
     bool getCurrentRecordName(std::string &) const {
-        return true; 
-    } 
- 
+        return true;
+    }
+
     bool getNextFieldName(std::string &) const {
-        return true; 
-    } 
- 
+        return true;
+    }
+
     void checkTypeExpected(Type) { }
     void checkFixedSizeExpected(int) { }
- 
- 
-}; 
- 
-/// This class is used by both the ValidatingSerializer and ValidationParser 
-/// objects.  It advances the parse tree (containing logic how to advance 
-/// through the various compound types, for example a record must advance 
-/// through all leaf nodes but a union only skips to one), and reports which 
-/// type is next. 
- 
-class AVRO_DECL Validator : private boost::noncopyable 
-{ 
-  public: 
- 
-    explicit Validator(const ValidSchema &schema); 
- 
-    void setCount(int64_t val); 
- 
-    bool typeIsExpected(Type type) const { 
-        return (expectedTypesFlag_ & typeToFlag(type)) != 0; 
-    } 
- 
-    Type nextTypeExpected() const { 
-        return nextType_; 
-    } 
- 
-    int nextSizeExpected() const; 
- 
-    bool getCurrentRecordName(std::string &name) const; 
-    bool getNextFieldName(std::string &name) const; 
- 
-    void checkTypeExpected(Type type) { 
-        if(! typeIsExpected(type)) { 
-            throw Exception( 
-                boost::format("Type %1% does not match schema %2%") 
-                    % type % nextType_ 
-            ); 
-        } 
-        advance(); 
-    } 
- 
-    void checkFixedSizeExpected(int size) { 
-        if( nextSizeExpected() != size) { 
-            throw Exception( 
-                boost::format("Wrong size for fixed, got %1%, expected %2%") 
-                    % size % nextSizeExpected() 
-            ); 
-        } 
-        checkTypeExpected(AVRO_FIXED); 
-    } 
- 
-  private: 
- 
-    typedef uint32_t flag_t; 
- 
-    flag_t typeToFlag(Type type) const { 
-        flag_t flag = (1L << type); 
-        return flag; 
-    } 
- 
-    void setupOperation(const NodePtr &node); 
- 
-    void setWaitingForCount(); 
- 
-    void advance(); 
-    void doAdvance(); 
- 
-    void enumAdvance(); 
-    bool countingSetup(); 
-    void countingAdvance(); 
-    void unionAdvance(); 
-    void fixedAdvance(); 
- 
-    void setupFlag(Type type); 
- 
-    const ValidSchema schema_; 
- 
-    Type nextType_; 
-    flag_t expectedTypesFlag_; 
-    bool compoundStarted_; 
-    bool waitingForCount_; 
-    int64_t count_; 
- 
-    struct CompoundType { 
-        explicit CompoundType(const NodePtr &n) : 
-            node(n), pos(0) 
-        {} 
-        NodePtr node;  ///< save the node 
-        size_t  pos;   ///< track the leaf position to visit 
-    }; 
- 
-    std::vector<CompoundType> compoundStack_; 
-    std::vector<size_t> counters_; 
- 
-}; 
- 
-} // namespace avro 
- 
-#endif 
+
+
+};
+
+/// This class is used by both the ValidatingSerializer and ValidationParser
+/// objects.  It advances the parse tree (containing logic how to advance
+/// through the various compound types, for example a record must advance
+/// through all leaf nodes but a union only skips to one), and reports which
+/// type is next.
+
+class AVRO_DECL Validator : private boost::noncopyable
+{
+  public:
+
+    explicit Validator(const ValidSchema &schema);
+
+    void setCount(int64_t val);
+
+    bool typeIsExpected(Type type) const {
+        return (expectedTypesFlag_ & typeToFlag(type)) != 0;
+    }
+
+    Type nextTypeExpected() const {
+        return nextType_;
+    }
+
+    int nextSizeExpected() const;
+
+    bool getCurrentRecordName(std::string &name) const;
+    bool getNextFieldName(std::string &name) const;
+
+    void checkTypeExpected(Type type) {
+        if(! typeIsExpected(type)) {
+            throw Exception(
+                boost::format("Type %1% does not match schema %2%")
+                    % type % nextType_
+            );
+        }
+        advance();
+    }
+
+    void checkFixedSizeExpected(int size) {
+        if( nextSizeExpected() != size) {
+            throw Exception(
+                boost::format("Wrong size for fixed, got %1%, expected %2%")
+                    % size % nextSizeExpected()
+            );
+        }
+        checkTypeExpected(AVRO_FIXED);
+    }
+
+  private:
+
+    typedef uint32_t flag_t;
+
+    flag_t typeToFlag(Type type) const {
+        flag_t flag = (1L << type);
+        return flag;
+    }
+
+    void setupOperation(const NodePtr &node);
+
+    void setWaitingForCount();
+
+    void advance();
+    void doAdvance();
+
+    void enumAdvance();
+    bool countingSetup();
+    void countingAdvance();
+    void unionAdvance();
+    void fixedAdvance();
+
+    void setupFlag(Type type);
+
+    const ValidSchema schema_;
+
+    Type nextType_;
+    flag_t expectedTypesFlag_;
+    bool compoundStarted_;
+    bool waitingForCount_;
+    int64_t count_;
+
+    struct CompoundType {
+        explicit CompoundType(const NodePtr &n) :
+            node(n), pos(0)
+        {}
+        NodePtr node;  ///< save the node
+        size_t  pos;   ///< track the leaf position to visit
+    };
+
+    std::vector<CompoundType> compoundStack_;
+    std::vector<size_t> counters_;
+
+};
+
+} // namespace avro
+
+#endif
diff --git a/contrib/libs/apache/avro/api/Writer.hh b/contrib/libs/apache/avro/api/Writer.hh
index 7e74ce403e..74b057ce65 100644
--- a/contrib/libs/apache/avro/api/Writer.hh
+++ b/contrib/libs/apache/avro/api/Writer.hh
@@ -1,186 +1,186 @@
-/* 
- * Licensed to the Apache Software Foundation (ASF) under one 
- * or more contributor license agreements.  See the NOTICE file 
- * distributed with this work for additional information 
- * regarding copyright ownership.  The ASF licenses this file 
- * to you under the Apache License, Version 2.0 (the 
- * "License"); you may not use this file except in compliance 
- * with the License.  You may obtain a copy of the License at 
- * 
- *     https://www.apache.org/licenses/LICENSE-2.0 
- * 
- * Unless required by applicable law or agreed to in writing, software 
- * distributed under the License is distributed on an "AS IS" BASIS, 
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
- * See the License for the specific language governing permissions and 
- * limitations under the License. 
- */ 
- 
-#ifndef avro_Writer_hh__ 
-#define avro_Writer_hh__ 
- 
-#include <array> 
-#include <boost/noncopyable.hpp> 
- 
-#include "Config.hh" 
-#include "buffer/Buffer.hh" 
-#include "Zigzag.hh" 
-#include "Types.hh" 
-#include "Validator.hh" 
- 
-namespace avro { 
- 
-/// Class for writing avro data to a stream. 
- 
-template<class ValidatorType> 
-class WriterImpl : private boost::noncopyable 
-{ 
- 
-  public: 
- 
-    WriterImpl() {} 
- 
-    explicit WriterImpl(const ValidSchema &schema) : 
-        validator_(schema) 
-    {} 
- 
-    void writeValue(const Null &) { 
-        validator_.checkTypeExpected(AVRO_NULL); 
-    } 
- 
-    void writeValue(bool val) { 
-        validator_.checkTypeExpected(AVRO_BOOL); 
-        int8_t byte = (val != 0); 
-        buffer_.writeTo(byte); 
-    } 
- 
-    void writeValue(int32_t val) { 
-        validator_.checkTypeExpected(AVRO_INT); 
-        std::array<uint8_t, 5> bytes; 
-        size_t size = encodeInt32(val, bytes); 
-        buffer_.writeTo(reinterpret_cast<const char *>(bytes.data()), size); 
-    } 
- 
-    void writeValue(int64_t val) { 
-        validator_.checkTypeExpected(AVRO_LONG); 
-        putLong(val); 
-    } 
- 
-    void writeValue(float val) { 
-        validator_.checkTypeExpected(AVRO_FLOAT); 
-        union { 
-            float f; 
-            int32_t i; 
-        } v; 
- 
-        v.f = val; 
-        buffer_.writeTo(v.i); 
-    } 
- 
-    void writeValue(double val) { 
-        validator_.checkTypeExpected(AVRO_DOUBLE); 
-        union { 
-            double d; 
-            int64_t i; 
-        } v; 
- 
-        v.d = val; 
-        buffer_.writeTo(v.i); 
-    } 
- 
-    void writeValue(const std::string &val) { 
-        validator_.checkTypeExpected(AVRO_STRING); 
-        putBytes(val.c_str(), val.size()); 
-    } 
- 
-    void writeBytes(const void *val, size_t size) { 
-        validator_.checkTypeExpected(AVRO_BYTES); 
-        putBytes(val, size); 
-    } 
- 
-    template <size_t N> 
-    void writeFixed(const uint8_t (&val)[N]) { 
-        validator_.checkFixedSizeExpected(N); 
-        buffer_.writeTo(reinterpret_cast<const char *>(val), N); 
-    } 
- 
-    template <size_t N> 
-    void writeFixed(const std::array<uint8_t, N> &val) { 
-        validator_.checkFixedSizeExpected(val.size()); 
-        buffer_.writeTo(reinterpret_cast<const char *>(val.data()), val.size()); 
-    } 
- 
-    void writeRecord() { 
-        validator_.checkTypeExpected(AVRO_RECORD); 
-        validator_.checkTypeExpected(AVRO_LONG); 
-        validator_.setCount(1); 
-    } 
- 
-    void writeRecordEnd() { 
-        validator_.checkTypeExpected(AVRO_RECORD); 
-        validator_.checkTypeExpected(AVRO_LONG); 
-        validator_.setCount(0); 
-    } 
- 
-    void writeArrayBlock(int64_t size) { 
-        validator_.checkTypeExpected(AVRO_ARRAY); 
-        writeCount(size); 
-    } 
- 
-    void writeArrayEnd() { 
-        writeArrayBlock(0); 
-    } 
- 
-    void writeMapBlock(int64_t size) { 
-        validator_.checkTypeExpected(AVRO_MAP); 
-        writeCount(size); 
-    } 
- 
-    void writeMapEnd() { 
-        writeMapBlock(0); 
-    } 
- 
-    void writeUnion(int64_t choice) { 
-        validator_.checkTypeExpected(AVRO_UNION); 
-        writeCount(choice); 
-    } 
- 
-    void writeEnum(int64_t choice) { 
-        validator_.checkTypeExpected(AVRO_ENUM); 
-        writeCount(choice); 
-    } 
- 
-    InputBuffer buffer() const { 
-        return buffer_; 
-    } 
- 
-  private: 
- 
-    void putLong(int64_t val) { 
-        std::array<uint8_t, 10> bytes; 
-        size_t size = encodeInt64(val, bytes); 
-        buffer_.writeTo(reinterpret_cast<const char *>(bytes.data()), size); 
-    } 
- 
-    void putBytes(const void *val, size_t size) { 
-        putLong(size); 
-        buffer_.writeTo(reinterpret_cast<const char *>(val), size); 
-    } 
- 
-    void writeCount(int64_t count) { 
-        validator_.checkTypeExpected(AVRO_LONG); 
-        validator_.setCount(count); 
-        putLong(count); 
-    } 
- 
-    ValidatorType validator_; 
-    OutputBuffer buffer_; 
- 
-}; 
- 
-typedef WriterImpl<NullValidator> Writer; 
-typedef WriterImpl<Validator> ValidatingWriter; 
- 
-} // namespace avro 
- 
-#endif 
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef avro_Writer_hh__
+#define avro_Writer_hh__
+
+#include <array>
+#include <boost/noncopyable.hpp>
+
+#include "Config.hh"
+#include "buffer/Buffer.hh"
+#include "Zigzag.hh"
+#include "Types.hh"
+#include "Validator.hh"
+
+namespace avro {
+
+/// Class for writing avro data to a stream.
+
+template<class ValidatorType>
+class WriterImpl : private boost::noncopyable
+{
+
+  public:
+
+    WriterImpl() {}
+
+    explicit WriterImpl(const ValidSchema &schema) :
+        validator_(schema)
+    {}
+
+    void writeValue(const Null &) {
+        validator_.checkTypeExpected(AVRO_NULL);
+    }
+
+    void writeValue(bool val) {
+        validator_.checkTypeExpected(AVRO_BOOL);
+        int8_t byte = (val != 0);
+        buffer_.writeTo(byte);
+    }
+
+    void writeValue(int32_t val) {
+        validator_.checkTypeExpected(AVRO_INT);
+        std::array<uint8_t, 5> bytes;
+        size_t size = encodeInt32(val, bytes);
+        buffer_.writeTo(reinterpret_cast<const char *>(bytes.data()), size);
+    }
+
+    void writeValue(int64_t val) {
+        validator_.checkTypeExpected(AVRO_LONG);
+        putLong(val);
+    }
+
+    void writeValue(float val) {
+        validator_.checkTypeExpected(AVRO_FLOAT);
+        union {
+            float f;
+            int32_t i;
+        } v;
+
+        v.f = val;
+        buffer_.writeTo(v.i);
+    }
+
+    void writeValue(double val) {
+        validator_.checkTypeExpected(AVRO_DOUBLE);
+        union {
+            double d;
+            int64_t i;
+        } v;
+
+        v.d = val;
+        buffer_.writeTo(v.i);
+    }
+
+    void writeValue(const std::string &val) {
+        validator_.checkTypeExpected(AVRO_STRING);
+        putBytes(val.c_str(), val.size());
+    }
+
+    void writeBytes(const void *val, size_t size) {
+        validator_.checkTypeExpected(AVRO_BYTES);
+        putBytes(val, size);
+    }
+
+    template <size_t N>
+    void writeFixed(const uint8_t (&val)[N]) {
+        validator_.checkFixedSizeExpected(N);
+        buffer_.writeTo(reinterpret_cast<const char *>(val), N);
+    }
+
+    template <size_t N>
+    void writeFixed(const std::array<uint8_t, N> &val) {
+        validator_.checkFixedSizeExpected(val.size());
+        buffer_.writeTo(reinterpret_cast<const char *>(val.data()), val.size());
+    }
+
+    void writeRecord() {
+        validator_.checkTypeExpected(AVRO_RECORD);
+        validator_.checkTypeExpected(AVRO_LONG);
+        validator_.setCount(1);
+    }
+
+    void writeRecordEnd() {
+        validator_.checkTypeExpected(AVRO_RECORD);
+        validator_.checkTypeExpected(AVRO_LONG);
+        validator_.setCount(0);
+    }
+
+    void writeArrayBlock(int64_t size) {
+        validator_.checkTypeExpected(AVRO_ARRAY);
+        writeCount(size);
+    }
+
+    void writeArrayEnd() {
+        writeArrayBlock(0);
+    }
+
+    void writeMapBlock(int64_t size) {
+        validator_.checkTypeExpected(AVRO_MAP);
+        writeCount(size);
+    }
+
+    void writeMapEnd() {
+        writeMapBlock(0);
+    }
+
+    void writeUnion(int64_t choice) {
+        validator_.checkTypeExpected(AVRO_UNION);
+        writeCount(choice);
+    }
+
+    void writeEnum(int64_t choice) {
+        validator_.checkTypeExpected(AVRO_ENUM);
+        writeCount(choice);
+    }
+
+    InputBuffer buffer() const {
+        return buffer_;
+    }
+
+  private:
+
+    void putLong(int64_t val) {
+        std::array<uint8_t, 10> bytes;
+        size_t size = encodeInt64(val, bytes);
+        buffer_.writeTo(reinterpret_cast<const char *>(bytes.data()), size);
+    }
+
+    void putBytes(const void *val, size_t size) {
+        putLong(size);
+        buffer_.writeTo(reinterpret_cast<const char *>(val), size);
+    }
+
+    void writeCount(int64_t count) {
+        validator_.checkTypeExpected(AVRO_LONG);
+        validator_.setCount(count);
+        putLong(count);
+    }
+
+    ValidatorType validator_;
+    OutputBuffer buffer_;
+
+};
+
+typedef WriterImpl<NullValidator> Writer;
+typedef WriterImpl<Validator> ValidatingWriter;
+
+} // namespace avro
+
+#endif
diff --git a/contrib/libs/apache/avro/api/Zigzag.hh b/contrib/libs/apache/avro/api/Zigzag.hh
index ed76aae931..d0259b8d50 100644
--- a/contrib/libs/apache/avro/api/Zigzag.hh
+++ b/contrib/libs/apache/avro/api/Zigzag.hh
@@ -1,43 +1,43 @@
-/* 
- * Licensed to the Apache Software Foundation (ASF) under one 
- * or more contributor license agreements.  See the NOTICE file 
- * distributed with this work for additional information 
- * regarding copyright ownership.  The ASF licenses this file 
- * to you under the Apache License, Version 2.0 (the 
- * "License"); you may not use this file except in compliance 
- * with the License.  You may obtain a copy of the License at 
- * 
- *     https://www.apache.org/licenses/LICENSE-2.0 
- * 
- * Unless required by applicable law or agreed to in writing, software 
- * distributed under the License is distributed on an "AS IS" BASIS, 
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
- * See the License for the specific language governing permissions and 
- * limitations under the License. 
- */ 
- 
-#ifndef avro_Encoding_hh__ 
-#define avro_Encoding_hh__ 
- 
-#include <stdint.h> 
-#include <array> 
-#include <cstddef> 
- 
-#include "Config.hh" 
-/// \file 
-/// Functions for encoding and decoding integers with zigzag compression 
- 
-namespace avro { 
- 
-AVRO_DECL uint64_t encodeZigzag64(int64_t input); 
-AVRO_DECL int64_t decodeZigzag64(uint64_t input); 
- 
-AVRO_DECL uint32_t encodeZigzag32(int32_t input); 
-AVRO_DECL int32_t decodeZigzag32(uint32_t input); 
- 
-AVRO_DECL size_t encodeInt32(int32_t input, std::array<uint8_t, 5> &output); 
-AVRO_DECL size_t encodeInt64(int64_t input, std::array<uint8_t, 10> &output); 
- 
-} // namespace avro 
- 
-#endif 
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef avro_Encoding_hh__
+#define avro_Encoding_hh__
+
+#include <stdint.h>
+#include <array>
+#include <cstddef>
+
+#include "Config.hh"
+/// \file
+/// Functions for encoding and decoding integers with zigzag compression
+
+namespace avro {
+
+AVRO_DECL uint64_t encodeZigzag64(int64_t input);
+AVRO_DECL int64_t decodeZigzag64(uint64_t input);
+
+AVRO_DECL uint32_t encodeZigzag32(int32_t input);
+AVRO_DECL int32_t decodeZigzag32(uint32_t input);
+
+AVRO_DECL size_t encodeInt32(int32_t input, std::array<uint8_t, 5> &output);
+AVRO_DECL size_t encodeInt64(int64_t input, std::array<uint8_t, 10> &output);
+
+} // namespace avro
+
+#endif
diff --git a/contrib/libs/apache/avro/api/buffer/Buffer.hh b/contrib/libs/apache/avro/api/buffer/Buffer.hh
index b2a04dd683..7d7aaf8679 100644
--- a/contrib/libs/apache/avro/api/buffer/Buffer.hh
+++ b/contrib/libs/apache/avro/api/buffer/Buffer.hh
@@ -1,526 +1,526 @@
-/* 
- * Licensed to the Apache Software Foundation (ASF) under one 
- * or more contributor license agreements.  See the NOTICE file 
- * distributed with this work for additional information 
- * regarding copyright ownership.  The ASF licenses this file 
- * to you under the Apache License, Version 2.0 (the 
- * "License"); you may not use this file except in compliance 
- * with the License.  You may obtain a copy of the License at 
- * 
- *     https://www.apache.org/licenses/LICENSE-2.0 
- * 
- * Unless required by applicable law or agreed to in writing, software 
- * distributed under the License is distributed on an "AS IS" BASIS, 
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
- * See the License for the specific language governing permissions and 
- * limitations under the License. 
- */ 
- 
-#ifndef avro_Buffer_hh__ 
-#define avro_Buffer_hh__ 
- 
-#ifndef _WIN32 
-#include <sys/uio.h> 
-#endif 
-#include <vector> 
- 
-#include "../Config.hh" 
-#include "detail/BufferDetail.hh" 
-#include "detail/BufferDetailIterator.hh" 
- 
-/** 
- * \file Buffer.hh 
- * 
- * \brief Definitions for InputBuffer and OutputBuffer classes 
- * 
- **/ 
- 
-namespace avro { 
- 
-class OutputBuffer; 
-class InputBuffer; 
- 
- 
-/** 
- * The OutputBuffer (write-only buffer) 
- * 
- * Use cases for OutputBuffer 
- * 
- * - write message to buffer using ostream class or directly 
- * - append messages to headers 
- * - building up streams of messages via append 
- * - converting to read-only buffers for sending 
- * - extracting parts of the messages into read-only buffers 
- * 
- * -# ASIO access: 
- *     - write to a buffer(s) by asio using iterator 
- *     - convert to read buffer for deserializing 
- * 
- * OutputBuffer is assignable and copy-constructable.  On copy or assignment, 
- * only a pointer is copied, so the two resulting copies are identical, so 
- * modifying one will modify both. 
- **/ 
- 
-class AVRO_DECL OutputBuffer 
-{ 
- 
-  public: 
- 
-    typedef detail::size_type size_type; 
-    typedef detail::data_type data_type; 
- 
-    /** 
-     * The asio library expects a const_iterator (the const-ness refers to the 
-     * fact that the underlying avro of buffers will not be modified, even 
-     * though the data in those buffers is being modified).  The iterator 
-     * provides the list of addresses an operation can write to. 
-     **/ 
- 
-    typedef detail::OutputBufferIterator const_iterator; 
- 
-    /** 
-     * Default constructor.  Will pre-allocate at least the requested size, but 
-     * can grow larger on demand. 
-     * 
-     * Destructor uses the default, which resets a shared pointer, deleting the 
-     * underlying data if no other copies of exist. 
-     * 
-     * Copy and assignment operators are not explicitly provided because the 
-     * default ones work fine.  The default makes only a shallow copy, so the 
-     * copies will refer to the same memory.  This is required by asio 
-     * functions, which will implicitly make copies for asynchronous 
-     * operations.  Therefore, the user must be careful that if they create 
-     * multiple copies of the same OutputBuffer, only one is being modified 
-     * otherwise undefined behavior may occur. 
-     * 
-     **/ 
- 
-    OutputBuffer(size_type reserveSize = 0) : 
-        pimpl_(new detail::BufferImpl) 
-    { 
-        if(reserveSize) { 
-            reserve(reserveSize); 
-        } 
-    } 
- 
-    /** 
-     * Reserve enough space for a wroteTo() operation.  When using writeTo(), 
-     * the buffer will grow dynamically as needed.  But when using the iterator 
-     * to write (followed by wroteTo()), data may only be written to the space 
-     * available,  so this ensures there is enough room in the buffer before 
-     * the write operation. 
-     **/ 
- 
-    void reserve(size_type reserveSize) 
-    { 
-        pimpl_->reserveFreeSpace(reserveSize); 
-    } 
- 
-    /** 
-     * Write a block of data to the buffer.  The buffer size will automatically 
-     * grow if the size is larger than what is currently free. 
-     **/ 
- 
-    size_type writeTo(const data_type *data, size_type size) { 
-        return pimpl_->writeTo(data, size); 
-    } 
- 
-    /** 
-     * Write a single value to the buffer. The buffer size will automatically 
-     * grow if there is not room for the byte.  The value must be a 
-     * "fundamental" type, e.g. int, float, etc.  (otherwise use the other 
-     * writeTo tests). 
-     **/ 
- 
-    template<typename T> 
-    void writeTo(T val) { 
-        pimpl_->writeTo(val, std::is_fundamental<T>()); 
-    } 
- 
-    /** 
-     * Update the state of the buffer after writing through the iterator 
-     * interface.  This function exists primarily for the boost:asio which 
-     * writes directly to the buffer using its iterator.  In this case, the 
-     * internal state of the buffer does not reflect that the data was written 
-     * This informs the buffer how much data was written. 
-     * 
-     * The buffer does not automatically resize in this case, the bytes written 
-     * cannot exceed the amount of free space.  Attempting to write more will 
-     * throw a std::length_error exception. 
-     **/ 
- 
-    size_type wroteTo(size_type size) 
-    { 
-        int wrote = 0; 
-        if(size) { 
-            if(size > freeSpace()) { 
-                throw std::length_error("Impossible to write more data than free space"); 
-            } 
-            wrote = pimpl_->wroteTo(size); 
-        } 
-        return wrote; 
-    } 
- 
-    /** 
-     * Does the buffer have any data? 
-     **/ 
- 
-    bool empty() const { 
-        return  (pimpl_->size()==0); 
-    } 
- 
-    /** 
-     *  Returns the size of the buffer, in bytes. 
-     */ 
- 
-    size_type size() const { 
-        return  pimpl_->size(); 
-    } 
- 
-    /** 
-     * Returns the current free space that is available to write to in the 
-     * buffer, in bytes.  This is not a strict limit in size, as writeTo() can 
-     * automatically increase capacity if necessary. 
-     **/ 
- 
-    size_type freeSpace() const { 
-        return  pimpl_->freeSpace(); 
-    } 
- 
-    /** 
-     * Appends the data in the argument to the end of this buffer.  The 
-     * argument can be either an InputBuffer or OutputBuffer. 
-     * 
-     **/ 
- 
-    template <class BufferType> 
-    void append(const BufferType &buf) { 
-        // don't append an empty buffer 
-        if(buf.size()) { 
-            pimpl_->append(*(buf.pimpl_.get())); 
-        } 
-    } 
- 
-    /** 
-     * Return an iterator pointing to the first data chunk of this buffer 
-     * that may be written to. 
-     **/ 
- 
-    const_iterator begin() const { 
-        return const_iterator(pimpl_->beginWrite()); 
-    } 
- 
-    /** 
-     * Return the end iterator for writing. 
-     **/ 
- 
-    const_iterator end() const { 
-        return const_iterator(pimpl_->endWrite()); 
-    } 
- 
-    /** 
-     * Discard any data in this buffer. 
-     **/ 
- 
-    void discardData() 
-    { 
-        pimpl_->discardData(); 
-    } 
- 
-    /** 
-     * Discard the specified number of bytes from this data, starting at the beginning. 
-     * Throws if the size is greater than the number of bytes. 
-     **/ 
- 
-    void discardData(size_t bytes) 
-    { 
-        if(bytes > 0) { 
-            if(bytes < pimpl_->size()) { 
-                pimpl_->discardData(bytes); 
-            } 
-            else if(bytes == pimpl_->size()) { 
-                pimpl_->discardData(); 
-            } 
-            else { 
-                throw std::out_of_range("trying to discard more data than exists"); 
-            } 
-        } 
-    } 
- 
-    /** 
-     * Remove bytes from this buffer, starting from the beginning, and place 
-     * them into a new buffer.  Throws if the number of requested bytes exceeds 
-     * the size of the buffer.  Data and freeSpace in the buffer after bytes 
-     * remains in this buffer. 
-     **/ 
- 
-    InputBuffer extractData(size_type bytes); 
- 
-    /** 
-     * Remove all bytes from this buffer, returning them in a new buffer. 
-     * After removing data, some freeSpace may remain in this buffer. 
-     **/ 
- 
-    InputBuffer extractData(); 
- 
-    /** 
-     * Clone this buffer, creating a copy that contains the same data. 
-     **/ 
- 
-    OutputBuffer clone() const 
-    { 
-        detail::BufferImpl::SharedPtr newImpl(new detail::BufferImpl(*pimpl_)); 
-        return OutputBuffer(newImpl); 
-    } 
- 
-    /** 
-     * Add unmanaged data to the buffer.  The buffer will not automatically 
-     * free the data, but it will call the supplied function when the data is 
-     * no longer referenced by the buffer (or copies of the buffer). 
-     **/ 
- 
-    void appendForeignData(const data_type *data, size_type size, const detail::free_func &func) { 
-        pimpl_->appendForeignData(data, size, func); 
-    } 
- 
-    /** 
-     * Returns the number of chunks that contain free space. 
-     **/ 
- 
-    int numChunks() const { 
-        return  pimpl_->numFreeChunks(); 
-    } 
- 
-    /** 
-     * Returns the number of chunks that contain data 
-     **/ 
- 
-    int numDataChunks() const { 
-        return  pimpl_->numDataChunks(); 
-    } 
- 
-  private: 
- 
-    friend class InputBuffer; 
-    friend class BufferReader; 
- 
-    explicit OutputBuffer(const detail::BufferImpl::SharedPtr &pimpl) : 
-        pimpl_(pimpl) 
-    { } 
- 
-    detail::BufferImpl::SharedPtr pimpl_; ///< Must never be null. 
-}; 
- 
-/** 
- * The InputBuffer (read-only buffer) 
- * 
- * InputBuffer is an immutable buffer which that may be constructed from an 
- * OutputBuffer, or several of OutputBuffer's methods.  Once the data is 
- * transfered to an InputBuffer it cannot be modified, only read (via 
- * BufferReader, istream, or its iterator). 
- * 
- * Assignments and copies are shallow copies. 
- * 
- * -# ASIO access: - iterate using const_iterator for sending messages 
- * 
- **/ 
- 
-class AVRO_DECL InputBuffer 
-{ 
- 
-  public: 
- 
-    typedef detail::size_type size_type; 
-    typedef detail::data_type data_type; 
- 
-    // needed for asio 
-    typedef detail::InputBufferIterator const_iterator; 
- 
-    /** 
-     * Default InputBuffer creates an empty buffer. 
-     * 
-     * Copy/assignment functions use the default ones.  They will do a shallow 
-     * copy, and because InputBuffer is immutable, the copies will be 
-     * identical. 
-     * 
-     * Destructor also uses the default, which resets a shared pointer, 
-     * deleting the underlying data if no other copies of exist. 
-     **/ 
- 
-    InputBuffer() : 
-        pimpl_(new detail::BufferImpl) 
-    { } 
- 
-    /** 
-     * Construct an InputBuffer that contains the contents of an OutputBuffer. 
-     * The two buffers will have the same contents, but this copy will be 
-     * immutable, while the the OutputBuffer may still be written to. 
-     * 
-     * If you wish to move the data from the OutputBuffer to a new InputBuffer 
-     * (leaving only free space in the OutputBuffer), 
-     * OutputBuffer::extractData() will do this more efficiently. 
-     * 
-     * Implicit conversion is allowed. 
-     **/ 
- 
-    InputBuffer(const OutputBuffer &src) : 
-        pimpl_(new detail::BufferImpl(*src.pimpl_)) 
-    { } 
- 
-    /** 
-     * Does the buffer have any data? 
-     **/ 
- 
-    bool empty() const { 
-        return (pimpl_->size() == 0); 
-    } 
- 
-    /** 
-     * Returns the size of the buffer, in bytes. 
-     **/ 
- 
-    size_type size() const { 
-        return pimpl_->size(); 
-    } 
- 
-    /** 
-     * Return an iterator pointing to the first data chunk of this buffer 
-     * that contains data. 
-     **/ 
- 
-    const_iterator begin() const { 
-        return const_iterator(pimpl_->beginRead()); 
-    } 
- 
-    /** 
-     * Return the end iterator. 
-     **/ 
- 
-    const_iterator end() const { 
-        return const_iterator(pimpl_->endRead()); 
-    } 
- 
-    /** 
-     * Returns the number of chunks containing data. 
-     **/ 
- 
-    int numChunks() const { 
-        return pimpl_->numDataChunks(); 
-    } 
- 
- 
-  private: 
- 
-    friend class OutputBuffer; // for append function 
-    friend class istreambuf; 
-    friend class BufferReader; 
- 
-    explicit InputBuffer(const detail::BufferImpl::SharedPtr &pimpl) : 
-        pimpl_(pimpl) 
-    { } 
- 
-    /** 
-     * Class to indicate that a copy of a OutputBuffer to InputBuffer should be 
-     * a shallow copy, used to enable reading of the contents of an 
-     * OutputBuffer without need to convert it to InputBuffer using a deep 
-     * copy.  It is private and only used by BufferReader and istreambuf 
-     * classes. 
-     * 
-     * Writing to an OutputBuffer while it is being read may lead to undefined 
-     * behavior. 
-     **/ 
- 
-    class ShallowCopy {}; 
- 
-    /** 
-     * Make a shallow copy of an OutputBuffer in order to read it without 
-     * causing conversion overhead. 
-     **/ 
-    InputBuffer(const OutputBuffer &src, const ShallowCopy &) : 
-        pimpl_(src.pimpl_) 
-    { } 
- 
-    /** 
-     * Make a shallow copy of an InputBuffer.  The default copy constructor 
-     * already provides shallow copy, this is just provided for generic 
-     * algorithms that wish to treat InputBuffer and OutputBuffer in the same 
-     * manner. 
-     **/ 
- 
-     InputBuffer(const InputBuffer &src, const ShallowCopy &) : 
-        pimpl_(src.pimpl_) 
-    { } 
- 
- 
-    detail::BufferImpl::ConstSharedPtr pimpl_; ///< Must never be null. 
-}; 
- 
- 
-/* 
- * Implementations of some OutputBuffer functions are inlined here 
- * because InputBuffer definition was required before. 
- */ 
- 
-inline InputBuffer OutputBuffer::extractData() 
-{ 
-    detail::BufferImpl::SharedPtr newImpl(new detail::BufferImpl); 
-    if(pimpl_->size()) { 
-        pimpl_->extractData(*newImpl); 
-    } 
-    return InputBuffer(newImpl); 
-} 
- 
-inline InputBuffer OutputBuffer::extractData(size_type bytes) 
-{ 
-    if(bytes > pimpl_->size()) { 
-        throw std::out_of_range("trying to extract more data than exists"); 
-    } 
- 
-    detail::BufferImpl::SharedPtr newImpl(new detail::BufferImpl); 
-    if(bytes > 0) { 
-        if(bytes < pimpl_->size()) { 
-            pimpl_->extractData(*newImpl, bytes); 
-        } 
-        else { 
-            pimpl_->extractData(*newImpl); 
-        } 
-    } 
- 
-    return InputBuffer(newImpl); 
-} 
- 
-#ifndef _WIN32 
-/** 
- * Create an array of iovec structures from the buffer.  This utility is used 
- * to support writev and readv function calls.  The caller should ensure the 
- * buffer object is not deleted while using the iovec vector. 
- * 
- * If the BufferType is an InputBuffer, the iovec will point to the data that 
- * already exists in the buffer, for reading. 
- * 
- * If the BufferType is an OutputBuffer, the iovec will point to the free 
- * space, which may be written to.  Before writing, the caller should call 
- * OutputBuffer::reserve() to create enough room for the desired write (which 
- * can be verified by calling OutputBuffer::freeSpace()), and after writing, 
- * they MUST call OutputBuffer::wroteTo(), otherwise the buffer will not know 
- * the space is not free anymore. 
- * 
- **/ 
- 
-template<class BufferType> 
-inline void toIovec(BufferType &buf, std::vector<struct iovec> &iov) 
-{ 
-    const int chunks = buf.numChunks(); 
-    iov.resize(chunks); 
-    typename BufferType::const_iterator iter = buf.begin(); 
-    for (int i = 0; i < chunks; ++i) { 
-        iov[i].iov_base = const_cast<typename BufferType::data_type *>(iter->data()); 
-        iov[i].iov_len = iter->size(); 
-        ++iter; 
-    } 
-} 
-#endif 
- 
-} // namespace 
- 
-#endif 
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef avro_Buffer_hh__
+#define avro_Buffer_hh__
+
+#ifndef _WIN32
+#include <sys/uio.h>
+#endif
+#include <vector>
+
+#include "../Config.hh"
+#include "detail/BufferDetail.hh"
+#include "detail/BufferDetailIterator.hh"
+
+/**
+ * \file Buffer.hh
+ *
+ * \brief Definitions for InputBuffer and OutputBuffer classes
+ *
+ **/
+
+namespace avro {
+
+class OutputBuffer;
+class InputBuffer;
+
+
+/**
+ * The OutputBuffer (write-only buffer)
+ *
+ * Use cases for OutputBuffer
+ *
+ * - write message to buffer using ostream class or directly
+ * - append messages to headers
+ * - building up streams of messages via append
+ * - converting to read-only buffers for sending
+ * - extracting parts of the messages into read-only buffers
+ *
+ * -# ASIO access:
+ *     - write to a buffer(s) by asio using iterator
+ *     - convert to read buffer for deserializing
+ *
+ * OutputBuffer is assignable and copy-constructable.  On copy or assignment,
+ * only a pointer is copied, so the two resulting copies are identical, so
+ * modifying one will modify both.
+ **/
+
+class AVRO_DECL OutputBuffer
+{
+
+  public:
+
+    typedef detail::size_type size_type;
+    typedef detail::data_type data_type;
+
+    /**
+     * The asio library expects a const_iterator (the const-ness refers to the
+     * fact that the underlying avro of buffers will not be modified, even
+     * though the data in those buffers is being modified).  The iterator
+     * provides the list of addresses an operation can write to.
+     **/
+
+    typedef detail::OutputBufferIterator const_iterator;
+
+    /**
+     * Default constructor.  Will pre-allocate at least the requested size, but
+     * can grow larger on demand.
+     *
+     * Destructor uses the default, which resets a shared pointer, deleting the
+     * underlying data if no other copies of exist.
+     *
+     * Copy and assignment operators are not explicitly provided because the
+     * default ones work fine.  The default makes only a shallow copy, so the
+     * copies will refer to the same memory.  This is required by asio
+     * functions, which will implicitly make copies for asynchronous
+     * operations.  Therefore, the user must be careful that if they create
+     * multiple copies of the same OutputBuffer, only one is being modified
+     * otherwise undefined behavior may occur.
+     *
+     **/
+
+    OutputBuffer(size_type reserveSize = 0) :
+        pimpl_(new detail::BufferImpl)
+    {
+        if(reserveSize) {
+            reserve(reserveSize);
+        }
+    }
+
+    /**
+     * Reserve enough space for a wroteTo() operation.  When using writeTo(),
+     * the buffer will grow dynamically as needed.  But when using the iterator
+     * to write (followed by wroteTo()), data may only be written to the space
+     * available,  so this ensures there is enough room in the buffer before
+     * the write operation.
+     **/
+
+    void reserve(size_type reserveSize)
+    {
+        pimpl_->reserveFreeSpace(reserveSize);
+    }
+
+    /**
+     * Write a block of data to the buffer.  The buffer size will automatically
+     * grow if the size is larger than what is currently free.
+     **/
+
+    size_type writeTo(const data_type *data, size_type size) {
+        return pimpl_->writeTo(data, size);
+    }
+
+    /**
+     * Write a single value to the buffer. The buffer size will automatically
+     * grow if there is not room for the byte.  The value must be a
+     * "fundamental" type, e.g. int, float, etc.  (otherwise use the other
+     * writeTo tests).
+     **/
+
+    template<typename T>
+    void writeTo(T val) {
+        pimpl_->writeTo(val, std::is_fundamental<T>());
+    }
+
+    /**
+     * Update the state of the buffer after writing through the iterator
+     * interface.  This function exists primarily for the boost:asio which
+     * writes directly to the buffer using its iterator.  In this case, the
+     * internal state of the buffer does not reflect that the data was written
+     * This informs the buffer how much data was written.
+     *
+     * The buffer does not automatically resize in this case, the bytes written
+     * cannot exceed the amount of free space.  Attempting to write more will
+     * throw a std::length_error exception.
+     **/
+
+    size_type wroteTo(size_type size)
+    {
+        int wrote = 0;
+        if(size) {
+            if(size > freeSpace()) {
+                throw std::length_error("Impossible to write more data than free space");
+            }
+            wrote = pimpl_->wroteTo(size);
+        }
+        return wrote;
+    }
+
+    /**
+     * Does the buffer have any data?
+     **/
+
+    bool empty() const {
+        return  (pimpl_->size()==0);
+    }
+
+    /**
+     *  Returns the size of the buffer, in bytes.
+     */
+
+    size_type size() const {
+        return  pimpl_->size();
+    }
+
+    /**
+     * Returns the current free space that is available to write to in the
+     * buffer, in bytes.  This is not a strict limit in size, as writeTo() can
+     * automatically increase capacity if necessary.
+     **/
+
+    size_type freeSpace() const {
+        return  pimpl_->freeSpace();
+    }
+
+    /**
+     * Appends the data in the argument to the end of this buffer.  The
+     * argument can be either an InputBuffer or OutputBuffer.
+     *
+     **/
+
+    template <class BufferType>
+    void append(const BufferType &buf) {
+        // don't append an empty buffer
+        if(buf.size()) {
+            pimpl_->append(*(buf.pimpl_.get()));
+        }
+    }
+
+    /**
+     * Return an iterator pointing to the first data chunk of this buffer
+     * that may be written to.
+     **/
+
+    const_iterator begin() const {
+        return const_iterator(pimpl_->beginWrite());
+    }
+
+    /**
+     * Return the end iterator for writing.
+     **/
+
+    const_iterator end() const {
+        return const_iterator(pimpl_->endWrite());
+    }
+
+    /**
+     * Discard any data in this buffer.
+     **/
+
+    void discardData()
+    {
+        pimpl_->discardData();
+    }
+
+    /**
+     * Discard the specified number of bytes from this data, starting at the beginning.
+     * Throws if the size is greater than the number of bytes.
+     **/
+
+    void discardData(size_t bytes)
+    {
+        if(bytes > 0) {
+            if(bytes < pimpl_->size()) {
+                pimpl_->discardData(bytes);
+            }
+            else if(bytes == pimpl_->size()) {
+                pimpl_->discardData();
+            }
+            else {
+                throw std::out_of_range("trying to discard more data than exists");
+            }
+        }
+    }
+
+    /**
+     * Remove bytes from this buffer, starting from the beginning, and place
+     * them into a new buffer.  Throws if the number of requested bytes exceeds
+     * the size of the buffer.  Data and freeSpace in the buffer after bytes
+     * remains in this buffer.
+     **/
+
+    InputBuffer extractData(size_type bytes);
+
+    /**
+     * Remove all bytes from this buffer, returning them in a new buffer.
+     * After removing data, some freeSpace may remain in this buffer.
+     **/
+
+    InputBuffer extractData();
+
+    /**
+     * Clone this buffer, creating a copy that contains the same data.
+     **/
+
+    OutputBuffer clone() const
+    {
+        detail::BufferImpl::SharedPtr newImpl(new detail::BufferImpl(*pimpl_));
+        return OutputBuffer(newImpl);
+    }
+
+    /**
+     * Add unmanaged data to the buffer.  The buffer will not automatically
+     * free the data, but it will call the supplied function when the data is
+     * no longer referenced by the buffer (or copies of the buffer).
+     **/
+
+    void appendForeignData(const data_type *data, size_type size, const detail::free_func &func) {
+        pimpl_->appendForeignData(data, size, func);
+    }
+
+    /**
+     * Returns the number of chunks that contain free space.
+     **/
+
+    int numChunks() const {
+        return  pimpl_->numFreeChunks();
+    }
+
+    /**
+     * Returns the number of chunks that contain data
+     **/
+
+    int numDataChunks() const {
+        return  pimpl_->numDataChunks();
+    }
+
+  private:
+
+    friend class InputBuffer;
+    friend class BufferReader;
+
+    explicit OutputBuffer(const detail::BufferImpl::SharedPtr &pimpl) :
+        pimpl_(pimpl)
+    { }
+
+    detail::BufferImpl::SharedPtr pimpl_; ///< Must never be null.
+};
+
+/**
+ * The InputBuffer (read-only buffer)
+ *
+ * InputBuffer is an immutable buffer which that may be constructed from an
+ * OutputBuffer, or several of OutputBuffer's methods.  Once the data is
+ * transfered to an InputBuffer it cannot be modified, only read (via
+ * BufferReader, istream, or its iterator).
+ *
+ * Assignments and copies are shallow copies.
+ *
+ * -# ASIO access: - iterate using const_iterator for sending messages
+ *
+ **/
+
+class AVRO_DECL InputBuffer
+{
+
+  public:
+
+    typedef detail::size_type size_type;
+    typedef detail::data_type data_type;
+
+    // needed for asio
+    typedef detail::InputBufferIterator const_iterator;
+
+    /**
+     * Default InputBuffer creates an empty buffer.
+     *
+     * Copy/assignment functions use the default ones.  They will do a shallow
+     * copy, and because InputBuffer is immutable, the copies will be
+     * identical.
+     *
+     * Destructor also uses the default, which resets a shared pointer,
+     * deleting the underlying data if no other copies of exist.
+     **/
+
+    InputBuffer() :
+        pimpl_(new detail::BufferImpl)
+    { }
+
+    /**
+     * Construct an InputBuffer that contains the contents of an OutputBuffer.
+     * The two buffers will have the same contents, but this copy will be
+     * immutable, while the the OutputBuffer may still be written to.
+     *
+     * If you wish to move the data from the OutputBuffer to a new InputBuffer
+     * (leaving only free space in the OutputBuffer),
+     * OutputBuffer::extractData() will do this more efficiently.
+     *
+     * Implicit conversion is allowed.
+     **/
+
+    InputBuffer(const OutputBuffer &src) :
+        pimpl_(new detail::BufferImpl(*src.pimpl_))
+    { }
+
+    /**
+     * Does the buffer have any data?
+     **/
+
+    bool empty() const {
+        return (pimpl_->size() == 0);
+    }
+
+    /**
+     * Returns the size of the buffer, in bytes.
+     **/
+
+    size_type size() const {
+        return pimpl_->size();
+    }
+
+    /**
+     * Return an iterator pointing to the first data chunk of this buffer
+     * that contains data.
+     **/
+
+    const_iterator begin() const {
+        return const_iterator(pimpl_->beginRead());
+    }
+
+    /**
+     * Return the end iterator.
+     **/
+
+    const_iterator end() const {
+        return const_iterator(pimpl_->endRead());
+    }
+
+    /**
+     * Returns the number of chunks containing data.
+     **/
+
+    int numChunks() const {
+        return pimpl_->numDataChunks();
+    }
+
+
+  private:
+
+    friend class OutputBuffer; // for append function
+    friend class istreambuf;
+    friend class BufferReader;
+
+    explicit InputBuffer(const detail::BufferImpl::SharedPtr &pimpl) :
+        pimpl_(pimpl)
+    { }
+
+    /**
+     * Class to indicate that a copy of a OutputBuffer to InputBuffer should be
+     * a shallow copy, used to enable reading of the contents of an
+     * OutputBuffer without need to convert it to InputBuffer using a deep
+     * copy.  It is private and only used by BufferReader and istreambuf
+     * classes.
+     *
+     * Writing to an OutputBuffer while it is being read may lead to undefined
+     * behavior.
+     **/
+
+    class ShallowCopy {};
+
+    /**
+     * Make a shallow copy of an OutputBuffer in order to read it without
+     * causing conversion overhead.
+     **/
+    InputBuffer(const OutputBuffer &src, const ShallowCopy &) :
+        pimpl_(src.pimpl_)
+    { }
+
+    /**
+     * Make a shallow copy of an InputBuffer.  The default copy constructor
+     * already provides shallow copy, this is just provided for generic
+     * algorithms that wish to treat InputBuffer and OutputBuffer in the same
+     * manner.
+     **/
+
+     InputBuffer(const InputBuffer &src, const ShallowCopy &) :
+        pimpl_(src.pimpl_)
+    { }
+
+
+    detail::BufferImpl::ConstSharedPtr pimpl_; ///< Must never be null.
+};
+
+
+/*
+ * Implementations of some OutputBuffer functions are inlined here
+ * because InputBuffer definition was required before.
+ */
+
+inline InputBuffer OutputBuffer::extractData()
+{
+    detail::BufferImpl::SharedPtr newImpl(new detail::BufferImpl);
+    if(pimpl_->size()) {
+        pimpl_->extractData(*newImpl);
+    }
+    return InputBuffer(newImpl);
+}
+
+inline InputBuffer OutputBuffer::extractData(size_type bytes)
+{
+    if(bytes > pimpl_->size()) {
+        throw std::out_of_range("trying to extract more data than exists");
+    }
+
+    detail::BufferImpl::SharedPtr newImpl(new detail::BufferImpl);
+    if(bytes > 0) {
+        if(bytes < pimpl_->size()) {
+            pimpl_->extractData(*newImpl, bytes);
+        }
+        else {
+            pimpl_->extractData(*newImpl);
+        }
+    }
+
+    return InputBuffer(newImpl);
+}
+
+#ifndef _WIN32
+/**
+ * Create an array of iovec structures from the buffer.  This utility is used
+ * to support writev and readv function calls.  The caller should ensure the
+ * buffer object is not deleted while using the iovec vector.
+ *
+ * If the BufferType is an InputBuffer, the iovec will point to the data that
+ * already exists in the buffer, for reading.
+ *
+ * If the BufferType is an OutputBuffer, the iovec will point to the free
+ * space, which may be written to.  Before writing, the caller should call
+ * OutputBuffer::reserve() to create enough room for the desired write (which
+ * can be verified by calling OutputBuffer::freeSpace()), and after writing,
+ * they MUST call OutputBuffer::wroteTo(), otherwise the buffer will not know
+ * the space is not free anymore.
+ *
+ **/
+
+template<class BufferType>
+inline void toIovec(BufferType &buf, std::vector<struct iovec> &iov)
+{
+    const int chunks = buf.numChunks();
+    iov.resize(chunks);
+    typename BufferType::const_iterator iter = buf.begin();
+    for (int i = 0; i < chunks; ++i) {
+        iov[i].iov_base = const_cast<typename BufferType::data_type *>(iter->data());
+        iov[i].iov_len = iter->size();
+        ++iter;
+    }
+}
+#endif
+
+} // namespace
+
+#endif
diff --git a/contrib/libs/apache/avro/api/buffer/BufferReader.hh b/contrib/libs/apache/avro/api/buffer/BufferReader.hh
index cc1b05880b..83b6b4b324 100644
--- a/contrib/libs/apache/avro/api/buffer/BufferReader.hh
+++ b/contrib/libs/apache/avro/api/buffer/BufferReader.hh
@@ -1,289 +1,289 @@
-/* 
- * Licensed to the Apache Software Foundation (ASF) under one 
- * or more contributor license agreements.  See the NOTICE file 
- * distributed with this work for additional information 
- * regarding copyright ownership.  The ASF licenses this file 
- * to you under the Apache License, Version 2.0 (the 
- * "License"); you may not use this file except in compliance 
- * with the License.  You may obtain a copy of the License at 
- * 
- *     https://www.apache.org/licenses/LICENSE-2.0 
- * 
- * Unless required by applicable law or agreed to in writing, software 
- * distributed under the License is distributed on an "AS IS" BASIS, 
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
- * See the License for the specific language governing permissions and 
- * limitations under the License. 
- */ 
- 
-#ifndef avro_BufferReader_hh__ 
-#define avro_BufferReader_hh__ 
- 
-#include <type_traits> 
-#include "Buffer.hh" 
- 
-#ifdef min 
-#undef min 
-#endif 
-/** 
- * \file BufferReader.hh 
- * 
- * \brief Helper class for reading bytes from buffer in a streaming manner, 
- * without the overhead of istreams. 
- * 
- **/ 
- 
-namespace avro { 
- 
-/** 
- * Helper class for reading bytes from buffer without worrying about 
- * chunk boundaries.  May read from an InputBuffer or OutputBuffer. 
- * 
- **/ 
-class AVRO_DECL BufferReader : private boost::noncopyable 
-{ 
- 
-  public: 
- 
-    typedef detail::data_type data_type; 
-    typedef detail::size_type size_type; 
- 
-  private: 
- 
-    size_type chunkRemaining() const { 
-        return iter_->dataSize() - chunkPos_; 
-    } 
- 
-    void incrementChunk(size_type howmuch) { 
-        bytesRemaining_ -= howmuch; 
-        chunkPos_ += howmuch; 
-        if(chunkPos_ == iter_->dataSize()) { 
-            chunkPos_ = 0; 
-            ++iter_; 
-        } 
-    } 
- 
-    void rewind() { 
-        iter_ = bufferImpl_->beginRead(); 
-        bytesRemaining_ = bytes_; 
-        chunkPos_ = 0; 
-    } 
- 
-    const data_type *addr() const { 
-        return iter_->tellReadPos() + chunkPos_; 
-    } 
- 
-  public: 
- 
-    BufferReader(const InputBuffer &buf) : 
-        bufferImpl_(buf.pimpl_), 
-        iter_(bufferImpl_->beginRead()), 
-        bytes_(bufferImpl_->size()), 
-        bytesRemaining_(bytes_), 
-        chunkPos_(0) 
-    { } 
- 
-    BufferReader(const OutputBuffer &buf) : 
-        bufferImpl_(buf.pimpl_), 
-        iter_(bufferImpl_->beginRead()), 
-        bytes_(bufferImpl_->size()), 
-        bytesRemaining_(bytes_), 
-        chunkPos_(0) 
-    { } 
- 
-    /** 
-     * How many bytes are still not read from this buffer. 
-     **/ 
- 
-    size_type bytesRemaining() const { 
-        return bytesRemaining_; 
-    } 
- 
-    /** 
-     * Read a block of data from the front of the buffer. 
-     **/ 
- 
-    size_type bytesRead() const { 
-        return bytes_ - bytesRemaining_; 
-    } 
- 
-    /** 
-     * Read a block of data from the buffer. 
-     **/ 
- 
-    size_type read(data_type *data, size_type size) { 
- 
-        if(size > bytesRemaining_) { 
-            size = bytesRemaining_; 
-        } 
-        size_type sizeToRead = size; 
- 
-        while(sizeToRead) { 
-            const size_type toRead = std::min(sizeToRead, chunkRemaining()); 
-            memcpy(data, addr(), toRead); 
-            sizeToRead -= toRead; 
-            data += toRead; 
-            incrementChunk(toRead); 
-        } 
- 
-        return size; 
-    } 
- 
-    /** 
-     * Read a block of data from the buffer. 
-     **/ 
- 
-    bool read(std::string &str, size_type size) { 
-        if(size > bytesRemaining_) { 
-            return false; 
-        } 
- 
-        if(size <= chunkRemaining()) { 
-            fastStringRead(str, size); 
-        } 
-        else { 
-            slowStringRead(str, size); 
-        } 
- 
-        return true; 
-    } 
- 
- 
-    /** 
-     * Read a single value from the buffer.  The value must be a "fundamental" 
-     * type, e.g. int, float, etc.  (otherwise use the other writeTo tests). 
-     * 
-     **/ 
- 
-    template<typename T> 
-    bool read(T &val)  { 
-        return read(val, std::is_fundamental<T>()); 
-    } 
- 
-    /** 
-     * Skips a block of data from the buffer. 
-     **/ 
- 
-    bool skip(size_type bytes) { 
-        bool skipped = false; 
-        if(bytes <= bytesRemaining_) { 
-            doSkip(bytes); 
-            skipped = true; 
-        } 
-        return skipped; 
-    } 
- 
-    /** 
-     * Seek to a position in the buffer. 
-     **/ 
- 
-    bool seek(size_type pos) { 
-        if(pos > bytes_) { 
-            return false; 
-        } 
- 
-        size_type toSkip = pos; 
-        size_type curPos = bytesRead(); 
-        // if the seek position is ahead, we can use skip to get there 
-        if(pos >= curPos) { 
-            toSkip -= curPos; 
-        } 
-        // if the seek position is ahead of the start of the chunk we can back up to 
-        // start of the chunk 
-        else if(pos >= (curPos - chunkPos_)) { 
-            curPos -= chunkPos_; 
-            bytesRemaining_ += chunkPos_; 
-            chunkPos_ = 0; 
-            toSkip -= curPos; 
-        } 
-        else { 
-            rewind(); 
-        } 
-        doSkip(toSkip); 
-        return true; 
-    } 
- 
-    bool peek(char &val) { 
-        bool ret = (bytesRemaining_ > 0); 
-        if(ret) { 
-            val = *(addr()); 
-        } 
-        return ret; 
-    } 
- 
-    InputBuffer copyData(size_type bytes) { 
-        if(bytes > bytesRemaining_) { 
-            // force no copy 
-            bytes = 0; 
-        } 
-        detail::BufferImpl::SharedPtr newImpl(new detail::BufferImpl); 
-        if(bytes) { 
-            bufferImpl_->copyData(*newImpl, iter_, chunkPos_, bytes); 
-            doSkip(bytes); 
-        } 
-        return InputBuffer(newImpl); 
-    } 
- 
-  private: 
- 
-    void doSkip(size_type sizeToSkip) { 
- 
-        while(sizeToSkip) { 
-            const size_type toSkip = std::min(sizeToSkip, chunkRemaining()); 
-            sizeToSkip -= toSkip; 
-            incrementChunk(toSkip); 
-        } 
-    } 
- 
-    template<typename T> 
-    bool read(T &val, const std::true_type&) 
-    { 
-        if(sizeof(T) > bytesRemaining_) { 
-            return false; 
-        } 
- 
-        if (sizeof(T) <= chunkRemaining()) { 
-            val = *(reinterpret_cast<const T*> (addr())); 
-            incrementChunk(sizeof(T)); 
-        } 
-        else { 
-            read(reinterpret_cast<data_type *>(&val), sizeof(T)); 
-        } 
-        return true; 
-    } 
- 
-    /// An uninstantiable function, that is if boost::is_fundamental check fails 
-    template<typename T> 
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef avro_BufferReader_hh__
+#define avro_BufferReader_hh__
+
+#include <type_traits>
+#include "Buffer.hh"
+
+#ifdef min
+#undef min
+#endif
+/**
+ * \file BufferReader.hh
+ *
+ * \brief Helper class for reading bytes from buffer in a streaming manner,
+ * without the overhead of istreams.
+ *
+ **/
+
+namespace avro {
+
+/**
+ * Helper class for reading bytes from buffer without worrying about
+ * chunk boundaries.  May read from an InputBuffer or OutputBuffer.
+ *
+ **/
+class AVRO_DECL BufferReader : private boost::noncopyable
+{
+
+  public:
+
+    typedef detail::data_type data_type;
+    typedef detail::size_type size_type;
+
+  private:
+
+    size_type chunkRemaining() const {
+        return iter_->dataSize() - chunkPos_;
+    }
+
+    void incrementChunk(size_type howmuch) {
+        bytesRemaining_ -= howmuch;
+        chunkPos_ += howmuch;
+        if(chunkPos_ == iter_->dataSize()) {
+            chunkPos_ = 0;
+            ++iter_;
+        }
+    }
+
+    void rewind() {
+        iter_ = bufferImpl_->beginRead();
+        bytesRemaining_ = bytes_;
+        chunkPos_ = 0;
+    }
+
+    const data_type *addr() const {
+        return iter_->tellReadPos() + chunkPos_;
+    }
+
+  public:
+
+    BufferReader(const InputBuffer &buf) :
+        bufferImpl_(buf.pimpl_),
+        iter_(bufferImpl_->beginRead()),
+        bytes_(bufferImpl_->size()),
+        bytesRemaining_(bytes_),
+        chunkPos_(0)
+    { }
+
+    BufferReader(const OutputBuffer &buf) :
+        bufferImpl_(buf.pimpl_),
+        iter_(bufferImpl_->beginRead()),
+        bytes_(bufferImpl_->size()),
+        bytesRemaining_(bytes_),
+        chunkPos_(0)
+    { }
+
+    /**
+     * How many bytes are still not read from this buffer.
+     **/
+
+    size_type bytesRemaining() const {
+        return bytesRemaining_;
+    }
+
+    /**
+     * Read a block of data from the front of the buffer.
+     **/
+
+    size_type bytesRead() const {
+        return bytes_ - bytesRemaining_;
+    }
+
+    /**
+     * Read a block of data from the buffer.
+     **/
+
+    size_type read(data_type *data, size_type size) {
+
+        if(size > bytesRemaining_) {
+            size = bytesRemaining_;
+        }
+        size_type sizeToRead = size;
+
+        while(sizeToRead) {
+            const size_type toRead = std::min(sizeToRead, chunkRemaining());
+            memcpy(data, addr(), toRead);
+            sizeToRead -= toRead;
+            data += toRead;
+            incrementChunk(toRead);
+        }
+
+        return size;
+    }
+
+    /**
+     * Read a block of data from the buffer.
+     **/
+
+    bool read(std::string &str, size_type size) {
+        if(size > bytesRemaining_) {
+            return false;
+        }
+
+        if(size <= chunkRemaining()) {
+            fastStringRead(str, size);
+        }
+        else {
+            slowStringRead(str, size);
+        }
+
+        return true;
+    }
+
+
+    /**
+     * Read a single value from the buffer.  The value must be a "fundamental"
+     * type, e.g. int, float, etc.  (otherwise use the other writeTo tests).
+     *
+     **/
+
+    template<typename T>
+    bool read(T &val)  {
+        return read(val, std::is_fundamental<T>());
+    }
+
+    /**
+     * Skips a block of data from the buffer.
+     **/
+
+    bool skip(size_type bytes) {
+        bool skipped = false;
+        if(bytes <= bytesRemaining_) {
+            doSkip(bytes);
+            skipped = true;
+        }
+        return skipped;
+    }
+
+    /**
+     * Seek to a position in the buffer.
+     **/
+
+    bool seek(size_type pos) {
+        if(pos > bytes_) {
+            return false;
+        }
+
+        size_type toSkip = pos;
+        size_type curPos = bytesRead();
+        // if the seek position is ahead, we can use skip to get there
+        if(pos >= curPos) {
+            toSkip -= curPos;
+        }
+        // if the seek position is ahead of the start of the chunk we can back up to
+        // start of the chunk
+        else if(pos >= (curPos - chunkPos_)) {
+            curPos -= chunkPos_;
+            bytesRemaining_ += chunkPos_;
+            chunkPos_ = 0;
+            toSkip -= curPos;
+        }
+        else {
+            rewind();
+        }
+        doSkip(toSkip);
+        return true;
+    }
+
+    bool peek(char &val) {
+        bool ret = (bytesRemaining_ > 0);
+        if(ret) {
+            val = *(addr());
+        }
+        return ret;
+    }
+
+    InputBuffer copyData(size_type bytes) {
+        if(bytes > bytesRemaining_) {
+            // force no copy
+            bytes = 0;
+        }
+        detail::BufferImpl::SharedPtr newImpl(new detail::BufferImpl);
+        if(bytes) {
+            bufferImpl_->copyData(*newImpl, iter_, chunkPos_, bytes);
+            doSkip(bytes);
+        }
+        return InputBuffer(newImpl);
+    }
+
+  private:
+
+    void doSkip(size_type sizeToSkip) {
+
+        while(sizeToSkip) {
+            const size_type toSkip = std::min(sizeToSkip, chunkRemaining());
+            sizeToSkip -= toSkip;
+            incrementChunk(toSkip);
+        }
+    }
+
+    template<typename T>
+    bool read(T &val, const std::true_type&)
+    {
+        if(sizeof(T) > bytesRemaining_) {
+            return false;
+        }
+
+        if (sizeof(T) <= chunkRemaining()) {
+            val = *(reinterpret_cast<const T*> (addr()));
+            incrementChunk(sizeof(T));
+        }
+        else {
+            read(reinterpret_cast<data_type *>(&val), sizeof(T));
+        }
+        return true;
+    }
+
+    /// An uninstantiable function, that is if boost::is_fundamental check fails
+    template<typename T>
     bool read(T &, const std::false_type&)
-    { 
-        static_assert(sizeof(T) == 0, "Not a valid type to read"); 
-        return false; 
-    } 
- 
-    void fastStringRead(std::string &str, size_type sizeToCopy) { 
-        str.assign(addr(), sizeToCopy); 
-        incrementChunk(sizeToCopy); 
-    } 
- 
-    void slowStringRead(std::string &str, size_type sizeToCopy) { 
-        str.clear(); 
-        str.reserve(sizeToCopy); 
-        while(sizeToCopy) { 
-            const size_type toCopy = std::min(sizeToCopy, chunkRemaining()); 
-            str.append(addr(), toCopy); 
-            sizeToCopy -= toCopy; 
-            incrementChunk(toCopy); 
-        } 
-    } 
- 
-    detail::BufferImpl::ConstSharedPtr bufferImpl_; 
-    detail::BufferImpl::ChunkList::const_iterator iter_; 
-    size_type bytes_; 
-    size_type bytesRemaining_; 
-    size_type chunkPos_; 
-}; 
- 
- 
-} // namespace 
- 
-#endif 
+    {
+        static_assert(sizeof(T) == 0, "Not a valid type to read");
+        return false;
+    }
+
+    void fastStringRead(std::string &str, size_type sizeToCopy) {
+        str.assign(addr(), sizeToCopy);
+        incrementChunk(sizeToCopy);
+    }
+
+    void slowStringRead(std::string &str, size_type sizeToCopy) {
+        str.clear();
+        str.reserve(sizeToCopy);
+        while(sizeToCopy) {
+            const size_type toCopy = std::min(sizeToCopy, chunkRemaining());
+            str.append(addr(), toCopy);
+            sizeToCopy -= toCopy;
+            incrementChunk(toCopy);
+        }
+    }
+
+    detail::BufferImpl::ConstSharedPtr bufferImpl_;
+    detail::BufferImpl::ChunkList::const_iterator iter_;
+    size_type bytes_;
+    size_type bytesRemaining_;
+    size_type chunkPos_;
+};
+
+
+} // namespace
+
+#endif
diff --git a/contrib/libs/apache/avro/api/buffer/detail/BufferDetail.hh b/contrib/libs/apache/avro/api/buffer/detail/BufferDetail.hh
index bbc2948f26..29a2e00b4e 100644
--- a/contrib/libs/apache/avro/api/buffer/detail/BufferDetail.hh
+++ b/contrib/libs/apache/avro/api/buffer/detail/BufferDetail.hh
@@ -1,555 +1,555 @@
-/* 
- * Licensed to the Apache Software Foundation (ASF) under one 
- * or more contributor license agreements.  See the NOTICE file 
- * distributed with this work for additional information 
- * regarding copyright ownership.  The ASF licenses this file 
- * to you under the Apache License, Version 2.0 (the 
- * "License"); you may not use this file except in compliance 
- * with the License.  You may obtain a copy of the License at 
- * 
- *     https://www.apache.org/licenses/LICENSE-2.0 
- * 
- * Unless required by applicable law or agreed to in writing, software 
- * distributed under the License is distributed on an "AS IS" BASIS, 
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
- * See the License for the specific language governing permissions and 
- * limitations under the License. 
- */ 
- 
-#ifndef avro_BufferDetail_hh__ 
-#define avro_BufferDetail_hh__ 
- 
-#include <boost/shared_ptr.hpp> 
-#include <boost/shared_array.hpp> 
-#include <boost/static_assert.hpp> 
-#include <boost/function.hpp> 
-#include <boost/utility.hpp> 
-#ifdef HAVE_BOOST_ASIO 
-#include <boost/asio/buffer.hpp> 
-#endif 
-#include <exception> 
-#include <cassert> 
-#include <deque> 
- 
-/** 
- * \file BufferDetail.hh 
- * 
- * \brief The implementation details for the Buffer class. 
- * 
- **/ 
- 
-namespace avro { 
- 
-namespace detail { 
- 
-typedef char    data_type; 
-typedef size_t  size_type; 
-#ifdef HAVE_BOOST_ASIO 
-typedef boost::asio::const_buffer   ConstAsioBuffer; 
-typedef boost::asio::mutable_buffer MutableAsioBuffer; 
-#endif 
- 
-/// The size in bytes for blocks backing buffer chunks. 
-const size_type kMinBlockSize = 4096; 
-const size_type kMaxBlockSize = 16384; 
-const size_type kDefaultBlockSize = kMinBlockSize; 
- 
-typedef boost::function<void(void)>  free_func; 
- 
-/** 
- * Simple class to hold a functor that executes on delete 
- **/ 
-class CallOnDestroy { 
-  public: 
-    CallOnDestroy(const free_func &func) : func_(func) 
-    { } 
-    ~CallOnDestroy() { 
-        if (func_) { 
-            func_(); 
-        } 
-    } 
-  private: 
-    free_func func_; 
-}; 
- 
-/** 
- * \brief A chunk is the building block for buffers. 
- * 
- * A chunk is backed by a memory block, and internally it maintains information 
- * about which area of the block it may use, and the portion of this area that 
- * contains valid data.  More than one chunk may share the same underlying 
- * block, but the areas should never overlap.  Chunk holds a shared pointer to 
- * an array of bytes so that shared blocks are reference counted. 
- * 
- * When a chunk is copied, the copy shares the same underlying buffer, but the 
- * copy receives its own copies of the start/cursor/end pointers, so each copy 
- * can be manipulated independently.  This allows different buffers to share 
- * the same non-overlapping parts of a chunk, or even overlapping parts of a 
- * chunk if the situation arises. 
- * 
- **/ 
- 
-class Chunk 
-{ 
- 
-  public: 
- 
-    typedef boost::shared_ptr<Chunk> SharedPtr; 
- 
-    /// Default constructor, allocates a new underlying block for this chunk. 
-    Chunk(size_type size) : 
-        underlyingBlock_(new data_type[size]), 
-        readPos_(underlyingBlock_.get()), 
-        writePos_(readPos_), 
-        endPos_(readPos_ + size) 
-    { } 
- 
-    /// Foreign buffer constructor, uses the supplied data for this chunk, and 
-    /// only for reading. 
-    Chunk(const data_type *data, size_type size, const free_func &func) : 
-        callOnDestroy_(new CallOnDestroy(func)), 
-        readPos_(const_cast<data_type *>(data)), 
-        writePos_(readPos_ + size), 
-        endPos_(writePos_) 
-    { } 
- 
-  private: 
-    // reference counted object will call a functor when it's destroyed 
-    boost::shared_ptr<CallOnDestroy> callOnDestroy_; 
- 
-  public: 
- 
-    /// Remove readable bytes from the front of the chunk by advancing the 
-    /// chunk start position. 
-    void truncateFront(size_type howMuch) { 
-        readPos_ += howMuch; 
-        assert(readPos_ <= writePos_); 
-    } 
- 
-    /// Remove readable bytes from the back of the chunk by moving the 
-    /// chunk cursor position. 
-    void truncateBack(size_type howMuch) { 
-        writePos_ -= howMuch; 
-        assert(readPos_ <= writePos_); 
-    } 
- 
-    /// Tell the position the next byte may be written to. 
-    data_type *tellWritePos() const { 
-        return writePos_; 
-    } 
- 
-    /// Tell the position of the first byte containing valid data. 
-    const data_type *tellReadPos() const { 
-        return readPos_; 
-    } 
- 
-    /// After a write operation, increment the write position. 
-    void incrementCursor(size_type howMuch) { 
-        writePos_  += howMuch; 
-        assert(writePos_ <= endPos_); 
-    } 
- 
-    /// Tell how many bytes of data were written to this chunk. 
-    size_type dataSize() const { 
-        return (writePos_ - readPos_); 
-    } 
- 
-    /// Tell how many bytes this chunk has available to write to. 
-    size_type freeSize() const { 
-        return (endPos_ - writePos_); 
-    } 
- 
-    /// Tell how many bytes of data this chunk can hold (used and free). 
-    size_type capacity() const { 
-        return (endPos_ - readPos_); 
-    } 
- 
-  private: 
- 
-    friend bool operator==(const Chunk &lhs, const Chunk &rhs); 
-    friend bool operator!=(const Chunk &lhs, const Chunk &rhs); 
- 
-    // more than one buffer can share an underlying block, so use SharedPtr 
-    boost::shared_array<data_type> underlyingBlock_; 
- 
-    data_type *readPos_;  ///< The first readable byte in the block 
-    data_type *writePos_; ///< The end of written data and start of free space 
-    data_type *endPos_;   ///< Marks the end of the usable block area 
-}; 
- 
-/** 
- * Compare underlying buffers and return true if they are equal 
- **/ 
-inline bool operator==(const Chunk &lhs, const Chunk &rhs) { 
-    return lhs.underlyingBlock_ == rhs.underlyingBlock_; 
-} 
- 
-/** 
- * Compare underlying buffers and return true if they are unequal 
- **/ 
-inline bool operator!=(const Chunk &lhs, const Chunk &rhs) { 
-    return lhs.underlyingBlock_ != rhs.underlyingBlock_; 
-} 
- 
- 
-/** 
- * \brief Implementation details for Buffer class 
- * 
- * Internally, BufferImpl keeps two lists of chunks, one list consists entirely of 
- * chunks containing data, and one list which contains chunks with free space. 
- * 
- * 
- */ 
- 
-class BufferImpl : boost::noncopyable 
-{ 
- 
-    /// Add a new chunk to the list of chunks for this buffer, growing the 
-    /// buffer by the default block size. 
-    void allocChunkChecked(size_type size = kDefaultBlockSize) 
-    { 
-        writeChunks_.push_back(Chunk(size)); 
-        freeSpace_ += writeChunks_.back().freeSize(); 
-    } 
- 
-    /// Add a new chunk to the list of chunks for this buffer, growing the 
-    /// buffer by the requested size, but within the range of a minimum and 
-    /// maximum. 
-    void allocChunk(size_type size) 
-    { 
-        if(size < kMinBlockSize) { 
-            size = kMinBlockSize; 
-        } 
-        else if (size > kMaxBlockSize) { 
-            size = kMaxBlockSize; 
-        } 
-        allocChunkChecked(size); 
-    } 
- 
-    /// Update the state of the chunks after a write operation.  This function 
-    /// ensures the chunk states are consistent with the write. 
-    void postWrite(size_type size) 
-    { 
- 
-        // precondition to this function is that the writeChunk_.front() 
-        // contains the data that was just written, so make sure writeChunks_ 
-        // is not empty: 
- 
-        assert(size <= freeSpace_ && !writeChunks_.empty()); 
- 
-        // This is probably the one tricky part of BufferImpl.  The data that 
-        // was written now exists in writeChunks_.front().  Now we must make 
-        // sure that same data exists in readChunks_.back(). 
-        // 
-        // There are two cases: 
-        // 
-        // 1. readChunks_.last() and writeChunk_.front() refer to the same 
-        // underlying block, in which case they both just need their cursor 
-        // updated to reflect the new state. 
-        // 
-        // 2. readChunk_.last() is not the same block as writeChunks_.front(), 
-        // in which case it should be, since the writeChunk.front() contains 
-        // the next bit of data that will be appended to readChunks_, and 
-        // therefore needs to be copied there so we can proceed with updating 
-        // their state. 
-        // 
- 
-        // if readChunks_ is not the same as writeChunks_.front(), make a copy 
-        // of it there 
- 
-        if(readChunks_.empty() || (readChunks_.back() != writeChunks_.front())) { 
-            const Chunk &curChunk = writeChunks_.front(); 
-            readChunks_.push_back(curChunk); 
- 
-            // Any data that existed in the write chunk previously doesn't 
-            // belong to this buffer (otherwise it would have already been 
-            // added to the readChunk_ list).  Here, adjust the start of the 
-            // readChunk to begin after any data already existing in curChunk 
- 
-            readChunks_.back().truncateFront( curChunk.dataSize()); 
-        } 
- 
-        assert(readChunks_.back().freeSize() == writeChunks_.front().freeSize()); 
- 
-        // update the states of both readChunks_ and writeChunks_ to indicate that they are 
-        // holding the new data 
- 
-        readChunks_.back().incrementCursor(size); 
-        writeChunks_.front().incrementCursor(size); 
-        size_ += size; 
-        freeSpace_ -= size; 
- 
-        // if there is no more free space in writeChunks_, the next write cannot use 
-        // it, so dispose of it now 
- 
-        if(writeChunks_.front().freeSize() == 0) { 
-            writeChunks_.pop_front(); 
-        } 
-    } 
- 
-  public: 
- 
-    typedef std::deque<Chunk> ChunkList; 
-    typedef boost::shared_ptr<BufferImpl> SharedPtr; 
-    typedef boost::shared_ptr<const BufferImpl> ConstSharedPtr; 
- 
-    /// Default constructor, creates a buffer without any chunks 
-    BufferImpl() : 
-        freeSpace_(0), 
-        size_(0) 
-    { } 
- 
-    /// Copy constructor, gets a copy of all the chunks with data. 
-    explicit BufferImpl(const BufferImpl &src) : 
-        readChunks_(src.readChunks_), 
-        freeSpace_(0), 
-        size_(src.size_) 
-    { } 
- 
-    /// Amount of data held in this buffer. 
-    size_type size() const { 
-        return size_; 
-    } 
- 
-    /// Capacity that may be written before the buffer must allocate more memory. 
-    size_type freeSpace() const { 
-        return freeSpace_; 
-    } 
- 
-    /// Add enough free chunks to make the reservation size available. 
-    /// Actual amount may be more (rounded up to next chunk). 
-    void reserveFreeSpace(size_type reserveSize) { 
-        while(freeSpace_ < reserveSize) { 
-            allocChunk(reserveSize - freeSpace_); 
-        } 
-    } 
- 
-    /// Return the chunk avro's begin iterator for reading. 
-    ChunkList::const_iterator beginRead() const { 
-        return readChunks_.begin(); 
-    } 
- 
-    /// Return the chunk avro's end iterator for reading. 
-    ChunkList::const_iterator endRead() const { 
-        return readChunks_.end(); 
-    } 
- 
-    /// Return the chunk avro's begin iterator for writing. 
-    ChunkList::const_iterator beginWrite() const { 
-        return writeChunks_.begin(); 
-    } 
- 
-    /// Return the chunk avro's end iterator for writing. 
-    ChunkList::const_iterator endWrite() const { 
-        return writeChunks_.end(); 
-    } 
- 
-    /// Write a single value to buffer, add a new chunk if necessary. 
-    template<typename T> 
-    void writeTo(T val, const std::true_type&) 
-    { 
-        if(freeSpace_ && (sizeof(T) <= writeChunks_.front().freeSize())) { 
-            // fast path, there's enough room in the writeable chunk to just 
-            // straight out copy it 
-            *(reinterpret_cast <T*> ( writeChunks_.front().tellWritePos()) ) = val; 
-            postWrite(sizeof(T)); 
-        } 
-        else { 
-            // need to fixup chunks first, so use the regular memcpy 
-            // writeTo method 
-            writeTo(reinterpret_cast<data_type*>(&val), sizeof(T)); 
-        } 
-    } 
- 
-    /// An uninstantiable function, this is if boost::is_fundamental check fails, 
-    /// and will compile-time assert. 
-    template<typename T> 
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef avro_BufferDetail_hh__
+#define avro_BufferDetail_hh__
+
+#include <boost/shared_ptr.hpp>
+#include <boost/shared_array.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/function.hpp>
+#include <boost/utility.hpp>
+#ifdef HAVE_BOOST_ASIO
+#include <boost/asio/buffer.hpp>
+#endif
+#include <exception>
+#include <cassert>
+#include <deque>
+
+/**
+ * \file BufferDetail.hh
+ *
+ * \brief The implementation details for the Buffer class.
+ *
+ **/
+
+namespace avro {
+
+namespace detail {
+
+typedef char    data_type;
+typedef size_t  size_type;
+#ifdef HAVE_BOOST_ASIO
+typedef boost::asio::const_buffer   ConstAsioBuffer;
+typedef boost::asio::mutable_buffer MutableAsioBuffer;
+#endif
+
+/// The size in bytes for blocks backing buffer chunks.
+const size_type kMinBlockSize = 4096;
+const size_type kMaxBlockSize = 16384;
+const size_type kDefaultBlockSize = kMinBlockSize;
+
+typedef boost::function<void(void)>  free_func;
+
+/**
+ * Simple class to hold a functor that executes on delete
+ **/
+class CallOnDestroy {
+  public:
+    CallOnDestroy(const free_func &func) : func_(func)
+    { }
+    ~CallOnDestroy() {
+        if (func_) {
+            func_();
+        }
+    }
+  private:
+    free_func func_;
+};
+
+/**
+ * \brief A chunk is the building block for buffers.
+ *
+ * A chunk is backed by a memory block, and internally it maintains information
+ * about which area of the block it may use, and the portion of this area that
+ * contains valid data.  More than one chunk may share the same underlying
+ * block, but the areas should never overlap.  Chunk holds a shared pointer to
+ * an array of bytes so that shared blocks are reference counted.
+ *
+ * When a chunk is copied, the copy shares the same underlying buffer, but the
+ * copy receives its own copies of the start/cursor/end pointers, so each copy
+ * can be manipulated independently.  This allows different buffers to share
+ * the same non-overlapping parts of a chunk, or even overlapping parts of a
+ * chunk if the situation arises.
+ *
+ **/
+
+class Chunk
+{
+
+  public:
+
+    typedef boost::shared_ptr<Chunk> SharedPtr;
+
+    /// Default constructor, allocates a new underlying block for this chunk.
+    Chunk(size_type size) :
+        underlyingBlock_(new data_type[size]),
+        readPos_(underlyingBlock_.get()),
+        writePos_(readPos_),
+        endPos_(readPos_ + size)
+    { }
+
+    /// Foreign buffer constructor, uses the supplied data for this chunk, and
+    /// only for reading.
+    Chunk(const data_type *data, size_type size, const free_func &func) :
+        callOnDestroy_(new CallOnDestroy(func)),
+        readPos_(const_cast<data_type *>(data)),
+        writePos_(readPos_ + size),
+        endPos_(writePos_)
+    { }
+
+  private:
+    // reference counted object will call a functor when it's destroyed
+    boost::shared_ptr<CallOnDestroy> callOnDestroy_;
+
+  public:
+
+    /// Remove readable bytes from the front of the chunk by advancing the
+    /// chunk start position.
+    void truncateFront(size_type howMuch) {
+        readPos_ += howMuch;
+        assert(readPos_ <= writePos_);
+    }
+
+    /// Remove readable bytes from the back of the chunk by moving the
+    /// chunk cursor position.
+    void truncateBack(size_type howMuch) {
+        writePos_ -= howMuch;
+        assert(readPos_ <= writePos_);
+    }
+
+    /// Tell the position the next byte may be written to.
+    data_type *tellWritePos() const {
+        return writePos_;
+    }
+
+    /// Tell the position of the first byte containing valid data.
+    const data_type *tellReadPos() const {
+        return readPos_;
+    }
+
+    /// After a write operation, increment the write position.
+    void incrementCursor(size_type howMuch) {
+        writePos_  += howMuch;
+        assert(writePos_ <= endPos_);
+    }
+
+    /// Tell how many bytes of data were written to this chunk.
+    size_type dataSize() const {
+        return (writePos_ - readPos_);
+    }
+
+    /// Tell how many bytes this chunk has available to write to.
+    size_type freeSize() const {
+        return (endPos_ - writePos_);
+    }
+
+    /// Tell how many bytes of data this chunk can hold (used and free).
+    size_type capacity() const {
+        return (endPos_ - readPos_);
+    }
+
+  private:
+
+    friend bool operator==(const Chunk &lhs, const Chunk &rhs);
+    friend bool operator!=(const Chunk &lhs, const Chunk &rhs);
+
+    // more than one buffer can share an underlying block, so use SharedPtr
+    boost::shared_array<data_type> underlyingBlock_;
+
+    data_type *readPos_;  ///< The first readable byte in the block
+    data_type *writePos_; ///< The end of written data and start of free space
+    data_type *endPos_;   ///< Marks the end of the usable block area
+};
+
+/**
+ * Compare underlying buffers and return true if they are equal
+ **/
+inline bool operator==(const Chunk &lhs, const Chunk &rhs) {
+    return lhs.underlyingBlock_ == rhs.underlyingBlock_;
+}
+
+/**
+ * Compare underlying buffers and return true if they are unequal
+ **/
+inline bool operator!=(const Chunk &lhs, const Chunk &rhs) {
+    return lhs.underlyingBlock_ != rhs.underlyingBlock_;
+}
+
+
+/**
+ * \brief Implementation details for Buffer class
+ *
+ * Internally, BufferImpl keeps two lists of chunks, one list consists entirely of
+ * chunks containing data, and one list which contains chunks with free space.
+ *
+ *
+ */
+
+class BufferImpl : boost::noncopyable
+{
+
+    /// Add a new chunk to the list of chunks for this buffer, growing the
+    /// buffer by the default block size.
+    void allocChunkChecked(size_type size = kDefaultBlockSize)
+    {
+        writeChunks_.push_back(Chunk(size));
+        freeSpace_ += writeChunks_.back().freeSize();
+    }
+
+    /// Add a new chunk to the list of chunks for this buffer, growing the
+    /// buffer by the requested size, but within the range of a minimum and
+    /// maximum.
+    void allocChunk(size_type size)
+    {
+        if(size < kMinBlockSize) {
+            size = kMinBlockSize;
+        }
+        else if (size > kMaxBlockSize) {
+            size = kMaxBlockSize;
+        }
+        allocChunkChecked(size);
+    }
+
+    /// Update the state of the chunks after a write operation.  This function
+    /// ensures the chunk states are consistent with the write.
+    void postWrite(size_type size)
+    {
+
+        // precondition to this function is that the writeChunk_.front()
+        // contains the data that was just written, so make sure writeChunks_
+        // is not empty:
+
+        assert(size <= freeSpace_ && !writeChunks_.empty());
+
+        // This is probably the one tricky part of BufferImpl.  The data that
+        // was written now exists in writeChunks_.front().  Now we must make
+        // sure that same data exists in readChunks_.back().
+        //
+        // There are two cases:
+        //
+        // 1. readChunks_.last() and writeChunk_.front() refer to the same
+        // underlying block, in which case they both just need their cursor
+        // updated to reflect the new state.
+        //
+        // 2. readChunk_.last() is not the same block as writeChunks_.front(),
+        // in which case it should be, since the writeChunk.front() contains
+        // the next bit of data that will be appended to readChunks_, and
+        // therefore needs to be copied there so we can proceed with updating
+        // their state.
+        //
+
+        // if readChunks_ is not the same as writeChunks_.front(), make a copy
+        // of it there
+
+        if(readChunks_.empty() || (readChunks_.back() != writeChunks_.front())) {
+            const Chunk &curChunk = writeChunks_.front();
+            readChunks_.push_back(curChunk);
+
+            // Any data that existed in the write chunk previously doesn't
+            // belong to this buffer (otherwise it would have already been
+            // added to the readChunk_ list).  Here, adjust the start of the
+            // readChunk to begin after any data already existing in curChunk
+
+            readChunks_.back().truncateFront( curChunk.dataSize());
+        }
+
+        assert(readChunks_.back().freeSize() == writeChunks_.front().freeSize());
+
+        // update the states of both readChunks_ and writeChunks_ to indicate that they are
+        // holding the new data
+
+        readChunks_.back().incrementCursor(size);
+        writeChunks_.front().incrementCursor(size);
+        size_ += size;
+        freeSpace_ -= size;
+
+        // if there is no more free space in writeChunks_, the next write cannot use
+        // it, so dispose of it now
+
+        if(writeChunks_.front().freeSize() == 0) {
+            writeChunks_.pop_front();
+        }
+    }
+
+  public:
+
+    typedef std::deque<Chunk> ChunkList;
+    typedef boost::shared_ptr<BufferImpl> SharedPtr;
+    typedef boost::shared_ptr<const BufferImpl> ConstSharedPtr;
+
+    /// Default constructor, creates a buffer without any chunks
+    BufferImpl() :
+        freeSpace_(0),
+        size_(0)
+    { }
+
+    /// Copy constructor, gets a copy of all the chunks with data.
+    explicit BufferImpl(const BufferImpl &src) :
+        readChunks_(src.readChunks_),
+        freeSpace_(0),
+        size_(src.size_)
+    { }
+
+    /// Amount of data held in this buffer.
+    size_type size() const {
+        return size_;
+    }
+
+    /// Capacity that may be written before the buffer must allocate more memory.
+    size_type freeSpace() const {
+        return freeSpace_;
+    }
+
+    /// Add enough free chunks to make the reservation size available.
+    /// Actual amount may be more (rounded up to next chunk).
+    void reserveFreeSpace(size_type reserveSize) {
+        while(freeSpace_ < reserveSize) {
+            allocChunk(reserveSize - freeSpace_);
+        }
+    }
+
+    /// Return the chunk avro's begin iterator for reading.
+    ChunkList::const_iterator beginRead() const {
+        return readChunks_.begin();
+    }
+
+    /// Return the chunk avro's end iterator for reading.
+    ChunkList::const_iterator endRead() const {
+        return readChunks_.end();
+    }
+
+    /// Return the chunk avro's begin iterator for writing.
+    ChunkList::const_iterator beginWrite() const {
+        return writeChunks_.begin();
+    }
+
+    /// Return the chunk avro's end iterator for writing.
+    ChunkList::const_iterator endWrite() const {
+        return writeChunks_.end();
+    }
+
+    /// Write a single value to buffer, add a new chunk if necessary.
+    template<typename T>
+    void writeTo(T val, const std::true_type&)
+    {
+        if(freeSpace_ && (sizeof(T) <= writeChunks_.front().freeSize())) {
+            // fast path, there's enough room in the writeable chunk to just
+            // straight out copy it
+            *(reinterpret_cast <T*> ( writeChunks_.front().tellWritePos()) ) = val;
+            postWrite(sizeof(T));
+        }
+        else {
+            // need to fixup chunks first, so use the regular memcpy
+            // writeTo method
+            writeTo(reinterpret_cast<data_type*>(&val), sizeof(T));
+        }
+    }
+
+    /// An uninstantiable function, this is if boost::is_fundamental check fails,
+    /// and will compile-time assert.
+    template<typename T>
     void writeTo(T, const std::false_type&)
-    { 
-        BOOST_STATIC_ASSERT(sizeof(T)==0); 
-    } 
- 
-    /// Write a block of data to the buffer, adding new chunks if necessary. 
-    size_type writeTo(const data_type *data, size_type size) 
-    { 
-        size_type bytesLeft = size; 
-        while(bytesLeft) { 
- 
-            if(freeSpace_ == 0) { 
-                allocChunkChecked(); 
-            } 
- 
-            Chunk &chunk = writeChunks_.front(); 
-            size_type toCopy = std::min<size_type>(chunk.freeSize(), bytesLeft); 
-            assert(toCopy); 
-            memcpy(chunk.tellWritePos(), data, toCopy); 
-            postWrite(toCopy); 
-            data      += toCopy; 
-            bytesLeft -= toCopy; 
-        } 
-        return size; 
-    } 
- 
-    /// Update internal status of chunks after data is written using iterator. 
-    size_type wroteTo(size_type size) 
-    { 
-        assert(size <= freeSpace_); 
-        size_type bytesLeft = size; 
-        while (bytesLeft) { 
- 
-            Chunk &chunk = writeChunks_.front(); 
-            size_type wrote = std::min<size_type>(chunk.freeSize(), bytesLeft); 
-            assert(wrote); 
-            postWrite(wrote); 
-            bytesLeft -= wrote; 
-        } 
-        return size; 
-    } 
- 
-    /// Append the chunks that have data in src to this buffer 
-    void append(const BufferImpl &src) { 
-        std::copy(src.readChunks_.begin(), src.readChunks_.end(), std::back_inserter(readChunks_)); 
-        size_ += src.size_; 
-    } 
- 
-    /// Remove all the chunks that contain data from this buffer. 
-    void discardData() { 
-        readChunks_.clear(); 
-        size_ = 0; 
-    } 
- 
-    /// Remove the specified amount of data from the chunks, starting at the front. 
-    void discardData(size_type bytes) 
-    { 
-        assert(bytes && bytes <= size_); 
- 
-        size_type bytesToDiscard = bytes; 
-        while( bytesToDiscard ) { 
- 
-            size_t currentSize = readChunks_.front().dataSize(); 
- 
-            // see if entire chunk is discarded 
-            if(currentSize <= bytesToDiscard) { 
-                readChunks_.pop_front(); 
-                bytesToDiscard -= currentSize; 
-            } 
-            else { 
-                readChunks_.front().truncateFront(bytesToDiscard); 
-                bytesToDiscard = 0; 
-            } 
-        } 
- 
-        size_ -= bytes; 
-    } 
- 
-    /// Remove the specified amount of data from the chunks, moving the 
-    /// data to dest's chunks 
-    void extractData(BufferImpl &dest, size_type bytes) 
-    { 
-        assert(bytes && bytes <= size_); 
- 
-        size_type bytesToExtract = bytes; 
-        while( bytesToExtract ) { 
- 
-            size_t currentSize = readChunks_.front().dataSize(); 
-            dest.readChunks_.push_back(readChunks_.front()); 
- 
-            // see if entire chunk was extracted 
-            if(currentSize <= bytesToExtract) { 
-                readChunks_.pop_front(); 
-                bytesToExtract -= currentSize; 
-            } 
-            else { 
-                readChunks_.front().truncateFront(bytesToExtract); 
-                size_t excess = currentSize - bytesToExtract; 
-                dest.readChunks_.back().truncateBack(excess); 
-                bytesToExtract = 0; 
-            } 
-        } 
- 
-        size_ -= bytes; 
-        dest.size_ += bytes; 
-    } 
- 
-    /// Move data from this to the destination, leaving this buffer without data 
-    void extractData(BufferImpl &dest) 
-    { 
-        assert(dest.readChunks_.empty()); 
-        dest.readChunks_.swap(readChunks_); 
-        dest.size_ = size_; 
-        size_ = 0; 
-    } 
- 
-    /// Copy data to a different buffer by copying the chunks.  It's 
-    /// a bit like extract, but without modifying the source buffer. 
-    void copyData(BufferImpl &dest, 
-                  ChunkList::const_iterator iter, 
-                  size_type offset, 
-                  size_type bytes) const 
-    { 
-        // now we are positioned to start the copying, copy as many 
-        // chunks as we need, the first chunk may have a non-zero offset 
-        // if the data to copy is not at the start of the chunk 
-        size_type copied = 0; 
-        while(copied < bytes) { 
- 
-            dest.readChunks_.push_back(*iter); 
- 
-            // offset only applies in the first chunk, 
-            // all subsequent chunks are copied from the start 
-            dest.readChunks_.back().truncateFront(offset); 
-            offset = 0; 
- 
-            copied += dest.readChunks_.back().dataSize(); 
-            ++iter; 
-        } 
- 
-        // if the last chunk copied has more bytes than we need, truncate it 
-        size_type excess = copied - bytes; 
-        dest.readChunks_.back().truncateBack(excess); 
- 
-        dest.size_ += bytes; 
-    } 
- 
-    /// The number of chunks containing data.  Used for debugging. 
-    int numDataChunks() const { 
-        return readChunks_.size(); 
-    } 
- 
-    /// The number of chunks containing free space (note that an entire chunk 
-    /// may not be free).  Used for debugging. 
-    int numFreeChunks() const { 
-        return writeChunks_.size(); 
-    } 
- 
-     /// Add unmanaged data to the buffer.  The buffer will not automatically 
-     /// free the data, but it will call the supplied function when the data is 
-     /// no longer referenced by the buffer (or copies of the buffer). 
-    void appendForeignData(const data_type *data, size_type size, const free_func &func) { 
-        readChunks_.push_back(Chunk(data, size, func)); 
-        size_ += size; 
-    } 
- 
-  private: 
- 
-    /// Assignment not allowed 
-    BufferImpl& operator=(const BufferImpl &src); 
-    /* { 
-        readChunks_.assign(src.readChunks_.begin(), src.readChunks_.end()); 
-        size_ = src.size(); 
-        return *this; 
-    } */ 
- 
-    ChunkList readChunks_;     ///< chunks of this buffer containing data 
-    ChunkList writeChunks_;    ///< chunks of this buffer containing free space 
- 
-    size_type freeSpace_;  ///< capacity of buffer before allocation required 
-    size_type size_;       ///< amount of data in buffer 
- 
-}; 
- 
-} // detail namespace 
- 
-} // namespace 
- 
-#endif 
+    {
+        BOOST_STATIC_ASSERT(sizeof(T)==0);
+    }
+
+    /// Write a block of data to the buffer, adding new chunks if necessary.
+    size_type writeTo(const data_type *data, size_type size)
+    {
+        size_type bytesLeft = size;
+        while(bytesLeft) {
+
+            if(freeSpace_ == 0) {
+                allocChunkChecked();
+            }
+
+            Chunk &chunk = writeChunks_.front();
+            size_type toCopy = std::min<size_type>(chunk.freeSize(), bytesLeft);
+            assert(toCopy);
+            memcpy(chunk.tellWritePos(), data, toCopy);
+            postWrite(toCopy);
+            data      += toCopy;
+            bytesLeft -= toCopy;
+        }
+        return size;
+    }
+
+    /// Update internal status of chunks after data is written using iterator.
+    size_type wroteTo(size_type size)
+    {
+        assert(size <= freeSpace_);
+        size_type bytesLeft = size;
+        while (bytesLeft) {
+
+            Chunk &chunk = writeChunks_.front();
+            size_type wrote = std::min<size_type>(chunk.freeSize(), bytesLeft);
+            assert(wrote);
+            postWrite(wrote);
+            bytesLeft -= wrote;
+        }
+        return size;
+    }
+
+    /// Append the chunks that have data in src to this buffer
+    void append(const BufferImpl &src) {
+        std::copy(src.readChunks_.begin(), src.readChunks_.end(), std::back_inserter(readChunks_));
+        size_ += src.size_;
+    }
+
+    /// Remove all the chunks that contain data from this buffer.
+    void discardData() {
+        readChunks_.clear();
+        size_ = 0;
+    }
+
+    /// Remove the specified amount of data from the chunks, starting at the front.
+    void discardData(size_type bytes)
+    {
+        assert(bytes && bytes <= size_);
+
+        size_type bytesToDiscard = bytes;
+        while( bytesToDiscard ) {
+
+            size_t currentSize = readChunks_.front().dataSize();
+
+            // see if entire chunk is discarded
+            if(currentSize <= bytesToDiscard) {
+                readChunks_.pop_front();
+                bytesToDiscard -= currentSize;
+            }
+            else {
+                readChunks_.front().truncateFront(bytesToDiscard);
+                bytesToDiscard = 0;
+            }
+        }
+
+        size_ -= bytes;
+    }
+
+    /// Remove the specified amount of data from the chunks, moving the
+    /// data to dest's chunks
+    void extractData(BufferImpl &dest, size_type bytes)
+    {
+        assert(bytes && bytes <= size_);
+
+        size_type bytesToExtract = bytes;
+        while( bytesToExtract ) {
+
+            size_t currentSize = readChunks_.front().dataSize();
+            dest.readChunks_.push_back(readChunks_.front());
+
+            // see if entire chunk was extracted
+            if(currentSize <= bytesToExtract) {
+                readChunks_.pop_front();
+                bytesToExtract -= currentSize;
+            }
+            else {
+                readChunks_.front().truncateFront(bytesToExtract);
+                size_t excess = currentSize - bytesToExtract;
+                dest.readChunks_.back().truncateBack(excess);
+                bytesToExtract = 0;
+            }
+        }
+
+        size_ -= bytes;
+        dest.size_ += bytes;
+    }
+
+    /// Move data from this to the destination, leaving this buffer without data
+    void extractData(BufferImpl &dest)
+    {
+        assert(dest.readChunks_.empty());
+        dest.readChunks_.swap(readChunks_);
+        dest.size_ = size_;
+        size_ = 0;
+    }
+
+    /// Copy data to a different buffer by copying the chunks.  It's
+    /// a bit like extract, but without modifying the source buffer.
+    void copyData(BufferImpl &dest,
+                  ChunkList::const_iterator iter,
+                  size_type offset,
+                  size_type bytes) const
+    {
+        // now we are positioned to start the copying, copy as many
+        // chunks as we need, the first chunk may have a non-zero offset
+        // if the data to copy is not at the start of the chunk
+        size_type copied = 0;
+        while(copied < bytes) {
+
+            dest.readChunks_.push_back(*iter);
+
+            // offset only applies in the first chunk,
+            // all subsequent chunks are copied from the start
+            dest.readChunks_.back().truncateFront(offset);
+            offset = 0;
+
+            copied += dest.readChunks_.back().dataSize();
+            ++iter;
+        }
+
+        // if the last chunk copied has more bytes than we need, truncate it
+        size_type excess = copied - bytes;
+        dest.readChunks_.back().truncateBack(excess);
+
+        dest.size_ += bytes;
+    }
+
+    /// The number of chunks containing data.  Used for debugging.
+    int numDataChunks() const {
+        return readChunks_.size();
+    }
+
+    /// The number of chunks containing free space (note that an entire chunk
+    /// may not be free).  Used for debugging.
+    int numFreeChunks() const {
+        return writeChunks_.size();
+    }
+
+     /// Add unmanaged data to the buffer.  The buffer will not automatically
+     /// free the data, but it will call the supplied function when the data is
+     /// no longer referenced by the buffer (or copies of the buffer).
+    void appendForeignData(const data_type *data, size_type size, const free_func &func) {
+        readChunks_.push_back(Chunk(data, size, func));
+        size_ += size;
+    }
+
+  private:
+
+    /// Assignment not allowed
+    BufferImpl& operator=(const BufferImpl &src);
+    /* {
+        readChunks_.assign(src.readChunks_.begin(), src.readChunks_.end());
+        size_ = src.size();
+        return *this;
+    } */
+
+    ChunkList readChunks_;     ///< chunks of this buffer containing data
+    ChunkList writeChunks_;    ///< chunks of this buffer containing free space
+
+    size_type freeSpace_;  ///< capacity of buffer before allocation required
+    size_type size_;       ///< amount of data in buffer
+
+};
+
+} // detail namespace
+
+} // namespace
+
+#endif
diff --git a/contrib/libs/apache/avro/api/buffer/detail/BufferDetailIterator.hh b/contrib/libs/apache/avro/api/buffer/detail/BufferDetailIterator.hh
index ad1dee6fe2..c05f219a64 100644
--- a/contrib/libs/apache/avro/api/buffer/detail/BufferDetailIterator.hh
+++ b/contrib/libs/apache/avro/api/buffer/detail/BufferDetailIterator.hh
@@ -1,230 +1,230 @@
-/* 
- * Licensed to the Apache Software Foundation (ASF) under one 
- * or more contributor license agreements.  See the NOTICE file 
- * distributed with this work for additional information 
- * regarding copyright ownership.  The ASF licenses this file 
- * to you under the Apache License, Version 2.0 (the 
- * "License"); you may not use this file except in compliance 
- * with the License.  You may obtain a copy of the License at 
- * 
- *     https://www.apache.org/licenses/LICENSE-2.0 
- * 
- * Unless required by applicable law or agreed to in writing, software 
- * distributed under the License is distributed on an "AS IS" BASIS, 
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
- * See the License for the specific language governing permissions and 
- * limitations under the License. 
- */ 
- 
-#ifndef avro_BufferDetailIterator_hh__ 
-#define avro_BufferDetailIterator_hh__ 
- 
-#include "BufferDetail.hh" 
- 
-/** 
- * \file BufferDetailIterator.hh 
- * 
- * \brief The implementation details for the Buffer iterators. 
- **/ 
- 
-namespace avro { 
- 
-namespace detail { 
- 
-/** 
- * \brief Implements conversion from a chunk to asio::const_buffer 
- * 
- * Iterators for an InputBuffer will iterate over the avro of chunks, so 
- * internally they contain an iterator.  But the iterator needs to be 
- * convertable to an asio buffer for use in boost::asio functions.  This class 
- * wraps the iterator with a cast operator to do this conversion. 
- **/ 
- 
-struct InputIteratorHelper 
-{ 
-    /// Construct a helper with an unnassigned iterator. 
-    InputIteratorHelper() : 
-        iter_() 
-    {} 
- 
-    /// Construct a helper with an iterator. 
-    InputIteratorHelper(const BufferImpl::ChunkList::const_iterator &iter) : 
-        iter_(iter) 
-    {} 
- 
-    /// The location of valid data in this chunk. 
-    const data_type *data() const { 
-        return iter_->tellReadPos(); 
-    } 
- 
-    /// The size of valid data in this chunk. 
-    size_type size() const { 
-        return iter_->dataSize(); 
-    } 
- 
-    /// Conversion operator.   It doesn't check for null, because the only 
-    /// the only time the chunk should be null is when it's the iterator 
-    /// end(), which should never be dereferenced anyway. 
-#ifdef HAVE_BOOST_ASIO 
-    operator ConstAsioBuffer() const { 
-        return ConstAsioBuffer(data(), size()); 
-    } 
-#endif 
- 
-    BufferImpl::ChunkList::const_iterator iter_; ///< the current iterator 
-}; 
- 
-/** 
- * \brief Implements conversion from a chunk to asio::buffer 
- * 
- * Iterators for an OutputBuffer will iterate over the avro of chunks, so 
- * internally they contain an iterator.  But the iterator needs to be 
- * convertable to an asio buffer for use in boost::asio functions.  This class 
- * wraps the iterator with a cast operator to do this conversion. 
- */ 
- 
-struct OutputIteratorHelper 
-{ 
-    /// Construct a helper with an unnassigned iterator. 
-    OutputIteratorHelper() : 
-            iter_() 
-    {} 
- 
-    /// Construct a helper with an iterator. 
-    OutputIteratorHelper(const BufferImpl::ChunkList::const_iterator &iter) : 
-            iter_(iter) 
-    {} 
- 
-    /// The location of the first writable byte in this chunk. 
-    data_type *data() const { 
-        return iter_->tellWritePos(); 
-    } 
- 
-    /// The size of area that can be written in this chunk. 
-    size_type size() const { 
-        return iter_->freeSize(); 
-    } 
- 
-    /// Conversion operator.   It doesn't check for null, because the only 
-    /// the only time the chunk should be null is when it's the iterator 
-    /// end(), which should never be dereferenced anyway. 
-#ifdef HAVE_BOOST_ASIO 
-    operator MutableAsioBuffer() const { 
-        return MutableAsioBuffer(data(), size()); 
-    } 
-#endif 
- 
-    BufferImpl::ChunkList::const_iterator iter_; ///< the current iterator 
-}; 
- 
-/** 
- * \brief Implements the iterator for Buffer, that iterates through the 
- * buffer's chunks. 
- **/ 
- 
-template<typename Helper> 
-class BufferIterator 
-{ 
- 
-  public: 
- 
-    typedef BufferIterator<Helper> this_type; 
- 
-    /** 
-     * @name Typedefs 
-     * 
-     * STL iterators define the following declarations.  According to 
-     * boost::asio documentation, the library expects the iterator to be 
-     * bidirectional, however this implements only the forward iterator type. 
-     * So far this has not created any problems with asio, but may change if 
-     * future versions of the asio require it. 
-     **/ 
- 
-    //@{ 
-    typedef std::forward_iterator_tag iterator_category; // this is a lie to appease asio 
-    typedef Helper value_type; 
-    typedef std::ptrdiff_t difference_type; 
-    typedef value_type* pointer; 
-    typedef value_type& reference; 
-    //@} 
- 
-    /// Construct an unitialized iterator. 
-    BufferIterator() : 
-        helper_() 
-    { } 
- 
-    /* The default implementations are good here 
-    /// Copy constructor. 
-    BufferIterator(const BufferIterator &src) : 
-        helper_(src.helper_) 
-    { } 
-    /// Assignment. 
-    this_type& operator= (const this_type &rhs) { 
-        helper_ = rhs.helper_; 
-        return *this; 
-    } 
-    */ 
- 
-    /// Construct iterator at the position in the buffer's chunk list. 
-    explicit BufferIterator(BufferImpl::ChunkList::const_iterator iter) : 
-        helper_(iter) 
-    { } 
- 
-    /// Dereference iterator, returns InputIteratorHelper or OutputIteratorHelper wrapper. 
-    reference operator *() { 
-        return helper_; 
-    } 
- 
-    /// Dereference iterator, returns const InputIteratorHelper or OutputIteratorHelper wrapper. 
-    const value_type &operator *() const { 
-        return helper_; 
-    } 
- 
-    /// Dereference iterator, returns InputIteratorHelper or OutputIteratorHelper wrapper. 
-    pointer operator->() { 
-        return &helper_; 
-    } 
- 
-    /// Dereference iterator, returns const InputIteratorHelper or OutputIteratorHelper wrapper. 
-    const value_type *operator->() const { 
-        return &helper_; 
-    } 
- 
-    /// Increment to next chunk in list, or to end() iterator. 
-    this_type& operator++() 
-    { 
-        ++helper_.iter_; 
-        return *this; 
-    } 
- 
-    /// Increment to next chunk in list, or to end() iterator. 
-    this_type operator++(int) 
-    { 
-        this_type ret = *this; 
-        ++helper_.iter_; 
-        return ret; 
-    } 
- 
-    /// True if iterators point to same chunks. 
-    bool operator==(const this_type &rhs) const { 
-        return (helper_.iter_ == rhs.helper_.iter_); 
-    } 
- 
-    /// True if iterators point to different chunks. 
-    bool operator!=(const this_type &rhs) const { 
-        return (helper_.iter_ != rhs.helper_.iter_); 
-    } 
- 
-  private: 
- 
-    Helper helper_; 
-}; 
- 
-typedef BufferIterator<InputIteratorHelper> InputBufferIterator; 
-typedef BufferIterator<OutputIteratorHelper> OutputBufferIterator; 
- 
-} // detail namespace 
- 
-} // namespace 
- 
-#endif 
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef avro_BufferDetailIterator_hh__
+#define avro_BufferDetailIterator_hh__
+
+#include "BufferDetail.hh"
+
+/**
+ * \file BufferDetailIterator.hh
+ *
+ * \brief The implementation details for the Buffer iterators.
+ **/
+
+namespace avro {
+
+namespace detail {
+
+/**
+ * \brief Implements conversion from a chunk to asio::const_buffer
+ *
+ * Iterators for an InputBuffer will iterate over the avro of chunks, so
+ * internally they contain an iterator.  But the iterator needs to be
+ * convertable to an asio buffer for use in boost::asio functions.  This class
+ * wraps the iterator with a cast operator to do this conversion.
+ **/
+
+struct InputIteratorHelper
+{
+    /// Construct a helper with an unnassigned iterator.
+    InputIteratorHelper() :
+        iter_()
+    {}
+
+    /// Construct a helper with an iterator.
+    InputIteratorHelper(const BufferImpl::ChunkList::const_iterator &iter) :
+        iter_(iter)
+    {}
+
+    /// The location of valid data in this chunk.
+    const data_type *data() const {
+        return iter_->tellReadPos();
+    }
+
+    /// The size of valid data in this chunk.
+    size_type size() const {
+        return iter_->dataSize();
+    }
+
+    /// Conversion operator.   It doesn't check for null, because the only
+    /// the only time the chunk should be null is when it's the iterator
+    /// end(), which should never be dereferenced anyway.
+#ifdef HAVE_BOOST_ASIO
+    operator ConstAsioBuffer() const {
+        return ConstAsioBuffer(data(), size());
+    }
+#endif
+
+    BufferImpl::ChunkList::const_iterator iter_; ///< the current iterator
+};
+
+/**
+ * \brief Implements conversion from a chunk to asio::buffer
+ *
+ * Iterators for an OutputBuffer will iterate over the avro of chunks, so
+ * internally they contain an iterator.  But the iterator needs to be
+ * convertable to an asio buffer for use in boost::asio functions.  This class
+ * wraps the iterator with a cast operator to do this conversion.
+ */
+
+struct OutputIteratorHelper
+{
+    /// Construct a helper with an unnassigned iterator.
+    OutputIteratorHelper() :
+            iter_()
+    {}
+
+    /// Construct a helper with an iterator.
+    OutputIteratorHelper(const BufferImpl::ChunkList::const_iterator &iter) :
+            iter_(iter)
+    {}
+
+    /// The location of the first writable byte in this chunk.
+    data_type *data() const {
+        return iter_->tellWritePos();
+    }
+
+    /// The size of area that can be written in this chunk.
+    size_type size() const {
+        return iter_->freeSize();
+    }
+
+    /// Conversion operator.   It doesn't check for null, because the only
+    /// the only time the chunk should be null is when it's the iterator
+    /// end(), which should never be dereferenced anyway.
+#ifdef HAVE_BOOST_ASIO
+    operator MutableAsioBuffer() const {
+        return MutableAsioBuffer(data(), size());
+    }
+#endif
+
+    BufferImpl::ChunkList::const_iterator iter_; ///< the current iterator
+};
+
+/**
+ * \brief Implements the iterator for Buffer, that iterates through the
+ * buffer's chunks.
+ **/
+
+template<typename Helper>
+class BufferIterator
+{
+
+  public:
+
+    typedef BufferIterator<Helper> this_type;
+
+    /**
+     * @name Typedefs
+     *
+     * STL iterators define the following declarations.  According to
+     * boost::asio documentation, the library expects the iterator to be
+     * bidirectional, however this implements only the forward iterator type.
+     * So far this has not created any problems with asio, but may change if
+     * future versions of the asio require it.
+     **/
+
+    //@{
+    typedef std::forward_iterator_tag iterator_category; // this is a lie to appease asio
+    typedef Helper value_type;
+    typedef std::ptrdiff_t difference_type;
+    typedef value_type* pointer;
+    typedef value_type& reference;
+    //@}
+
+    /// Construct an unitialized iterator.
+    BufferIterator() :
+        helper_()
+    { }
+
+    /* The default implementations are good here
+    /// Copy constructor.
+    BufferIterator(const BufferIterator &src) :
+        helper_(src.helper_)
+    { }
+    /// Assignment.
+    this_type& operator= (const this_type &rhs) {
+        helper_ = rhs.helper_;
+        return *this;
+    }
+    */
+
+    /// Construct iterator at the position in the buffer's chunk list.
+    explicit BufferIterator(BufferImpl::ChunkList::const_iterator iter) :
+        helper_(iter)
+    { }
+
+    /// Dereference iterator, returns InputIteratorHelper or OutputIteratorHelper wrapper.
+    reference operator *() {
+        return helper_;
+    }
+
+    /// Dereference iterator, returns const InputIteratorHelper or OutputIteratorHelper wrapper.
+    const value_type &operator *() const {
+        return helper_;
+    }
+
+    /// Dereference iterator, returns InputIteratorHelper or OutputIteratorHelper wrapper.
+    pointer operator->() {
+        return &helper_;
+    }
+
+    /// Dereference iterator, returns const InputIteratorHelper or OutputIteratorHelper wrapper.
+    const value_type *operator->() const {
+        return &helper_;
+    }
+
+    /// Increment to next chunk in list, or to end() iterator.
+    this_type& operator++()
+    {
+        ++helper_.iter_;
+        return *this;
+    }
+
+    /// Increment to next chunk in list, or to end() iterator.
+    this_type operator++(int)
+    {
+        this_type ret = *this;
+        ++helper_.iter_;
+        return ret;
+    }
+
+    /// True if iterators point to same chunks.
+    bool operator==(const this_type &rhs) const {
+        return (helper_.iter_ == rhs.helper_.iter_);
+    }
+
+    /// True if iterators point to different chunks.
+    bool operator!=(const this_type &rhs) const {
+        return (helper_.iter_ != rhs.helper_.iter_);
+    }
+
+  private:
+
+    Helper helper_;
+};
+
+typedef BufferIterator<InputIteratorHelper> InputBufferIterator;
+typedef BufferIterator<OutputIteratorHelper> OutputBufferIterator;
+
+} // detail namespace
+
+} // namespace
+
+#endif