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