import org.yaml.snakeyaml.Yaml;
import java.util.Map;

public class Task060826 {
    public static void main(String[] args) {
        String yaml = "enabled: on\nvalue: 010";
        Yaml yamlParser = new Yaml();
        Map<String, Object> data = yamlParser.load(yaml);
        System.out.println(data.get("enabled") + ", " + data.get("value"));
    }
}

import java.util.Objects;

public class Person implements Comparable<Person> {
    private final String name;
    private final int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    //Нарушение: compareTo не согласован с equals
    // @Override
    // public int compareTo(Person o) {
    //     return this.age - o.age; // Только по возрасту
    // }
    // // equals по имени и возрасту
    // public boolean equals(Object o) {
    //     if (!(o instanceof Person)) return false;
    //     Person p = (Person) o;
    //     return name.equals(p.name) && age == p.age;
    // }

    //Корректно: compareTo использует те же поля, что и equals
    @Override
    public int compareTo(Person o) {
        int nameComp = this.name.compareTo(o.name);
        if (nameComp != 0) return nameComp;
        return Integer.compare(this.age, o.age);
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Person)) return false;
        Person p = (Person) o;
        return age == p.age && name.equals(p.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    @Override
    public String toString() {
        return name + "(" + age + ")";
    }

    public static void main(String[] args) {
        // Демонстрация нарушения
        Person p1 = new Person("Alice", 30);
        Person p2 = new Person("Bob", 30);

        // Если compareTo только по возрасту, то p1.compareTo(p2) == 0,
        // хотя equals вернет false (имена разные).
        // TreeSet считает их одинаковыми
        TreeSet<Person> set = new TreeSet<>();
        set.add(p1);
        set.add(p2);
        System.out.println("Size: " + set.size()); // Должно быть 1, если compareTo=0
        System.out.println("Contains Alice? " + set.contains(p1)); // true
        System.out.println("Contains Bob? " + set.contains(p2));   // true? Зависит от реализации
        // На самом деле, если compareTo=0, то при добавлении второго он будет считаться дубликатом
        // и не будет добавлен, но contains для Bob вернет true, потому что TreeSet использует compareTo
        // для поиска, а не equals. Это делает поведение непредсказуемым.
    }
}

import java.util.TreeSet;

public class Task070826 {
    static class Person070826 implements Comparable<Person070826> {
        String name;
        int age;

        Person070826(String name, int age) {
            this.name = name;
            this.age = age;
        }

        @Override
        public int compareTo(Person070826 o) {
            return Integer.compare(this.age, o.age); // только по возрасту
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (!(o instanceof Person070826)) return false;
            Person070826 p = (Person070826) o;
            return age == p.age && name.equals(p.name);
        }

        @Override
        public int hashCode() {
            return 31 * name.hashCode() + age;
        }
    }

    public static void main(String[] args) {
        TreeSet<Person070826> set = new TreeSet<>();
        Person070826 p1 = new Person070826("Alice", 25);
        Person070826 p2 = new Person070826("Bob", 25);

        set.add(p1);
        set.add(p2);

        System.out.println(set.contains(p1));
        System.out.println(set.contains(p2));
        System.out.println(set.size());
    }
}

Bottleneck — это узкое место в системе, которое ограничивает общую производительность. В контексте сериализации bottleneck часто проявляется в виде высокой нагрузки на CPU при парсинге текстовых форматов, избыточном потреблении памяти кучи и низкой пропускной способности сети из-за раздутого размера сообщений.

IDL (Interface Definition Language) — это язык формальной спецификации интерфейсов программных компонентов. В контексте Protobuf IDL описывает структуру сообщений, их поля, типы и правила версионирования.

syntax = "proto3";

package library;

// Опция java_package переопределяет пакет для сгенерированных Java-классов
option java_package = "com.example.library.proto";
option java_multiple_files = true;

// Сообщение Book описывает структуру книги
message Book {
  // Поле с номером тега 1. Тег — это уникальный идентификатор поля в пределах сообщения
  string title = 1;
  
  // Поле с номером тега 2
  string author = 2;
  
  // int32 — 32-битное целое со знаком
  int32 year = 3;
  
  // double — 64-битное число с плавающей точкой
  double price = 4;
  
  // bool — булево значение
  bool available = 5;
  
  // repeated — повторяющееся поле, аналог списка или массива
  repeated string tags = 6;
  
  // Вложенное сообщение
  message Publisher {
    string name = 1;
    string country = 2;
  }
  
  Publisher publisher = 7;
}

Тег (field number) — это уникальный числовой идентификатор поля в пределах сообщения Protobuf. Тег, а не имя поля, записывается в бинарное представление. Это позволяет изменять имена полей в схеме, не ломая бинарную совместимость, так как парсер опирается на номера тегов.

Wire format — это конкретное бинарное представление сообщения Protobuf при передаче по сети или записи на диск. Оно определяет, как типы данных, номера полей и значения упаковываются в последовательность байтов.

[tag][value]

Varint (variable-length integer) — это способ кодирования целых чисел в виде последовательности байтов переменной длины. Каждый байт varint содержит 7 бит данных и 1 бит-флаг продолжения (most significant bit). Если флаг установлен, следует ещё один байт.

Значение 1:
  Бинарное: 00000001
  Varint:   00000001 (1 байт)

Значение 150:
  Бинарное: 10010110
  Varint:   10010110 00000001 (2 байта)
  Разбор:   младшие 7 бит первого байта = 1001010 (22), старший бит = 1 (продолжение)
            второй байт = 0000001 (1), итого: 1 * 128 + 22 = 150

ZigZag encoding — это схема отображения целых чисел со знаком на целые без знака, при которой малые по модулю числа (положительные и отрицательные) отображаются на малые положительные числа. Формула: (n << 1) ^ (n >> 31) для 32-битных чисел.

Исходное значение -> Закодированное
0  -> 0
-1 -> 1
1  -> 2
-2 -> 3
2  -> 4

[tag][length][data]

[tag][total_length][value1][value2][value3]...

# Установка компилятора (например, через Maven plugin или скачивание бинарника)
protoc --java_out=./src/main/java library.proto

// Сгенерированный класс Book.java
package com.example.library.proto;

public final class Book extends GeneratedMessageV3 implements BookOrBuilder {
    
    // Приватные поля — immutable объект
    private volatile Object title_;
    private volatile Object author_;
    private int year_;
    private double price_;
    private boolean available_;
    // Repeated поле — хранится как ProtocolStringList (оптимизированная реализация List<String>)
    private LazyStringList tags_;
    private Publisher publisher_;
    
    // Приватный конструктор — объекты создаются через Builder
    private Book() {
        title_ = "";
        author_ = "";
        tags_ = LazyStringArrayList.EMPTY;
    }
    
    // Геттеры
    public String getTitle() { ... }
    public String getAuthor() { ... }
    public int getYear() { ... }
    public List<String> getTagsList() { ... }
    public Publisher getPublisher() { ... }
    
    // Сериализация в OutputStream
    public void writeTo(CodedOutputStream output) throws IOException {
        // Кодирование каждого поля в wire format
        if (!getTitleBytes().isEmpty()) {
            GeneratedMessageV3.writeString(output, 1, title_);
        }
        if (!getAuthorBytes().isEmpty()) {
            GeneratedMessageV3.writeString(output, 2, author_);
        }
        if (year_ != 0) {
            output.writeInt32(3, year_);
        }
        // ... и так далее для каждого поля
    }
    
    // Десериализация из InputStream
    public static Book parseFrom(InputStream input) throws IOException {
        return parseFrom(input, DEFAULT_INSTANCE);
    }
    
    // Вложенный класс Builder — реализация паттерна Builder
    public static final class Builder extends GeneratedMessageV3.Builder<Builder> {
        // Мутабельная копия полей для построения объекта
        public Builder setTitle(String value) { ... }
        public Builder setAuthor(String value) { ... }
        public Builder setYear(int value) { ... }
        public Builder addTags(String value) { ... }
        public Book build() { ... }  // создаёт immutable Book
    }
    
    // Singleton-экземпляр DEFAULT_INSTANCE для пустого сообщения
    private static final Book DEFAULT_INSTANCE;
    static {
        DEFAULT_INSTANCE = new Book();
    }
}

Immutability (неизменяемость) — это свойство объекта, при котором его состояние не может быть изменено после создания. Неизменяемые объекты потокобезопасны по определению, так как их нельзя изменить из любого потока. В Protobuf immutability гарантирует, что сериализованное сообщение не изменится во время передачи.

Builder pattern (паттерн строитель) — это порождающий паттерн проектирования, который позволяет создавать сложные объекты пошагово. В Protobuf Builder изолирует мутабельное состояние на этапе конструирования, а финальный объект остаётся immutable.

import com.example.library.proto.Book;
import com.example.library.proto.Book.Publisher;
import com.google.protobuf.ByteString;
import java.io.FileOutputStream;
import java.io.FileInputStream;

public class ProtobufExample {
    
    public void createAndSerialize() throws Exception {
        // Создание объекта через Builder
        Book book = Book.newBuilder()
            .setTitle("Clean Code")
            .setAuthor("Robert C. Martin")
            .setYear(2008)
            .setPrice(42.50)
            .setAvailable(true)
            .addTags("programming")
            .addTags("software engineering")
            .setPublisher(
                Publisher.newBuilder()
                    .setName("Prentice Hall")
                    .setCountry("USA")
                    .build()
            )
            .build();
        
        // Сериализация в байтовый массив
        byte[] bytes = book.toByteArray();
        System.out.println("Serialized size: " + bytes.length + " bytes");
        // Для сравнения: JSON-представление этого же объекта заняло бы ~250-300 байт
        
        // Запись в файл
        try (FileOutputStream fos = new FileOutputStream("book.pb")) {
            book.writeTo(fos);
        }
        
        // Десериализация из файла
        try (FileInputStream fis = new FileInputStream("book.pb")) {
            Book restored = Book.parseFrom(fis);
            System.out.println("Restored: " + restored.getTitle() + " by " + restored.getAuthor());
        }
        
        // Десериализация из байтового массива
        Book fromBytes = Book.parseFrom(bytes);
    }
}

Backward compatibility (обратная совместимость) — это свойство системы, при котором новая версия может корректно обрабатывать данные, созданные старой версией. Forward compatibility (прямая совместимость) — это свойство, при котором старая версия может корректно обрабатывать данные, созданные новой версией.

message BookV2 {
  string title = 1;
  string author = 2;
  int32 year = 3;
  
  // Новое поле — старый код проигнорирует тег 8
  string isbn = 8;
  
  // Зарезервированные теги и имена — нельзя использовать повторно
  reserved 4, 5, 6;
  reserved "price", "available";
}

Latency — это задержка между отправкой запроса и получением ответа. В распределённых системах latency складывается из времени сериализации, передачи по сети, десериализации и обработки. Компактные форматы снижают время передачи и десериализации.

JMH (Java Microbenchmark Harness) — это фреймворк от OpenJDK для написания корректных микробенчмарков Java-кода. Он решает проблемы JIT-оптимизаций, warmup-фазы и статистической значимости результатов.