Move C++ generation code into C++ namespace
Use this namespace to shorten the class names now that we
needn't distinguish them as C++ specific.
Test: unittests pass
Change-Id: Idace1e87be1e9fd5129550941532d05be83ec985
diff --git a/aidl.cpp b/aidl.cpp
index a55724a..f2c1a33 100644
--- a/aidl.cpp
+++ b/aidl.cpp
@@ -639,7 +639,7 @@
// TODO(wiley) b/23600457 generate a dependency file if requested with -b
- return (GenerateCpp(options, interface)) ? 0 : 1;
+ return (cpp::GenerateCpp(options, interface)) ? 0 : 1;
}
int compile_aidl_to_java(const JavaOptions& options) {
diff --git a/ast_cpp.cpp b/ast_cpp.cpp
index 8ec7af8..e990d76 100644
--- a/ast_cpp.cpp
+++ b/ast_cpp.cpp
@@ -6,16 +6,17 @@
namespace android {
namespace aidl {
+namespace cpp {
-CppClassDeclaration::CppClassDeclaration(const std::string& name, const std::string& parent,
- std::vector<unique_ptr<CppDeclaration>> public_members,
- std::vector<unique_ptr<CppDeclaration>> private_members)
+ClassDecl::ClassDecl(const std::string& name, const std::string& parent,
+ std::vector<unique_ptr<Declaration>> public_members,
+ std::vector<unique_ptr<Declaration>> private_members)
: name_(name),
parent_(parent),
public_members_(std::move(public_members)),
private_members_(std::move(private_members)) {}
-void CppClassDeclaration::Write(CodeWriter* to) const {
+void ClassDecl::Write(CodeWriter* to) const {
to->Write("class %s ", name_.c_str());
if (parent_.length() > 0)
@@ -38,7 +39,7 @@
to->Write("}; // class %s\n", name_.c_str());
}
-CppMacroOrConstructorDeclaration::CppMacroOrConstructorDeclaration(
+ConstructorDecl::ConstructorDecl(
const std::string& name,
std::vector<std::string> arguments,
bool is_const,
@@ -48,7 +49,7 @@
is_const_(is_const),
is_virtual_(is_virtual) {}
-void CppMacroOrConstructorDeclaration::Write(CodeWriter* to) const {
+void ConstructorDecl::Write(CodeWriter* to) const {
if (is_virtual_)
to->Write("virtual ");
@@ -71,18 +72,18 @@
to->Write(";\n");
}
-CppMethodDeclaration::CppMethodDeclaration(const std::string& return_type,
- const std::string& name,
- std::vector<std::string> arguments,
- bool is_const,
- bool is_virtual)
+MethodDecl::MethodDecl(const std::string& return_type,
+ const std::string& name,
+ std::vector<std::string> arguments,
+ bool is_const,
+ bool is_virtual)
: return_type_(return_type),
name_(name),
arguments_(arguments),
is_const_(is_const),
is_virtual_(is_virtual) {}
-void CppMethodDeclaration::Write(CodeWriter* to) const {
+void MethodDecl::Write(CodeWriter* to) const {
if (is_virtual_)
to->Write("virtual ");
@@ -106,7 +107,7 @@
}
CppNamespace::CppNamespace(const std::string& name,
- std::vector<unique_ptr<CppDeclaration>> declarations)
+ std::vector<unique_ptr<Declaration>> declarations)
: declarations_(std::move(declarations)),
name_(name) {}
@@ -121,12 +122,12 @@
to->Write("} // namespace %s\n", name_.c_str());
}
-CppDocument::CppDocument(const std::vector<std::string>& include_list,
- unique_ptr<CppNamespace> a_namespace)
+Document::Document(const std::vector<std::string>& include_list,
+ unique_ptr<CppNamespace> a_namespace)
: include_list_(include_list),
namespace_(std::move(a_namespace)) {}
-void CppDocument::Write(CodeWriter* to) const {
+void Document::Write(CodeWriter* to) const {
for (const auto& include : include_list_) {
to->Write("#include <%s>\n", include.c_str());
}
@@ -138,14 +139,14 @@
CppHeader::CppHeader(const std::string& include_guard,
const std::vector<std::string>& include_list,
unique_ptr<CppNamespace> a_namespace)
- : CppDocument(include_list, std::move(a_namespace)),
+ : Document(include_list, std::move(a_namespace)),
include_guard_(include_guard) {}
void CppHeader::Write(CodeWriter* to) const {
to->Write("#ifndef %s\n", include_guard_.c_str());
to->Write("#define %s\n\n", include_guard_.c_str());
- CppDocument::Write(to);
+ Document::Write(to);
to->Write("\n");
to->Write("#endif // %s", include_guard_.c_str());
@@ -153,7 +154,8 @@
CppSource::CppSource(const std::vector<std::string>& include_list,
unique_ptr<CppNamespace> a_namespace)
- : CppDocument(include_list, std::move(a_namespace)) {}
+ : Document(include_list, std::move(a_namespace)) {}
+} // namespace cpp
} // namespace aidl
} // namespace android
diff --git a/ast_cpp.h b/ast_cpp.h
index 056f0eb..ed33262 100644
--- a/ast_cpp.h
+++ b/ast_cpp.h
@@ -14,8 +14,8 @@
* limitations under the License.
*/
-#ifndef AIDL_AST_JAVA_H_
-#define AIDL_AST_JAVA_H_
+#ifndef AIDL_AST_CPP_H_
+#define AIDL_AST_CPP_H_
#include <memory>
#include <string>
@@ -25,56 +25,61 @@
namespace android {
namespace aidl {
-
class CodeWriter;
+} // namespace aidl
+} // namespace android
-class CppNode {
+namespace android {
+namespace aidl {
+namespace cpp {
+
+class AstNode {
public:
- CppNode() = default;
- virtual ~CppNode() = default;
+ AstNode() = default;
+ virtual ~AstNode() = default;
virtual void Write(CodeWriter* to) const = 0;
private:
- DISALLOW_COPY_AND_ASSIGN(CppNode);
-}; // class CppNode
+ DISALLOW_COPY_AND_ASSIGN(AstNode);
+}; // class AstNode
-class CppDeclaration : public CppNode {
+class Declaration : public AstNode {
public:
- CppDeclaration() = default;
- virtual ~CppDeclaration() = default;
+ Declaration() = default;
+ virtual ~Declaration() = default;
private:
- DISALLOW_COPY_AND_ASSIGN(CppDeclaration);
-}; // class CppDeclaration
+ DISALLOW_COPY_AND_ASSIGN(Declaration);
+}; // class Declaration
-class CppClassDeclaration : public CppDeclaration {
+class ClassDecl : public Declaration {
public:
- CppClassDeclaration(const std::string& name,
- const std::string& parent,
- std::vector<std::unique_ptr<CppDeclaration>> public_members,
- std::vector<std::unique_ptr<CppDeclaration>> private_members);
- virtual ~CppClassDeclaration() = default;
+ ClassDecl(const std::string& name,
+ const std::string& parent,
+ std::vector<std::unique_ptr<Declaration>> public_members,
+ std::vector<std::unique_ptr<Declaration>> private_members);
+ virtual ~ClassDecl() = default;
void Write(CodeWriter* to) const override;
private:
std::string name_;
std::string parent_;
- std::vector<std::unique_ptr<CppDeclaration>> public_members_;
- std::vector<std::unique_ptr<CppDeclaration>> private_members_;
+ std::vector<std::unique_ptr<Declaration>> public_members_;
+ std::vector<std::unique_ptr<Declaration>> private_members_;
- DISALLOW_COPY_AND_ASSIGN(CppClassDeclaration);
-}; // class CppClassDeclaration
+ DISALLOW_COPY_AND_ASSIGN(ClassDecl);
+}; // class ClassDecl
-class CppMacroOrConstructorDeclaration : public CppDeclaration {
+class ConstructorDecl : public Declaration {
public:
- CppMacroOrConstructorDeclaration(const std::string& name,
- std::vector<std::string> arguments,
- bool is_const = false,
- bool is_virtual = false);
+ ConstructorDecl(const std::string& name,
+ std::vector<std::string> arguments,
+ bool is_const = false,
+ bool is_virtual = false);
- virtual ~CppMacroOrConstructorDeclaration() = default;
+ virtual ~ConstructorDecl() = default;
void Write(CodeWriter* to) const override;
@@ -84,17 +89,17 @@
bool is_const_;
bool is_virtual_;
- DISALLOW_COPY_AND_ASSIGN(CppMacroOrConstructorDeclaration);
+ DISALLOW_COPY_AND_ASSIGN(ConstructorDecl);
};
-class CppMethodDeclaration : public CppDeclaration {
+class MethodDecl : public Declaration {
public:
- CppMethodDeclaration(const std::string& return_type,
- const std::string& name,
- std::vector<std::string> arguments,
- bool is_const = false,
- bool is_virtual = false);
- virtual ~CppMethodDeclaration() = default;
+ MethodDecl(const std::string& return_type,
+ const std::string& name,
+ std::vector<std::string> arguments,
+ bool is_const = false,
+ bool is_virtual = false);
+ virtual ~MethodDecl() = default;
void Write(CodeWriter* to) const override;
@@ -105,28 +110,28 @@
bool is_const_;
bool is_virtual_;
- DISALLOW_COPY_AND_ASSIGN(CppMethodDeclaration);
+ DISALLOW_COPY_AND_ASSIGN(MethodDecl);
};
-class CppNamespace : public CppDeclaration {
+class CppNamespace : public Declaration {
public:
CppNamespace(const std::string& name,
- std::vector<std::unique_ptr<CppDeclaration>> declarations);
+ std::vector<std::unique_ptr<Declaration>> declarations);
virtual ~CppNamespace() = default;
void Write(CodeWriter* to) const override;
private:
- std::vector<std::unique_ptr<CppDeclaration>> declarations_;
+ std::vector<std::unique_ptr<Declaration>> declarations_;
std::string name_;
DISALLOW_COPY_AND_ASSIGN(CppNamespace);
}; // class CppNamespace
-class CppDocument : public CppNode {
+class Document : public AstNode {
public:
- CppDocument(const std::vector<std::string>& include_list,
- std::unique_ptr<CppNamespace> a_namespace);
+ Document(const std::vector<std::string>& include_list,
+ std::unique_ptr<CppNamespace> a_namespace);
void Write(CodeWriter* to) const override;
@@ -134,10 +139,10 @@
std::vector<std::string> include_list_;
std::unique_ptr<CppNamespace> namespace_;
- DISALLOW_COPY_AND_ASSIGN(CppDocument);
-}; // class CppDocument
+ DISALLOW_COPY_AND_ASSIGN(Document);
+}; // class Document
-class CppHeader final : public CppDocument {
+class CppHeader final : public Document {
public:
CppHeader(const std::string& include_guard,
const std::vector<std::string>& include_list,
@@ -150,7 +155,7 @@
DISALLOW_COPY_AND_ASSIGN(CppHeader);
}; // class CppHeader
-class CppSource final : public CppDocument {
+class CppSource final : public Document {
public:
CppSource(const std::vector<std::string>& include_list,
std::unique_ptr<CppNamespace> a_namespace);
@@ -159,7 +164,8 @@
DISALLOW_COPY_AND_ASSIGN(CppSource);
}; // class CppSource
+} // namespace cpp
} // namespace aidl
} // namespace android
-#endif // AIDL_AST_JAVA_H_
+#endif // AIDL_AST_CPP_H_
diff --git a/ast_cpp_unittest.cpp b/ast_cpp_unittest.cpp
index 8ba5557..016399f 100644
--- a/ast_cpp_unittest.cpp
+++ b/ast_cpp_unittest.cpp
@@ -27,6 +27,7 @@
namespace android {
namespace aidl {
+namespace cpp {
namespace {
const char kExpectedHeaderOutput[] =
@@ -60,41 +61,41 @@
} // namespace
TEST(AstCppTests, GeneratesHeader) {
- unique_ptr<CppMethodDeclaration> norm{new CppMethodDeclaration("void",
- "NormalMethod",
- { "int normalarg",
- "float normal2" })};
- unique_ptr<CppMethodDeclaration> sub{new CppMethodDeclaration("void",
- "SubMethod",
- { "int subarg" },
- true,
- true)};
- unique_ptr<CppMethodDeclaration> sub2{new CppMethodDeclaration("void",
- "SubMethod",
- { "int subarg" },
- true,
- true)};
- vector<unique_ptr<CppDeclaration>> test_methods;
+ unique_ptr<MethodDecl> norm{new MethodDecl("void",
+ "NormalMethod",
+ { "int normalarg",
+ "float normal2" })};
+ unique_ptr<MethodDecl> sub{new MethodDecl("void",
+ "SubMethod",
+ { "int subarg" },
+ true,
+ true)};
+ unique_ptr<MethodDecl> sub2{new MethodDecl("void",
+ "SubMethod",
+ { "int subarg" },
+ true,
+ true)};
+ vector<unique_ptr<Declaration>> test_methods;
test_methods.push_back(std::move(norm));
test_methods.push_back(std::move(sub));
- vector<unique_ptr<CppDeclaration>> test_sub_methods;
+ vector<unique_ptr<Declaration>> test_sub_methods;
test_sub_methods.push_back(std::move(sub2));
- unique_ptr<CppDeclaration> test{new CppClassDeclaration { "TestClass", "",
+ unique_ptr<Declaration> test{new ClassDecl { "TestClass", "",
std::move(test_methods), {} }};
- unique_ptr<CppDeclaration> test_sub{new CppClassDeclaration { "TestSubClass",
+ unique_ptr<Declaration> test_sub{new ClassDecl { "TestSubClass",
"TestClass", std::move(test_sub_methods), {} }};
- vector<unique_ptr<CppDeclaration>> classes;
+ vector<unique_ptr<Declaration>> classes;
classes.push_back(std::move(test));
classes.push_back(std::move(test_sub));
unique_ptr<CppNamespace> test_ns{new CppNamespace {"test",
std::move(classes)}};
- vector<unique_ptr<CppDeclaration>> test_ns_vec;
+ vector<unique_ptr<Declaration>> test_ns_vec;
test_ns_vec.push_back(std::move(test_ns));
unique_ptr<CppNamespace> android_ns{new CppNamespace {"android", std::move(test_ns_vec) }};
@@ -107,5 +108,6 @@
EXPECT_EQ(string(kExpectedHeaderOutput), actual_output);
}
+} // namespace cpp
} // namespace aidl
} // namespace android
diff --git a/generate_cpp.cpp b/generate_cpp.cpp
index 84fd150..370b584 100644
--- a/generate_cpp.cpp
+++ b/generate_cpp.cpp
@@ -33,6 +33,7 @@
namespace android {
namespace aidl {
+namespace cpp {
namespace internals {
string StrippedLiteral(const buffer_type& buffer) {
@@ -67,33 +68,33 @@
name + type->Brackets();
}
-unique_ptr<CppDocument> BuildClientSource(interface_type* parsed_doc) {
+unique_ptr<Document> BuildClientSource(interface_type* parsed_doc) {
unique_ptr<CppNamespace> ns{new CppNamespace{"android", {}}};
- return unique_ptr<CppDocument>{new CppSource{ {}, std::move(ns)}};
+ return unique_ptr<Document>{new CppSource{ {}, std::move(ns)}};
}
-unique_ptr<CppDocument> BuildServerSource(interface_type* parsed_doc) {
+unique_ptr<Document> BuildServerSource(interface_type* parsed_doc) {
unique_ptr<CppNamespace> ns{new CppNamespace{"android", {}}};
- return unique_ptr<CppDocument>{new CppSource{ {}, std::move(ns)}};
+ return unique_ptr<Document>{new CppSource{ {}, std::move(ns)}};
}
-unique_ptr<CppDocument> BuildInterfaceSource(interface_type* parsed_doc) {
+unique_ptr<Document> BuildInterfaceSource(interface_type* parsed_doc) {
unique_ptr<CppNamespace> ns{new CppNamespace{"android", {}}};
- return unique_ptr<CppDocument>{new CppSource{ {}, std::move(ns)}};
+ return unique_ptr<Document>{new CppSource{ {}, std::move(ns)}};
}
-unique_ptr<CppDocument> BuildClientHeader(interface_type* parsed_doc) {
+unique_ptr<Document> BuildClientHeader(interface_type* parsed_doc) {
string i_name = parsed_doc->name.Literal();
string c_name = StrippedLiteral(parsed_doc->name);
string bp_name = "Bp" + c_name;
- unique_ptr<CppMacroOrConstructorDeclaration> constructor{
- new CppMacroOrConstructorDeclaration(bp_name, {}, false, false)};
+ unique_ptr<ConstructorDecl> constructor{
+ new ConstructorDecl(bp_name, {}, false, false)};
- unique_ptr<CppMacroOrConstructorDeclaration> destructor{
- new CppMacroOrConstructorDeclaration("~" + bp_name, {}, false, false)};
+ unique_ptr<ConstructorDecl> destructor{
+ new ConstructorDecl("~" + bp_name, {}, false, false)};
- vector<unique_ptr<CppDeclaration>> publics;
+ vector<unique_ptr<Declaration>> publics;
publics.push_back(std::move(constructor));
publics.push_back(std::move(destructor));
@@ -119,78 +120,80 @@
args.push_back(return_arg);
- unique_ptr<CppDeclaration> meth {
- new CppMethodDeclaration("android::status_t", method_name,
- args, false, true)
+ unique_ptr<Declaration> meth {
+ new MethodDecl("android::status_t", method_name,
+ args, false, true)
};
publics.push_back(std::move(meth));
}
- unique_ptr<CppClassDeclaration> bp_class{
- new CppClassDeclaration{bp_name,
- "public android::BpInterface<" + i_name + ">",
- std::move(publics),
- {}
+ unique_ptr<ClassDecl> bp_class{
+ new ClassDecl{bp_name,
+ "public android::BpInterface<" + i_name + ">",
+ std::move(publics),
+ {}
}};
- vector<unique_ptr<CppDeclaration>> bp_class_vec;
+ vector<unique_ptr<Declaration>> bp_class_vec;
bp_class_vec.push_back(std::move(bp_class));
- unique_ptr<CppNamespace> ns {new CppNamespace{"android", std::move(bp_class_vec)}};
+ unique_ptr<CppNamespace> ns {new CppNamespace{"android",
+ std::move(bp_class_vec)}};
- unique_ptr<CppDocument> bp_header{new CppHeader{bp_name + "_H",
- {"binder/IBinder.h",
- "binder/IInterface.h",
- "utils/Errors.h",
- i_name + ".h"},
- std::move(ns) }};
+ unique_ptr<Document> bp_header{new CppHeader{bp_name + "_H",
+ {"binder/IBinder.h",
+ "binder/IInterface.h",
+ "utils/Errors.h",
+ i_name + ".h"},
+ std::move(ns) }};
return bp_header;
}
-unique_ptr<CppDocument> BuildServerHeader(interface_type* parsed_doc) {
+unique_ptr<Document> BuildServerHeader(interface_type* parsed_doc) {
string i_name = parsed_doc->name.Literal();;
string c_name = StrippedLiteral(parsed_doc->name);
string bn_name = "Bn" + c_name;
- unique_ptr<CppDeclaration> on_transact{
- new CppMethodDeclaration("android::status_t", "onTransact",
- { "uint32_t code",
- "const android::Parcel& data",
- "android::Parcel* reply",
- "uint32_t flags = 0"
- })};
+ unique_ptr<Declaration> on_transact{
+ new MethodDecl("android::status_t", "onTransact",
+ { "uint32_t code",
+ "const android::Parcel& data",
+ "android::Parcel* reply",
+ "uint32_t flags = 0"
+ })};
- std::vector<unique_ptr<CppDeclaration>> publics;
+ std::vector<unique_ptr<Declaration>> publics;
publics.push_back(std::move(on_transact));
- unique_ptr<CppClassDeclaration> bn_class{
- new CppClassDeclaration{bn_name,
- "public android::BnInterface<" + i_name + ">",
- std::move(publics),
- {}
+ unique_ptr<ClassDecl> bn_class{
+ new ClassDecl{bn_name,
+ "public android::BnInterface<" + i_name + ">",
+ std::move(publics),
+ {}
}};
- std::vector<unique_ptr<CppDeclaration>> declarations;
+ std::vector<unique_ptr<Declaration>> declarations;
declarations.push_back(std::move(bn_class));
- unique_ptr<CppNamespace> ns{new CppNamespace{"android", std::move(declarations)}};
+ unique_ptr<CppNamespace> ns{
+ new CppNamespace{"android", std::move(declarations)}};
- unique_ptr<CppDocument> bn_header{new CppHeader{bn_name + "_H",
- {"binder/IInterface.h",
- i_name + ".h"},
- std::move(ns) }};
+ unique_ptr<Document> bn_header{new CppHeader{bn_name + "_H",
+ {"binder/IInterface.h",
+ i_name + ".h"},
+ std::move(ns) }};
return bn_header;
}
-unique_ptr<CppDocument> BuildInterfaceHeader(interface_type* parsed_doc) {
+unique_ptr<Document> BuildInterfaceHeader(interface_type* parsed_doc) {
unique_ptr<CppNamespace> ns{new CppNamespace{"android", {}}};
- return unique_ptr<CppDocument>{new CppSource{ {}, std::move(ns)}};
+ return unique_ptr<Document>{new CppSource{ {}, std::move(ns)}};
}
-bool GenerateCppForFile(const std::string& name, unique_ptr<CppDocument> doc) {
+bool GenerateCppForFile(const std::string& name, unique_ptr<Document> doc) {
if (!doc) {
return false;
}
@@ -222,5 +225,6 @@
return success;
}
-} // namespace android
+} // namespace cpp
} // namespace aidl
+} // namespace android
diff --git a/generate_cpp.h b/generate_cpp.h
index 2c321b0..3a01cf2 100644
--- a/generate_cpp.h
+++ b/generate_cpp.h
@@ -22,10 +22,12 @@
namespace android {
namespace aidl {
+namespace cpp {
bool GenerateCpp(const CppOptions& options, interface_type* parsed_doc);
-} // namespace android
+} // namespace cpp
} // namespace aidl
+} // namespace android
#endif // AIDL_GENERATE_CPP_H_
diff --git a/generate_cpp_unittest.cpp b/generate_cpp_unittest.cpp
index b3b70ab..93ede8a 100644
--- a/generate_cpp_unittest.cpp
+++ b/generate_cpp_unittest.cpp
@@ -27,9 +27,10 @@
namespace android {
namespace aidl {
+namespace cpp {
namespace internals {
-unique_ptr<CppDocument> BuildClientHeader(interface_type* parsed_doc);
+unique_ptr<Document> BuildClientHeader(interface_type* parsed_doc);
}
namespace {
@@ -77,7 +78,7 @@
interface_type *interface = (interface_type*)parsed_doc;
- unique_ptr<CppDocument> doc = internals::BuildClientHeader(interface);
+ unique_ptr<Document> doc = internals::BuildClientHeader(interface);
string output;
unique_ptr<CodeWriter> cw = GetStringWriter(&output);
@@ -87,5 +88,6 @@
EXPECT_EQ(kExpectedTrivialClientHeaderOutput, output);
}
+} // namespace cpp
} // namespace aidl
} // namespace android