virtual std::vector<grpc::string> namespace_parts() const = 0;
virtual grpc::string name() const = 0;
+ virtual bool is_internal() const = 0;
virtual int method_count() const = 0;
virtual std::unique_ptr<const Method> method(int i) const = 0;
printer->Print("\t\tself.defaultCallOptions = defaultCallOptions\n");
printer->Print("\t}");
printer->Print("\n");
- vars["GenAccess"] = "public";
+ vars["GenAccess"] = service->is_internal() ? "internal" : "public";
for (auto it = 0; it < service->method_count(); it++) {
auto method = service->method(it);
vars["Input"] = GenerateMessage(method->get_input_namespace_parts(), method->get_input_type_name());
if (!file->package().empty()) { vars["PATH"].append("."); }
vars["ServiceQualifiedName"] = WrapInNameSpace(service->namespace_parts(), service->name());
vars["ServiceName"] = service->name();
- vars["ACCESS"] = "public";
+ vars["ACCESS"] = service->is_internal() ? "internal" : "public";
auto printer = file->CreatePrinter(&output);
printer->Print(vars,
"/// Usage: instantiate $ServiceQualifiedName$ServiceClient, then call "
std::string name() const { return method_->name; }
- // TODO: This method need to incorporate namespace for C++ side. Other language bindings
- // simply don't use this method.
+ // TODO: This method need to incorporate namespace for C++ side. Other
+ // language bindings simply don't use this method.
std::string GRPCType(const StructDef &sd) const {
return "flatbuffers::grpc::Message<" + sd.name + ">";
}
- std::vector<std::string> get_input_namespace_parts() const { return (*method_->request).defined_namespace->components; }
+ std::vector<std::string> get_input_namespace_parts() const {
+ return (*method_->request).defined_namespace->components;
+ }
std::string get_input_type_name() const { return (*method_->request).name; }
- std::vector<std::string> get_output_namespace_parts() const { return (*method_->response).defined_namespace->components; }
+ std::vector<std::string> get_output_namespace_parts() const {
+ return (*method_->response).defined_namespace->components;
+ }
std::string get_output_type_name() const { return (*method_->response).name; }
return service_->doc_comment;
}
- std::vector<grpc::string> namespace_parts() const { return service_->defined_namespace->components; }
+ std::vector<grpc::string> namespace_parts() const {
+ return service_->defined_namespace->components;
+ }
std::string name() const { return service_->name; }
+ bool is_internal() const {
+ return service_->Definition::attributes.Lookup("private") ? true : false;
+ }
int method_count() const {
return static_cast<int>(service_->calls.vec.size());
}
inline std::string GenArrayMainBody(const std::string &optional) {
- return "public func {{VALUENAME}}(at index: Int32) -> {{VALUETYPE}}" +
+ return "{{ACCESS_TYPE}} func {{VALUENAME}}(at index: Int32) -> "
+ "{{VALUETYPE}}" +
optional + " { ";
}
// Generates the create function for swift
void GenStructWriter(const StructDef &struct_def) {
+ auto is_private_access = struct_def.attributes.Lookup("private");
+ code_.SetValue("ACCESS_TYPE", is_private_access ? "internal" : "public");
code_.SetValue("STRUCTNAME", NameWrappedInNameSpace(struct_def));
code_.SetValue("SHORT_STRUCTNAME", Name(struct_def));
code_ += "extension {{STRUCTNAME}} {";
Indent();
- code_ += "public static func create{{SHORT_STRUCTNAME}}(\\";
+ code_ += "{{ACCESS_TYPE}} static func create{{SHORT_STRUCTNAME}}(\\";
std::string func_header = "";
GenerateStructArgs(struct_def, &func_header, "", "");
code_ += func_header.substr(0, func_header.size() - 2) + "\\";
code_.SetValue("PROTOCOL",
struct_def.fixed ? "Readable" : "FlatBufferObject");
code_.SetValue("OBJECTTYPE", struct_def.fixed ? "Struct" : "Table");
- code_ += "public struct {{STRUCTNAME}}: {{PROTOCOL}}\\";
+ code_ += "{{ACCESS_TYPE}} struct {{STRUCTNAME}}: {{PROTOCOL}}\\";
if (!struct_def.fixed && parser_.opts.generate_object_based_api)
code_ += ", ObjectAPI\\";
code_ += " {\n";
Indent();
code_ += ValidateFunc();
- code_ += "public var __buffer: ByteBuffer! { return {{ACCESS}}.bb }";
+ code_ +=
+ "{{ACCESS_TYPE}} var __buffer: ByteBuffer! { return {{ACCESS}}.bb }";
code_ += "private var {{ACCESS}}: {{OBJECTTYPE}}\n";
if (struct_def.fixed) {
code_.SetValue("BYTESIZE", NumToString(struct_def.bytesize));
code_.SetValue("MINALIGN", NumToString(struct_def.minalign));
- code_ += "public static var size = {{BYTESIZE}}";
- code_ += "public static var alignment = {{MINALIGN}}";
+ code_ += "{{ACCESS_TYPE}} static var size = {{BYTESIZE}}";
+ code_ += "{{ACCESS_TYPE}} static var alignment = {{MINALIGN}}";
} else {
if (parser_.file_identifier_.length()) {
code_.SetValue("FILENAME", parser_.file_identifier_);
code_ +=
- "public static func finish(_ fbb: inout FlatBufferBuilder, end: "
+ "{{ACCESS_TYPE}} static func finish(_ fbb: inout "
+ "FlatBufferBuilder, end: "
"Offset<UOffset>, prefix: Bool = false) { fbb.finish(offset: end, "
"fileId: "
"\"{{FILENAME}}\", addPrefix: prefix) }";
}
code_ +=
- "public static func getRootAs{{SHORT_STRUCTNAME}}(bb: ByteBuffer) -> "
+ "{{ACCESS_TYPE}} static func getRootAs{{SHORT_STRUCTNAME}}(bb: "
+ "ByteBuffer) -> "
"{{STRUCTNAME}} { return {{STRUCTNAME}}(Table(bb: bb, position: "
"Int32(bb.read(def: UOffset.self, position: bb.reader)) + "
"Int32(bb.reader))) }\n";
code_ += "private init(_ t: Table) { {{ACCESS}} = t }";
}
code_ +=
- "public init(_ bb: ByteBuffer, o: Int32) { {{ACCESS}} = "
+ "{{ACCESS_TYPE}} init(_ bb: ByteBuffer, o: Int32) { {{ACCESS}} = "
"{{OBJECTTYPE}}(bb: "
"bb, position: o) }";
code_ += "";
// Generates the reader for swift
void GenTable(const StructDef &struct_def) {
+ auto is_private_access = struct_def.attributes.Lookup("private");
+ code_.SetValue("ACCESS_TYPE", is_private_access ? "internal" : "public");
+
GenObjectHeader(struct_def);
GenTableAccessors(struct_def);
GenTableReader(struct_def);
void GenTableAccessors(const StructDef &struct_def) {
// Generate field id constants.
if (struct_def.fields.vec.size() > 0) {
- code_ += "enum {{TABLEOFFSET}}: VOffset {";
+ code_ += "private enum {{TABLEOFFSET}}: VOffset {";
Indent();
for (auto it = struct_def.fields.vec.begin();
it != struct_def.fields.vec.end(); ++it) {
void GenerateObjectAPIExtensionHeader() {
code_ += "\n";
- code_ += "public mutating func unpack() -> " +
+ code_ += "{{ACCESS_TYPE}} mutating func unpack() -> " +
ObjectAPIName("{{STRUCTNAME}}") + " {";
Indent();
code_ += "return " + ObjectAPIName("{{STRUCTNAME}}") + "(&self)";
Outdent();
code_ += "}";
code_ +=
- "public static func pack(_ builder: inout FlatBufferBuilder, obj: "
+ "{{ACCESS_TYPE}} static func pack(_ builder: inout FlatBufferBuilder, "
+ "obj: "
"inout " +
ObjectAPIName("{{STRUCTNAME}}") + "?) -> Offset<UOffset> {";
Indent();
code_ += "}";
code_ += "";
code_ +=
- "public static func pack(_ builder: inout FlatBufferBuilder, obj: "
+ "{{ACCESS_TYPE}} static func pack(_ builder: inout FlatBufferBuilder, "
+ "obj: "
"inout " +
ObjectAPIName("{{STRUCTNAME}}") + ") -> Offset<UOffset> {";
Indent();
code_.SetValue("NUMBEROFFIELDS", NumToString(struct_def.fields.vec.size()));
code_ +=
- "public static func start{{SHORT_STRUCTNAME}}(_ fbb: inout "
+ "{{ACCESS_TYPE}} static func start{{SHORT_STRUCTNAME}}(_ fbb: inout "
"FlatBufferBuilder) -> "
"UOffset { fbb.startTable(with: {{NUMBEROFFIELDS}}) }";
GenTableWriterFields(field, &create_func_body, &create_func_header);
}
code_ +=
- "public static func end{{SHORT_STRUCTNAME}}(_ fbb: inout "
+ "{{ACCESS_TYPE}} static func end{{SHORT_STRUCTNAME}}(_ fbb: inout "
"FlatBufferBuilder, "
"start: "
"UOffset) -> Offset<UOffset> { let end = Offset<UOffset>(offset: "
code_ += "; return end }";
if (should_generate_create) {
- code_ += "public static func create{{SHORT_STRUCTNAME}}(";
+ code_ += "{{ACCESS_TYPE}} static func create{{SHORT_STRUCTNAME}}(";
Indent();
code_ += "_ fbb: inout FlatBufferBuilder,";
for (auto it = create_func_header.begin(); it < create_func_header.end();
code_.SetValue("VOFFSET", NumToString(key_field->value.offset));
code_ +=
- "public static func "
+ "{{ACCESS_TYPE}} static func "
"sortVectorOf{{SHORT_VALUENAME}}(offsets:[Offset<UOffset>], "
"_ fbb: inout FlatBufferBuilder) -> Offset<UOffset> {";
Indent();
? "VectorOf("
: "(";
auto body = "add" + check_if_vector + name + ": ";
- code_ += "public static func " + body + "\\";
+ code_ += "{{ACCESS_TYPE}} static func " + body + "\\";
create_func_body.push_back("{{STRUCTNAME}}." + body + name + ", &fbb)");
code_.SetValue("CONSTANT", "nil");
code_ += GenReaderMainBody(is_required) + GenOffset() +
required_reader + "{{ACCESS}}.string(at: o) }";
- code_ += "public var {{VALUENAME}}SegmentArray: [UInt8]" + is_required +
+ code_ += "{{ACCESS_TYPE}} var {{VALUENAME}}SegmentArray: [UInt8]" +
+ is_required +
" { return "
"{{ACCESS}}.getVector(at: {{TABLEOFFSET}}.{{OFFSET}}.v) }";
break;
case BASE_TYPE_UNION:
code_.SetValue("CONSTANT", "nil");
code_ +=
- "public func {{VALUENAME}}<T: FlatBufferObject>(type: "
+ "{{ACCESS_TYPE}} func {{VALUENAME}}<T: FlatBufferObject>(type: "
"T.Type) -> T" +
is_required + " { " + GenOffset() + required_reader +
"{{ACCESS}}.union(o) }";
const std::string &const_string) {
auto vectortype = field.value.type.VectorType();
code_.SetValue("SIZE", NumToString(InlineSize(vectortype)));
- code_ += "public var {{VALUENAME}}Count: Int32 { " + GenOffset() +
+ code_ += "{{ACCESS_TYPE}} var {{VALUENAME}}Count: Int32 { " + GenOffset() +
const_string + "{{ACCESS}}.vector(count: o) }";
code_.SetValue("CONSTANT", IsScalar(vectortype.base_type) == true
? field.value.constant
code_ += GenArrayMainBody(nullable) + GenOffset() + "\\";
} else {
code_ +=
- "public func {{VALUENAME}}<T: FlatBufferObject>(at index: "
+ "{{ACCESS_TYPE}} func {{VALUENAME}}<T: FlatBufferObject>(at index: "
"Int32, type: T.Type) -> T? { " +
GenOffset() + "\\";
}
"{{ACCESS}}.directRead(of: {{VALUETYPE}}.self, offset: "
"{{ACCESS}}.vector(at: o) + index * {{SIZE}}) }";
code_ +=
- "public var {{VALUENAME}}: [{{VALUETYPE}}] { return "
+ "{{ACCESS_TYPE}} var {{VALUENAME}}: [{{VALUETYPE}}] { return "
"{{ACCESS}}.getVector(at: {{TABLEOFFSET}}.{{OFFSET}}.v) ?? [] }";
if (parser_.opts.mutable_buffer) code_ += GenMutateArray();
return;
void GenByKeyFunctions(const FieldDef &key_field) {
code_.SetValue("TYPE", GenType(key_field.value.type));
code_ +=
- "public func {{VALUENAME}}By(key: {{TYPE}}) -> {{VALUETYPE}}? { \\";
+ "{{ACCESS_TYPE}} func {{VALUENAME}}By(key: {{TYPE}}) -> {{VALUETYPE}}? "
+ "{ \\";
code_ += GenOffset() +
"return o == 0 ? nil : {{VALUETYPE}}.lookupByKey(vector: "
"{{ACCESS}}.vector(at: o), key: key, fbb: {{ACCESS}}.bb) }";
// Generates the reader for swift
void GenStructReader(const StructDef &struct_def) {
+ auto is_private_access = struct_def.attributes.Lookup("private");
+ code_.SetValue("ACCESS_TYPE", is_private_access ? "internal" : "public");
+
GenObjectHeader(struct_def);
for (auto it = struct_def.fields.vec.begin();
it != struct_def.fields.vec.end(); ++it) {
void GenEnum(const EnumDef &enum_def) {
if (enum_def.generated) return;
+ auto is_private_access = enum_def.attributes.Lookup("private");
+ code_.SetValue("ACCESS_TYPE", is_private_access ? "internal" : "public");
code_.SetValue("ENUM_NAME", NameWrappedInNameSpace(enum_def));
code_.SetValue("BASE_TYPE", GenTypeBasic(enum_def.underlying_type, false));
GenComment(enum_def.doc_comment);
- code_ += "public enum {{ENUM_NAME}}: {{BASE_TYPE}}, Enum { ";
+ code_ += "{{ACCESS_TYPE}} enum {{ENUM_NAME}}: {{BASE_TYPE}}, Enum { ";
Indent();
- code_ += "public typealias T = {{BASE_TYPE}}";
+ code_ += "{{ACCESS_TYPE}} typealias T = {{BASE_TYPE}}";
code_ +=
- "public static var byteSize: Int { return "
+ "{{ACCESS_TYPE}} static var byteSize: Int { return "
"MemoryLayout<{{BASE_TYPE}}>.size "
"}";
- code_ += "public var value: {{BASE_TYPE}} { return self.rawValue }";
+ code_ +=
+ "{{ACCESS_TYPE}} var value: {{BASE_TYPE}} { return self.rawValue }";
for (auto it = enum_def.Vals().begin(); it != enum_def.Vals().end(); ++it) {
const auto &ev = **it;
auto name = Name(ev);
Outdent();
code_ += "}\n";
if (parser_.opts.generate_object_based_api && enum_def.is_union) {
- code_ += "struct {{ENUM_NAME}}Union {";
+ code_ += "{{ACCESS_TYPE}} struct {{ENUM_NAME}}Union {";
Indent();
- code_ += "var type: {{ENUM_NAME}}";
- code_ += "var value: NativeTable?";
- code_ += "init(_ v: NativeTable?, type: {{ENUM_NAME}}) {";
+ code_ += "{{ACCESS_TYPE}} var type: {{ENUM_NAME}}";
+ code_ += "{{ACCESS_TYPE}} var value: NativeTable?";
+ code_ += "{{ACCESS_TYPE}} init(_ v: NativeTable?, type: {{ENUM_NAME}}) {";
Indent();
code_ += "self.type = type";
code_ += "self.value = v";
Outdent();
code_ += "}";
code_ +=
- "func pack(builder: inout FlatBufferBuilder) -> Offset<UOffset> {";
+ "{{ACCESS_TYPE}} func pack(builder: inout FlatBufferBuilder) -> "
+ "Offset<UOffset> {";
Indent();
BuildUnionEnumSwitchCaseWritter(enum_def);
Outdent();
}
void GenObjectAPI(const StructDef &struct_def) {
- code_ +=
- "public class " + ObjectAPIName("{{STRUCTNAME}}") + ": NativeTable {\n";
+ code_ += "{{ACCESS_TYPE}} class " + ObjectAPIName("{{STRUCTNAME}}") +
+ ": NativeTable {\n";
std::vector<std::string> buffer_constructor;
std::vector<std::string> base_constructor;
Indent();
BuildObjectAPIConstructor(base_constructor);
if (!struct_def.fixed)
code_ +=
- "func serialize() -> ByteBuffer { return serialize(type: "
+ "{{ACCESS_TYPE}} func serialize() -> ByteBuffer { return "
+ "serialize(type: "
"{{STRUCTNAME}}.self) }\n";
Outdent();
code_ += "}";
void BuildObjectAPIConstructor(const std::vector<std::string> &body,
const std::string &header = "") {
code_.SetValue("HEADER", header);
- code_ += "init({{HEADER}}) {";
+ code_ += "{{ACCESS_TYPE}} init({{HEADER}}) {";
Indent();
for (auto it = body.begin(); it < body.end(); ++it) code_ += *it;
Outdent();
std::string question_mark =
(field.required || (optional && is_fixed) ? "" : "?");
- code_ += "var {{VALUENAME}}: {{VALUETYPE}}" + question_mark;
+ code_ +=
+ "{{ACCESS_TYPE}} var {{VALUENAME}}: {{VALUETYPE}}" + question_mark;
buffer_constructor.push_back("" + name + " = __" + name +
(field.required ? "!" : question_mark) +
".unpack()");
break;
}
case BASE_TYPE_STRING: {
- code_ += "var {{VALUENAME}}: String" + is_required;
+ code_ += "{{ACCESS_TYPE}} var {{VALUENAME}}: String" + is_required;
buffer_constructor.push_back(name + " = _t." + name);
if (field.required) base_constructor.push_back(name + " = \"\"");
break;
std::string nullable = field.nullable ? "?" : "";
if (IsScalar(field.value.type.base_type) &&
!IsBool(field.value.type.base_type) && !IsEnum(field.value.type)) {
- code_ += "var {{VALUENAME}}: {{VALUETYPE}}" + nullable;
+ code_ +=
+ "{{ACCESS_TYPE}} var {{VALUENAME}}: {{VALUETYPE}}" + nullable;
if (!field.nullable)
base_constructor.push_back(name + " = " + field.value.constant);
break;
auto default_value = IsEnum(field.value.type)
? GenEnumDefaultValue(field)
: field.value.constant;
- code_ += "var {{VALUENAME}}: {{VALUETYPE}}";
+ code_ += "{{ACCESS_TYPE}} var {{VALUENAME}}: {{VALUETYPE}}";
base_constructor.push_back(name + " = " + default_value);
break;
}
if (IsBool(field.value.type.base_type)) {
- code_ += "var {{VALUENAME}}: Bool" + nullable;
+ code_ += "{{ACCESS_TYPE}} var {{VALUENAME}}: Bool" + nullable;
std::string default_value =
"0" == field.value.constant ? "false" : "true";
if (!field.nullable)
switch (vectortype.base_type) {
case BASE_TYPE_STRUCT: {
code_.SetValue("VALUETYPE", GenType(vectortype, true));
- code_ += "var {{VALUENAME}}: [{{VALUETYPE}}?]";
+ code_ += "{{ACCESS_TYPE}} var {{VALUENAME}}: [{{VALUETYPE}}?]";
buffer_constructor.push_back(indentation + "var __v_ = _t." + name +
"(at: index)");
buffer_constructor.push_back(indentation + name +
code_.SetValue("VALUETYPE", (vectortype.base_type == BASE_TYPE_STRING
? "String?"
: GenType(vectortype)));
- code_ += "var {{VALUENAME}}: [{{VALUETYPE}}]";
+ code_ += "{{ACCESS_TYPE}} var {{VALUENAME}}: [{{VALUETYPE}}]";
if (IsEnum(vectortype) && vectortype.base_type != BASE_TYPE_UNION) {
auto default_value = IsEnum(field.value.type)
const bool is_vector = false) {
auto field_name = NameWrappedInNameSpace(ev);
code_.SetValue("VALUETYPE", field_name);
- code_ += "var {{VALUENAME}}: \\";
+ code_ += "{{ACCESS_TYPE}} var {{VALUENAME}}: \\";
code_ += is_vector ? "[{{VALUETYPE}}Union?]" : "{{VALUETYPE}}Union?";
auto vector_reader = is_vector ? "(at: index" : "";
void AddMinOrMaxEnumValue(const std::string &str, const std::string &type) {
auto current_value = str;
code_.SetValue(type, current_value);
- code_ += "public static var " + type + ": {{ENUM_NAME}} { return .{{" +
- type + "}} }";
+ code_ += "{{ACCESS_TYPE}} static var " + type +
+ ": {{ENUM_NAME}} { return .{{" + type + "}} }";
}
void GenLookup(const FieldDef &key_field) {
}
std::string GenReaderMainBody(const std::string &optional = "") {
- return "public var {{VALUENAME}}: {{VALUETYPE}}" + optional + " { ";
+ return "{{ACCESS_TYPE}} var {{VALUENAME}}: {{VALUETYPE}}" + optional +
+ " { ";
}
std::string GenReader(const std::string &type,
std::string GenMutate(const std::string &offset,
const std::string &get_offset, bool isRaw = false) {
- return "@discardableResult public func mutate({{VALUENAME}}: "
+ return "@discardableResult {{ACCESS_TYPE}} func mutate({{VALUENAME}}: "
"{{VALUETYPE}}) -> Bool {" +
get_offset + " return {{ACCESS}}.mutate({{VALUENAME}}" +
(isRaw ? ".rawValue" : "") + ", index: " + offset + ") }";
}
std::string GenMutateArray() {
- return "public func mutate({{VALUENAME}}: {{VALUETYPE}}, at index: "
+ return "{{ACCESS_TYPE}} func mutate({{VALUENAME}}: {{VALUETYPE}}, at "
+ "index: "
"Int32) -> Bool { " +
GenOffset() +
"return {{ACCESS}}.directMutate({{VALUENAME}}, index: "
private init(_ t: Table) { _accessor = t }
public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
- enum VTOFFSET: VOffset {
+ private enum VTOFFSET: VOffset {
case message = 4
var v: Int32 { Int32(self.rawValue) }
var p: VOffset { self.rawValue }
private init(_ t: Table) { _accessor = t }
public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
- enum VTOFFSET: VOffset {
+ private enum VTOFFSET: VOffset {
case name = 4
var v: Int32 { Int32(self.rawValue) }
var p: VOffset { self.rawValue }
private init(_ t: Table) { _accessor = t }
public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
- enum VTOFFSET: VOffset {
+ private enum VTOFFSET: VOffset {
case name = 4
case numGreetings = 6
var v: Int32 { Int32(self.rawValue) }
],
dependencies: [
.package(path: "../../swift/"),
- .package(url: "https://github.com/grpc/grpc-swift.git", from: "1.0.0-alpha.17")
+ .package(url: "https://github.com/grpc/grpc-swift.git", from: "1.0.0-alpha.18")
],
targets: [
.target(name: "SwiftFlatBuffers"),
import Foundation
@testable import FlatBuffers
-public typealias Test = MyGame_Example_Test
-public typealias Monster = MyGame_Example_Monster
-public typealias Vec3 = MyGame_Example_Vec3
-public typealias Stat = MyGame_Example_Stat
+typealias Test = MyGame_Example_Test
+typealias Monster = MyGame_Example_Monster
+typealias Vec3 = MyGame_Example_Vec3
+typealias Stat = MyGame_Example_Stat
class FlatBuffersMonsterWriterTests: XCTestCase {
public static var min: MyGame_Example_Any_ { return .none_ }
}
-struct MyGame_Example_Any_Union {
- var type: MyGame_Example_Any_
- var value: NativeTable?
- init(_ v: NativeTable?, type: MyGame_Example_Any_) {
+public struct MyGame_Example_Any_Union {
+ public var type: MyGame_Example_Any_
+ public var value: NativeTable?
+ public init(_ v: NativeTable?, type: MyGame_Example_Any_) {
self.type = type
self.value = v
}
- func pack(builder: inout FlatBufferBuilder) -> Offset<UOffset> {
+ public func pack(builder: inout FlatBufferBuilder) -> Offset<UOffset> {
switch type {
case .monster:
var __obj = value as? MyGame_Example_MonsterT
public static var min: MyGame_Example_AnyUniqueAliases { return .none_ }
}
-struct MyGame_Example_AnyUniqueAliasesUnion {
- var type: MyGame_Example_AnyUniqueAliases
- var value: NativeTable?
- init(_ v: NativeTable?, type: MyGame_Example_AnyUniqueAliases) {
+public struct MyGame_Example_AnyUniqueAliasesUnion {
+ public var type: MyGame_Example_AnyUniqueAliases
+ public var value: NativeTable?
+ public init(_ v: NativeTable?, type: MyGame_Example_AnyUniqueAliases) {
self.type = type
self.value = v
}
- func pack(builder: inout FlatBufferBuilder) -> Offset<UOffset> {
+ public func pack(builder: inout FlatBufferBuilder) -> Offset<UOffset> {
switch type {
case .m:
var __obj = value as? MyGame_Example_MonsterT
public static var min: MyGame_Example_AnyAmbiguousAliases { return .none_ }
}
-struct MyGame_Example_AnyAmbiguousAliasesUnion {
- var type: MyGame_Example_AnyAmbiguousAliases
- var value: NativeTable?
- init(_ v: NativeTable?, type: MyGame_Example_AnyAmbiguousAliases) {
+public struct MyGame_Example_AnyAmbiguousAliasesUnion {
+ public var type: MyGame_Example_AnyAmbiguousAliases
+ public var value: NativeTable?
+ public init(_ v: NativeTable?, type: MyGame_Example_AnyAmbiguousAliases) {
self.type = type
self.value = v
}
- func pack(builder: inout FlatBufferBuilder) -> Offset<UOffset> {
+ public func pack(builder: inout FlatBufferBuilder) -> Offset<UOffset> {
switch type {
case .m1:
var __obj = value as? MyGame_Example_MonsterT
public class MyGame_Example_TestT: NativeTable {
- var a: Int16
- var b: Int8
+ public var a: Int16
+ public var b: Int8
- init(_ _t: inout MyGame_Example_Test) {
+ public init(_ _t: inout MyGame_Example_Test) {
a = _t.a
b = _t.b
}
- init() {
+ public init() {
a = 0
b = 0
}
public class MyGame_Example_Vec3T: NativeTable {
- var x: Float32
- var y: Float32
- var z: Float32
- var test1: Double
- var test2: MyGame_Example_Color
- var test3: MyGame_Example_TestT
+ public var x: Float32
+ public var y: Float32
+ public var z: Float32
+ public var test1: Double
+ public var test2: MyGame_Example_Color
+ public var test3: MyGame_Example_TestT
- init(_ _t: inout MyGame_Example_Vec3) {
+ public init(_ _t: inout MyGame_Example_Vec3) {
x = _t.x
y = _t.y
z = _t.z
test3 = __test3.unpack()
}
- init() {
+ public init() {
x = 0.0
y = 0.0
z = 0.0
public class MyGame_Example_AbilityT: NativeTable {
- var id: UInt32
- var distance: UInt32
+ public var id: UInt32
+ public var distance: UInt32
- init(_ _t: inout MyGame_Example_Ability) {
+ public init(_ _t: inout MyGame_Example_Ability) {
id = _t.id
distance = _t.distance
}
- init() {
+ public init() {
id = 0
distance = 0
}
public class MyGame_InParentNamespaceT: NativeTable {
- init(_ _t: inout MyGame_InParentNamespace) {
+ public init(_ _t: inout MyGame_InParentNamespace) {
}
- init() {
+ public init() {
}
- func serialize() -> ByteBuffer { return serialize(type: MyGame_InParentNamespace.self) }
+ public func serialize() -> ByteBuffer { return serialize(type: MyGame_InParentNamespace.self) }
}
public struct MyGame_Example2_Monster: FlatBufferObject, ObjectAPI {
public class MyGame_Example2_MonsterT: NativeTable {
- init(_ _t: inout MyGame_Example2_Monster) {
+ public init(_ _t: inout MyGame_Example2_Monster) {
}
- init() {
+ public init() {
}
- func serialize() -> ByteBuffer { return serialize(type: MyGame_Example2_Monster.self) }
+ public func serialize() -> ByteBuffer { return serialize(type: MyGame_Example2_Monster.self) }
}
-public struct MyGame_Example_TestSimpleTableWithEnum: FlatBufferObject, ObjectAPI {
+internal struct MyGame_Example_TestSimpleTableWithEnum: FlatBufferObject, ObjectAPI {
static func validateVersion() { FlatBuffersVersion_1_12_0() }
- public var __buffer: ByteBuffer! { return _accessor.bb }
+ internal var __buffer: ByteBuffer! { return _accessor.bb }
private var _accessor: Table
- public static func finish(_ fbb: inout FlatBufferBuilder, end: Offset<UOffset>, prefix: Bool = false) { fbb.finish(offset: end, fileId: "MONS", addPrefix: prefix) }
- public static func getRootAsTestSimpleTableWithEnum(bb: ByteBuffer) -> MyGame_Example_TestSimpleTableWithEnum { return MyGame_Example_TestSimpleTableWithEnum(Table(bb: bb, position: Int32(bb.read(def: UOffset.self, position: bb.reader)) + Int32(bb.reader))) }
+ internal static func finish(_ fbb: inout FlatBufferBuilder, end: Offset<UOffset>, prefix: Bool = false) { fbb.finish(offset: end, fileId: "MONS", addPrefix: prefix) }
+ internal static func getRootAsTestSimpleTableWithEnum(bb: ByteBuffer) -> MyGame_Example_TestSimpleTableWithEnum { return MyGame_Example_TestSimpleTableWithEnum(Table(bb: bb, position: Int32(bb.read(def: UOffset.self, position: bb.reader)) + Int32(bb.reader))) }
private init(_ t: Table) { _accessor = t }
- public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
+ internal init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
- enum VTOFFSET: VOffset {
+ private enum VTOFFSET: VOffset {
case color = 4
var v: Int32 { Int32(self.rawValue) }
var p: VOffset { self.rawValue }
}
- public var color: MyGame_Example_Color { let o = _accessor.offset(VTOFFSET.color.v); return o == 0 ? .green : MyGame_Example_Color(rawValue: _accessor.readBuffer(of: UInt8.self, at: o)) ?? .green }
- @discardableResult public func mutate(color: MyGame_Example_Color) -> Bool {let o = _accessor.offset(VTOFFSET.color.v); return _accessor.mutate(color.rawValue, index: o) }
- public static func startTestSimpleTableWithEnum(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 1) }
- public static func add(color: MyGame_Example_Color, _ fbb: inout FlatBufferBuilder) { fbb.add(element: color.rawValue, def: 2, at: VTOFFSET.color.p) }
- public static func endTestSimpleTableWithEnum(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset<UOffset> { let end = Offset<UOffset>(offset: fbb.endTable(at: start)); return end }
- public static func createTestSimpleTableWithEnum(
+ internal var color: MyGame_Example_Color { let o = _accessor.offset(VTOFFSET.color.v); return o == 0 ? .green : MyGame_Example_Color(rawValue: _accessor.readBuffer(of: UInt8.self, at: o)) ?? .green }
+ @discardableResult internal func mutate(color: MyGame_Example_Color) -> Bool {let o = _accessor.offset(VTOFFSET.color.v); return _accessor.mutate(color.rawValue, index: o) }
+ internal static func startTestSimpleTableWithEnum(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 1) }
+ internal static func add(color: MyGame_Example_Color, _ fbb: inout FlatBufferBuilder) { fbb.add(element: color.rawValue, def: 2, at: VTOFFSET.color.p) }
+ internal static func endTestSimpleTableWithEnum(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset<UOffset> { let end = Offset<UOffset>(offset: fbb.endTable(at: start)); return end }
+ internal static func createTestSimpleTableWithEnum(
_ fbb: inout FlatBufferBuilder,
color: MyGame_Example_Color = .green
) -> Offset<UOffset> {
}
- public mutating func unpack() -> MyGame_Example_TestSimpleTableWithEnumT {
+ internal mutating func unpack() -> MyGame_Example_TestSimpleTableWithEnumT {
return MyGame_Example_TestSimpleTableWithEnumT(&self)
}
- public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_TestSimpleTableWithEnumT?) -> Offset<UOffset> {
+ internal static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_TestSimpleTableWithEnumT?) -> Offset<UOffset> {
guard var obj = obj else { return Offset<UOffset>() }
return pack(&builder, obj: &obj)
}
- public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_TestSimpleTableWithEnumT) -> Offset<UOffset> {
+ internal static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_TestSimpleTableWithEnumT) -> Offset<UOffset> {
let __root = MyGame_Example_TestSimpleTableWithEnum.startTestSimpleTableWithEnum(&builder)
MyGame_Example_TestSimpleTableWithEnum.add(color: obj.color, &builder)
return MyGame_Example_TestSimpleTableWithEnum.endTestSimpleTableWithEnum(&builder, start: __root)
}
}
-public class MyGame_Example_TestSimpleTableWithEnumT: NativeTable {
+internal class MyGame_Example_TestSimpleTableWithEnumT: NativeTable {
- var color: MyGame_Example_Color
+ internal var color: MyGame_Example_Color
- init(_ _t: inout MyGame_Example_TestSimpleTableWithEnum) {
+ internal init(_ _t: inout MyGame_Example_TestSimpleTableWithEnum) {
color = _t.color
}
- init() {
+ internal init() {
color = .green
}
- func serialize() -> ByteBuffer { return serialize(type: MyGame_Example_TestSimpleTableWithEnum.self) }
+ internal func serialize() -> ByteBuffer { return serialize(type: MyGame_Example_TestSimpleTableWithEnum.self) }
}
public struct MyGame_Example_Stat: FlatBufferObject, ObjectAPI {
private init(_ t: Table) { _accessor = t }
public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
- enum VTOFFSET: VOffset {
+ private enum VTOFFSET: VOffset {
case id = 4
case val = 6
case count = 8
public class MyGame_Example_StatT: NativeTable {
- var id: String?
- var val: Int64
- var count: UInt16
+ public var id: String?
+ public var val: Int64
+ public var count: UInt16
- init(_ _t: inout MyGame_Example_Stat) {
+ public init(_ _t: inout MyGame_Example_Stat) {
id = _t.id
val = _t.val
count = _t.count
}
- init() {
+ public init() {
val = 0
count = 0
}
- func serialize() -> ByteBuffer { return serialize(type: MyGame_Example_Stat.self) }
+ public func serialize() -> ByteBuffer { return serialize(type: MyGame_Example_Stat.self) }
}
public struct MyGame_Example_Referrable: FlatBufferObject, ObjectAPI {
private init(_ t: Table) { _accessor = t }
public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
- enum VTOFFSET: VOffset {
+ private enum VTOFFSET: VOffset {
case id = 4
var v: Int32 { Int32(self.rawValue) }
var p: VOffset { self.rawValue }
public class MyGame_Example_ReferrableT: NativeTable {
- var id: UInt64
+ public var id: UInt64
- init(_ _t: inout MyGame_Example_Referrable) {
+ public init(_ _t: inout MyGame_Example_Referrable) {
id = _t.id
}
- init() {
+ public init() {
id = 0
}
- func serialize() -> ByteBuffer { return serialize(type: MyGame_Example_Referrable.self) }
+ public func serialize() -> ByteBuffer { return serialize(type: MyGame_Example_Referrable.self) }
}
/// an example documentation comment: "monster object"
private init(_ t: Table) { _accessor = t }
public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
- enum VTOFFSET: VOffset {
+ private enum VTOFFSET: VOffset {
case pos = 4
case mana = 6
case hp = 8
public class MyGame_Example_MonsterT: NativeTable {
- var pos: MyGame_Example_Vec3T?
- var mana: Int16
- var hp: Int16
- var name: String
- var inventory: [UInt8]
- var color: MyGame_Example_Color
- var test: MyGame_Example_Any_Union?
- var test4: [MyGame_Example_TestT?]
- var testarrayofstring: [String?]
- var testarrayoftables: [MyGame_Example_MonsterT?]
- var enemy: MyGame_Example_MonsterT?
- var testnestedflatbuffer: [UInt8]
- var testempty: MyGame_Example_StatT?
- var testbool: Bool
- var testhashs32Fnv1: Int32
- var testhashu32Fnv1: UInt32
- var testhashs64Fnv1: Int64
- var testhashu64Fnv1: UInt64
- var testhashs32Fnv1a: Int32
- var testhashu32Fnv1a: UInt32
- var testhashs64Fnv1a: Int64
- var testhashu64Fnv1a: UInt64
- var testarrayofbools: [Bool]
- var testf: Float32
- var testf2: Float32
- var testf3: Float32
- var testarrayofstring2: [String?]
- var testarrayofsortedstruct: [MyGame_Example_AbilityT?]
- var flex: [UInt8]
- var test5: [MyGame_Example_TestT?]
- var vectorOfLongs: [Int64]
- var vectorOfDoubles: [Double]
- var parentNamespaceTest: MyGame_InParentNamespaceT?
- var vectorOfReferrables: [MyGame_Example_ReferrableT?]
- var singleWeakReference: UInt64
- var vectorOfWeakReferences: [UInt64]
- var vectorOfStrongReferrables: [MyGame_Example_ReferrableT?]
- var coOwningReference: UInt64
- var vectorOfCoOwningReferences: [UInt64]
- var nonOwningReference: UInt64
- var vectorOfNonOwningReferences: [UInt64]
- var anyUnique: MyGame_Example_AnyUniqueAliasesUnion?
- var anyAmbiguous: MyGame_Example_AnyAmbiguousAliasesUnion?
- var vectorOfEnums: [MyGame_Example_Color]
- var signedEnum: MyGame_Example_Race
-
- init(_ _t: inout MyGame_Example_Monster) {
+ public var pos: MyGame_Example_Vec3T?
+ public var mana: Int16
+ public var hp: Int16
+ public var name: String
+ public var inventory: [UInt8]
+ public var color: MyGame_Example_Color
+ public var test: MyGame_Example_Any_Union?
+ public var test4: [MyGame_Example_TestT?]
+ public var testarrayofstring: [String?]
+ public var testarrayoftables: [MyGame_Example_MonsterT?]
+ public var enemy: MyGame_Example_MonsterT?
+ public var testnestedflatbuffer: [UInt8]
+ public var testempty: MyGame_Example_StatT?
+ public var testbool: Bool
+ public var testhashs32Fnv1: Int32
+ public var testhashu32Fnv1: UInt32
+ public var testhashs64Fnv1: Int64
+ public var testhashu64Fnv1: UInt64
+ public var testhashs32Fnv1a: Int32
+ public var testhashu32Fnv1a: UInt32
+ public var testhashs64Fnv1a: Int64
+ public var testhashu64Fnv1a: UInt64
+ public var testarrayofbools: [Bool]
+ public var testf: Float32
+ public var testf2: Float32
+ public var testf3: Float32
+ public var testarrayofstring2: [String?]
+ public var testarrayofsortedstruct: [MyGame_Example_AbilityT?]
+ public var flex: [UInt8]
+ public var test5: [MyGame_Example_TestT?]
+ public var vectorOfLongs: [Int64]
+ public var vectorOfDoubles: [Double]
+ public var parentNamespaceTest: MyGame_InParentNamespaceT?
+ public var vectorOfReferrables: [MyGame_Example_ReferrableT?]
+ public var singleWeakReference: UInt64
+ public var vectorOfWeakReferences: [UInt64]
+ public var vectorOfStrongReferrables: [MyGame_Example_ReferrableT?]
+ public var coOwningReference: UInt64
+ public var vectorOfCoOwningReferences: [UInt64]
+ public var nonOwningReference: UInt64
+ public var vectorOfNonOwningReferences: [UInt64]
+ public var anyUnique: MyGame_Example_AnyUniqueAliasesUnion?
+ public var anyAmbiguous: MyGame_Example_AnyAmbiguousAliasesUnion?
+ public var vectorOfEnums: [MyGame_Example_Color]
+ public var signedEnum: MyGame_Example_Race
+
+ public init(_ _t: inout MyGame_Example_Monster) {
var __pos = _t.pos
pos = __pos?.unpack()
mana = _t.mana
signedEnum = _t.signedEnum
}
- init() {
+ public init() {
pos = MyGame_Example_Vec3T()
mana = 150
hp = 100
signedEnum = .none_
}
- func serialize() -> ByteBuffer { return serialize(type: MyGame_Example_Monster.self) }
+ public func serialize() -> ByteBuffer { return serialize(type: MyGame_Example_Monster.self) }
}
public struct MyGame_Example_TypeAliases: FlatBufferObject, ObjectAPI {
private init(_ t: Table) { _accessor = t }
public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
- enum VTOFFSET: VOffset {
+ private enum VTOFFSET: VOffset {
case i8 = 4
case u8 = 6
case i16 = 8
public class MyGame_Example_TypeAliasesT: NativeTable {
- var i8: Int8
- var u8: UInt8
- var i16: Int16
- var u16: UInt16
- var i32: Int32
- var u32: UInt32
- var i64: Int64
- var u64: UInt64
- var f32: Float32
- var f64: Double
- var v8: [Int8]
- var vf64: [Double]
-
- init(_ _t: inout MyGame_Example_TypeAliases) {
+ public var i8: Int8
+ public var u8: UInt8
+ public var i16: Int16
+ public var u16: UInt16
+ public var i32: Int32
+ public var u32: UInt32
+ public var i64: Int64
+ public var u64: UInt64
+ public var f32: Float32
+ public var f64: Double
+ public var v8: [Int8]
+ public var vf64: [Double]
+
+ public init(_ _t: inout MyGame_Example_TypeAliases) {
i8 = _t.i8
u8 = _t.u8
i16 = _t.i16
}
}
- init() {
+ public init() {
i8 = 0
u8 = 0
i16 = 0
vf64 = []
}
- func serialize() -> ByteBuffer { return serialize(type: MyGame_Example_TypeAliases.self) }
+ public func serialize() -> ByteBuffer { return serialize(type: MyGame_Example_TypeAliases.self) }
}
private init(_ t: Table) { _accessor = t }
public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
- enum VTOFFSET: VOffset {
+ private enum VTOFFSET: VOffset {
case justI8 = 4
case maybeI8 = 6
case defaultI8 = 8
public static var min: Character { return .none_ }
}
-struct CharacterUnion {
- var type: Character
- var value: NativeTable?
- init(_ v: NativeTable?, type: Character) {
+public struct CharacterUnion {
+ public var type: Character
+ public var value: NativeTable?
+ public init(_ v: NativeTable?, type: Character) {
self.type = type
self.value = v
}
- func pack(builder: inout FlatBufferBuilder) -> Offset<UOffset> {
+ public func pack(builder: inout FlatBufferBuilder) -> Offset<UOffset> {
switch type {
case .mulan:
var __obj = value as? AttackerT
public class RapunzelT: NativeTable {
- var hairLength: Int32
+ public var hairLength: Int32
- init(_ _t: inout Rapunzel) {
+ public init(_ _t: inout Rapunzel) {
hairLength = _t.hairLength
}
- init() {
+ public init() {
hairLength = 0
}
public class BookReaderT: NativeTable {
- var booksRead: Int32
+ public var booksRead: Int32
- init(_ _t: inout BookReader) {
+ public init(_ _t: inout BookReader) {
booksRead = _t.booksRead
}
- init() {
+ public init() {
booksRead = 0
}
private init(_ t: Table) { _accessor = t }
public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
- enum VTOFFSET: VOffset {
+ private enum VTOFFSET: VOffset {
case swordAttackDamage = 4
var v: Int32 { Int32(self.rawValue) }
var p: VOffset { self.rawValue }
public class AttackerT: NativeTable {
- var swordAttackDamage: Int32
+ public var swordAttackDamage: Int32
- init(_ _t: inout Attacker) {
+ public init(_ _t: inout Attacker) {
swordAttackDamage = _t.swordAttackDamage
}
- init() {
+ public init() {
swordAttackDamage = 0
}
- func serialize() -> ByteBuffer { return serialize(type: Attacker.self) }
+ public func serialize() -> ByteBuffer { return serialize(type: Attacker.self) }
}
public struct Movie: FlatBufferObject, ObjectAPI {
private init(_ t: Table) { _accessor = t }
public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
- enum VTOFFSET: VOffset {
+ private enum VTOFFSET: VOffset {
case mainCharacterType = 4
case mainCharacter = 6
case charactersType = 8
public class MovieT: NativeTable {
- var mainCharacter: CharacterUnion?
- var characters: [CharacterUnion?]
+ public var mainCharacter: CharacterUnion?
+ public var characters: [CharacterUnion?]
- init(_ _t: inout Movie) {
+ public init(_ _t: inout Movie) {
switch _t.mainCharacterType {
case .mulan:
var _v = _t.mainCharacter(type: Attacker.self)
}
}
- init() {
+ public init() {
characters = []
}
- func serialize() -> ByteBuffer { return serialize(type: Movie.self) }
+ public func serialize() -> ByteBuffer { return serialize(type: Movie.self) }
}
projects / platform / upstream / flatbuffers.git / commitdiff