public GenericChildKeyStrategy(InformationHandlingFlags typeHandling, [NotNull] ITypeSerializerStrategy <TKeyType> keyTypeSerializerStrategy) { if (keyTypeSerializerStrategy == null) { throw new ArgumentNullException(nameof(keyTypeSerializerStrategy)); } int i; if (!Enum.IsDefined(typeof(InformationHandlingFlags), typeHandling) && Int32.TryParse(typeHandling.ToString(), out i)) { throw new ArgumentOutOfRangeException(nameof(typeHandling), "Value should be defined in the InformationHandlingFlags enum."); } /*int i; * * if (!Enum.IsDefined(typeof(InformationHandlingFlags), typeHandling) && Int32.TryParse(typeHandling.ToString(), out i)) * throw new InvalidEnumArgumentException(nameof(typeHandling), (int)typeHandling, * typeof(InformationHandlingFlags));*/ //Try to get the max value for this type DefaultKey = GenericMath.Convert <TKeyType, int>(GenericMath.Convert <int, TKeyType>(Int32.MaxValue)); typeHandlingFlags = typeHandling; KeyTypeSerializerStrategy = keyTypeSerializerStrategy; }
/// <inheritdoc /> protected override void Load(ContainerBuilder register) { if (typeof(TKeyType) == typeof(int)) { //Because of active load scene, we have to iterate each scene foreach (var registerable in new SceneUiElementEnumerable()) { //Registers the adapter with the specified Key and Service Type. register.RegisterInstance(registerable) .SingleInstance() .Keyed(registerable.RegisterationKey, registerable.UIServiceType); } } else { //Because of active load scene, we have to iterate each scene foreach (var registerable in new SceneUiElementEnumerable()) { //Registers the adapter with the specified Key and Service Type. register.RegisterInstance(registerable) .SingleInstance() .Keyed(GenericMath.Convert <int, TKeyType>(registerable.RegisterationKey), registerable.UIServiceType); } } }
/// <inheritdoc /> public override Task WriteAsync(TEnumType value, IWireStreamWriterStrategyAsync dest) { if (dest == null) { throw new ArgumentNullException(nameof(dest)); } return(serializerStrategy.WriteAsync(GenericMath.Convert <TEnumType, TBaseType>(value), dest)); }
/// <inheritdoc /> public override void Write(TEnumType value, IWireStreamWriterStrategy dest) { if (dest == null) { throw new ArgumentNullException(nameof(dest)); } serializerStrategy.Write(GenericMath.Convert <TEnumType, TBaseType>(value), dest); }
public void ConvertInt32ToDouble() { int from = 280; double d = GenericMath.Convert <int, double>(from); int i = GenericMath.Convert <double, int>(d); Assert.AreEqual(i, from); Assert.AreEqual(d, (double)i); }
/// <inheritdoc /> public async Task <int> ReadAsync(IWireStreamReaderStrategyAsync source) { //Read the key from the stream. TKeyType key = await KeyTypeSerializerStrategy .ReadAsync(typeHandlingFlags.HasFlag(InformationHandlingFlags.DontConsumeRead)?source.WithOnlyPeekingAsync() : source) .ConfigureAwait(false); return(GenericMath.Convert <TKeyType, int>(key)); }
public static TValueType GetEnumFieldValue <TValueType>(this IReadonlyEntityDataFieldContainer container, GameObjectField index) where TValueType : Enum { if (container == null) { throw new ArgumentNullException(nameof(container)); } return(GenericMath.Convert <int, TValueType>(container.GetFieldValue <int>((int)index))); }
/// <inheritdoc /> public override TEnumType Read(IWireStreamReaderStrategy source) { if (source == null) { throw new ArgumentNullException(nameof(source)); } //TODO: Should be handle exceptions? return(GenericMath.Convert <TBaseType, TEnumType>(serializerStrategy.Read(source))); }
/// <summary> /// Helper extension for setting entity data in <see cref="IEntityDataFieldContainer"/> /// based on the int value of a specified Enum value <see cref="index"/>. /// </summary> /// <typeparam name="TEnumType"></typeparam> /// <param name="container"></param> /// <param name="index"></param> /// <param name="guid"></param> public static void SetFieldValue <TEnumType>(this IEntityDataFieldContainer container, TEnumType index, NetworkEntityGuid guid) where TEnumType : Enum { if (container == null) { throw new ArgumentNullException(nameof(container)); } container.SetFieldValue(GenericMath.Convert <TEnumType, int>(index), guid.RawGuidValue); }
/// <summary> /// Determines the size of the collection from the stream. /// </summary> public int Size(IWireStreamReaderStrategy reader) { if (reader == null) { throw new ArgumentNullException(nameof(reader)); } //Read the byte size from the stream. //Readd the addedsize so that we know how many items are really there. return(GenericMath.Convert <TSizeType, int>(SizeTypeSerializerStrategy.Read(reader)) + AddedSize); }
/// <summary> /// Helper extension for setting entity data in <see cref="IEntityDataFieldContainer"/> /// based on the int value of a specified Enum value <see cref="index"/>. /// </summary> /// <typeparam name="TEnumType"></typeparam> /// <typeparam name="TValueType"></typeparam> /// <param name="container"></param> /// <param name="index"></param> /// <param name="value"></param> public static void SetFieldValue <TEnumType, TValueType>(this IEntityDataFieldContainer container, TEnumType index, TValueType value) where TValueType : struct where TEnumType : Enum { if (container == null) { throw new ArgumentNullException(nameof(container)); } container.SetFieldValue(GenericMath.Convert <TEnumType, int>(index), value); }
/// <inheritdoc /> public override async Task <TEnumType> ReadAsync(IWireStreamReaderStrategyAsync source) { if (source == null) { throw new ArgumentNullException(nameof(source)); } //TODO: Should be handle exceptions? return(GenericMath.Convert <TBaseType, TEnumType>(await serializerStrategy.ReadAsync(source) .ConfigureAwait(false))); }
private static bool HasOpCodeAttribute <TWireLinkBaseAttributeType, TOpcodeType>(Type t, TOpcodeType opcode) where TWireLinkBaseAttributeType : WireDataContractBaseLinkAttribute { TWireLinkBaseAttributeType attri = t.GetCustomAttribute <TWireLinkBaseAttributeType>(); if (attri == null) { return(false); } return(attri.Index == GenericMath.Convert <TOpcodeType, int>(opcode)); }
/// <inheritdoc /> public int Size(IWireStreamReaderStrategy reader) { if (reader == null) { throw new ArgumentNullException(nameof(reader)); } TSizeType size = sizeSerializer.Read(reader); //Using JonSkeets MiscUtils we can convert objects efficently return(GenericMath <TSizeType, int> .Convert(size) + AddedSize); }
private void WriteCollectionSizeToField(TContainingType obj) { //We must first access the collection to get the size and then write it into the field //before we try to truly serialize it ICollection enumerable = CollectionGetter.Getter(obj) as ICollection; if (enumerable == null) { throw new InvalidOperationException($"Tried to read the size of collection in Type: {typeof(TContainingType).Name} but did not implement {nameof(ICollection)}."); } MemberSetter.Setter(obj, GenericMath.Convert <int, TSizeType>(enumerable.Count)); }
/// <inheritdoc /> public int Read(IWireStreamReaderStrategy source) { if (source == null) { throw new ArgumentNullException(nameof(source)); } //Read the key from the stream. TKeyType key = KeyTypeSerializerStrategy .Read(typeHandlingFlags.HasFlag(InformationHandlingFlags.DontConsumeRead) ? source.WithOnlyPeeking() : source); return(GenericMath.Convert <TKeyType, int>(key)); }
/// <inheritdoc /> public async Task <int> SizeAsync(IWireStreamReaderStrategyAsync reader) { if (reader == null) { throw new ArgumentNullException(nameof(reader)); } TSizeType size = await sizeSerializer.ReadAsync(reader) .ConfigureAwait(false); //Using JonSkeets MiscUtils we can convert objects efficently return(GenericMath <TSizeType, int> .Convert(size) + AddedSize); }
/// <inheritdoc /> public async Task <int> SizeAsync(IWireStreamReaderStrategyAsync reader) { if (reader == null) { throw new ArgumentNullException(nameof(reader)); } //Read the byte size from the stream. TSizeType result = await SizeTypeSerializerStrategy.ReadAsync(reader) .ConfigureAwait(false); //Readd the addedsize so that we know how many items are really there. return(GenericMath.Convert <TSizeType, int>(result) + AddedSize); }
/// <inheritdoc /> public void Write(int value, IWireStreamWriterStrategy dest) { if (dest == null) { throw new ArgumentNullException(nameof(dest)); } //If the key shouldn't be written then we avoid writing it //It may be that the data is needed to be left in the stream to indicate //something about the type later down the line. if (!typeHandlingFlags.HasFlag(InformationHandlingFlags.DontWrite)) { KeyTypeSerializerStrategy.Write(GenericMath.Convert <int, TKeyType>(value), dest); } }
/// <summary> /// /// </summary> /// <param name="key"></param> /// <exception cref="InconclusiveException">Throws if the key cannot be constructed.</exception> /// <returns></returns> private static TKeyType TryBuildKey(int key) { //TODO: Is there a better way to do this? TKeyType keyValue = default(TKeyType); try { keyValue = GenericMath.Convert <int, TKeyType>(key); } catch (Exception) { Assert.Inconclusive($"Unable to convert Key: {key} to Type: {typeof(TKeyType).Name} so skipping."); } return(keyValue); }
/// <inheritdoc /> public int Size(string stringValue, IWireStreamWriterStrategy writer) { if (stringValue == null) { throw new ArgumentNullException(nameof(stringValue)); } if (writer == null) { throw new ArgumentNullException(nameof(writer)); } int size = stringValue.Length - AddedSize; //add one for null terminator //Using JonSkeets MiscUtils we can convert objects efficently sizeSerializer.Write(GenericMath <int, TSizeType> .Convert(size + (includeNullTerminatorInSizeCalculation ? 1 : 0)), writer); return(size); }
/// <summary> /// The size to consider the collection. /// </summary> public int Size <TCollectionType, TElementType>(TCollectionType collection, IWireStreamWriterStrategy writer) where TCollectionType : IEnumerable, IEnumerable <TElementType> { if (collection == null) { throw new ArgumentNullException(nameof(collection)); } if (writer == null) { throw new ArgumentNullException(nameof(writer)); } //When writing N items we want to write N - X. The otherside will X so it will still understand //This was added to suppose very rare scenarios where the encoded size was off from the actual size. int size = collection.Count() - AddedSize; //Since the size is unknown it's critical that we write the size to the stream. SizeTypeSerializerStrategy.Write(GenericMath.Convert <int, TSizeType>(size), writer); //We don't know the size so just provide the size of the collection return(size); }
/// <inheritdoc /> public async Task <int> SizeAsync <TCollectionType, TElementType>(TCollectionType collection, IWireStreamWriterStrategyAsync writer) where TCollectionType : IEnumerable, IEnumerable <TElementType> { if (collection == null) { throw new ArgumentNullException(nameof(collection)); } if (writer == null) { throw new ArgumentNullException(nameof(writer)); } //When writing N items we want to write N - X. The otherside will X so it will still understand //This was added to suppose very rare scenarios where the encoded size was off from the actual size. int size = collection.Count() - AddedSize; //yield until we write (shouldn't take long and maybe syncronous is more efficient and performant but async API should be fully async) await SizeTypeSerializerStrategy.WriteAsync(GenericMath.Convert <int, TSizeType>(size), writer) .ConfigureAwait(false); //We don't know the size so just provide the size of the collection return(size); }
/// <summary> /// Method should convert the <paramref name="statType"/> to a key-value; implementation is /// deferred to implementing concrete (non-generic) types. /// </summary> /// <param name="statType">The stat type to convert to int.</param> /// <returns>A key value for the given <paramref name="statType"/>.</returns> protected int ConvertStatToKey(TStatType statType) { return(GenericMath.Convert <TStatType, int>(statType)); }
/// <inheritdoc /> public void SetFieldValue <TValueType>(TFieldType index, TValueType value) where TValueType : struct { SetFieldValue <TValueType>(GenericMath.Convert <TFieldType, int>(index), value); }
//TFieldType public TValueType GetFieldValue <TValueType>(TFieldType index) where TValueType : struct { return(GetFieldValue <TValueType>(GenericMath.Convert <TFieldType, int>(index))); }
public static bool HasAnyFlags <T>(this T enumValue, T flags) where T : Enum { return((GenericMath.Convert <T, int>(enumValue) & GenericMath.Convert <T, int>(flags)) != 0); }
private static short ConvertPayloadOperationCode <TBasePayloadType, TOperationType>(TBasePayloadType payload) where TBasePayloadType : IOperationCodeable <TOperationType>, ITypeSerializerReadingStrategy <TBasePayloadType> where TOperationType : Enum { return(GenericMath.Convert <TOperationType, short>(payload.OperationCode)); }
public static string BuildPacketDocumentation <TOutgoingPayloadAttributeType, TIncomingPayloadAttributeType, TOpcodeType>([NotNull] IEnumerable <Type> packets, string packetType) where TOpcodeType : struct where TOutgoingPayloadAttributeType : WireDataContractBaseLinkAttribute where TIncomingPayloadAttributeType : WireDataContractBaseLinkAttribute { if (packets == null) { throw new ArgumentNullException(nameof(packets)); } packets = packets.ToList(); StringBuilder builder = new StringBuilder(); //Generate the patch packet documentation builder.Append(BuildHeader(1, $"{packetType} Packets")); InsertLineBreak(builder); InsertLineBreak(builder); builder.Append(BuildPacketHeaderRow()); InsertLineBreak(builder); foreach (TOpcodeType opcode in Enum.GetValues(typeof(TOpcodeType))) { Type serverPayloadType = packets.FirstOrDefault(p => HasOpCodeAttribute <TIncomingPayloadAttributeType, TOpcodeType>(p, opcode)); Type clientPayloadType = packets.FirstOrDefault(p => HasOpCodeAttribute <TOutgoingPayloadAttributeType, TOpcodeType>(p, opcode)); //Skip if there are no payloads for this OpCode if (serverPayloadType == null && clientPayloadType == null) { continue; } string row = BuildPacketInformationRow(opcode.ToString(), $"0x{String.Format("{0:X4}", GenericMath.Convert<TOpcodeType, int>(opcode))}", serverPayloadType, clientPayloadType, packetType); builder.Append(row); InsertLineBreak(builder); } InsertLineBreak(builder); InsertLineBreak(builder); builder.Append("This documentation was automatically generated using the documentation tools."); return(builder.ToString()); }
/// <inheritdoc /> public void OnEntityStateChanged(byte value) => OnEntityStateChanged(GenericMath <byte, TNetworkStateType> .Convert(value));