GitHub/flatbuffers
1
0
Fork 0
mirror of https://github.com/google/flatbuffers.git synced 2025-04-09 00:12:15 +08: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
Show Stats 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,
M = 1,
T = 2,
TS = 2,
M2 = 3,
};

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

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

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

@ -6,10 +6,10 @@ public final class AnyUniqueAliases {
private AnyUniqueAliases() { }
public static final byte NONE = 0;
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 String[] names = { "NONE", "M", "T", "M2", };
public static final String[] names = { "NONE", "M", "TS", "M2", };
public static String name(int e) { return names[e]; }
}

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

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

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

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

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

@ -5,6 +5,6 @@
class AnyUniqueAliases(object):
NONE = 0
M = 1
T = 2
TS = 2
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 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 }
struct Test { a:short; b:byte; }

2
tests/monster_test.schema.json
View File

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

36
tests/monster_test_generated.h
View File

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

4
tests/monster_test_generated.js
View File

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

4
tests/monster_test_generated.lobster
View File

@ -17,7 +17,7 @@ enum Any:
enum AnyUniqueAliases:
AnyUniqueAliases_NONE = 0
AnyUniqueAliases_M = 1
AnyUniqueAliases_T = 2
AnyUniqueAliases_TS = 2
AnyUniqueAliases_M2 = 3
enum AnyAmbiguousAliases:
@ -332,7 +332,7 @@ class Monster : flatbuffers_handle
return AnyUniqueAliases(buf_.flatbuffers_field_int8(pos_, 90, 0))
def any_unique_as_M():
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) }
def any_unique_as_M2():
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 {
NONE = 0,
M = 1,
T = 2,
TS = 2,
M2 = 3,
}
@ -347,7 +347,7 @@ impl flatbuffers::Push for AnyUniqueAliases {
const ENUM_VALUES_ANY_UNIQUE_ALIASES:[AnyUniqueAliases; 4] = [
AnyUniqueAliases::NONE,
AnyUniqueAliases::M,
AnyUniqueAliases::T,
AnyUniqueAliases::TS,
AnyUniqueAliases::M2
];
@ -355,7 +355,7 @@ const ENUM_VALUES_ANY_UNIQUE_ALIASES:[AnyUniqueAliases; 4] = [
const ENUM_NAMES_ANY_UNIQUE_ALIASES:[&'static str; 4] = [
"NONE",
"M",
"T",
"TS",
"M2"
];
@ -1294,8 +1294,8 @@ impl<'a> Monster<'a> {
#[inline]
#[allow(non_snake_case)]
pub fn any_unique_as_t(&self) -> Option<TestSimpleTableWithEnum<'a>> {
if self.any_unique_type() == AnyUniqueAliases::T {
pub fn any_unique_as_ts(&self) -> Option<TestSimpleTableWithEnum<'a>> {
if self.any_unique_type() == AnyUniqueAliases::TS {
self.any_unique().map(|u| TestSimpleTableWithEnum::init_from_table(u))
} else {
None

2
tests/monster_test_generated.ts
View File

@ -28,7 +28,7 @@ export namespace MyGame.Example{
export enum AnyUniqueAliases{
NONE= 0,
M= 1,
T= 2,
TS= 2,
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 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 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();
@ -738,7 +738,7 @@ class Monster {
dynamic get anyUnique {
switch (anyUniqueType?.value) {
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);
default: return null;
}