public override void Serialize(SerializeContext context)
{
base.Serialize(context);
context.Write(SourceAuthorityIndex);
context.Write(DestinationAuthorityIndex);
context.Write(Value);
}
public void Deserialize(ref SerializeContext context, ref NetworkReader reader)
{
action = (State)reader.ReadInt32();
phaseStartTick = reader.ReadInt32();
ammoInClip = reader.ReadInt32();
COF = reader.ReadFloatQ();
}
public static void RunTest()
{
TreeTest input = new TreeTest(43);
TreeTest common = new TreeTest(66);
common.other.Add(new TreeTest(100));
input.other.Add(common);
input.other.Add(common);
input.other.Add(common);
MemoryStream ms = new MemoryStream();
BinaryWriter bw = new BinaryWriter(ms);
SerializeContext serializeContext = new SerializeContext(bw);
Field.Serialize(serializeContext, bw, ref input);
BinaryReader br = new BinaryReader(new MemoryStream(ms.ToArray()));
DeserializeContext deserializeContext = new DeserializeContext(br);
TreeTest result = null;
Field.Deserialize(deserializeContext, br, ref result);
Debug.Assert(input.Equals(result));
foreach (var item in result.other)
{
// Check the graph works:
Debug.Assert(ReferenceEquals(item, result.other[0]));
}
}
public void Serialize(ref SerializeContext context, ref NetworkWriter writer)
{
context.RefSerializer.SerializeReference(ref writer, "triggerEntity", TriggeredEntity);
context.RefSerializer.SerializeReference(ref writer, "PreTriggeredEntity", PreTriggeredEntity);
writer.WriteBoolean("IsAllowTrigger", IsAllowTrigger);
}
public void Deserialize(ref SerializeContext context, ref NetworkReader reader)
{
fireTick = reader.ReadInt32();
fireEndPos = reader.ReadVector3Q();
impactType = (ImpactType)reader.ReadInt32();
impactNormal = reader.ReadVector3Q();
}
public void Serialize(ref SerializeContext context, ref NetworkWriter writer)
{
writer.WriteVector3Q("position", position, 2);
writer.WriteFloatQ("rotation", rotation, 0);
writer.WriteFloatQ("aimYaw", aimYaw, 0);
writer.WriteFloatQ("aimPitch", aimPitch, 0);
writer.WriteFloatQ("moveYaw", moveYaw, 0);
writer.WriteInt32("charLocoState", (int)charLocoState);
writer.WriteInt32("charLocoTick", charLocoTick);
writer.WriteInt32("characterAction", (int)charAction);
writer.WriteInt32("characterActionTick", charActionTick);
writer.WriteBoolean("sprinting", sprinting == 1);
writer.WriteFloatQ("sprintWeight", sprintWeight, 2);
writer.WriteInt32("damageTick", damageTick);
writer.WriteFloatQ("damageDirection", damageDirection, 1);
//writer.WriteFloatQ("moveAngleLocal", moveAngleLocal, 0);
//writer.WriteFloatQ("shootPoseWeight", shootPoseWeight);
//writer.WriteVector2Q("locomotionVector", locomotionVector);
//writer.WriteFloatQ("locomotionPhase", locomotionPhase);
//writer.WriteFloatQ("banking", banking);
//writer.WriteFloatQ("landAnticWeight", landAnticWeight, 2);
//writer.WriteFloatQ("turnStartAngle", turnStartAngle, 0);
//writer.WriteInt16("turnDirection", turnDirection);
//writer.WriteFloatQ("squashTime", squashTime, 2);
//writer.WriteFloatQ("squashWeight", squashWeight, 2);
//writer.WriteFloatQ("inAirTime", inAirTime, 2);
//writer.WriteFloatQ("jumpTime", jumpTime, 2);
//writer.WriteFloatQ("simpleTime", simpleTime, 2);
//writer.WriteVector2Q("footIkOffset", footIkOffset, 2);
//writer.WriteVector3Q("footIkNormalLeft", footIkNormalLeft, 2);
//writer.WriteVector3Q("footIkNormaRight", footIkNormaRight, 2);
}
public static void Serialize <T>(SerializeContext context, BinaryWriter bw, TagLookup <T> value)
{
for (var i = 0; i < value.Count; i++)
{
Field.Serialize(context, bw, ref value.values[i]);
}
}
static void TestPrimitiveType()
{
PrimitiveTypes subject = new PrimitiveTypes()
{
@bool = true,
@float = 3.14159f,
@double = 9.999,
@char = 'q',
@int = 42,
@sbyte = 1
};
MemoryStream ms = new MemoryStream();
BinaryWriter bw = new BinaryWriter(ms);
SerializeContext serializeContext = new SerializeContext(bw);
Field.Serialize(serializeContext, bw, ref subject);
BinaryReader br = new BinaryReader(new MemoryStream(ms.ToArray()));
DeserializeContext deserializeContext = new DeserializeContext(br);
PrimitiveTypes result = default(PrimitiveTypes);
Field.Deserialize(deserializeContext, br, ref result);
Debug.Assert(object.Equals(result, subject));
}
public void Serialize(ref SerializeContext context, ref NetworkWriter writer)
{
var transform = context.entityManager.GetComponentObject <Transform>(context.entity);
writer.WriteVector3Q("position", transform.position);
writer.WriteQuaternionQ("rotation", transform.rotation);
}
public void ProcessCommand(int connectionId, int tick, ref NetworkReader data)
{
ServerGameLoop.ClientInfo client;
if (!m_Clients.TryGetValue(connectionId, out client))
{
return;
}
if (client.player)
{
var serializeContext = new SerializeContext {
entityManager = _gameWorld.GetEntityManager(),
entity = Entity.Null,
refSerializer = null,
tick = tick
};
if (tick == _gameWorld.WorldTime.tick)
{
client.latestCommand.Deserialize(ref serializeContext, ref data);
}
// Pass on command to controlled entity
if (client.player.controlledEntity != Entity.Null)
{
var userCommand = _gameWorld.GetEntityManager().GetComponentData <UserCommandComponentData>(
client.player.controlledEntity);
userCommand.command = client.latestCommand;
_gameWorld.GetEntityManager().SetComponentData(client.player.controlledEntity, userCommand);
}
}
}
public override void Serialize(SerializeContext context)
{
base.Serialize(context);
context.Write(Cookie);
context.Write(Certificate);
context.Write(SignDateTime);
}
internal void NetworkSerializeHelper(SerializeContext context, BinaryWriter bw)
{
for (int i = 0; i < count; i++)
{
Field.Serialize(context, bw, ref values[i]);
}
}
public override void Serialize(IBitWriter bs, SerializeContext ctx)
{
bs.WriteVector3(transform.position);
var euler = transform.rotation.eulerAngles;
euler.x = Mathf.Repeat(euler.x, 360);
euler.y = Mathf.Repeat(euler.y, 360);
euler.z = Mathf.Repeat(euler.z, 360);
bs.WriteLossyFloat(euler.x, 0, 360);
bs.WriteLossyFloat(euler.y, 0, 360);
bs.WriteLossyFloat(euler.z, 0, 360);
var sleeping = rigidbody.IsSleeping();
bs.WriteBool(sleeping);
if (!sleeping)
{
var velocity = rigidbody.velocity;
bs.WriteLossyFloat(velocity.x, -maxVelocity, maxVelocity);
bs.WriteLossyFloat(velocity.y, -maxVelocity, maxVelocity);
bs.WriteLossyFloat(velocity.z, -maxVelocity, maxVelocity);
var angularVelocity = rigidbody.angularVelocity;
bs.WriteLossyFloat(angularVelocity.x, -maxAngularVelocity, maxAngularVelocity);
bs.WriteLossyFloat(angularVelocity.y, -maxAngularVelocity, maxAngularVelocity);
bs.WriteLossyFloat(angularVelocity.z, -maxAngularVelocity, maxAngularVelocity);
}
}
public static void SerializeArray3DField <T>(SerializeContext context, BinaryWriter bw, T[,,] array)
{
if (!context.Walk(array)) // null check
{
return;
}
context.VisitObject(array);
int length0, length1, length2;
bw.WriteSmallInt32(length0 = array.GetLength(0));
bw.WriteSmallInt32(length1 = array.GetLength(1));
bw.WriteSmallInt32(length2 = array.GetLength(2));
for (var i = 0; i < length0; i++)
{
for (var j = 0; j < length1; j++)
{
for (var k = 0; k < length2; k++)
{
Field.Serialize(context, bw, ref array[i, j, k]);
}
}
}
context.LeaveObject();
}
protected override void SerializeBase(uint?objectItem, BinaryWriter writer, SerializeContext context)
{
var isNull = objectItem == null; writer.Write(isNull); if (!isNull)
{
writer.Write(objectItem.Value);
}
}
public void Interpolate(ref SerializeContext context, ref MovableData first, ref MovableData last, float t)
{
var transform = context.entityManager.GetComponentObject <Transform>(context.entity);
transform.position = Vector3.Lerp(first.position, last.position, t);
transform.rotation = Quaternion.Lerp(first.rotation, last.rotation, t);
}
/// <summary>
/// Serializes the object to binary.
/// </summary>
/// <param name="context">Context for serializable.</param>
public override void Serialize(SerializeContext context)
{
base.Serialize(context);
context.Write(Data);
context.Write(Signature);
context.Write(CertificateData);
}
public void Serialize(ref SerializeContext context, ref NetworkWriter writer)
{
// FSLog.Info($"TransformPredictedState Serialize,enity:{context.Entity},Position:{Position}!");
writer.WriteVector3Q("position", Position);
writer.WriteQuaternionQ("rotation", Rotation);
}
public void Deserialize(ref SerializeContext context, ref NetworkReader reader)
{
state = (State)reader.ReadInt32();
actionStartTick = reader.ReadInt32();
ammoInClip = reader.ReadInt32();
fireRate = reader.ReadFloatQ();
}
/// <summary>
/// Creates a new sum proof.
/// </summary>
/// <param name="r">The randomness used to encrypt the vote.</param>
/// <param name="voteSum">The sum of all votes for which to generate a proof.</param>
/// <param name="publicKey">The public key with which the vote was encrypted.</param>
/// <param name="parameters">Cryptographic Parameters.</param>
public Proof(BigInt r, Vote voteSum, BigInt publicKey, BaseParameters parameters)
{
if (r == null)
throw new ArgumentNullException("r");
if (voteSum == null)
throw new ArgumentNullException("vote");
if (publicKey == null)
throw new ArgumentNullException("publicKey");
if (parameters == null)
throw new ArgumentNullException("parameters");
BigInt r0 = parameters.Random();
T0 = publicKey.PowerMod(r0, parameters.P);
MemoryStream serializeStream = new MemoryStream();
SerializeContext serializer = new SerializeContext(serializeStream);
serializer.Write(voteSum.Ciphertext);
serializer.Write(voteSum.HalfKey);
serializer.Write(publicKey);
serializer.Write(T0);
serializer.Close();
serializeStream.Close();
SHA512Managed sha512 = new SHA512Managed();
byte[] hash = sha512.ComputeHash(serializeStream.ToArray());
C0 = hash[0] | (hash[1] << 8);
S0 = r0 + r * C0;
}
/// <summary>
/// Serializes the object to binary.
/// </summary>
/// <param name="context">Context for serializable.</param>
public override void Serialize(SerializeContext context)
{
base.Serialize(context);
context.Write(Exception == null);
if (Exception != null)
context.Write(Exception.ToBinary());
}
public void Serialize(ref SerializeContext context, ref NetworkWriter writer)
{
var behaviour = context.entityManager.GetComponentObject <PlayerState>(context.entity);
writer.WriteInt32("playerId", behaviour.playerId);
writer.WriteString("playerName", behaviour.playerName);
writer.WriteInt32("teamIndex", behaviour.teamIndex);
writer.WriteInt32("score", behaviour.score);
context.refSerializer.SerializeReference(ref writer, "controlledEntity", behaviour.controlledEntity);
writer.SetFieldSection(NetworkWriter.FieldSectionType.OnlyPredicting);
writer.WriteBoolean("displayScoreBoard", behaviour.displayScoreBoard);
writer.WriteBoolean("displayGameScore", behaviour.displayGameScore);
writer.WriteBoolean("displayGameResult", behaviour.displayGameResult);
writer.WriteString("gameResult", behaviour.gameResult);
writer.WriteBoolean("displayGoal", behaviour.displayGoal);
writer.WriteVector3Q("goalPosition", behaviour.goalPosition, 2);
writer.WriteUInt32("goalDefendersColor", behaviour.goalDefendersColor);
writer.WriteUInt32("goalAttackersColor", behaviour.goalAttackersColor);
writer.WriteUInt32("goalAtackers", behaviour.goalAttackers);
writer.WriteUInt32("goalDefenders", behaviour.goalDefenders);
writer.WriteString("goalString", behaviour.goalString);
writer.WriteString("actionString", behaviour.actionString);
writer.WriteFloatQ("goalCompletion", behaviour.goalCompletion, 2);
writer.ClearFieldSection();
}
public void Serialize(ref SerializeContext context, ref NetworkWriter writer)
{
writer.WriteInt32("primFireTick", fireTick);
writer.WriteVector3Q("fireEndPos", fireEndPos, 2);
writer.WriteInt32("impact", (int)impactType);
writer.WriteVector3Q("impactNormal", impactNormal, 1);
}
public void Deserialize(ref SerializeContext context, ref NetworkReader reader)
{
var behaviour = context.entityManager.GetComponentObject <PlayerState>(context.entity);
behaviour.playerId = reader.ReadInt32();
behaviour.playerName = reader.ReadString();
behaviour.teamIndex = reader.ReadInt32();
behaviour.score = reader.ReadInt32();
context.refSerializer.DeserializeReference(ref reader, ref behaviour.controlledEntity);
behaviour.displayScoreBoard = reader.ReadBoolean();
behaviour.displayGameScore = reader.ReadBoolean();
behaviour.displayGameResult = reader.ReadBoolean();
behaviour.gameResult = reader.ReadString();
behaviour.displayGoal = reader.ReadBoolean();
behaviour.goalPosition = reader.ReadVector3Q();
behaviour.goalDefendersColor = reader.ReadUInt32();
behaviour.goalAttackersColor = reader.ReadUInt32();
behaviour.goalAttackers = reader.ReadUInt32();
behaviour.goalDefenders = reader.ReadUInt32();
behaviour.goalString = reader.ReadString();
behaviour.actionString = reader.ReadString();
behaviour.goalCompletion = reader.ReadFloatQ();
}
public void Serialize(ref SerializeContext context, ref NetworkWriter writer)
{
writer.WriteInt32("phase", (int)action);
writer.WriteInt32("phaseStart", phaseStartTick);
writer.WriteInt32("ammoInClip", ammoInClip);
writer.WriteFloatQ("COF", COF, 0);
}
public void Serialize(ref SerializeContext context, ref NetworkWriter writer)
{
writer.WriteInt32("phase", (int)state);
writer.WriteInt32("phaseStart", actionStartTick);
writer.WriteInt32("ammoInClip", ammoInClip);
writer.WriteFloatQ("fireRate", fireRate, 2);
}
public void Deserialize(ref SerializeContext context, ref NetworkReader reader)
{
position = reader.ReadVector3Q();
rotation = reader.ReadFloatQ();
aimYaw = reader.ReadFloatQ();
aimPitch = reader.ReadFloatQ();
moveYaw = reader.ReadFloatQ();
charLocoState = (CharacterPredictedData.LocoState)reader.ReadInt32();
charLocoTick = reader.ReadInt32();
charAction = (CharacterPredictedData.Action)reader.ReadInt32();
charActionTick = reader.ReadInt32();
sprinting = reader.ReadBoolean() ? 1 : 0;
sprintWeight = reader.ReadFloatQ();
damageTick = reader.ReadInt32();
damageDirection = reader.ReadFloatQ();
//moveAngleLocal = reader.ReadFloatQ();
//shootPoseWeight = reader.ReadFloatQ();
//locomotionVector = reader.ReadVector2Q();
//locomotionPhase = reader.ReadFloatQ();
//banking = reader.ReadFloatQ();
//landAnticWeight = reader.ReadFloatQ();
//turnStartAngle = reader.ReadFloatQ();
//turnDirection = reader.ReadInt16();
//squashTime = reader.ReadFloatQ();
//squashWeight = reader.ReadFloatQ();
//inAirTime = reader.ReadFloatQ();
//jumpTime = reader.ReadFloatQ();
//simpleTime = reader.ReadFloatQ();
//footIkOffset = reader.ReadVector2Q();
//footIkNormalLeft = reader.ReadVector3Q();
//footIkNormaRight = reader.ReadVector3Q();
}
public static void SendCommand(LocalPlayer localPlayer, int tick)
{
if (localPlayer.playerState == null)
{
return;
}
var command = UserCommand.defaultCommand;
var commandValid = localPlayer.commandBuffer.TryGetValue(tick, ref command);
if (commandValid)
{
var serializeContext = new SerializeContext
{
entityManager = null,
entity = Entity.Null,
refSerializer = null,
tick = tick
};
localPlayer.networkClient.QueueCommand(tick, (ref NetworkWriter writer) =>
{
command.Serialize(ref serializeContext, ref writer);
});
}
}
public void Deserialize(ref SerializeContext context, ref NetworkReader reader)
{
var behaviour = context.entityManager.GetComponentObject <CapturePoint>(context.entity);
behaviour.objectiveName = reader.ReadString();
behaviour.status = (CapturePoint.Status)reader.ReadByte();
behaviour.captured = reader.ReadFloatQ();
// TODO (petera) replace with proper cross scene reference system
foreach (var i in CapturePointReference.capturePointReferences)
{
if (i.index == behaviour.captureIndex && i.animator != null)
{
int captured = 0;
if (behaviour.status == CapturePoint.Status.Capturing || behaviour.status == CapturePoint.Status.Contested)
{
captured = 1;
}
else if (behaviour.status == CapturePoint.Status.Completed)
{
captured = 2;
}
i.animator.SetInteger("Captured", captured);
}
}
}
public void Interpolate(ref SerializeContext context, ref InterpolatedState first, ref InterpolatedState last,
float t)
{
position = math.lerp(first.position, last.position, t);
exploded = first.exploded;
bouncetick = first.bouncetick;
}
public void Deserialize(ref SerializeContext context, ref NetworkReader reader)
{
position = reader.ReadVector3();
exploded = reader.ReadBoolean() ? 1 : 0;
bouncetick = reader.ReadInt32();
velocity = reader.ReadVector3();
}
public void Serialize(ref SerializeContext context, ref NetworkWriter writer)
{
context.RefSerializer.SerializeReference(ref writer, "FilledIn1", FilledIn1);
context.RefSerializer.SerializeReference(ref writer, "FilledIn2", FilledIn2);
context.RefSerializer.SerializeReference(ref writer, "FilledIn3", FilledIn3);
context.RefSerializer.SerializeReference(ref writer, "FilledIn4", FilledIn4);
}
public override void Serialize(SerializeContext context)
{
base.Serialize(context);
context.Write(Request);
context.Write(SecureRequest);
context.Write(SecureRequestInfo);
}
/// <summary>
/// Serializes the object to binary.
/// </summary>
/// <param name="context">Context for serializable.</param>
public override void Serialize(SerializeContext context)
{
base.Serialize(context);
context.Write((int)Status);
context.Write(SignatureResponse);
}
private static void SerializeDelegate(SerializeContext context, BinaryWriter bw, Delegate d, Type delegateType)
{
Debug.Assert(d != null);
Debug.Assert(StaticDelegateTable.delegateTypeTable.ContainsKey(delegateType));
var delegateTypeInfo = StaticDelegateTable.delegateTypeTable[delegateType];
var methodId = delegateTypeInfo.GetIdForMethod(d.Method);
bw.Write(methodId);
var delegateMethodInfo = delegateTypeInfo.GetMethodInfoForId(methodId);
if (delegateMethodInfo.canHaveTarget)
{
var target = d.Target;
if (context.Walk(target))
{
StaticDispatchTable.SerializationDispatcher(context, bw, target);
}
}
else
{
Debug.Assert(d.Target == null);
}
}
public override void SerializeDestruction(BitStream bs, SerializeContext ctx)
{
bs.Write(deathReason.HasValue);
if (deathReason.HasValue)
{
bs.Write(deathReason.Value);
}
}
/// <summary>
/// Serializes the object to binary.
/// </summary>
/// <param name="context">Context for serializable.</param>
public override void Serialize(SerializeContext context)
{
base.Serialize(context);
if (Exception == null)
{
context.WriteList(this.votings);
}
}
/// <summary>
/// Serializes the object to binary.
/// </summary>
/// <param name="context">Context for serializable.</param>
public override void Serialize(SerializeContext context)
{
base.Serialize(context);
if (Exception == null)
{
context.Write(EncryptedCode);
}
}
public void Deserialize(ref SerializeContext context, ref NetworkReader reader)
{
context.RefSerializer.DeserializeReference(ref reader, ref FilledIn1);
context.RefSerializer.DeserializeReference(ref reader, ref FilledIn2);
context.RefSerializer.DeserializeReference(ref reader, ref FilledIn3);
context.RefSerializer.DeserializeReference(ref reader, ref FilledIn4);
// FSLog.Info($"SlotPredictedState DeserializeReference:{FilledInEntity}");
}
public override void Serialize(SerializeContext context)
{
base.Serialize(context);
if (Exception == null)
{
context.WriteList(SignChecks);
context.Write(EncryptedSignatureRequest);
}
}
/// <summary>
/// Serializes the object to binary.
/// </summary>
/// <param name="context">Context for serializable.</param>
public override void Serialize(SerializeContext context)
{
base.Serialize(context);
if (Exception == null)
{
context.Write(this.votingMaterials.Count);
foreach (var votingMaterial in this.votingMaterials)
{
context.Write(votingMaterial.First);
context.Write((int)votingMaterial.Second);
context.WriteList(votingMaterial.Third);
}
}
}
/// <summary>
/// Serializes the object to binary.
/// </summary>
/// <param name="context">Context for serializable.</param>
public override void Serialize(SerializeContext context)
{
base.Serialize(context);
context.Write(this.fullName);
}
/// <summary>
/// Save the data of the authority to file.
/// </summary>
/// <param name="fileName">Name of file to save.</param>
public void Save(string fileName)
{
FileStream fileStream = new FileStream(fileName, FileMode.Create, FileAccess.Write);
SerializeContext context = new SerializeContext(fileStream);
context.Write(this.parameters);
context.Write(this.signedParameters);
context.Write(this.authorities.Count);
this.authorities.Foreach(pair => { context.Write(pair.Key); context.Write(pair.Value); });
this.authority.Serialize(context);
context.Close();
fileStream.Close();
}
public override void Serialize(SerializeContext context)
{
base.Serialize(context);
context.Write(Id);
context.Write(Title);
context.Write(Description);
context.WriteList(this.questions);
context.Write(VotingBeginDate);
context.Write(VotingEndDate);
context.Write(AuthorityCount);
}
/// <summary>
/// Serializes the object to binary.
/// </summary>
/// <param name="context">Context for serializable.</param>
public override void Serialize(SerializeContext context)
{
base.Serialize(context);
context.Write(VotingId);
context.Write(Title);
context.Write(Description);
context.Write(Url);
context.Write(VotingBeginDate);
context.Write(VotingEndDate);
context.Write(GroupId);
}
/// <summary>
/// Serializes the object to binary.
/// </summary>
/// <param name="context">Context for serializable.</param>
public override void Serialize(SerializeContext context)
{
base.Serialize(context);
context.Write(SystemName);
context.Write(WelcomeMessage);
context.Write(Image);
context.Write(Url);
context.Write(UpdateVersion);
context.Write(UpdateUrl);
}
/// <summary>
/// Serializes the object to binary.
/// </summary>
/// <param name="context">Context for serializable.</param>
public override void Serialize(SerializeContext context)
{
base.Serialize(context);
context.Write(AuthorityIndex);
context.WriteList(EncryptedShares);
context.WriteList(VerificationValues);
}
/// <summary>
/// Serializes the object to binary.
/// </summary>
/// <param name="context">Context for serializable.</param>
public override void Serialize(SerializeContext context)
{
base.Serialize(context);
context.Write(VotingId);
context.Write(AuthorityIndex);
context.WriteList(PartialDeciphers);
context.Write(EnvelopeCount);
context.Write(EnvelopeHash);
context.Write(Date);
}
/// <summary>
/// Serializes the object to binary.
/// </summary>
/// <param name="context">Context for serializable.</param>
public override void Serialize(SerializeContext context)
{
base.Serialize(context);
context.Write(EnvelopeCount);
}
public override void Serialize(SerializeContext context)
{
base.Serialize(context);
context.WriteList(this.coefficients);
}
/// <summary>
/// Serializes the object to binary.
/// </summary>
/// <param name="context">Context for serializable.</param>
public override void Serialize(SerializeContext context)
{
base.Serialize(context);
context.Write(P);
context.Write(Q);
context.Write(G);
context.Write(F);
context.Write(Thereshold);
context.Write(AuthorityCount);
context.Write(ProofCount);
context.WriteList(this.questions);
}
/// <summary>
/// Serializes the object to binary.
/// </summary>
/// <param name="context">Context for serializable.</param>
public override void Serialize(SerializeContext context)
{
base.Serialize(context);
context.Write(Config);
context.WriteList(Groups);
}
/// <summary>
/// Serializes the object to binary.
/// </summary>
/// <param name="context">Context for serializable.</param>
public override void Serialize(SerializeContext context)
{
base.Serialize(context);
}
/// <summary>
/// Serializes the object to binary.
/// </summary>
/// <param name="context">Context for serializable.</param>
public override void Serialize(SerializeContext context)
{
base.Serialize(context);
context.Write(VotingId);
context.Write(VoterId);
context.WriteList(Ballots);
context.Write(Date);
}
public override void Serialize(SerializeContext context)
{
base.Serialize(context);
context.Write(ComplainingAuthorityIndex);
context.Write(CertificateStorage);
context.Write(SignedParameters);
context.Write(AllShareParts);
context.WriteDictionary(TrapDoors);
context.WriteDictionary(Authorities);
}
/// <summary>
/// Serializes the object to binary.
/// </summary>
/// <param name="context">Context for serializable.</param>
public override void Serialize(SerializeContext context)
{
base.Serialize(context);
context.Write(ReceiverId);
context.Write(Data);
}
/// <summary>
/// Serializes the object to binary.
/// </summary>
/// <param name="context">Context for serializable.</param>
public override void Serialize(SerializeContext context)
{
base.Serialize(context);
context.Write(VoteReceipt);
}
public override void Serialize(SerializeContext context)
{
base.Serialize(context);
context.Write(Title);
context.Write(Descrption);
context.Write(Url);
context.WriteList(Questions);
}
public override void Serialize(SerializeContext context)
{
base.Serialize(context);
context.Write(P);
context.Write(Q);
context.Write(G);
context.Write(F);
context.Write(Thereshold);
context.Write(AuthorityCount);
context.Write(MaxVota);
context.Write(OptionCount);
context.Write(ProofCount);
}
/// <summary>
/// Serializes the object to binary.
/// </summary>
/// <param name="context">Context for serializable.</param>
public override void Serialize(SerializeContext context)
{
base.Serialize(context);
context.Write(FirstName);
context.Write(FamilyName);
context.Write(EmailAddress);
}
