1 // Protocol Buffers - Google's data interchange format
2 // Copyright 2008 Google Inc. All rights reserved.
3 // https://developers.google.com/protocol-buffers/
4 //
5 // Redistribution and use in source and binary forms, with or without
6 // modification, are permitted provided that the following conditions are
7 // met:
8 //
9 // * Redistributions of source code must retain the above copyright
10 // notice, this list of conditions and the following disclaimer.
11 // * Redistributions in binary form must reproduce the above
12 // copyright notice, this list of conditions and the following disclaimer
13 // in the documentation and/or other materials provided with the
14 // distribution.
15 // * Neither the name of Google Inc. nor the names of its
16 // contributors may be used to endorse or promote products derived from
17 // this software without specific prior written permission.
18 //
19 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
23 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30
31 #include <google/protobuf/compiler/java/java_context.h>
32
33 #include <google/protobuf/compiler/java/java_field.h>
34 #include <google/protobuf/compiler/java/java_helpers.h>
35 #include <google/protobuf/compiler/java/java_name_resolver.h>
36 #include <google/protobuf/descriptor.h>
37 #include <google/protobuf/stubs/strutil.h>
38 #include <google/protobuf/stubs/map_util.h>
39
40 namespace google {
41 namespace protobuf {
42 namespace compiler {
43 namespace java {
44
Context(const FileDescriptor * file)45 Context::Context(const FileDescriptor* file)
46 : name_resolver_(new ClassNameResolver) {
47 InitializeFieldGeneratorInfo(file);
48 }
49
~Context()50 Context::~Context() {
51 }
52
GetNameResolver()53 ClassNameResolver* Context::GetNameResolver() {
54 return name_resolver_.get();
55 }
56
57 namespace {
58 // Whether two fields have conflicting accessors (assuming name1 and name2
59 // are different). name1 and name2 are field1 and field2's camel-case name
60 // respectively.
IsConflicting(const FieldDescriptor * field1,const string & name1,const FieldDescriptor * field2,const string & name2,string * info)61 bool IsConflicting(const FieldDescriptor* field1, const string& name1,
62 const FieldDescriptor* field2, const string& name2,
63 string* info) {
64 if (field1->is_repeated()) {
65 if (field2->is_repeated()) {
66 // Both fields are repeated.
67 return false;
68 } else {
69 // field1 is repeated, and field2 is not.
70 if (name1 + "Count" == name2) {
71 *info = "both repeated field \"" + field1->name() + "\" and singular " +
72 "field \"" + field2->name() + "\" generates the method \"" +
73 "get" + name1 + "Count()\"";
74 return true;
75 }
76 if (name1 + "List" == name2) {
77 *info = "both repeated field \"" + field1->name() + "\" and singular " +
78 "field \"" + field2->name() + "\" generates the method \"" +
79 "get" + name1 + "List()\"";
80 return true;
81 }
82 // Well, there are obviously many more conflicting cases, but it probably
83 // doesn't worth the effort to exhaust all of them because they rarely
84 // happen and as we are continuing adding new methods/changing existing
85 // methods the number of different conflicting cases will keep growing.
86 // We can just add more cases here when they are found in the real world.
87 return false;
88 }
89 } else {
90 if (field2->is_repeated()) {
91 return IsConflicting(field2, name2, field1, name1, info);
92 } else {
93 // None of the two fields are repeated.
94 return false;
95 }
96 }
97 }
98 } // namespace
99
InitializeFieldGeneratorInfo(const FileDescriptor * file)100 void Context::InitializeFieldGeneratorInfo(const FileDescriptor* file) {
101 for (int i = 0; i < file->message_type_count(); ++i) {
102 InitializeFieldGeneratorInfoForMessage(file->message_type(i));
103 }
104 }
105
InitializeFieldGeneratorInfoForMessage(const Descriptor * message)106 void Context::InitializeFieldGeneratorInfoForMessage(
107 const Descriptor* message) {
108 for (int i = 0; i < message->nested_type_count(); ++i) {
109 InitializeFieldGeneratorInfoForMessage(message->nested_type(i));
110 }
111 vector<const FieldDescriptor*> fields;
112 for (int i = 0; i < message->field_count(); ++i) {
113 fields.push_back(message->field(i));
114 }
115 InitializeFieldGeneratorInfoForFields(fields);
116
117 for (int i = 0; i < message->oneof_decl_count(); ++i) {
118 const OneofDescriptor* oneof = message->oneof_decl(i);
119 OneofGeneratorInfo info;
120 info.name = UnderscoresToCamelCase(oneof->name(), false);
121 info.capitalized_name = UnderscoresToCamelCase(oneof->name(), true);
122 oneof_generator_info_map_[oneof] = info;
123 }
124 }
125
InitializeFieldGeneratorInfoForFields(const vector<const FieldDescriptor * > & fields)126 void Context::InitializeFieldGeneratorInfoForFields(
127 const vector<const FieldDescriptor*>& fields) {
128 // Find out all fields that conflict with some other field in the same
129 // message.
130 vector<bool> is_conflict(fields.size());
131 vector<string> conflict_reason(fields.size());
132 for (int i = 0; i < fields.size(); ++i) {
133 const FieldDescriptor* field = fields[i];
134 const string& name = UnderscoresToCapitalizedCamelCase(field);
135 for (int j = i + 1; j < fields.size(); ++j) {
136 const FieldDescriptor* other = fields[j];
137 const string& other_name = UnderscoresToCapitalizedCamelCase(other);
138 if (name == other_name) {
139 is_conflict[i] = is_conflict[j] = true;
140 conflict_reason[i] = conflict_reason[j] =
141 "capitalized name of field \"" + field->name() +
142 "\" conflicts with field \"" + other->name() + "\"";
143 } else if (IsConflicting(field, name, other, other_name,
144 &conflict_reason[j])) {
145 is_conflict[i] = is_conflict[j] = true;
146 conflict_reason[i] = conflict_reason[j];
147 }
148 }
149 if (is_conflict[i]) {
150 GOOGLE_LOG(WARNING) << "field \"" << field->full_name() << "\" is conflicting "
151 << "with another field: " << conflict_reason[i];
152 }
153 }
154 for (int i = 0; i < fields.size(); ++i) {
155 const FieldDescriptor* field = fields[i];
156 FieldGeneratorInfo info;
157 info.name = UnderscoresToCamelCase(field);
158 info.capitalized_name = UnderscoresToCapitalizedCamelCase(field);
159 // For fields conflicting with some other fields, we append the field
160 // number to their field names in generated code to avoid conflicts.
161 if (is_conflict[i]) {
162 info.name += SimpleItoa(field->number());
163 info.capitalized_name += SimpleItoa(field->number());
164 info.disambiguated_reason = conflict_reason[i];
165 }
166 field_generator_info_map_[field] = info;
167 }
168 }
169
GetFieldGeneratorInfo(const FieldDescriptor * field) const170 const FieldGeneratorInfo* Context::GetFieldGeneratorInfo(
171 const FieldDescriptor* field) const {
172 const FieldGeneratorInfo* result =
173 FindOrNull(field_generator_info_map_, field);
174 if (result == NULL) {
175 GOOGLE_LOG(FATAL) << "Can not find FieldGeneratorInfo for field: "
176 << field->full_name();
177 }
178 return result;
179 }
180
GetOneofGeneratorInfo(const OneofDescriptor * oneof) const181 const OneofGeneratorInfo* Context::GetOneofGeneratorInfo(
182 const OneofDescriptor* oneof) const {
183 const OneofGeneratorInfo* result =
184 FindOrNull(oneof_generator_info_map_, oneof);
185 if (result == NULL) {
186 GOOGLE_LOG(FATAL) << "Can not find OneofGeneratorInfo for oneof: "
187 << oneof->name();
188 }
189 return result;
190 }
191
192 } // namespace java
193 } // namespace compiler
194 } // namespace protobuf
195 } // namespace google
196