// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc.  All rights reserved.
//
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file or at
// https://developers.google.com/open-source/licenses/bsd

edition = "2023";

package map_lite_test;

option features.field_presence = IMPLICIT;

option optimize_for = LITE_RUNTIME;
option java_package = "map_lite_test";
option java_outer_classname = "MapTestProto";

message TestMap {
  message MessageValue {
    int32 value = 1;
  }

  enum EnumValue {
    FOO = 0;
    BAR = 1;
    BAZ = 2;
    QUX = 3;
  }

  map<int32, int32> int32_to_int32_field = 1;
  map<int32, string> int32_to_string_field = 2;
  map<int32, bytes> int32_to_bytes_field = 3;
  map<int32, EnumValue> int32_to_enum_field = 4;
  map<int32, MessageValue> int32_to_message_field = 5;
  map<string, int32> string_to_int32_field = 6;
  map<uint32, int32> uint32_to_int32_field = 7;
  map<int64, int32> int64_to_int32_field = 8;
}

// Used to test that a nested builder containing map fields will properly
// propagate the onChange event and mark its parent dirty when a change
// is made to a map field.
message TestOnChangeEventPropagation {
  TestMap optional_message = 1;
}

// a decoy of TestMap for testing parsing errors
message BizarroTestMap {
  // same key type, different value
  map<int32, bytes> int32_to_int32_field = 1;

  // different key and value types
  map<string, int32> int32_to_string_field = 2;

  // different key types, same value
  map<string, int32> int32_to_bytes_field = 3;

  // different key and value types
  map<string, bytes> int32_to_enum_field = 4;

  // different key and value types
  map<string, bytes> int32_to_message_field = 5;

  // same key type, different value
  map<string, bytes> string_to_int32_field = 6;
}

// Used to test that java reserved words can be used as protobuf field names
// Not all reserved words are tested (to avoid bloat) but instead an arbitrary
// subset of them chosen to cover various keyword categories like
// type, modifier, declaration, etc.
message ReservedAsMapField {
  map<string, uint32> if = 1;
  map<string, uint32> const = 2;
  map<string, uint32> private = 3;
  map<string, uint32> class = 4;
  map<string, uint32> int = 5;
  map<string, uint32> void = 6;

  // These are also proto keywords
  map<string, uint32> string = 7;
  map<string, uint32> package = 8;

  // Most recent Java reserved word
  map<string, uint32> enum = 9;

  // null is not a 'reserved word' per se but as a literal needs similar care
  map<string, uint32> null = 10;
}

message ReservedAsMapFieldWithEnumValue {
  enum SampleEnum {
    A = 0;
    B = 1;
  }

  map<string, SampleEnum> if = 1;
  map<string, SampleEnum> const = 2;
  map<string, SampleEnum> private = 3;
  map<string, SampleEnum> class = 4;
  map<string, SampleEnum> int = 5;
  map<string, SampleEnum> void = 6;

  // These are also proto keywords
  map<string, SampleEnum> string = 7;
  map<string, SampleEnum> package = 8;

  // Most recent Java reserved word
  map<string, SampleEnum> enum = 9;

  // null is not a 'reserved word' per se but as a literal needs similar care
  map<string, SampleEnum> null = 10;
}

// https://github.com/protocolbuffers/protobuf/issues/9785
message MapContainer {
  map<string, string> my_map = 1;
}
