← Back to branch summary

~ubuntu-branches/ubuntu/trusty/protobuf/trusty-proposed

« back to all changes in this revision

Viewing changes to src/google/protobuf/compiler/java/java_extension.cc

  • Committer: Bazaar Package Importer
  • Author(s): Matthias Klose
  • Date: 2011-05-31 14:41:47 UTC
  • mfrom: (2.2.8 sid)
  • Revision ID: james.westby@ubuntu.com-20110531144147-s41g5fozgvyo462l
Tags: 2.4.0a-2ubuntu1
* Merge with Debian; remaining changes:
  - Fix linking with -lpthread.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/google/protobuf/compiler/java/java_extension.cc
86
86
 
87
87
ExtensionGenerator::~ExtensionGenerator() {}
88
88
 
 
89
// Initializes the vars referenced in the generated code templates.
 
90
void InitTemplateVars(const FieldDescriptor* descriptor,
 
91
                      const string& scope,
 
92
                      map<string, string>* vars_pointer) {
 
93
  map<string, string> &vars = *vars_pointer;
 
94
  vars["scope"] = scope;
 
95
  vars["name"] = UnderscoresToCamelCase(descriptor);
 
96
  vars["containing_type"] = ClassName(descriptor->containing_type());
 
97
  vars["number"] = SimpleItoa(descriptor->number());
 
98
  vars["constant_name"] = FieldConstantName(descriptor);
 
99
  vars["index"] = SimpleItoa(descriptor->index());
 
100
  vars["default"] =
 
101
      descriptor->is_repeated() ? "" : DefaultValue(descriptor);
 
102
  vars["type_constant"] = TypeName(GetType(descriptor));
 
103
  vars["packed"] = descriptor->options().packed() ? "true" : "false";
 
104
  vars["enum_map"] = "null";
 
105
  vars["prototype"] = "null";
 
106
 
 
107
  JavaType java_type = GetJavaType(descriptor);
 
108
  string singular_type;
 
109
  switch (java_type) {
 
110
    case JAVATYPE_MESSAGE:
 
111
      singular_type = ClassName(descriptor->message_type());
 
112
      vars["prototype"] = singular_type + ".getDefaultInstance()";
 
113
      break;
 
114
    case JAVATYPE_ENUM:
 
115
      singular_type = ClassName(descriptor->enum_type());
 
116
      vars["enum_map"] = singular_type + ".internalGetValueMap()";
 
117
      break;
 
118
    default:
 
119
      singular_type = BoxedPrimitiveTypeName(java_type);
 
120
      break;
 
121
  }
 
122
  vars["type"] = descriptor->is_repeated() ?
 
123
      "java.util.List<" + singular_type + ">" : singular_type;
 
124
  vars["singular_type"] = singular_type;
 
125
}
 
126
 
89
127
void ExtensionGenerator::Generate(io::Printer* printer) {
90
128
  map<string, string> vars;
91
 
  vars["name"] = UnderscoresToCamelCase(descriptor_);
92
 
  vars["containing_type"] = ClassName(descriptor_->containing_type());
93
 
  vars["number"] = SimpleItoa(descriptor_->number());
94
 
  vars["constant_name"] = FieldConstantName(descriptor_);
95
 
  vars["lite"] = HasDescriptorMethods(descriptor_->file()) ? "" : "Lite";
96
 
 
97
 
  JavaType java_type = GetJavaType(descriptor_);
98
 
  string singular_type;
99
 
  switch (java_type) {
100
 
    case JAVATYPE_MESSAGE:
101
 
      vars["type"] = ClassName(descriptor_->message_type());
102
 
      break;
103
 
    case JAVATYPE_ENUM:
104
 
      vars["type"] = ClassName(descriptor_->enum_type());
105
 
      break;
106
 
    default:
107
 
      vars["type"] = BoxedPrimitiveTypeName(java_type);
108
 
      break;
109
 
  }
110
 
 
 
129
  InitTemplateVars(descriptor_, scope_, &vars);
111
130
  printer->Print(vars,
112
 
    "public static final int $constant_name$ = $number$;\n");
113
 
  if (descriptor_->is_repeated()) {
114
 
    printer->Print(vars,
115
 
      "public static final\n"
116
 
      "  com.google.protobuf.GeneratedMessage$lite$.GeneratedExtension<\n"
117
 
      "    $containing_type$,\n"
118
 
      "    java.util.List<$type$>> $name$ =\n"
119
 
      "      com.google.protobuf.GeneratedMessage$lite$\n"
120
 
      "        .newGeneratedExtension();\n");
121
 
  } else {
122
 
    printer->Print(vars,
123
 
      "public static final\n"
124
 
      "  com.google.protobuf.GeneratedMessage$lite$.GeneratedExtension<\n"
125
 
      "    $containing_type$,\n"
126
 
      "    $type$> $name$ =\n"
127
 
      "      com.google.protobuf.GeneratedMessage$lite$\n"
128
 
      "        .newGeneratedExtension();\n");
129
 
  }
130
 
}
131
 
 
132
 
void ExtensionGenerator::GenerateInitializationCode(io::Printer* printer) {
133
 
  map<string, string> vars;
134
 
  vars["name"] = UnderscoresToCamelCase(descriptor_);
135
 
  vars["scope"] = scope_;
136
 
  vars["index"] = SimpleItoa(descriptor_->index());
137
 
  vars["extendee"] = ClassName(descriptor_->containing_type());
138
 
  vars["default"] = descriptor_->is_repeated() ? "" : DefaultValue(descriptor_);
139
 
  vars["number"] = SimpleItoa(descriptor_->number());
140
 
  vars["type_constant"] = TypeName(GetType(descriptor_));
141
 
  vars["packed"] = descriptor_->options().packed() ? "true" : "false";
142
 
  vars["enum_map"] = "null";
143
 
  vars["prototype"] = "null";
144
 
 
145
 
  JavaType java_type = GetJavaType(descriptor_);
146
 
  string singular_type;
147
 
  switch (java_type) {
148
 
    case JAVATYPE_MESSAGE:
149
 
      vars["type"] = ClassName(descriptor_->message_type());
150
 
      vars["prototype"] = ClassName(descriptor_->message_type()) +
151
 
                          ".getDefaultInstance()";
152
 
      break;
153
 
    case JAVATYPE_ENUM:
154
 
      vars["type"] = ClassName(descriptor_->enum_type());
155
 
      vars["enum_map"] = ClassName(descriptor_->enum_type()) +
156
 
                         ".internalGetValueMap()";
157
 
      break;
158
 
    default:
159
 
      vars["type"] = BoxedPrimitiveTypeName(java_type);
160
 
      break;
161
 
  }
 
131
      "public static final int $constant_name$ = $number$;\n");
162
132
 
163
133
  if (HasDescriptorMethods(descriptor_->file())) {
164
 
    printer->Print(vars,
165
 
      "$scope$.$name$.internalInit(\n"
166
 
      "    $scope$.getDescriptor().getExtensions().get($index$),\n"
167
 
      "    $type$.class);\n");
 
134
    // Non-lite extensions
 
135
    if (descriptor_->extension_scope() == NULL) {
 
136
      // Non-nested
 
137
      printer->Print(
 
138
          vars,
 
139
          "public static final\n"
 
140
          "  com.google.protobuf.GeneratedMessage.GeneratedExtension<\n"
 
141
          "    $containing_type$,\n"
 
142
          "    $type$> $name$ = com.google.protobuf.GeneratedMessage\n"
 
143
          "        .newFileScopedGeneratedExtension(\n"
 
144
          "      $singular_type$.class,\n"
 
145
          "      $prototype$);\n");
 
146
    } else {
 
147
      // Nested
 
148
      printer->Print(
 
149
          vars,
 
150
          "public static final\n"
 
151
          "  com.google.protobuf.GeneratedMessage.GeneratedExtension<\n"
 
152
          "    $containing_type$,\n"
 
153
          "    $type$> $name$ = com.google.protobuf.GeneratedMessage\n"
 
154
          "        .newMessageScopedGeneratedExtension(\n"
 
155
          "      $scope$.getDefaultInstance(),\n"
 
156
          "      $index$,\n"
 
157
          "      $singular_type$.class,\n"
 
158
          "      $prototype$);\n");
 
159
    }
168
160
  } else {
 
161
    // Lite extensions
169
162
    if (descriptor_->is_repeated()) {
170
 
      printer->Print(vars,
171
 
        "$scope$.$name$.internalInitRepeated(\n"
172
 
        "    $extendee$.getDefaultInstance(),\n"
173
 
        "    $prototype$,\n"
174
 
        "    $enum_map$,\n"
175
 
        "    $number$,\n"
176
 
        "    com.google.protobuf.WireFormat.FieldType.$type_constant$,\n"
177
 
        "    $packed$);\n");
 
163
      printer->Print(
 
164
          vars,
 
165
          "public static final\n"
 
166
          "  com.google.protobuf.GeneratedMessageLite.GeneratedExtension<\n"
 
167
          "    $containing_type$,\n"
 
168
          "    $type$> $name$ = com.google.protobuf.GeneratedMessageLite\n"
 
169
          "        .newRepeatedGeneratedExtension(\n"
 
170
          "      $containing_type$.getDefaultInstance(),\n"
 
171
          "      $prototype$,\n"
 
172
          "      $enum_map$,\n"
 
173
          "      $number$,\n"
 
174
          "      com.google.protobuf.WireFormat.FieldType.$type_constant$,\n"
 
175
          "      $packed$);\n");
178
176
    } else {
179
 
      printer->Print(vars,
180
 
        "$scope$.$name$.internalInitSingular(\n"
181
 
        "    $extendee$.getDefaultInstance(),\n"
182
 
        "    $default$,\n"
183
 
        "    $prototype$,\n"
184
 
        "    $enum_map$,\n"
185
 
        "    $number$,\n"
186
 
        "    com.google.protobuf.WireFormat.FieldType.$type_constant$);\n");
 
177
      printer->Print(
 
178
          vars,
 
179
          "public static final\n"
 
180
          "  com.google.protobuf.GeneratedMessageLite.GeneratedExtension<\n"
 
181
          "    $containing_type$,\n"
 
182
          "    $type$> $name$ = com.google.protobuf.GeneratedMessageLite\n"
 
183
          "        .newSingularGeneratedExtension(\n"
 
184
          "      $containing_type$.getDefaultInstance(),\n"
 
185
          "      $default$,\n"
 
186
          "      $prototype$,\n"
 
187
          "      $enum_map$,\n"
 
188
          "      $number$,\n"
 
189
          "      com.google.protobuf.WireFormat.FieldType.$type_constant$);\n");
187
190
    }
188
191
  }
189
192
}
190
193
 
 
194
void ExtensionGenerator::GenerateNonNestedInitializationCode(
 
195
    io::Printer* printer) {
 
196
  if (descriptor_->extension_scope() == NULL &&
 
197
      HasDescriptorMethods(descriptor_->file())) {
 
198
    // Only applies to non-nested, non-lite extensions.
 
199
    printer->Print(
 
200
        "$name$.internalInit(descriptor.getExtensions().get($index$));\n",
 
201
        "name", UnderscoresToCamelCase(descriptor_),
 
202
        "index", SimpleItoa(descriptor_->index()));
 
203
  }
 
204
}
 
205
 
191
206
void ExtensionGenerator::GenerateRegistrationCode(io::Printer* printer) {
192
207
  printer->Print(
193
208
    "registry.add($scope$.$name$);\n",