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// Author: kenton@google.com (Kenton Varda)
32// Based on original Protocol Buffers design by
33// Sanjay Ghemawat, Jeff Dean, and others.
34
35#ifndef GOOGLE_PROTOBUF_COMPILER_JAVA_SERVICE_H__
36#define GOOGLE_PROTOBUF_COMPILER_JAVA_SERVICE_H__
37
38#include <map>
39#include <google/protobuf/descriptor.h>
40
41namespace google {
42namespace protobuf {
43namespace compiler {
44namespace java {
45class Context; // context.h
46class ClassNameResolver; // name_resolver.h
47} // namespace java
48} // namespace compiler
49namespace io {
50class Printer; // printer.h
51}
52} // namespace protobuf
53} // namespace google
54
55namespace google {
56namespace protobuf {
57namespace compiler {
58namespace java {
59
60class ServiceGenerator {
61 public:
62 explicit ServiceGenerator(const ServiceDescriptor* descriptor);
63 virtual ~ServiceGenerator();
64
65 virtual void Generate(io::Printer* printer) = 0;
66
67 enum RequestOrResponse { REQUEST, RESPONSE };
68 enum IsAbstract { IS_ABSTRACT, IS_CONCRETE };
69
70 protected:
71 const ServiceDescriptor* descriptor_;
72
73 private:
74 GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ServiceGenerator);
75};
76
77class ImmutableServiceGenerator : public ServiceGenerator {
78 public:
79 ImmutableServiceGenerator(const ServiceDescriptor* descriptor,
80 Context* context);
81 ~ImmutableServiceGenerator() override;
82
83 void Generate(io::Printer* printer) override;
84
85 private:
86 // Generate the getDescriptorForType() method.
87 void GenerateGetDescriptorForType(io::Printer* printer);
88
89 // Generate a Java interface for the service.
90 void GenerateInterface(io::Printer* printer);
91
92 // Generate newReflectiveService() method.
93 void GenerateNewReflectiveServiceMethod(io::Printer* printer);
94
95 // Generate newReflectiveBlockingService() method.
96 void GenerateNewReflectiveBlockingServiceMethod(io::Printer* printer);
97
98 // Generate abstract method declarations for all methods.
99 void GenerateAbstractMethods(io::Printer* printer);
100
101 // Generate the implementation of Service.callMethod().
102 void GenerateCallMethod(io::Printer* printer);
103
104 // Generate the implementation of BlockingService.callBlockingMethod().
105 void GenerateCallBlockingMethod(io::Printer* printer);
106
107 // Generate the implementations of Service.get{Request,Response}Prototype().
108 void GenerateGetPrototype(RequestOrResponse which, io::Printer* printer);
109
110 // Generate a stub implementation of the service.
111 void GenerateStub(io::Printer* printer);
112
113 // Generate a method signature, possibly abstract, without body or trailing
114 // semicolon.
115 void GenerateMethodSignature(io::Printer* printer,
116 const MethodDescriptor* method,
117 IsAbstract is_abstract);
118
119 // Generate a blocking stub interface and implementation of the service.
120 void GenerateBlockingStub(io::Printer* printer);
121
122 // Generate the method signature for one method of a blocking stub.
123 void GenerateBlockingMethodSignature(io::Printer* printer,
124 const MethodDescriptor* method);
125
126 // Return the output type of the method.
127 std::string GetOutput(const MethodDescriptor* method);
128
129 Context* context_;
130 ClassNameResolver* name_resolver_;
131 GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ImmutableServiceGenerator);
132};
133
134} // namespace java
135} // namespace compiler
136} // namespace protobuf
137} // namespace google
138
139#endif // NET_PROTO2_COMPILER_JAVA_SERVICE_H__
140