BigfootDev/flatbuffers
1
0
Fork 1
mirror of https://github.com/google/flatbuffers.git synced 2026-06-01 19:58:15 +00:00
Code Issues Packages Projects Releases Wiki Activity

Rename AnyUniqueAliases.T to AnyUniqueAliases.TS to avoid naming conflict (#5362)

Browse Source
This commit is contained in:
iceboy
2019-05-30 16:02:57 -07:00
committed by Wouter van Oortmerssen
parent 93f74c0363
commit 9d92fd92e1
15 changed files with 43 additions and 43 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
tests/MyGame/Example/AnyUniqueAliases.cs
View File

@@ -9,7 +9,7 @@ public enum AnyUniqueAliases : byte
{ {
NONE = 0, NONE = 0,
M = 1, M = 1,
T = 2, TS = 2,
M2 = 3, M2 = 3,
}; };

6
tests/MyGame/Example/AnyUniqueAliases.go
View File

@@ -9,21 +9,21 @@ type AnyUniqueAliases byte
const ( const (
AnyUniqueAliasesNONE AnyUniqueAliases = 0 AnyUniqueAliasesNONE AnyUniqueAliases = 0
AnyUniqueAliasesM AnyUniqueAliases = 1 AnyUniqueAliasesM AnyUniqueAliases = 1
AnyUniqueAliasesT AnyUniqueAliases = 2 AnyUniqueAliasesTS AnyUniqueAliases = 2
AnyUniqueAliasesM2 AnyUniqueAliases = 3 AnyUniqueAliasesM2 AnyUniqueAliases = 3
) )
var EnumNamesAnyUniqueAliases = map[AnyUniqueAliases]string{ var EnumNamesAnyUniqueAliases = map[AnyUniqueAliases]string{
AnyUniqueAliasesNONE: "NONE", AnyUniqueAliasesNONE: "NONE",
AnyUniqueAliasesM: "M", AnyUniqueAliasesM: "M",
AnyUniqueAliasesT: "T", AnyUniqueAliasesTS: "TS",
AnyUniqueAliasesM2: "M2", AnyUniqueAliasesM2: "M2",
} }
var EnumValuesAnyUniqueAliases = map[string]AnyUniqueAliases{ var EnumValuesAnyUniqueAliases = map[string]AnyUniqueAliases{
"NONE": AnyUniqueAliasesNONE, "NONE": AnyUniqueAliasesNONE,
"M": AnyUniqueAliasesM, "M": AnyUniqueAliasesM,
"T": AnyUniqueAliasesT, "TS": AnyUniqueAliasesTS,
"M2": AnyUniqueAliasesM2, "M2": AnyUniqueAliasesM2,
} }

4
tests/MyGame/Example/AnyUniqueAliases.java
View File

@@ -6,10 +6,10 @@ public final class AnyUniqueAliases {
private AnyUniqueAliases() { } private AnyUniqueAliases() { }
public static final byte NONE = 0; public static final byte NONE = 0;
public static final byte M = 1; public static final byte M = 1;
public static final byte T = 2; public static final byte TS = 2;
public static final byte M2 = 3; public static final byte M2 = 3;
public static final String[] names = { "NONE", "M", "T", "M2", }; public static final String[] names = { "NONE", "M", "TS", "M2", };
public static String name(int e) { return names[e]; } public static String name(int e) { return names[e]; }
} }

2
tests/MyGame/Example/AnyUniqueAliases.lua
View File

@@ -5,7 +5,7 @@
local AnyUniqueAliases = { local AnyUniqueAliases = {
NONE = 0, NONE = 0,
M = 1, M = 1,
T = 2, TS = 2,
M2 = 3, M2 = 3,
} }

4
tests/MyGame/Example/AnyUniqueAliases.php
View File

@@ -7,13 +7,13 @@ class AnyUniqueAliases
{ {
const NONE = 0; const NONE = 0;
const M = 1; const M = 1;
const T = 2; const TS = 2;
const M2 = 3; const M2 = 3;
private static $names = array( private static $names = array(
AnyUniqueAliases::NONE=>"NONE", AnyUniqueAliases::NONE=>"NONE",
AnyUniqueAliases::M=>"M", AnyUniqueAliases::M=>"M",
AnyUniqueAliases::T=>"T", AnyUniqueAliases::TS=>"TS",
AnyUniqueAliases::M2=>"M2", AnyUniqueAliases::M2=>"M2",
); );

2
tests/MyGame/Example/AnyUniqueAliases.py
View File

@@ -5,6 +5,6 @@
class AnyUniqueAliases(object): class AnyUniqueAliases(object):
NONE = 0 NONE = 0
M = 1 M = 1
T = 2 TS = 2
M2 = 3 M2 = 3

BIN
tests/monster_test.bfbs
View File

Binary file not shown.

2
tests/monster_test.fbs
View File

@@ -18,7 +18,7 @@ enum Color:ubyte (bit_flags) { Red = 0, Green, Blue = 3, }
union Any { Monster, TestSimpleTableWithEnum, MyGame.Example2.Monster } union Any { Monster, TestSimpleTableWithEnum, MyGame.Example2.Monster }
union AnyUniqueAliases { M: Monster, T: TestSimpleTableWithEnum, M2: MyGame.Example2.Monster } union AnyUniqueAliases { M: Monster, TS: TestSimpleTableWithEnum, M2: MyGame.Example2.Monster }
union AnyAmbiguousAliases { M1: Monster, M2: Monster, M3: Monster } union AnyAmbiguousAliases { M1: Monster, M2: Monster, M3: Monster }
struct Test { a:short; b:byte; } struct Test { a:short; b:byte; }

2
tests/monster_test.schema.json
View File

@@ -15,7 +15,7 @@
}, },
"MyGame_Example_AnyUniqueAliases" : { "MyGame_Example_AnyUniqueAliases" : {
"type" : "string", "type" : "string",
"enum": ["NONE", "M", "T", "M2"] "enum": ["NONE", "M", "TS", "M2"]
}, },
"MyGame_Example_AnyAmbiguousAliases" : { "MyGame_Example_AnyAmbiguousAliases" : {
"type" : "string", "type" : "string",

36
tests/monster_test_generated.h
View File

@@ -282,7 +282,7 @@ bool VerifyAnyVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<
enum AnyUniqueAliases { enum AnyUniqueAliases {
AnyUniqueAliases_NONE = 0, AnyUniqueAliases_NONE = 0,
AnyUniqueAliases_M = 1, AnyUniqueAliases_M = 1,
AnyUniqueAliases_T = 2, AnyUniqueAliases_TS = 2,
AnyUniqueAliases_M2 = 3, AnyUniqueAliases_M2 = 3,
AnyUniqueAliases_MIN = AnyUniqueAliases_NONE, AnyUniqueAliases_MIN = AnyUniqueAliases_NONE,
AnyUniqueAliases_MAX = AnyUniqueAliases_M2 AnyUniqueAliases_MAX = AnyUniqueAliases_M2
@@ -292,7 +292,7 @@ inline const AnyUniqueAliases (&EnumValuesAnyUniqueAliases())[4] {
static const AnyUniqueAliases values[] = { static const AnyUniqueAliases values[] = {
AnyUniqueAliases_NONE, AnyUniqueAliases_NONE,
AnyUniqueAliases_M, AnyUniqueAliases_M,
AnyUniqueAliases_T, AnyUniqueAliases_TS,
AnyUniqueAliases_M2 AnyUniqueAliases_M2
}; };
return values; return values;
@@ -302,7 +302,7 @@ inline const char * const *EnumNamesAnyUniqueAliases() {
static const char * const names[5] = { static const char * const names[5] = {
"NONE", "NONE",
"M", "M",
"T", "TS",
"M2", "M2",
nullptr nullptr
}; };
@@ -324,7 +324,7 @@ template<> struct AnyUniqueAliasesTraits<Monster> {
}; };
template<> struct AnyUniqueAliasesTraits<TestSimpleTableWithEnum> { template<> struct AnyUniqueAliasesTraits<TestSimpleTableWithEnum> {
static const AnyUniqueAliases enum_value = AnyUniqueAliases_T; static const AnyUniqueAliases enum_value = AnyUniqueAliases_TS;
}; };
template<> struct AnyUniqueAliasesTraits<MyGame::Example2::Monster> { template<> struct AnyUniqueAliasesTraits<MyGame::Example2::Monster> {
@@ -371,12 +371,12 @@ struct AnyUniqueAliasesUnion {
return type == AnyUniqueAliases_M ? return type == AnyUniqueAliases_M ?
reinterpret_cast<const MonsterT *>(value) : nullptr; reinterpret_cast<const MonsterT *>(value) : nullptr;
} }
TestSimpleTableWithEnumT *AsT() { TestSimpleTableWithEnumT *AsTS() {
return type == AnyUniqueAliases_T ? return type == AnyUniqueAliases_TS ?
reinterpret_cast<TestSimpleTableWithEnumT *>(value) : nullptr; reinterpret_cast<TestSimpleTableWithEnumT *>(value) : nullptr;
} }
const TestSimpleTableWithEnumT *AsT() const { const TestSimpleTableWithEnumT *AsTS() const {
return type == AnyUniqueAliases_T ? return type == AnyUniqueAliases_TS ?
reinterpret_cast<const TestSimpleTableWithEnumT *>(value) : nullptr; reinterpret_cast<const TestSimpleTableWithEnumT *>(value) : nullptr;
} }
MyGame::Example2::MonsterT *AsM2() { MyGame::Example2::MonsterT *AsM2() {
@@ -400,7 +400,7 @@ inline bool operator==(const AnyUniqueAliasesUnion &lhs, const AnyUniqueAliasesU
return *(reinterpret_cast<const MonsterT *>(lhs.value)) == return *(reinterpret_cast<const MonsterT *>(lhs.value)) ==
*(reinterpret_cast<const MonsterT *>(rhs.value)); *(reinterpret_cast<const MonsterT *>(rhs.value));
} }
case AnyUniqueAliases_T: { case AnyUniqueAliases_TS: {
return *(reinterpret_cast<const TestSimpleTableWithEnumT *>(lhs.value)) == return *(reinterpret_cast<const TestSimpleTableWithEnumT *>(lhs.value)) ==
*(reinterpret_cast<const TestSimpleTableWithEnumT *>(rhs.value)); *(reinterpret_cast<const TestSimpleTableWithEnumT *>(rhs.value));
} }
@@ -1553,8 +1553,8 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
const Monster *any_unique_as_M() const { const Monster *any_unique_as_M() const {
return any_unique_type() == AnyUniqueAliases_M ? static_cast<const Monster *>(any_unique()) : nullptr; return any_unique_type() == AnyUniqueAliases_M ? static_cast<const Monster *>(any_unique()) : nullptr;
} }
const TestSimpleTableWithEnum *any_unique_as_T() const { const TestSimpleTableWithEnum *any_unique_as_TS() const {
return any_unique_type() == AnyUniqueAliases_T ? static_cast<const TestSimpleTableWithEnum *>(any_unique()) : nullptr; return any_unique_type() == AnyUniqueAliases_TS ? static_cast<const TestSimpleTableWithEnum *>(any_unique()) : nullptr;
} }
const MyGame::Example2::Monster *any_unique_as_M2() const { const MyGame::Example2::Monster *any_unique_as_M2() const {
return any_unique_type() == AnyUniqueAliases_M2 ? static_cast<const MyGame::Example2::Monster *>(any_unique()) : nullptr; return any_unique_type() == AnyUniqueAliases_M2 ? static_cast<const MyGame::Example2::Monster *>(any_unique()) : nullptr;
@@ -1692,7 +1692,7 @@ template<> inline const Monster *Monster::any_unique_as<Monster>() const {
} }
template<> inline const TestSimpleTableWithEnum *Monster::any_unique_as<TestSimpleTableWithEnum>() const { template<> inline const TestSimpleTableWithEnum *Monster::any_unique_as<TestSimpleTableWithEnum>() const {
return any_unique_as_T(); return any_unique_as_TS();
} }
template<> inline const MyGame::Example2::Monster *Monster::any_unique_as<MyGame::Example2::Monster>() const { template<> inline const MyGame::Example2::Monster *Monster::any_unique_as<MyGame::Example2::Monster>() const {
@@ -2843,7 +2843,7 @@ inline bool VerifyAnyUniqueAliases(flatbuffers::Verifier &verifier, const void *
auto ptr = reinterpret_cast<const Monster *>(obj); auto ptr = reinterpret_cast<const Monster *>(obj);
return verifier.VerifyTable(ptr); return verifier.VerifyTable(ptr);
} }
case AnyUniqueAliases_T: { case AnyUniqueAliases_TS: {
auto ptr = reinterpret_cast<const TestSimpleTableWithEnum *>(obj); auto ptr = reinterpret_cast<const TestSimpleTableWithEnum *>(obj);
return verifier.VerifyTable(ptr); return verifier.VerifyTable(ptr);
} }
@@ -2873,7 +2873,7 @@ inline void *AnyUniqueAliasesUnion::UnPack(const void *obj, AnyUniqueAliases typ
auto ptr = reinterpret_cast<const Monster *>(obj); auto ptr = reinterpret_cast<const Monster *>(obj);
return ptr->UnPack(resolver); return ptr->UnPack(resolver);
} }
case AnyUniqueAliases_T: { case AnyUniqueAliases_TS: {
auto ptr = reinterpret_cast<const TestSimpleTableWithEnum *>(obj); auto ptr = reinterpret_cast<const TestSimpleTableWithEnum *>(obj);
return ptr->UnPack(resolver); return ptr->UnPack(resolver);
} }
@@ -2891,7 +2891,7 @@ inline flatbuffers::Offset<void> AnyUniqueAliasesUnion::Pack(flatbuffers::FlatBu
auto ptr = reinterpret_cast<const MonsterT *>(value); auto ptr = reinterpret_cast<const MonsterT *>(value);
return CreateMonster(_fbb, ptr, _rehasher).Union(); return CreateMonster(_fbb, ptr, _rehasher).Union();
} }
case AnyUniqueAliases_T: { case AnyUniqueAliases_TS: {
auto ptr = reinterpret_cast<const TestSimpleTableWithEnumT *>(value); auto ptr = reinterpret_cast<const TestSimpleTableWithEnumT *>(value);
return CreateTestSimpleTableWithEnum(_fbb, ptr, _rehasher).Union(); return CreateTestSimpleTableWithEnum(_fbb, ptr, _rehasher).Union();
} }
@@ -2909,7 +2909,7 @@ inline AnyUniqueAliasesUnion::AnyUniqueAliasesUnion(const AnyUniqueAliasesUnion
FLATBUFFERS_ASSERT(false); // MonsterT not copyable. FLATBUFFERS_ASSERT(false); // MonsterT not copyable.
break; break;
} }
case AnyUniqueAliases_T: { case AnyUniqueAliases_TS: {
value = new TestSimpleTableWithEnumT(*reinterpret_cast<TestSimpleTableWithEnumT *>(u.value)); value = new TestSimpleTableWithEnumT(*reinterpret_cast<TestSimpleTableWithEnumT *>(u.value));
break; break;
} }
@@ -2929,7 +2929,7 @@ inline void AnyUniqueAliasesUnion::Reset() {
delete ptr; delete ptr;
break; break;
} }
case AnyUniqueAliases_T: { case AnyUniqueAliases_TS: {
auto ptr = reinterpret_cast<TestSimpleTableWithEnumT *>(value); auto ptr = reinterpret_cast<TestSimpleTableWithEnumT *>(value);
delete ptr; delete ptr;
break; break;
@@ -3116,7 +3116,7 @@ inline const flatbuffers::TypeTable *AnyUniqueAliasesTypeTable() {
static const char * const names[] = { static const char * const names[] = {
"NONE", "NONE",
"M", "M",
"T", "TS",
"M2" "M2"
}; };
static const flatbuffers::TypeTable tt = { static const flatbuffers::TypeTable tt = {

4
tests/monster_test_generated.js
View File

@@ -68,7 +68,7 @@ MyGame.Example.AnyName = {
MyGame.Example.AnyUniqueAliases = { MyGame.Example.AnyUniqueAliases = {
NONE: 0, NONE: 0,
M: 1, M: 1,
T: 2, TS: 2,
M2: 3 M2: 3
}; };
@@ -78,7 +78,7 @@ MyGame.Example.AnyUniqueAliases = {
MyGame.Example.AnyUniqueAliasesName = { MyGame.Example.AnyUniqueAliasesName = {
0: 'NONE', 0: 'NONE',
1: 'M', 1: 'M',
2: 'T', 2: 'TS',
3: 'M2' 3: 'M2'
}; };

4
tests/monster_test_generated.lobster
View File

@@ -17,7 +17,7 @@ enum Any:
enum AnyUniqueAliases: enum AnyUniqueAliases:
AnyUniqueAliases_NONE = 0 AnyUniqueAliases_NONE = 0
AnyUniqueAliases_M = 1 AnyUniqueAliases_M = 1
AnyUniqueAliases_T = 2 AnyUniqueAliases_TS = 2
AnyUniqueAliases_M2 = 3 AnyUniqueAliases_M2 = 3
enum AnyAmbiguousAliases: enum AnyAmbiguousAliases:
@@ -332,7 +332,7 @@ class Monster : flatbuffers_handle
return AnyUniqueAliases(buf_.flatbuffers_field_int8(pos_, 90, 0)) return AnyUniqueAliases(buf_.flatbuffers_field_int8(pos_, 90, 0))
def any_unique_as_M(): def any_unique_as_M():
return MyGame_Example_Monster { buf_, buf_.flatbuffers_field_table(pos_, 92) } return MyGame_Example_Monster { buf_, buf_.flatbuffers_field_table(pos_, 92) }
def any_unique_as_T(): def any_unique_as_TS():
return MyGame_Example_TestSimpleTableWithEnum { buf_, buf_.flatbuffers_field_table(pos_, 92) } return MyGame_Example_TestSimpleTableWithEnum { buf_, buf_.flatbuffers_field_table(pos_, 92) }
def any_unique_as_M2(): def any_unique_as_M2():
return MyGame_Example2_Monster { buf_, buf_.flatbuffers_field_table(pos_, 92) } return MyGame_Example2_Monster { buf_, buf_.flatbuffers_field_table(pos_, 92) }

10
tests/monster_test_generated.rs
View File

@@ -304,7 +304,7 @@ pub struct AnyUnionTableOffset {}
pub enum AnyUniqueAliases { pub enum AnyUniqueAliases {
NONE = 0, NONE = 0,
M = 1, M = 1,
T = 2, TS = 2,
M2 = 3, M2 = 3,
} }
@@ -347,7 +347,7 @@ impl flatbuffers::Push for AnyUniqueAliases {
const ENUM_VALUES_ANY_UNIQUE_ALIASES:[AnyUniqueAliases; 4] = [ const ENUM_VALUES_ANY_UNIQUE_ALIASES:[AnyUniqueAliases; 4] = [
AnyUniqueAliases::NONE, AnyUniqueAliases::NONE,
AnyUniqueAliases::M, AnyUniqueAliases::M,
AnyUniqueAliases::T, AnyUniqueAliases::TS,
AnyUniqueAliases::M2 AnyUniqueAliases::M2
]; ];
@@ -355,7 +355,7 @@ const ENUM_VALUES_ANY_UNIQUE_ALIASES:[AnyUniqueAliases; 4] = [
const ENUM_NAMES_ANY_UNIQUE_ALIASES:[&'static str; 4] = [ const ENUM_NAMES_ANY_UNIQUE_ALIASES:[&'static str; 4] = [
"NONE", "NONE",
"M", "M",
"T", "TS",
"M2" "M2"
]; ];
@@ -1294,8 +1294,8 @@ impl<'a> Monster<'a> {
#[inline] #[inline]
#[allow(non_snake_case)] #[allow(non_snake_case)]
pub fn any_unique_as_t(&self) -> Option<TestSimpleTableWithEnum<'a>> { pub fn any_unique_as_ts(&self) -> Option<TestSimpleTableWithEnum<'a>> {
if self.any_unique_type() == AnyUniqueAliases::T { if self.any_unique_type() == AnyUniqueAliases::TS {
self.any_unique().map(|u| TestSimpleTableWithEnum::init_from_table(u)) self.any_unique().map(|u| TestSimpleTableWithEnum::init_from_table(u))
} else { } else {
None None

2
tests/monster_test_generated.ts
View File

@@ -28,7 +28,7 @@ export namespace MyGame.Example{
export enum AnyUniqueAliases{ export enum AnyUniqueAliases{
NONE= 0, NONE= 0,
M= 1, M= 1,
T= 2, TS= 2,
M2= 3 M2= 3
}}; }};

6
tests/monster_test_my_game.example_generated.dart
View File

@@ -106,9 +106,9 @@ class AnyUniqueAliasesTypeId {
static const AnyUniqueAliasesTypeId NONE = const AnyUniqueAliasesTypeId._(0); static const AnyUniqueAliasesTypeId NONE = const AnyUniqueAliasesTypeId._(0);
static const AnyUniqueAliasesTypeId M = const AnyUniqueAliasesTypeId._(1); static const AnyUniqueAliasesTypeId M = const AnyUniqueAliasesTypeId._(1);
static const AnyUniqueAliasesTypeId T = const AnyUniqueAliasesTypeId._(2); static const AnyUniqueAliasesTypeId TS = const AnyUniqueAliasesTypeId._(2);
static const AnyUniqueAliasesTypeId M2 = const AnyUniqueAliasesTypeId._(3); static const AnyUniqueAliasesTypeId M2 = const AnyUniqueAliasesTypeId._(3);
static get values => {0: NONE,1: M,2: T,3: M2,}; static get values => {0: NONE,1: M,2: TS,3: M2,};
static const fb.Reader<AnyUniqueAliasesTypeId> reader = const _AnyUniqueAliasesTypeIdReader(); static const fb.Reader<AnyUniqueAliasesTypeId> reader = const _AnyUniqueAliasesTypeIdReader();
@@ -738,7 +738,7 @@ class Monster {
dynamic get anyUnique { dynamic get anyUnique {
switch (anyUniqueType?.value) { switch (anyUniqueType?.value) {
case 1: return M.reader.vTableGet(_bc, _bcOffset, 92, null); case 1: return M.reader.vTableGet(_bc, _bcOffset, 92, null);
case 2: return T.reader.vTableGet(_bc, _bcOffset, 92, null); case 2: return TS.reader.vTableGet(_bc, _bcOffset, 92, null);
case 3: return M2.reader.vTableGet(_bc, _bcOffset, 92, null); case 3: return M2.reader.vTableGet(_bc, _bcOffset, 92, null);
default: return null; default: return null;
} }