async void MainWindow_Loaded(object sender, RoutedEventArgs e)
{
Workspace workspace = new Workspace();
workspace.AddURIHandler(new WebSocketURIHandler());
resource = await workspace.OpenAsync("ws://localhost:8888/images");
DispatcherTimer dispatcherTimer = new DispatcherTimer();
dispatcherTimer.Tick += Refresh;
dispatcherTimer.Interval = TimeSpan.FromMilliseconds(100);
dispatcherTimer.Start();
positions = (TSet<TArray<double>>) resource.Value;
button.IsEnabled = true;
// Register a handler on the set to be notified when an image
// is added that needs to be displayed.
positions.Added += (item) =>
{
AddImageToUI((TArray<double>) item);
};
// Some images might already be shared, show them. Use an atomic
// block to get a stable view of the collection.
workspace.Atomic(() =>
{
foreach (TArray<double> position in positions)
AddImageToUI(position);
});
}
public static void Skip(TProtocol prot, TType type)
{
switch (type)
{
case TType.Bool:
prot.ReadBool();
break;
case TType.Byte:
prot.ReadByte();
break;
case TType.I16:
prot.ReadI16();
break;
case TType.I32:
prot.ReadI32();
break;
case TType.I64:
prot.ReadI64();
break;
case TType.Double:
prot.ReadDouble();
break;
case TType.String:
// Don't try to decode the string, just skip it.
prot.ReadBinary();
break;
case TType.Struct:
prot.ReadStructBegin();
while (true)
{
TField field = prot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
Skip(prot, field.Type);
prot.ReadFieldEnd();
}
prot.ReadStructEnd();
break;
case TType.Map:
TMap map = prot.ReadMapBegin();
for (int i = 0; i < map.Count; i++)
{
Skip(prot, map.KeyType);
Skip(prot, map.ValueType);
}
prot.ReadMapEnd();
break;
case TType.Set:
TSet set = prot.ReadSetBegin();
for (int i = 0; i < set.Count; i++)
{
Skip(prot, set.ElementType);
}
prot.ReadSetEnd();
break;
case TType.List:
TList list = prot.ReadListBegin();
for (int i = 0; i < list.Count; i++)
{
Skip(prot, list.ElementType);
}
prot.ReadListEnd();
break;
}
}
public override string Accept(TSet type)
{
return($"Bright.Transaction.Collections.PSet1<{type.ElementType.Apply(this)}>");
}
public async Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
{
iprot.IncrementRecursionDepth();
try
{
bool isset_path = false;
bool isset_dataTypeOrdinal = false;
bool isset_queryId = false;
bool isset_deviceMeasurements = false;
bool isset_header = false;
bool isset_requestor = false;
TField field;
await iprot.ReadStructBeginAsync(cancellationToken);
while (true)
{
field = await iprot.ReadFieldBeginAsync(cancellationToken);
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.String)
{
Path = await iprot.ReadStringAsync(cancellationToken);
isset_path = true;
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 2:
if (field.Type == TType.I32)
{
DataTypeOrdinal = await iprot.ReadI32Async(cancellationToken);
isset_dataTypeOrdinal = true;
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 3:
if (field.Type == TType.I64)
{
QueryId = await iprot.ReadI64Async(cancellationToken);
isset_queryId = true;
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 4:
if (field.Type == TType.Set)
{
{
TSet _set45 = await iprot.ReadSetBeginAsync(cancellationToken);
DeviceMeasurements = new THashSet <string>(_set45.Count);
for (int _i46 = 0; _i46 < _set45.Count; ++_i46)
{
string _elem47;
_elem47 = await iprot.ReadStringAsync(cancellationToken);
DeviceMeasurements.Add(_elem47);
}
await iprot.ReadSetEndAsync(cancellationToken);
}
isset_deviceMeasurements = true;
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 5:
if (field.Type == TType.Struct)
{
Header = new Node();
await Header.ReadAsync(iprot, cancellationToken);
isset_header = true;
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 6:
if (field.Type == TType.Struct)
{
Requestor = new Node();
await Requestor.ReadAsync(iprot, cancellationToken);
isset_requestor = true;
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
default:
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
break;
}
await iprot.ReadFieldEndAsync(cancellationToken);
}
await iprot.ReadStructEndAsync(cancellationToken);
if (!isset_path)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
if (!isset_dataTypeOrdinal)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
if (!isset_queryId)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
if (!isset_deviceMeasurements)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
if (!isset_header)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
if (!isset_requestor)
{
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public DType Accept(TSet type, object converter, ExcelStream x, DefAssembly ass)
{
return(new DSet(type, ReadList(type.ElementType, converter, x, ass)));
}
public DType Accept(TSet type, JsonElement x, DefAssembly ass)
{
return(new DSet(type, ReadList(type.ElementType, x, ass)));
}
public void Accept(TSet type, HashSet <DefTypeBase> x)
{
type.ElementType.Apply(this, x);
}
public async Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
{
iprot.IncrementRecursionDepth();
try
{
TField field;
await iprot.ReadStructBeginAsync(cancellationToken);
while (true)
{
field = await iprot.ReadFieldBeginAsync(cancellationToken);
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 2:
if (field.Type == TType.Set)
{
{
TSet _set479 = await iprot.ReadSetBeginAsync(cancellationToken);
UpdatedAttrs = new THashSet <SquareChatMemberAttribute>(_set479.Count);
for (int _i480 = 0; _i480 < _set479.Count; ++_i480)
{
SquareChatMemberAttribute _elem481;
_elem481 = (SquareChatMemberAttribute)await iprot.ReadI32Async(cancellationToken);
UpdatedAttrs.Add(_elem481);
}
await iprot.ReadSetEndAsync(cancellationToken);
}
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 3:
if (field.Type == TType.Struct)
{
ChatMember = new SquareChatMember();
await ChatMember.ReadAsync(iprot, cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
default:
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
break;
}
await iprot.ReadFieldEndAsync(cancellationToken);
}
await iprot.ReadStructEndAsync(cancellationToken);
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public void Read(TProtocol iprot)
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.I32)
{
ExtendType = (PluginType)iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Set)
{
{
SupportSite = new THashSet <string>();
TSet _set5 = iprot.ReadSetBegin();
for (int _i6 = 0; _i6 < _set5.Count; ++_i6)
{
string _elem7 = null;
_elem7 = iprot.ReadString();
SupportSite.Add(_elem7);
}
iprot.ReadSetEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String)
{
Path = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.String)
{
Host = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.I32)
{
Port = iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.String)
{
UrlFormat = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.String)
{
HttpMethod = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
public bool Accept(TSet type, TType x, Dictionary <DefTypeBase, bool> y, HashSet <DefTypeBase> z)
{
return(type.ElementType.Apply(this, ((TSet)x).ElementType, y, z));
}
public string Accept(TSet type, string bufName, string fieldName)
{
return($"{{int n = Math.min({bufName}.readSize(), {bufName}.size());{fieldName} = new {type.Apply(JavaDefineTypeName.Ins)}(n * 3 / 2);for(var i = 0 ; i < n ; i++) {{ {type.ElementType.Apply(JavaBoxDefineTypeName.Ins)} _e; {type.ElementType.Apply(this, bufName, "_e")} {fieldName}.add(_e);}}}}");
}
public void Read(TProtocol iprot)
{
iprot.IncrementRecursionDepth();
try
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.Set)
{
{
UpdatedAttrs = new THashSet <SquareMemberAttribute>();
TSet _set441 = iprot.ReadSetBegin();
for (int _i442 = 0; _i442 < _set441.Count; ++_i442)
{
SquareMemberAttribute _elem443;
_elem443 = (SquareMemberAttribute)iprot.ReadI32();
UpdatedAttrs.Add(_elem443);
}
iprot.ReadSetEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Struct)
{
Editor = new SquareMember();
Editor.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.Map)
{
{
Members = new Dictionary <string, SquareMember>();
TMap _map444 = iprot.ReadMapBegin();
for (int _i445 = 0; _i445 < _map444.Count; ++_i445)
{
string _key446;
SquareMember _val447;
_key446 = iprot.ReadString();
_val447 = new SquareMember();
_val447.Read(iprot);
Members[_key446] = _val447;
}
iprot.ReadMapEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public override async Task WriteSetBeginAsync(TSet set, CancellationToken cancellationToken)
{
await WriteJsonArrayStartAsync(cancellationToken).ConfigureAwait(false);
await WriteJsonStringAsync(TJSONProtocolHelper.GetTypeNameForTypeId(set.ElementType), cancellationToken).ConfigureAwait(false);
await WriteJsonIntegerAsync(set.Count, cancellationToken).ConfigureAwait(false);
}
public void Read(TProtocol iprot)
{
iprot.IncrementRecursionDepth();
try
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.Bool)
{
V_bool = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Byte)
{
V_i8 = iprot.ReadByte();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.I16)
{
V_i16 = iprot.ReadI16();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.I32)
{
V_i32 = iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.I64)
{
V_i64 = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.Double)
{
V_double = iprot.ReadDouble();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.String)
{
V_string = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.List)
{
{
V_list = new List <Variant>();
TList _list0 = iprot.ReadListBegin();
for (int _i1 = 0; _i1 < _list0.Count; ++_i1)
{
Variant _elem2;
_elem2 = new Variant();
_elem2.Read(iprot);
V_list.Add(_elem2);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.Set)
{
{
V_set = new THashSet <Variant>();
TSet _set3 = iprot.ReadSetBegin();
for (int _i4 = 0; _i4 < _set3.Count; ++_i4)
{
Variant _elem5;
_elem5 = new Variant();
_elem5.Read(iprot);
V_set.Add(_elem5);
}
iprot.ReadSetEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.Map)
{
{
V_map = new Dictionary <Variant, Variant>();
TMap _map6 = iprot.ReadMapBegin();
for (int _i7 = 0; _i7 < _map6.Count; ++_i7)
{
Variant _key8;
Variant _val9;
_key8 = new Variant();
_key8.Read(iprot);
_val9 = new Variant();
_val9.Read(iprot);
V_map[_key8] = _val9;
}
iprot.ReadMapEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public string Accept(TSet type, string byteBufName, string fieldName)
{
return($"{byteBufName}.WriteInt(FieldTag.{type.ElementType.Apply(TagNameVisitor.Ins)}); foreach(var _e in {fieldName}) {{ {type.ElementType.Apply(this, byteBufName, "_e")} }}");
}
public void Read(TProtocol iprot)
{
iprot.IncrementRecursionDepth();
try
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 2:
if (field.Type == TType.Set)
{
{
UpdatedAttrs = new THashSet <SquareChatMemberAttribute>();
TSet _set479 = iprot.ReadSetBegin();
for (int _i480 = 0; _i480 < _set479.Count; ++_i480)
{
SquareChatMemberAttribute _elem481;
_elem481 = (SquareChatMemberAttribute)iprot.ReadI32();
UpdatedAttrs.Add(_elem481);
}
iprot.ReadSetEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.Struct)
{
ChatMember = new SquareChatMember();
ChatMember.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public override async Task WriteSetBeginAsync(TSet set, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
await WriteCollectionBeginAsync(set.ElementType, set.Count, cancellationToken);
}
public string Accept(TSet type, string fieldName, string tablesName)
{
throw new NotImplementedException();
}
public async Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
{
iprot.IncrementRecursionDepth();
try
{
TField field;
await iprot.ReadStructBeginAsync(cancellationToken);
while (true)
{
field = await iprot.ReadFieldBeginAsync(cancellationToken);
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.Set)
{
{
UpdatedAttrs = new THashSet <SquareMemberAttribute>();
TSet _set425 = await iprot.ReadSetBeginAsync(cancellationToken);
for (int _i426 = 0; _i426 < _set425.Count; ++_i426)
{
SquareMemberAttribute _elem427;
_elem427 = (SquareMemberAttribute)await iprot.ReadI32Async(cancellationToken);
UpdatedAttrs.Add(_elem427);
}
await iprot.ReadSetEndAsync(cancellationToken);
}
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 2:
if (field.Type == TType.Struct)
{
SquareMember = new SquareMember();
await SquareMember.ReadAsync(iprot, cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 3:
if (field.Type == TType.Set)
{
{
UpdatedPreferenceAttrs = new THashSet <SquarePreferenceAttribute>();
TSet _set428 = await iprot.ReadSetBeginAsync(cancellationToken);
for (int _i429 = 0; _i429 < _set428.Count; ++_i429)
{
SquarePreferenceAttribute _elem430;
_elem430 = (SquarePreferenceAttribute)await iprot.ReadI32Async(cancellationToken);
UpdatedPreferenceAttrs.Add(_elem430);
}
await iprot.ReadSetEndAsync(cancellationToken);
}
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
default:
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
break;
}
await iprot.ReadFieldEndAsync(cancellationToken);
}
await iprot.ReadStructEndAsync(cancellationToken);
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public void Accept(TSet type, HashSet <string> x)
{
type.ElementType.Apply(this, x);
}
public void Read(TProtocol iprot)
{
iprot.IncrementRecursionDepth();
try
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.String)
{
SessionId = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Set)
{
{
UserIds = new THashSet <string>();
TSet _set77 = iprot.ReadSetBegin();
for (int _i78 = 0; _i78 < _set77.Count; ++_i78)
{
string _elem79;
_elem79 = iprot.ReadString();
UserIds.Add(_elem79);
}
iprot.ReadSetEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public override void WriteSetBegin(TSet tSet)
{
WrappedProtocol.WriteSetBegin(tSet);
}
public void Read(TProtocol iprot)
{
iprot.IncrementRecursionDepth();
try
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.Set)
{
{
UpdateAttributes = new THashSet <SquareFeatureSetAttribute>();
TSet _set413 = iprot.ReadSetBegin();
for (int _i414 = 0; _i414 < _set413.Count; ++_i414)
{
SquareFeatureSetAttribute _elem415;
_elem415 = (SquareFeatureSetAttribute)iprot.ReadI32();
UpdateAttributes.Add(_elem415);
}
iprot.ReadSetEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Struct)
{
SquareFeatureSet = new SquareFeatureSet();
SquareFeatureSet.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public async Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
{
iprot.IncrementRecursionDepth();
try
{
TField field;
await iprot.ReadStructBeginAsync(cancellationToken);
while (true)
{
field = await iprot.ReadFieldBeginAsync(cancellationToken);
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 2:
if (field.Type == TType.String)
{
SquareMid = await iprot.ReadStringAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 3:
if (field.Type == TType.String)
{
TargetSquareMemberMid = await iprot.ReadStringAsync(cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 4:
if (field.Type == TType.Set)
{
{
TSet _set491 = await iprot.ReadSetBeginAsync(cancellationToken);
UpdatedAttrs = new THashSet <SquareMemberRelationAttribute>(_set491.Count);
for (int _i492 = 0; _i492 < _set491.Count; ++_i492)
{
SquareMemberRelationAttribute _elem493;
_elem493 = (SquareMemberRelationAttribute)await iprot.ReadI32Async(cancellationToken);
UpdatedAttrs.Add(_elem493);
}
await iprot.ReadSetEndAsync(cancellationToken);
}
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
case 5:
if (field.Type == TType.Struct)
{
Relation = new SquareMemberRelation();
await Relation.ReadAsync(iprot, cancellationToken);
}
else
{
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
}
break;
default:
await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
break;
}
await iprot.ReadFieldEndAsync(cancellationToken);
}
await iprot.ReadStructEndAsync(cancellationToken);
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public override string Accept(TSet type, string bufName, string fieldName)
{
return($"writeBool({bufName}, {fieldName}, {type.ElementType.Apply(LuaSerializeMethodNameVisitor.Ins)})");
}
public override bool Accept(TSet type)
{
return(true);
}
public string Accept(TSet type)
{
return($"std::unordered_set<{type.ElementType.Apply(this)}>");
}
public override string Accept(TSet type)
{
return($"new {ConstStrings.CsHashSet}<{type.ElementType.Apply(CsEditorDefineTypeName.Ins)}>()");
}
public void Read(TProtocol iprot)
{
iprot.IncrementRecursionDepth();
try
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.String)
{
Mid = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.I64)
{
MemberCount = iprot.ReadI64();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.Bool)
{
OnAir = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.Bool)
{
BusinessAccount = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.Bool)
{
Addable = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.Set)
{
{
AcceptableContentTypes = new THashSet <ContentType>();
TSet _set56 = iprot.ReadSetBegin();
for (int _i57 = 0; _i57 < _set56.Count; ++_i57)
{
ContentType _elem58;
_elem58 = (ContentType)iprot.ReadI32();
AcceptableContentTypes.Add(_elem58);
}
iprot.ReadSetEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.Bool)
{
CapableMyhome = iprot.ReadBool();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public override string Accept(TSet type, string x)
{
return($"readSet({x}, {type.ElementType.Apply(LuaDeserializeMethodNameVisitor.Ins)})");
}
public string Accept(TSet type, string x)
{
return($"{x} or {{}}");
}
