intermediate changes

ref:cde9a383711a11544ce7e107a78147fb96cc4029

1 files changed, 260 insertions, 0 deletions

diff --git a/contrib/libs/apache/avro/impl/Generic.cc b/contrib/libs/apache/avro/impl/Generic.cc
new file mode 100644
index 0000000000..8efb7e9ac4
--- /dev/null
+++ b/contrib/libs/apache/avro/impl/Generic.cc
@@ -0,0 +1,260 @@
+/**
+ * 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.
+ */
+
+#include "Generic.hh"
+#include <sstream>
+
+namespace avro {
+
+using std::string;
+using std::vector;
+using std::ostringstream;
+
+typedef vector<uint8_t> bytes;
+
+void GenericContainer::assertType(const NodePtr& schema, Type type) {
+    if (schema->type() != type) {
+        throw Exception(boost::format("Schema type %1 expected %2") %
+            toString(schema->type()) % toString(type));
+    }
+}
+
+GenericReader::GenericReader(const ValidSchema& s, const DecoderPtr& decoder) :
+    schema_(s), isResolving_(dynamic_cast<ResolvingDecoder*>(&(*decoder)) != 0),
+    decoder_(decoder)
+{
+}
+
+GenericReader::GenericReader(const ValidSchema& writerSchema,
+    const ValidSchema& readerSchema, const DecoderPtr& decoder) :
+    schema_(readerSchema),
+    isResolving_(true),
+    decoder_(resolvingDecoder(writerSchema, readerSchema, decoder))
+{
+}
+
+void GenericReader::read(GenericDatum& datum) const
+{
+    datum = GenericDatum(schema_.root());
+    read(datum, *decoder_, isResolving_);
+}
+
+void GenericReader::read(GenericDatum& datum, Decoder& d, bool isResolving)
+{
+    if (datum.isUnion()) {
+        datum.selectBranch(d.decodeUnionIndex());
+    }
+    switch (datum.type()) {
+    case AVRO_NULL:
+        d.decodeNull();
+        break;
+    case AVRO_BOOL:
+        datum.value<bool>() = d.decodeBool();
+        break;
+    case AVRO_INT:
+        datum.value<int32_t>() = d.decodeInt();
+        break;
+    case AVRO_LONG:
+        datum.value<int64_t>() = d.decodeLong();
+        break;
+    case AVRO_FLOAT:
+        datum.value<float>() = d.decodeFloat();
+        break;
+    case AVRO_DOUBLE:
+        datum.value<double>() = d.decodeDouble();
+        break;
+    case AVRO_STRING:
+        d.decodeString(datum.value<string>());
+        break;
+    case AVRO_BYTES:
+        d.decodeBytes(datum.value<bytes>());
+        break;
+    case AVRO_FIXED:
+        {
+            GenericFixed& f = datum.value<GenericFixed>();
+            d.decodeFixed(f.schema()->fixedSize(), f.value());
+        }
+        break;
+    case AVRO_RECORD:
+        {
+            GenericRecord& r = datum.value<GenericRecord>();
+            size_t c = r.schema()->leaves();
+            if (isResolving) {
+                std::vector<size_t> fo =
+                    static_cast<ResolvingDecoder&>(d).fieldOrder();
+                for (size_t i = 0; i < c; ++i) {
+                    read(r.fieldAt(fo[i]), d, isResolving);
+                }
+            } else {
+                for (size_t i = 0; i < c; ++i) {
+                    read(r.fieldAt(i), d, isResolving);
+                }
+            }
+        }
+        break;
+    case AVRO_ENUM:
+        datum.value<GenericEnum>().set(d.decodeEnum());
+        break;
+    case AVRO_ARRAY:
+        {
+            GenericArray& v = datum.value<GenericArray>();
+            vector<GenericDatum>& r = v.value();
+            const NodePtr& nn = v.schema()->leafAt(0);
+            r.resize(0);
+            size_t start = 0;
+            for (size_t m = d.arrayStart(); m != 0; m = d.arrayNext()) {
+                r.resize(r.size() + m);
+                for (; start < r.size(); ++start) {
+                    r[start] = GenericDatum(nn);
+                    read(r[start], d, isResolving);
+                }
+            }
+        }
+        break;
+    case AVRO_MAP:
+        {
+            GenericMap& v = datum.value<GenericMap>();
+            GenericMap::Value& r = v.value();
+            const NodePtr& nn = v.schema()->leafAt(1);
+            r.resize(0);
+            size_t start = 0;
+            for (size_t m = d.mapStart(); m != 0; m = d.mapNext()) {
+                r.resize(r.size() + m);
+                for (; start < r.size(); ++start) {
+                    d.decodeString(r[start].first);
+                    r[start].second = GenericDatum(nn);
+                    read(r[start].second, d, isResolving);
+                }
+            }
+        }
+        break;
+    default:
+        throw Exception(boost::format("Unknown schema type %1%") %
+            toString(datum.type()));
+    }
+}
+
+void GenericReader::read(Decoder& d, GenericDatum& g, const ValidSchema& s)
+{
+    g = GenericDatum(s);
+    read(d, g);
+}
+
+void GenericReader::read(Decoder& d, GenericDatum& g)
+{
+    read(g, d, dynamic_cast<ResolvingDecoder*>(&d) != 0);
+}
+
+GenericWriter::GenericWriter(const ValidSchema& s, const EncoderPtr& encoder) :
+    schema_(s), encoder_(encoder)
+{
+}
+
+void GenericWriter::write(const GenericDatum& datum) const
+{
+    write(datum, *encoder_);
+}
+
+void GenericWriter::write(const GenericDatum& datum, Encoder& e)
+{
+    if (datum.isUnion()) {
+        e.encodeUnionIndex(datum.unionBranch());
+    }
+    switch (datum.type()) {
+    case AVRO_NULL:
+        e.encodeNull();
+        break;
+    case AVRO_BOOL:
+        e.encodeBool(datum.value<bool>());
+        break;
+    case AVRO_INT:
+        e.encodeInt(datum.value<int32_t>());
+        break;
+    case AVRO_LONG:
+        e.encodeLong(datum.value<int64_t>());
+        break;
+    case AVRO_FLOAT:
+        e.encodeFloat(datum.value<float>());
+        break;
+    case AVRO_DOUBLE:
+        e.encodeDouble(datum.value<double>());
+        break;
+    case AVRO_STRING:
+        e.encodeString(datum.value<string>());
+        break;
+    case AVRO_BYTES:
+        e.encodeBytes(datum.value<bytes>());
+        break;
+    case AVRO_FIXED:
+        e.encodeFixed(datum.value<GenericFixed>().value());
+        break;
+    case AVRO_RECORD:
+        {
+            const GenericRecord& r = datum.value<GenericRecord>();
+            size_t c = r.schema()->leaves();
+            for (size_t i = 0; i < c; ++i) {
+                write(r.fieldAt(i), e);
+            }
+        }
+        break;
+    case AVRO_ENUM:
+        e.encodeEnum(datum.value<GenericEnum>().value());
+        break;
+    case AVRO_ARRAY:
+        {
+            const GenericArray::Value& r = datum.value<GenericArray>().value();
+            e.arrayStart();
+            if (! r.empty()) {
+                e.setItemCount(r.size());
+                for (GenericArray::Value::const_iterator it = r.begin();
+                    it != r.end(); ++it) {
+                    e.startItem();
+                    write(*it, e);
+                }
+            }
+            e.arrayEnd();
+        }
+        break;
+    case AVRO_MAP:
+        {
+            const GenericMap::Value& r = datum.value<GenericMap>().value();
+            e.mapStart();
+            if (! r.empty()) {
+                e.setItemCount(r.size());
+                for (GenericMap::Value::const_iterator it = r.begin();
+                    it != r.end(); ++it) {
+                    e.startItem();
+                    e.encodeString(it->first);
+                    write(it->second, e);
+                }
+            }
+            e.mapEnd();
+        }
+        break;
+    default:
+        throw Exception(boost::format("Unknown schema type %1%") %
+            toString(datum.type()));
+    }
+}
+
+void GenericWriter::write(Encoder& e, const GenericDatum& g)
+{
+    write(g, e);
+}
+
+}   // namespace avro