From fcb0a35be026377a014fa07cc3d36d5fe6ff15c3 Mon Sep 17 00:00:00 2001 From: JosepeDev Date: Tue, 24 Nov 2020 02:58:32 +0200 Subject: [PATCH 01/15] Update EncString.cs - Updated links - Added comments - Added 40 methods for string fuctionallity - Added more operators overlaoding --- EncTypes/EncString.cs | 102 +++++++++++++++++++++++++++++++++++------- 1 file changed, 86 insertions(+), 16 deletions(-) diff --git a/EncTypes/EncString.cs b/EncTypes/EncString.cs index fe8373a..688c2b4 100644 --- a/EncTypes/EncString.cs +++ b/EncTypes/EncString.cs @@ -1,4 +1,6 @@ using System; +using System.Globalization; +using System.Text; public class EncString { @@ -6,14 +8,17 @@ public class EncString /// In the memory it is saved as a wierd string that is affected by random very long an wierd key. { encryptionKey } /// Every time the value of the string changes, the encryption key changes too. And it works exactly as an string. /// - /// Wiki page: https://github.com/JosepeDev/VarEnc/wiki + /// WIKI & INFO: https://github.com/JosepeDev/VarEnc #region Variables And Properties private string _encryptionKey; private string _encryptedValue; - private string Value + /// + /// The decrypted value of the stored string. + /// + public string Value { get => EncryptorDecryptor(_encryptedValue, _encryptionKey); set => _encryptedValue = EncryptorDecryptor(value, _encryptionKey); @@ -31,10 +36,7 @@ public static string Empty public char this[int index] { - get - { - return Value[index]; - } + get => Value[index]; } #endregion @@ -52,18 +54,82 @@ public static string ReplaceAt(string input, int index, char newChar) else return null; } - public bool Equal(EncString encString) => encString.Value == this.Value; - + public bool IsEqual(EncString encString) => encString.Value == this.Value; public bool IsNull() => this.Value == null; - - public char[] ToCharArray() => this.Value.ToCharArray(); - public object Clone() => Value.Clone(); - - public override string ToString() - { - return Value.ToString(); - } + public override bool Equals(object obj) => Value.Equals(obj); + public override int GetHashCode() => Value.GetHashCode(); + public bool Contains(string value) => Value.Contains(value); + public int CompareTo(object value) => Value.CompareTo(value); + public int CompareTo(string strB) => Value.CompareTo(strB); + public void CopyTo(int sourceIndex, char[] destination, int destinationIndex, int count) => Value.CopyTo(sourceIndex, destination, destinationIndex, count); + public bool EndsWith(string value) => Value.EndsWith(value); + public bool EndsWith(string value, StringComparison comparisonType) => Value.EndsWith(value, comparisonType); + public bool EndsWith(string value, bool ignoreCase, CultureInfo culture) => Value.EndsWith(value, ignoreCase, culture); + public CharEnumerator GetEnumerator() => Value.GetEnumerator(); + public TypeCode GetTypeCode() => Value.GetTypeCode(); + public int IndexOf(string value, int startIndex, StringComparison comparisonType) => Value.IndexOf(value, startIndex, comparisonType); + public int IndexOf(string value, StringComparison comparisonType) => Value.IndexOf(value, comparisonType); + public int IndexOf(string value, int startIndex, int count) => Value.IndexOf(value, startIndex, count); + public int IndexOf(string value) => Value.IndexOf(value); + public int IndexOf(char value, int startIndex, int count) => Value.IndexOf(value, startIndex, count); + public int IndexOf(char value, int startIndex) => Value.IndexOf(value, startIndex); + public int IndexOf(char value) => Value.IndexOf(value); + public int IndexOf(string value, int startIndex, int count, StringComparison comparisonType) => Value.IndexOf(value, startIndex, count, comparisonType); + public int IndexOf(string value, int startIndex) => Value.IndexOf(value, startIndex); + public int IndexOfAny(char[] anyOf) => Value.IndexOfAny(anyOf); + public int IndexOfAny(char[] anyOf, int startIndex, int count) => Value.IndexOfAny(anyOf, startIndex, count); + public int IndexOfAny(char[] anyOf, int startIndex) => Value.IndexOfAny(anyOf, startIndex); + public string Insert(int startIndex, string value) => Value.Insert(startIndex, value); + public bool IsNormalized() => Value.IsNormalized(); + public bool IsNormalized(NormalizationForm normalizationForm) => Value.IsNormalized(normalizationForm); + public int LastIndexOf(string value, int startIndex, StringComparison comparisonType) => Value.LastIndexOf(value, startIndex, comparisonType); + public int LastIndexOf(string value, int startIndex, int count, StringComparison comparisonType) => Value.LastIndexOf(value, startIndex, count, comparisonType); + public int LastIndexOf(string value, int startIndex, int count) => Value.LastIndexOf(value, startIndex, count); + public int LastIndexOf(string value, StringComparison comparisonType) => Value.LastIndexOf(value, comparisonType); + public int LastIndexOf(string value) => Value.LastIndexOf(value); + public int LastIndexOf(char value, int startIndex, int count) => Value.LastIndexOf(value, startIndex, count); + public int LastIndexOf(char value, int startIndex) => Value.LastIndexOf(value, startIndex); + public int LastIndexOf(string value, int startIndex) => Value.LastIndexOf(value, startIndex); + public int LastIndexOf(char value) => Value.LastIndexOf(value); + public int LastIndexOfAny(char[] anyOf) => Value.LastIndexOfAny(anyOf); + public int LastIndexOfAny(char[] anyOf, int startIndex) => Value.LastIndexOfAny(anyOf, startIndex); + public int LastIndexOfAny(char[] anyOf, int startIndex, int count) => Value.LastIndexOfAny(anyOf, startIndex, count); + public string Normalize() => Value.Normalize(); + public string Normalize(NormalizationForm normalizationForm) => Value.Normalize(normalizationForm); + public string PadLeft(int totalWidth) => Value.PadLeft(totalWidth); + public string PadLeft(int totalWidth, char paddingChar) => Value.PadLeft(totalWidth, paddingChar); + public string PadRight(int totalWidth) => Value.PadRight(totalWidth); + public string PadRight(int totalWidth, char paddingChar) => Value.PadRight(totalWidth, paddingChar); + public string Remove(int startIndex) => Value.Remove(startIndex); + public string Remove(int startIndex, int count) => Value.Remove(startIndex, count); + public string Replace(string oldValue, string newValue) => Value.Replace(oldValue, newValue); + public string Replace(char oldChar, char newChar) => Value.Replace(oldChar, newChar); + public string[] Split(string[] separator, int count, StringSplitOptions options) => Value.Split(separator, count, options); + public string[] Split(params char[] separator) => Value.Split(separator); + public string[] Split(char[] separator, int count) => Value.Split(separator, count); + public string[] Split(char[] separator, int count, StringSplitOptions options) => Value.Split(separator, count, options); + public string[] Split(char[] separator, StringSplitOptions options) => Value.Split(separator, options); + public string[] Split(string[] separator, StringSplitOptions options) => Value.Split(separator, options); + public bool StartsWith(string value) => Value.StartsWith(value); + public bool StartsWith(string value, bool ignoreCase, CultureInfo culture) => Value.StartsWith(value, ignoreCase, culture); + public bool StartsWith(string value, StringComparison comparisonType) => Value.StartsWith(value, comparisonType); + public string Substring(int startIndex) => Value.Substring(startIndex); + public string Substring(int startIndex, int length) => Value.Substring(startIndex, length); + public char[] ToCharArray(int startIndex, int length) => Value.ToCharArray(startIndex, length); + public char[] ToCharArray() => Value.ToCharArray(); + public string ToLower() => Value.ToLower(); + public string ToLower(CultureInfo culture) => Value.ToLower(culture); + public string ToLowerInvariant() => Value.ToLowerInvariant(); + public override string ToString() => Value.ToString(); + public string ToString(IFormatProvider provider) => Value.ToString(provider); + public string ToUpper() => Value.ToUpper(); + public string ToUpper(CultureInfo culture) => Value.ToUpper(culture); + public string ToUpperInvariant() => Value.ToUpperInvariant(); + public string Trim() => Value.Trim(); + public string Trim(params char[] trimChars) => Value.Trim(trimChars); + public string TrimEnd(params char[] trimChars) => Value.TrimEnd(trimChars); + public string TrimStart(params char[] trimChars) => Value.TrimStart(trimChars); #endregion @@ -145,6 +211,10 @@ private static string EncryptorDecryptor(string data, string key) #region Operators Overloading + /// + + public static EncString operator +(EncString enc, string n) => NewEncString(enc.Value + n); + public static string operator +(string n, EncString enc) => enc.Value + n; + /// == != < > public static bool operator ==(EncString es1, string es2) => es1.Value == es2; public static bool operator !=(EncString es1, string es2) => es1.Value != es2; From 996c75dd156d19837752bd32b163b3c97179ad7a Mon Sep 17 00:00:00 2001 From: JosepeDev Date: Tue, 24 Nov 2020 12:37:58 +0200 Subject: [PATCH 02/15] Update EncString.cs --- EncTypes/EncString.cs | 26 +++++++++++++------------- 1 file changed, 13 insertions(+), 13 deletions(-) diff --git a/EncTypes/EncString.cs b/EncTypes/EncString.cs index 688c2b4..5d0f2f8 100644 --- a/EncTypes/EncString.cs +++ b/EncTypes/EncString.cs @@ -5,7 +5,7 @@ public class EncString { /// A class for storing a string while efficiently keeping it encrypted in the memory. - /// In the memory it is saved as a wierd string that is affected by random very long an wierd key. { encryptionKey } + /// In the memory it is saved as a wierd string that is affected by a very long random key. { encryptionKey } /// Every time the value of the string changes, the encryption key changes too. And it works exactly as an string. /// /// WIKI & INFO: https://github.com/JosepeDev/VarEnc @@ -18,7 +18,7 @@ public class EncString /// /// The decrypted value of the stored string. /// - public string Value + private string Value { get => EncryptorDecryptor(_encryptedValue, _encryptionKey); set => _encryptedValue = EncryptorDecryptor(value, _encryptionKey); @@ -43,17 +43,6 @@ public char this[int index] #region Methods - public static string ReplaceAt(string input, int index, char newChar) - { - if (input != null) - { - char[] chars = input.ToCharArray(); - chars[index] = newChar; - return new string(chars); - } - else return null; - } - public bool IsEqual(EncString encString) => encString.Value == this.Value; public bool IsNull() => this.Value == null; public object Clone() => Value.Clone(); @@ -207,6 +196,17 @@ private static string EncryptorDecryptor(string data, string key) } } + public static string ReplaceAt(string input, int index, char newChar) + { + if (input != null) + { + char[] chars = input.ToCharArray(); + chars[index] = newChar; + return new string(chars); + } + else return null; + } + #endregion #region Operators Overloading From a49a0db79dcad04de1f1fd04b01e63ec0ea6e2e5 Mon Sep 17 00:00:00 2001 From: JosepeDev Date: Tue, 24 Nov 2020 13:34:26 +0200 Subject: [PATCH 03/15] Update EncLong.cs --- EncTypes/EncLong.cs | 97 ++++++++++++++++++++++++++++++++++++++++----- 1 file changed, 86 insertions(+), 11 deletions(-) diff --git a/EncTypes/EncLong.cs b/EncTypes/EncLong.cs index d914462..2633dad 100644 --- a/EncTypes/EncLong.cs +++ b/EncTypes/EncLong.cs @@ -6,7 +6,7 @@ public struct EncLong /// In the memory it is saved as a floating-point number that is affected by random values. { encryptionKey1 & encryptionKey2 } /// Every time the value changes, the encryption keys change too. And it works exactly as an long. /// - /// Wiki page: https://github.com/JosepeDev/VarEnc/wiki + /// WIKI & INFO: https://github.com/JosepeDev/VarEnc #region Variables And Properties @@ -30,6 +30,9 @@ private decimal Value } } + public long MaxValue { get => Int64.MaxValue; } + public long MinValue { get => Int64.MinValue; } + #endregion #region Methods @@ -47,7 +50,7 @@ private static EncLong NewEncLong(long value) // Encryption Key Generator static private Random random = new Random(); - public static decimal GetEncryptionKey() => (decimal)(random.NextDouble() * 10); + static private decimal GetEncryptionKey() => (decimal)(random.NextDouble() * 10); // Takes a given value and returns it encrypted private decimal Encrypt(decimal value) @@ -67,11 +70,17 @@ private decimal Decrypt(decimal value) return valueToReturn; } - // Returns the stored value as a string - public override string ToString() - { - return ((long)Value).ToString(); - } + // Int64 methods + public int CompareTo(object value) => ((long)Value).CompareTo(value); + public int CompareTo(long value) => ((long)Value).CompareTo(value); + public bool Equals(long obj) => ((long)Value).Equals(obj); + public override bool Equals(object obj) => ((long)Value).Equals(obj); + public override int GetHashCode() => ((long)Value).GetHashCode(); + public TypeCode GetTypeCode() => ((long)Value).GetTypeCode(); + public override string ToString() => ((long)Value).ToString(); + public string ToString(IFormatProvider provider) => ((long)Value).ToString(provider); + public string ToString(string format) => ((long)Value).ToString(format); + public string ToString(string format, IFormatProvider provider) => ((long)Value).ToString(format, provider); #endregion @@ -96,11 +105,68 @@ public override string ToString() public static long operator /(EncLong elong1, int elong2) => (long)elong1.Value / elong2; public static long operator %(EncLong elong1, int elong2) => (long)elong1.Value % elong2; + public static long operator +(EncLong elong1, short elong2) => (long)elong1.Value + elong2; + public static long operator -(EncLong elong1, short elong2) => (long)elong1.Value - elong2; + public static long operator *(EncLong elong1, short elong2) => (long)elong1.Value * elong2; + public static long operator /(EncLong elong1, short elong2) => (long)elong1.Value / elong2; + public static long operator %(EncLong elong1, short elong2) => (long)elong1.Value % elong2; + + public static long operator +(EncLong elong1, ushort elong2) => (long)elong1.Value + elong2; + public static long operator -(EncLong elong1, ushort elong2) => (long)elong1.Value - elong2; + public static long operator *(EncLong elong1, ushort elong2) => (long)elong1.Value * elong2; + public static long operator /(EncLong elong1, ushort elong2) => (long)elong1.Value / elong2; + public static long operator %(EncLong elong1, ushort elong2) => (long)elong1.Value % elong2; + + public static long operator +(EncLong elong1, uint elong2) => (long)elong1.Value + elong2; + public static long operator -(EncLong elong1, uint elong2) => (long)elong1.Value - elong2; + public static long operator *(EncLong elong1, uint elong2) => (long)elong1.Value * elong2; + public static long operator /(EncLong elong1, uint elong2) => (long)elong1.Value / elong2; + public static long operator %(EncLong elong1, uint elong2) => (long)elong1.Value % elong2; + + public static long operator +(EncLong elong1, byte elong2) => (long)elong1.Value + elong2; + public static long operator -(EncLong elong1, byte elong2) => (long)elong1.Value - elong2; + public static long operator *(EncLong elong1, byte elong2) => (long)elong1.Value * elong2; + public static long operator /(EncLong elong1, byte elong2) => (long)elong1.Value / elong2; + public static long operator %(EncLong elong1, byte elong2) => (long)elong1.Value % elong2; + + public static long operator +(EncLong elong1, sbyte elong2) => (long)elong1.Value + elong2; + public static long operator -(EncLong elong1, sbyte elong2) => (long)elong1.Value - elong2; + public static long operator *(EncLong elong1, sbyte elong2) => (long)elong1.Value * elong2; + public static long operator /(EncLong elong1, sbyte elong2) => (long)elong1.Value / elong2; + public static long operator %(EncLong elong1, sbyte elong2) => (long)elong1.Value % elong2; + /// == != < > - public static bool operator ==(EncLong elong1, int elong2) => (int)elong1.Value == elong2; - public static bool operator !=(EncLong elong1, int elong2) => (int)elong1.Value != elong2; - public static bool operator >(EncLong elong1, int elong2) => (int)elong1.Value > elong2; - public static bool operator <(EncLong elong1, int elong2) => (int)elong1.Value < elong2; + /// + + public static bool operator ==(EncLong elong1, byte elong2) => (long)elong1.Value == elong2; + public static bool operator !=(EncLong elong1, byte elong2) => (long)elong1.Value != elong2; + public static bool operator >(EncLong elong1, byte elong2) => (long)elong1.Value > elong2; + public static bool operator <(EncLong elong1, byte elong2) => (long)elong1.Value < elong2; + + public static bool operator ==(EncLong elong1, sbyte elong2) => (long)elong1.Value == elong2; + public static bool operator !=(EncLong elong1, sbyte elong2) => (long)elong1.Value != elong2; + public static bool operator >(EncLong elong1, sbyte elong2) => (long)elong1.Value > elong2; + public static bool operator <(EncLong elong1, sbyte elong2) => (long)elong1.Value < elong2; + + public static bool operator ==(EncLong elong1, short elong2) => (long)elong1.Value == elong2; + public static bool operator !=(EncLong elong1, short elong2) => (long)elong1.Value != elong2; + public static bool operator >(EncLong elong1, short elong2) => (long)elong1.Value > elong2; + public static bool operator <(EncLong elong1, short elong2) => (long)elong1.Value < elong2; + + public static bool operator ==(EncLong elong1, ushort elong2) => (long)elong1.Value == elong2; + public static bool operator !=(EncLong elong1, ushort elong2) => (long)elong1.Value != elong2; + public static bool operator >(EncLong elong1, ushort elong2) => (long)elong1.Value > elong2; + public static bool operator <(EncLong elong1, ushort elong2) => (long)elong1.Value < elong2; + + public static bool operator ==(EncLong elong1, uint elong2) => (long)elong1.Value == elong2; + public static bool operator !=(EncLong elong1, uint elong2) => (long)elong1.Value != elong2; + public static bool operator >(EncLong elong1, uint elong2) => (long)elong1.Value > elong2; + public static bool operator <(EncLong elong1, uint elong2) => (long)elong1.Value < elong2; + + public static bool operator ==(EncLong elong1, int elong2) => (long)elong1.Value == elong2; + public static bool operator !=(EncLong elong1, int elong2) => (long)elong1.Value != elong2; + public static bool operator >(EncLong elong1, int elong2) => (long)elong1.Value > elong2; + public static bool operator <(EncLong elong1, int elong2) => (long)elong1.Value < elong2; public static bool operator ==(EncLong elong1, long elong2) => (long)elong1.Value == elong2; public static bool operator !=(EncLong elong1, long elong2) => (long)elong1.Value != elong2; @@ -115,7 +181,16 @@ public override string ToString() /// assign public static implicit operator EncLong(long value) => EncLong.NewEncLong(value); public static implicit operator long(EncLong elong1) => (long)elong1.Value; + public static explicit operator ulong(EncLong elong1) => (ulong)elong1.Value; + public static explicit operator uint(EncLong elong1) => (uint)elong1.Value; public static explicit operator int(EncLong elong1) => (int)elong1.Value; + public static explicit operator ushort(EncLong elong1) => (ushort)elong1.Value; + public static explicit operator short(EncLong elong1) => (short)elong1.Value; + public static explicit operator sbyte(EncLong elong1) => (sbyte)elong1.Value; + public static explicit operator byte(EncLong elong1) => (byte)elong1.Value; + public static explicit operator decimal(EncLong elong1) => elong1.Value; + public static explicit operator double(EncLong elong1) => (double)elong1.Value; + public static explicit operator float(EncLong elong1) => (float)elong1.Value; #endregion } \ No newline at end of file From d7bc60041bf06887660dfe5a193ab67e4485f4ba Mon Sep 17 00:00:00 2001 From: JosepeDev Date: Tue, 24 Nov 2020 13:34:31 +0200 Subject: [PATCH 04/15] Update EncInt.cs --- EncTypes/EncInt.cs | 100 ++++++++++++++++++++++++++++++++++++++------- 1 file changed, 85 insertions(+), 15 deletions(-) diff --git a/EncTypes/EncInt.cs b/EncTypes/EncInt.cs index bade41c..cd2ec05 100644 --- a/EncTypes/EncInt.cs +++ b/EncTypes/EncInt.cs @@ -6,7 +6,7 @@ public struct EncInt /// In the memory it is saved as a floating-point number that is affected by random values. { encryptionKey1 & encryptionKey2 } /// Every time the value changes, the encryption keys change too. And it works exactly as an int. /// - /// Wiki page: https://github.com/JosepeDev/VarEnc/wiki + /// WIKI & INFO: https://github.com/JosepeDev/VarEnc #region Variables And Properties @@ -20,16 +20,13 @@ public struct EncInt // The decrypted value private double Value { - set - { - encryptedValue = Encrypt(value); - } - get - { - return Math.Round(Decrypt(encryptedValue)); - } + set => encryptedValue = Encrypt(value); + get => Math.Round(Decrypt(encryptedValue)); } + public int MaxValue { get => Int32.MaxValue; } + public int MinValue { get => Int32.MinValue; } + #endregion #region Methods @@ -47,7 +44,7 @@ private static EncInt NewEncInt(int value) // Encryption Key Generator static private Random random = new Random(); - public static double GetEncryptionKey() => (random.NextDouble() * 10); + static private double GetEncryptionKey() => (random.NextDouble() * 10); // Takes a given value and returns it encrypted private double Encrypt(double value) @@ -67,11 +64,17 @@ private double Decrypt(double value) return valueToReturn; } - // Returns the stored value as a string - public override string ToString() - { - return ((int)Value).ToString(); - } + // Int32 methods + public Int32 CompareTo(object value) => ((int)Value).CompareTo(value); + public Int32 CompareTo(Int32 value) => ((int)Value).CompareTo(value); + public bool Equals(Int32 obj) => ((int)Value).Equals(obj); + public override bool Equals(object obj) => ((int)Value).Equals(obj); + public override Int32 GetHashCode() => ((int)Value).GetHashCode(); + public TypeCode GetTypeCode() => ((int)Value).GetTypeCode(); + public override string ToString() => ((int)Value).ToString(); + public string ToString(IFormatProvider provider) => ((int)Value).ToString(provider); + public string ToString(string format) => ((int)Value).ToString(format); + public string ToString(string format, IFormatProvider provider) => ((int)Value).ToString(format, provider); #endregion @@ -90,12 +93,70 @@ public override string ToString() public static int operator /(EncInt eint1, int eint2) => (int)eint1.Value / eint2; public static int operator %(EncInt eint1, int eint2) => (int)eint1.Value % eint2; + public static int operator +(EncInt eint1, short eint2) => (int)eint1.Value + eint2; + public static int operator -(EncInt eint1, short eint2) => (int)eint1.Value - eint2; + public static int operator *(EncInt eint1, short eint2) => (int)eint1.Value * eint2; + public static int operator /(EncInt eint1, short eint2) => (int)eint1.Value / eint2; + public static int operator %(EncInt eint1, short eint2) => (int)eint1.Value % eint2; + + public static int operator +(EncInt eint1, ushort eint2) => (int)eint1.Value + eint2; + public static int operator -(EncInt eint1, ushort eint2) => (int)eint1.Value - eint2; + public static int operator *(EncInt eint1, ushort eint2) => (int)eint1.Value * eint2; + public static int operator /(EncInt eint1, ushort eint2) => (int)eint1.Value / eint2; + public static int operator %(EncInt eint1, ushort eint2) => (int)eint1.Value % eint2; + + public static int operator +(EncInt eint1, byte eint2) => (int)eint1.Value + eint2; + public static int operator -(EncInt eint1, byte eint2) => (int)eint1.Value - eint2; + public static int operator *(EncInt eint1, byte eint2) => (int)eint1.Value * eint2; + public static int operator /(EncInt eint1, byte eint2) => (int)eint1.Value / eint2; + public static int operator %(EncInt eint1, byte eint2) => (int)eint1.Value % eint2; + + public static int operator +(EncInt eint1, sbyte eint2) => (int)eint1.Value + eint2; + public static int operator -(EncInt eint1, sbyte eint2) => (int)eint1.Value - eint2; + public static int operator *(EncInt eint1, sbyte eint2) => (int)eint1.Value * eint2; + public static int operator /(EncInt eint1, sbyte eint2) => (int)eint1.Value / eint2; + public static int operator %(EncInt eint1, sbyte eint2) => (int)eint1.Value % eint2; /// == != < > public static bool operator ==(EncInt eint1, int eint2) => (int)eint1.Value == eint2; public static bool operator !=(EncInt eint1, int eint2) => (int)eint1.Value != eint2; public static bool operator >(EncInt eint1, int eint2) => (int)eint1.Value > eint2; public static bool operator <(EncInt eint1, int eint2) => (int)eint1.Value < eint2; + public static bool operator ==(EncInt eint1, long eint2) => (long)eint1.Value == eint2; + public static bool operator !=(EncInt eint1, long eint2) => (long)eint1.Value != eint2; + public static bool operator >(EncInt eint1, long eint2) => (long)eint1.Value > eint2; + public static bool operator <(EncInt eint1, long eint2) => (long)eint1.Value < eint2; + + public static bool operator ==(EncInt eint1, ulong eint2) => (ulong)eint1.Value == eint2; + public static bool operator !=(EncInt eint1, ulong eint2) => (ulong)eint1.Value != eint2; + public static bool operator >(EncInt eint1, ulong eint2) => (ulong)eint1.Value > eint2; + public static bool operator <(EncInt eint1, ulong eint2) => (ulong)eint1.Value < eint2; + + public static bool operator ==(EncInt eint1, uint eint2) => (uint)eint1.Value == eint2; + public static bool operator !=(EncInt eint1, uint eint2) => (uint)eint1.Value != eint2; + public static bool operator >(EncInt eint1, uint eint2) => (uint)eint1.Value > eint2; + public static bool operator <(EncInt eint1, uint eint2) => (uint)eint1.Value < eint2; + + public static bool operator ==(EncInt eint1, short eint2) => (short)eint1.Value == eint2; + public static bool operator !=(EncInt eint1, short eint2) => (short)eint1.Value != eint2; + public static bool operator >(EncInt eint1, short eint2) => (short)eint1.Value > eint2; + public static bool operator <(EncInt eint1, short eint2) => (short)eint1.Value < eint2; + + public static bool operator ==(EncInt eint1, ushort eint2) => (ushort)eint1.Value == eint2; + public static bool operator !=(EncInt eint1, ushort eint2) => (ushort)eint1.Value != eint2; + public static bool operator >(EncInt eint1, ushort eint2) => (ushort)eint1.Value > eint2; + public static bool operator <(EncInt eint1, ushort eint2) => (ushort)eint1.Value < eint2; + + public static bool operator ==(EncInt eint1, byte eint2) => (byte)eint1.Value == eint2; + public static bool operator !=(EncInt eint1, byte eint2) => (byte)eint1.Value != eint2; + public static bool operator >(EncInt eint1, byte eint2) => (byte)eint1.Value > eint2; + public static bool operator <(EncInt eint1, byte eint2) => (byte)eint1.Value < eint2; + + public static bool operator ==(EncInt eint1, sbyte eint2) => (sbyte)eint1.Value == eint2; + public static bool operator !=(EncInt eint1, sbyte eint2) => (sbyte)eint1.Value != eint2; + public static bool operator >(EncInt eint1, sbyte eint2) => (sbyte)eint1.Value > eint2; + public static bool operator <(EncInt eint1, sbyte eint2) => (sbyte)eint1.Value < eint2; + public static bool operator ==(EncInt eint1, EncInt eint2) => (int)eint1.Value == (int)eint2.Value; public static bool operator !=(EncInt eint1, EncInt eint2) => (int)eint1.Value != (int)eint2.Value; public static bool operator <(EncInt eint1, EncInt eint2) => (int)eint1.Value < (int)eint2.Value; @@ -105,6 +166,15 @@ public override string ToString() public static implicit operator EncInt(int value) => EncInt.NewEncInt(value); public static implicit operator int(EncInt eint1) => (int)eint1.Value; public static implicit operator long(EncInt eint1) => (long)eint1.Value; + public static explicit operator uint(EncInt eint1) => (uint)eint1.Value; + public static explicit operator ulong(EncInt eint1) => (ulong)eint1.Value; + public static explicit operator short(EncInt eint1) => (short)eint1.Value; + public static explicit operator ushort(EncInt eint1) => (ushort)eint1.Value; + public static explicit operator byte(EncInt eint1) => (byte)eint1.Value; + public static explicit operator sbyte(EncInt eint1) => (sbyte)eint1.Value; + public static explicit operator decimal(EncInt eint1) => (decimal)eint1.Value; + public static explicit operator double(EncInt eint1) => (double)eint1.Value; + public static explicit operator float(EncInt eint1) => (float)eint1.Value; #endregion } \ No newline at end of file From b90c034e2163dfc8e0ea891587608839740a9f97 Mon Sep 17 00:00:00 2001 From: JosepeDev Date: Tue, 24 Nov 2020 15:17:45 +0200 Subject: [PATCH 05/15] Update EncDouble.cs --- EncTypes/EncDouble.cs | 152 ++++++++++++++++++++++++++++++++++++++---- 1 file changed, 138 insertions(+), 14 deletions(-) diff --git a/EncTypes/EncDouble.cs b/EncTypes/EncDouble.cs index 5fd691f..c6b1b9e 100644 --- a/EncTypes/EncDouble.cs +++ b/EncTypes/EncDouble.cs @@ -6,7 +6,7 @@ public struct EncDouble /// In the memory it is saved as a different that is affected by random values. { encryptionKey1 & encryptionKey2 } /// Every time the value changes, the encryption keys change too. And it works exactly as an double. /// - /// Wiki page: https://github.com/JosepeDev/VarEnc/wiki + /// WIKI & INFO: https://github.com/JosepeDev/VarEnc #region Variables And Properties @@ -18,7 +18,7 @@ public struct EncDouble private double encryptedValue; // The decrypted value - private double Value + public double Value { set { @@ -30,6 +30,13 @@ private double Value } } + public Double Epsilon { get => Double.Epsilon; } + public Double MaxValue { get => Double.MaxValue; } + public Double MinValue { get => Double.MinValue; } + public Double NaN { get => Double.NaN; } + public Double NegativeInfinity { get => Double.NegativeInfinity; } + public Double PositiveInfinity { get => Double.PositiveInfinity; } + #endregion #region Methods @@ -47,7 +54,7 @@ private static EncDouble NewEncDouble(double value) // Encryption key generator static private Random random = new Random(); - public static double GetEncryptionKey() => random.NextDouble(); + static private double GetEncryptionKey() => random.NextDouble(); // Takes a given value and returns it encrypted private double Encrypt(double value) @@ -67,11 +74,17 @@ private double Decrypt(double value) return valueToReturn; } - // Returns the stored value as a string - public override string ToString() - { - return (Value).ToString(); - } + // Overrides + public int CompareTo(object value) => Value.CompareTo(value); + public int CompareTo(Double value) => Value.CompareTo(value); + public bool Equals(Double obj) => Value.Equals(obj); + public override bool Equals(object obj) => Value.Equals(obj); + public override int GetHashCode() => Value.GetHashCode(); + public TypeCode GetTypeCode() => Value.GetTypeCode(); + public override string ToString() => Value.ToString(); + public string ToString(IFormatProvider provider) => Value.ToString(provider); + public string ToString(string format) => Value.ToString(format); + public string ToString(string format, IFormatProvider provider) => Value.ToString(format, provider); #endregion @@ -84,30 +97,141 @@ public override string ToString() public static EncDouble operator /(EncDouble eint1, EncDouble eint2) => EncDouble.NewEncDouble(eint1.Value / eint2.Value); public static EncDouble operator %(EncDouble eint1, EncDouble eint2) => EncDouble.NewEncDouble(eint1.Value % eint2.Value); + public static double operator +(EncDouble edouble1, ulong edouble2) => edouble1.Value + edouble2; + public static double operator -(EncDouble edouble1, ulong edouble2) => edouble1.Value - edouble2; + public static double operator *(EncDouble edouble1, ulong edouble2) => edouble1.Value * edouble2; + public static double operator /(EncDouble edouble1, ulong edouble2) => edouble1.Value / edouble2; + public static double operator %(EncDouble edouble1, ulong edouble2) => edouble1.Value % edouble2; + + public static double operator +(EncDouble edouble1, long edouble2) => edouble1.Value + edouble2; + public static double operator -(EncDouble edouble1, long edouble2) => edouble1.Value - edouble2; + public static double operator *(EncDouble edouble1, long edouble2) => edouble1.Value * edouble2; + public static double operator /(EncDouble edouble1, long edouble2) => edouble1.Value / edouble2; + public static double operator %(EncDouble edouble1, long edouble2) => edouble1.Value % edouble2; + + public static double operator +(EncDouble edouble1, uint edouble2) => edouble1.Value + edouble2; + public static double operator -(EncDouble edouble1, uint edouble2) => edouble1.Value - edouble2; + public static double operator *(EncDouble edouble1, uint edouble2) => edouble1.Value * edouble2; + public static double operator /(EncDouble edouble1, uint edouble2) => edouble1.Value / edouble2; + public static double operator %(EncDouble edouble1, uint edouble2) => edouble1.Value % edouble2; + + public static double operator +(EncDouble edouble1, int edouble2) => edouble1.Value + edouble2; + public static double operator -(EncDouble edouble1, int edouble2) => edouble1.Value - edouble2; + public static double operator *(EncDouble edouble1, int edouble2) => edouble1.Value * edouble2; + public static double operator /(EncDouble edouble1, int edouble2) => edouble1.Value / edouble2; + public static double operator %(EncDouble edouble1, int edouble2) => edouble1.Value % edouble2; + + public static double operator +(EncDouble edouble1, ushort edouble2) => edouble1.Value + edouble2; + public static double operator -(EncDouble edouble1, ushort edouble2) => edouble1.Value - edouble2; + public static double operator *(EncDouble edouble1, ushort edouble2) => edouble1.Value * edouble2; + public static double operator /(EncDouble edouble1, ushort edouble2) => edouble1.Value / edouble2; + public static double operator %(EncDouble edouble1, ushort edouble2) => edouble1.Value % edouble2; + + public static double operator +(EncDouble edouble1, short edouble2) => edouble1.Value + edouble2; + public static double operator -(EncDouble edouble1, short edouble2) => edouble1.Value - edouble2; + public static double operator *(EncDouble edouble1, short edouble2) => edouble1.Value * edouble2; + public static double operator /(EncDouble edouble1, short edouble2) => edouble1.Value / edouble2; + public static double operator %(EncDouble edouble1, short edouble2) => edouble1.Value % edouble2; + + public static double operator +(EncDouble edouble1, byte edouble2) => edouble1.Value + edouble2; + public static double operator -(EncDouble edouble1, byte edouble2) => edouble1.Value - edouble2; + public static double operator *(EncDouble edouble1, byte edouble2) => edouble1.Value * edouble2; + public static double operator /(EncDouble edouble1, byte edouble2) => edouble1.Value / edouble2; + public static double operator %(EncDouble edouble1, byte edouble2) => edouble1.Value % edouble2; + + public static double operator +(EncDouble edouble1, sbyte edouble2) => edouble1.Value + edouble2; + public static double operator -(EncDouble edouble1, sbyte edouble2) => edouble1.Value - edouble2; + public static double operator *(EncDouble edouble1, sbyte edouble2) => edouble1.Value * edouble2; + public static double operator /(EncDouble edouble1, sbyte edouble2) => edouble1.Value / edouble2; + public static double operator %(EncDouble edouble1, sbyte edouble2) => edouble1.Value % edouble2; + public static double operator +(EncDouble edouble1, double edouble2) => edouble1.Value + edouble2; public static double operator -(EncDouble edouble1, double edouble2) => edouble1.Value - edouble2; public static double operator *(EncDouble edouble1, double edouble2) => edouble1.Value * edouble2; public static double operator /(EncDouble edouble1, double edouble2) => edouble1.Value / edouble2; public static double operator %(EncDouble edouble1, double edouble2) => edouble1.Value % edouble2; + public static double operator +(EncDouble edouble1, float edouble2) => edouble1.Value + edouble2; + public static double operator -(EncDouble edouble1, float edouble2) => edouble1.Value - edouble2; + public static double operator *(EncDouble edouble1, float edouble2) => edouble1.Value * edouble2; + public static double operator /(EncDouble edouble1, float edouble2) => edouble1.Value / edouble2; + public static double operator %(EncDouble edouble1, float edouble2) => edouble1.Value % edouble2; + /// == != < > - public static bool operator ==(EncDouble eint1, double eint2) => eint1.Value == eint2; - public static bool operator !=(EncDouble eint1, double eint2) => eint1.Value != eint2; - public static bool operator >(EncDouble eint1, double eint2) => eint1.Value > eint2; - public static bool operator <(EncDouble eint1, double eint2) => eint1.Value < eint2; public static bool operator ==(EncDouble eint1, EncDouble eint2) => eint1.Value == eint2.Value; public static bool operator !=(EncDouble eint1, EncDouble eint2) => eint1.Value != eint2.Value; public static bool operator <(EncDouble eint1, EncDouble eint2) => eint1.Value < eint2.Value; public static bool operator >(EncDouble eint1, EncDouble eint2) => eint1.Value > eint2.Value; + public static bool operator ==(EncDouble eint1, ulong eint2) => eint1.Value == eint2; + public static bool operator !=(EncDouble eint1, ulong eint2) => eint1.Value != eint2; + public static bool operator >(EncDouble eint1, ulong eint2) => eint1.Value > eint2; + public static bool operator <(EncDouble eint1, ulong eint2) => eint1.Value < eint2; + + public static bool operator ==(EncDouble eint1, long eint2) => eint1.Value == eint2; + public static bool operator !=(EncDouble eint1, long eint2) => eint1.Value != eint2; + public static bool operator >(EncDouble eint1, long eint2) => eint1.Value > eint2; + public static bool operator <(EncDouble eint1, long eint2) => eint1.Value < eint2; + + public static bool operator ==(EncDouble eint1, uint eint2) => eint1.Value == eint2; + public static bool operator !=(EncDouble eint1, uint eint2) => eint1.Value != eint2; + public static bool operator >(EncDouble eint1, uint eint2) => eint1.Value > eint2; + public static bool operator <(EncDouble eint1, uint eint2) => eint1.Value < eint2; + + public static bool operator ==(EncDouble eint1, int eint2) => eint1.Value == eint2; + public static bool operator !=(EncDouble eint1, int eint2) => eint1.Value != eint2; + public static bool operator >(EncDouble eint1, int eint2) => eint1.Value > eint2; + public static bool operator <(EncDouble eint1, int eint2) => eint1.Value < eint2; + + public static bool operator ==(EncDouble eint1, ushort eint2) => eint1.Value == eint2; + public static bool operator !=(EncDouble eint1, ushort eint2) => eint1.Value != eint2; + public static bool operator >(EncDouble eint1, ushort eint2) => eint1.Value > eint2; + public static bool operator <(EncDouble eint1, ushort eint2) => eint1.Value < eint2; + + public static bool operator ==(EncDouble eint1, short eint2) => eint1.Value == eint2; + public static bool operator !=(EncDouble eint1, short eint2) => eint1.Value != eint2; + public static bool operator >(EncDouble eint1, short eint2) => eint1.Value > eint2; + public static bool operator <(EncDouble eint1, short eint2) => eint1.Value < eint2; + + public static bool operator ==(EncDouble eint1, byte eint2) => eint1.Value == eint2; + public static bool operator !=(EncDouble eint1, byte eint2) => eint1.Value != eint2; + public static bool operator >(EncDouble eint1, byte eint2) => eint1.Value > eint2; + public static bool operator <(EncDouble eint1, byte eint2) => eint1.Value < eint2; + + public static bool operator ==(EncDouble eint1, sbyte eint2) => eint1.Value == eint2; + public static bool operator !=(EncDouble eint1, sbyte eint2) => eint1.Value != eint2; + public static bool operator >(EncDouble eint1, sbyte eint2) => eint1.Value > eint2; + public static bool operator <(EncDouble eint1, sbyte eint2) => eint1.Value < eint2; + + public static bool operator ==(EncDouble eint1, decimal eint2) => (decimal)eint1.Value == eint2; + public static bool operator !=(EncDouble eint1, decimal eint2) => (decimal)eint1.Value != eint2; + public static bool operator >(EncDouble eint1, decimal eint2) => (decimal)eint1.Value > eint2; + public static bool operator <(EncDouble eint1, decimal eint2) => (decimal)eint1.Value < eint2; + + public static bool operator ==(EncDouble eint1, double eint2) => eint1.Value == eint2; + public static bool operator !=(EncDouble eint1, double eint2) => eint1.Value != eint2; + public static bool operator >(EncDouble eint1, double eint2) => eint1.Value > eint2; + public static bool operator <(EncDouble eint1, double eint2) => eint1.Value < eint2; + + public static bool operator ==(EncDouble eint1, float eint2) => eint1.Value == eint2; + public static bool operator !=(EncDouble eint1, float eint2) => eint1.Value != eint2; + public static bool operator >(EncDouble eint1, float eint2) => eint1.Value > eint2; + public static bool operator <(EncDouble eint1, float eint2) => eint1.Value < eint2; + /// assign public static implicit operator EncDouble(double value) => EncDouble.NewEncDouble(value); + public static explicit operator decimal(EncDouble eint1) => (decimal)eint1.Value; public static implicit operator double(EncDouble eint1) => eint1.Value; public static explicit operator float(EncDouble eint1) => (float)eint1.Value; - public static explicit operator decimal(EncDouble eint1) => (decimal)eint1.Value; - public static explicit operator int(EncDouble eint1) => (int)eint1.Value; + public static explicit operator ulong(EncDouble eint1) => (ulong)eint1.Value; public static explicit operator long(EncDouble eint1) => (long)eint1.Value; + public static explicit operator uint(EncDouble eint1) => (uint)eint1.Value; + public static explicit operator int(EncDouble eint1) => (int)eint1.Value; + public static explicit operator ushort(EncDouble eint1) => (ushort)eint1.Value; + public static explicit operator short(EncDouble eint1) => (short)eint1.Value; + public static explicit operator byte(EncDouble eint1) => (byte)eint1.Value; + public static explicit operator sbyte(EncDouble eint1) => (sbyte)eint1.Value; #endregion } \ No newline at end of file From b1d8303616466830945742c7d6840c51b3770098 Mon Sep 17 00:00:00 2001 From: JosepeDev Date: Tue, 24 Nov 2020 15:17:51 +0200 Subject: [PATCH 06/15] Update EncFloat.cs --- EncTypes/EncFloat.cs | 144 +++++++++++++++++++++++++++++++++++++++---- 1 file changed, 131 insertions(+), 13 deletions(-) diff --git a/EncTypes/EncFloat.cs b/EncTypes/EncFloat.cs index b761cb7..03d0d65 100644 --- a/EncTypes/EncFloat.cs +++ b/EncTypes/EncFloat.cs @@ -6,7 +6,7 @@ public struct EncFloat /// In the memory it is saved as a different that is affected by random values. { encryptionKey1 & encryptionKey2 } /// Every time the value changes, the encryption keys change too. And it works exactly as an flaot. /// - /// Wiki page: https://github.com/JosepeDev/VarEnc/wiki + /// WIKI & INFO: https://github.com/JosepeDev/VarEnc #region Variables And Properties @@ -30,6 +30,13 @@ private float Value } } + public float Epsilon { get => Single.Epsilon; } + public float MaxValue { get => Single.MaxValue; } + public float MinValue { get => Single.MinValue; } + public float NaN { get => Single.NaN; } + public float NegativeInfinity { get => Single.NegativeInfinity; } + public float PositiveInfinity { get => Single.PositiveInfinity; } + #endregion #region Methods @@ -67,11 +74,17 @@ private double Decrypt(double value) return valueToReturn; } - // Returns the stored value as a string - public override string ToString() - { - return (Value).ToString(); - } + // Single methods + public int CompareTo(Single value) => Value.CompareTo(value); + public int CompareTo(object value) => Value.CompareTo(value); + public override bool Equals(object obj) => Value.Equals(obj); + public bool Equals(Single obj) => Value.Equals(obj); + public override int GetHashCode() => Value.GetHashCode(); + public TypeCode GetTypeCode() => Value.GetTypeCode(); + public override string ToString() => Value.ToString(); + public string ToString(IFormatProvider provider) => Value.ToString(provider); + public string ToString(string format) => Value.ToString(format); + public string ToString(string format, IFormatProvider provider) => Value.ToString(format, provider); #endregion @@ -84,6 +97,54 @@ public override string ToString() public static EncFloat operator /(EncFloat eint1, EncFloat eint2) => EncFloat.NewEncFloat(eint1.Value / eint2.Value); public static EncFloat operator %(EncFloat eint1, EncFloat eint2) => EncFloat.NewEncFloat(eint1.Value % eint2.Value); + public static float operator +(EncFloat efloat1, ulong efloat2) => efloat1.Value + efloat2; + public static float operator -(EncFloat efloat1, ulong efloat2) => efloat1.Value - efloat2; + public static float operator *(EncFloat efloat1, ulong efloat2) => efloat1.Value * efloat2; + public static float operator /(EncFloat efloat1, ulong efloat2) => efloat1.Value / efloat2; + public static float operator %(EncFloat efloat1, ulong efloat2) => efloat1.Value % efloat2; + + public static float operator +(EncFloat efloat1, long efloat2) => efloat1.Value + efloat2; + public static float operator -(EncFloat efloat1, long efloat2) => efloat1.Value - efloat2; + public static float operator *(EncFloat efloat1, long efloat2) => efloat1.Value * efloat2; + public static float operator /(EncFloat efloat1, long efloat2) => efloat1.Value / efloat2; + public static float operator %(EncFloat efloat1, long efloat2) => efloat1.Value % efloat2; + + public static float operator +(EncFloat efloat1, uint efloat2) => efloat1.Value + efloat2; + public static float operator -(EncFloat efloat1, uint efloat2) => efloat1.Value - efloat2; + public static float operator *(EncFloat efloat1, uint efloat2) => efloat1.Value * efloat2; + public static float operator /(EncFloat efloat1, uint efloat2) => efloat1.Value / efloat2; + public static float operator %(EncFloat efloat1, uint efloat2) => efloat1.Value % efloat2; + + public static float operator +(EncFloat efloat1, int efloat2) => efloat1.Value + efloat2; + public static float operator -(EncFloat efloat1, int efloat2) => efloat1.Value - efloat2; + public static float operator *(EncFloat efloat1, int efloat2) => efloat1.Value * efloat2; + public static float operator /(EncFloat efloat1, int efloat2) => efloat1.Value / efloat2; + public static float operator %(EncFloat efloat1, int efloat2) => efloat1.Value % efloat2; + + public static float operator +(EncFloat efloat1, ushort efloat2) => efloat1.Value + efloat2; + public static float operator -(EncFloat efloat1, ushort efloat2) => efloat1.Value - efloat2; + public static float operator *(EncFloat efloat1, ushort efloat2) => efloat1.Value * efloat2; + public static float operator /(EncFloat efloat1, ushort efloat2) => efloat1.Value / efloat2; + public static float operator %(EncFloat efloat1, ushort efloat2) => efloat1.Value % efloat2; + + public static float operator +(EncFloat efloat1, short efloat2) => efloat1.Value + efloat2; + public static float operator -(EncFloat efloat1, short efloat2) => efloat1.Value - efloat2; + public static float operator *(EncFloat efloat1, short efloat2) => efloat1.Value * efloat2; + public static float operator /(EncFloat efloat1, short efloat2) => efloat1.Value / efloat2; + public static float operator %(EncFloat efloat1, short efloat2) => efloat1.Value % efloat2; + + public static float operator +(EncFloat efloat1, byte efloat2) => efloat1.Value + efloat2; + public static float operator -(EncFloat efloat1, byte efloat2) => efloat1.Value - efloat2; + public static float operator *(EncFloat efloat1, byte efloat2) => efloat1.Value * efloat2; + public static float operator /(EncFloat efloat1, byte efloat2) => efloat1.Value / efloat2; + public static float operator %(EncFloat efloat1, byte efloat2) => efloat1.Value % efloat2; + + public static float operator +(EncFloat efloat1, sbyte efloat2) => efloat1.Value + efloat2; + public static float operator -(EncFloat efloat1, sbyte efloat2) => efloat1.Value - efloat2; + public static float operator *(EncFloat efloat1, sbyte efloat2) => efloat1.Value * efloat2; + public static float operator /(EncFloat efloat1, sbyte efloat2) => efloat1.Value / efloat2; + public static float operator %(EncFloat efloat1, sbyte efloat2) => efloat1.Value % efloat2; + public static float operator +(EncFloat efloat1, float efloat2) => efloat1.Value + efloat2; public static float operator -(EncFloat efloat1, float efloat2) => efloat1.Value - efloat2; public static float operator *(EncFloat efloat1, float efloat2) => efloat1.Value * efloat2; @@ -91,23 +152,80 @@ public override string ToString() public static float operator %(EncFloat efloat1, float efloat2) => efloat1.Value % efloat2; /// == != < > - public static bool operator ==(EncFloat eint1, float eint2) => eint1.Value == eint2; - public static bool operator !=(EncFloat eint1, float eint2) => eint1.Value != eint2; - public static bool operator >(EncFloat eint1, float eint2) => eint1.Value > eint2; - public static bool operator <(EncFloat eint1, float eint2) => eint1.Value < eint2; public static bool operator ==(EncFloat eint1, EncFloat eint2) => eint1.Value == eint2.Value; public static bool operator !=(EncFloat eint1, EncFloat eint2) => eint1.Value != eint2.Value; public static bool operator <(EncFloat eint1, EncFloat eint2) => eint1.Value < eint2.Value; public static bool operator >(EncFloat eint1, EncFloat eint2) => eint1.Value > eint2.Value; + public static bool operator ==(EncFloat eint1, ulong eint2) => eint1.Value == eint2; + public static bool operator !=(EncFloat eint1, ulong eint2) => eint1.Value != eint2; + public static bool operator >(EncFloat eint1, ulong eint2) => eint1.Value > eint2; + public static bool operator <(EncFloat eint1, ulong eint2) => eint1.Value < eint2; + + public static bool operator ==(EncFloat eint1, long eint2) => eint1.Value == eint2; + public static bool operator !=(EncFloat eint1, long eint2) => eint1.Value != eint2; + public static bool operator >(EncFloat eint1, long eint2) => eint1.Value > eint2; + public static bool operator <(EncFloat eint1, long eint2) => eint1.Value < eint2; + + public static bool operator ==(EncFloat eint1, uint eint2) => eint1.Value == eint2; + public static bool operator !=(EncFloat eint1, uint eint2) => eint1.Value != eint2; + public static bool operator >(EncFloat eint1, uint eint2) => eint1.Value > eint2; + public static bool operator <(EncFloat eint1, uint eint2) => eint1.Value < eint2; + + public static bool operator ==(EncFloat eint1, int eint2) => eint1.Value == eint2; + public static bool operator !=(EncFloat eint1, int eint2) => eint1.Value != eint2; + public static bool operator >(EncFloat eint1, int eint2) => eint1.Value > eint2; + public static bool operator <(EncFloat eint1, int eint2) => eint1.Value < eint2; + + public static bool operator ==(EncFloat eint1, ushort eint2) => eint1.Value == eint2; + public static bool operator !=(EncFloat eint1, ushort eint2) => eint1.Value != eint2; + public static bool operator >(EncFloat eint1, ushort eint2) => eint1.Value > eint2; + public static bool operator <(EncFloat eint1, ushort eint2) => eint1.Value < eint2; + + public static bool operator ==(EncFloat eint1, short eint2) => eint1.Value == eint2; + public static bool operator !=(EncFloat eint1, short eint2) => eint1.Value != eint2; + public static bool operator >(EncFloat eint1, short eint2) => eint1.Value > eint2; + public static bool operator <(EncFloat eint1, short eint2) => eint1.Value < eint2; + + public static bool operator ==(EncFloat eint1, byte eint2) => eint1.Value == eint2; + public static bool operator !=(EncFloat eint1, byte eint2) => eint1.Value != eint2; + public static bool operator >(EncFloat eint1, byte eint2) => eint1.Value > eint2; + public static bool operator <(EncFloat eint1, byte eint2) => eint1.Value < eint2; + + public static bool operator ==(EncFloat eint1, sbyte eint2) => eint1.Value == eint2; + public static bool operator !=(EncFloat eint1, sbyte eint2) => eint1.Value != eint2; + public static bool operator >(EncFloat eint1, sbyte eint2) => eint1.Value > eint2; + public static bool operator <(EncFloat eint1, sbyte eint2) => eint1.Value < eint2; + + public static bool operator ==(EncFloat eint1, decimal eint2) => (decimal)eint1.Value == eint2; + public static bool operator !=(EncFloat eint1, decimal eint2) => (decimal)eint1.Value != eint2; + public static bool operator >(EncFloat eint1, decimal eint2) => (decimal)eint1.Value > eint2; + public static bool operator <(EncFloat eint1, decimal eint2) => (decimal)eint1.Value < eint2; + + public static bool operator ==(EncFloat eint1, double eint2) => eint1.Value == eint2; + public static bool operator !=(EncFloat eint1, double eint2) => eint1.Value != eint2; + public static bool operator >(EncFloat eint1, double eint2) => eint1.Value > eint2; + public static bool operator <(EncFloat eint1, double eint2) => eint1.Value < eint2; + + public static bool operator ==(EncFloat eint1, float eint2) => eint1.Value == eint2; + public static bool operator !=(EncFloat eint1, float eint2) => eint1.Value != eint2; + public static bool operator >(EncFloat eint1, float eint2) => eint1.Value > eint2; + public static bool operator <(EncFloat eint1, float eint2) => eint1.Value < eint2; + /// assign public static implicit operator EncFloat(float value) => EncFloat.NewEncFloat(value); - public static implicit operator float(EncFloat eint1) => eint1.Value; - public static implicit operator double(EncFloat eint1) => eint1.Value; public static explicit operator decimal(EncFloat eint1) => (decimal)eint1.Value; - public static explicit operator int(EncFloat eint1) => (int)eint1.Value; + public static implicit operator double(EncFloat eint1) => eint1.Value; + public static implicit operator float(EncFloat eint1) => eint1.Value; + public static explicit operator ulong(EncFloat eint1) => (ulong)eint1.Value; public static explicit operator long(EncFloat eint1) => (long)eint1.Value; + public static explicit operator uint(EncFloat eint1) => (uint)eint1.Value; + public static explicit operator int(EncFloat eint1) => (int)eint1.Value; + public static explicit operator ushort(EncFloat eint1) => (ushort)eint1.Value; + public static explicit operator short(EncFloat eint1) => (short)eint1.Value; + public static explicit operator byte(EncFloat eint1) => (byte)eint1.Value; + public static explicit operator sbyte(EncFloat eint1) => (sbyte)eint1.Value; #endregion } \ No newline at end of file From f5605f384395de86b3d223a40c77e136c4c943ef Mon Sep 17 00:00:00 2001 From: JosepeDev Date: Tue, 24 Nov 2020 15:17:57 +0200 Subject: [PATCH 07/15] Update EncInt.cs --- EncTypes/EncInt.cs | 69 +++++++++++++++++++++++++++++----------------- 1 file changed, 43 insertions(+), 26 deletions(-) diff --git a/EncTypes/EncInt.cs b/EncTypes/EncInt.cs index cd2ec05..6e6ef98 100644 --- a/EncTypes/EncInt.cs +++ b/EncTypes/EncInt.cs @@ -93,18 +93,18 @@ private double Decrypt(double value) public static int operator /(EncInt eint1, int eint2) => (int)eint1.Value / eint2; public static int operator %(EncInt eint1, int eint2) => (int)eint1.Value % eint2; - public static int operator +(EncInt eint1, short eint2) => (int)eint1.Value + eint2; - public static int operator -(EncInt eint1, short eint2) => (int)eint1.Value - eint2; - public static int operator *(EncInt eint1, short eint2) => (int)eint1.Value * eint2; - public static int operator /(EncInt eint1, short eint2) => (int)eint1.Value / eint2; - public static int operator %(EncInt eint1, short eint2) => (int)eint1.Value % eint2; - public static int operator +(EncInt eint1, ushort eint2) => (int)eint1.Value + eint2; public static int operator -(EncInt eint1, ushort eint2) => (int)eint1.Value - eint2; public static int operator *(EncInt eint1, ushort eint2) => (int)eint1.Value * eint2; public static int operator /(EncInt eint1, ushort eint2) => (int)eint1.Value / eint2; public static int operator %(EncInt eint1, ushort eint2) => (int)eint1.Value % eint2; + public static int operator +(EncInt eint1, short eint2) => (int)eint1.Value + eint2; + public static int operator -(EncInt eint1, short eint2) => (int)eint1.Value - eint2; + public static int operator *(EncInt eint1, short eint2) => (int)eint1.Value * eint2; + public static int operator /(EncInt eint1, short eint2) => (int)eint1.Value / eint2; + public static int operator %(EncInt eint1, short eint2) => (int)eint1.Value % eint2; + public static int operator +(EncInt eint1, byte eint2) => (int)eint1.Value + eint2; public static int operator -(EncInt eint1, byte eint2) => (int)eint1.Value - eint2; public static int operator *(EncInt eint1, byte eint2) => (int)eint1.Value * eint2; @@ -116,37 +116,44 @@ private double Decrypt(double value) public static int operator *(EncInt eint1, sbyte eint2) => (int)eint1.Value * eint2; public static int operator /(EncInt eint1, sbyte eint2) => (int)eint1.Value / eint2; public static int operator %(EncInt eint1, sbyte eint2) => (int)eint1.Value % eint2; + /// == != < > - public static bool operator ==(EncInt eint1, int eint2) => (int)eint1.Value == eint2; - public static bool operator !=(EncInt eint1, int eint2) => (int)eint1.Value != eint2; - public static bool operator >(EncInt eint1, int eint2) => (int)eint1.Value > eint2; - public static bool operator <(EncInt eint1, int eint2) => (int)eint1.Value < eint2; - public static bool operator ==(EncInt eint1, long eint2) => (long)eint1.Value == eint2; - public static bool operator !=(EncInt eint1, long eint2) => (long)eint1.Value != eint2; - public static bool operator >(EncInt eint1, long eint2) => (long)eint1.Value > eint2; - public static bool operator <(EncInt eint1, long eint2) => (long)eint1.Value < eint2; + public static bool operator ==(EncInt eint1, EncInt eint2) => (int)eint1.Value == (int)eint2.Value; + public static bool operator !=(EncInt eint1, EncInt eint2) => (int)eint1.Value != (int)eint2.Value; + public static bool operator <(EncInt eint1, EncInt eint2) => (int)eint1.Value < (int)eint2.Value; + public static bool operator >(EncInt eint1, EncInt eint2) => (int)eint1.Value > (int)eint2.Value; public static bool operator ==(EncInt eint1, ulong eint2) => (ulong)eint1.Value == eint2; public static bool operator !=(EncInt eint1, ulong eint2) => (ulong)eint1.Value != eint2; public static bool operator >(EncInt eint1, ulong eint2) => (ulong)eint1.Value > eint2; public static bool operator <(EncInt eint1, ulong eint2) => (ulong)eint1.Value < eint2; + public static bool operator ==(EncInt eint1, long eint2) => (long)eint1.Value == eint2; + public static bool operator !=(EncInt eint1, long eint2) => (long)eint1.Value != eint2; + public static bool operator >(EncInt eint1, long eint2) => (long)eint1.Value > eint2; + public static bool operator <(EncInt eint1, long eint2) => (long)eint1.Value < eint2; + public static bool operator ==(EncInt eint1, uint eint2) => (uint)eint1.Value == eint2; public static bool operator !=(EncInt eint1, uint eint2) => (uint)eint1.Value != eint2; public static bool operator >(EncInt eint1, uint eint2) => (uint)eint1.Value > eint2; public static bool operator <(EncInt eint1, uint eint2) => (uint)eint1.Value < eint2; - public static bool operator ==(EncInt eint1, short eint2) => (short)eint1.Value == eint2; - public static bool operator !=(EncInt eint1, short eint2) => (short)eint1.Value != eint2; - public static bool operator >(EncInt eint1, short eint2) => (short)eint1.Value > eint2; - public static bool operator <(EncInt eint1, short eint2) => (short)eint1.Value < eint2; + public static bool operator ==(EncInt eint1, int eint2) => (int)eint1.Value == eint2; + public static bool operator !=(EncInt eint1, int eint2) => (int)eint1.Value != eint2; + public static bool operator >(EncInt eint1, int eint2) => (int)eint1.Value > eint2; + public static bool operator <(EncInt eint1, int eint2) => (int)eint1.Value < eint2; public static bool operator ==(EncInt eint1, ushort eint2) => (ushort)eint1.Value == eint2; public static bool operator !=(EncInt eint1, ushort eint2) => (ushort)eint1.Value != eint2; public static bool operator >(EncInt eint1, ushort eint2) => (ushort)eint1.Value > eint2; public static bool operator <(EncInt eint1, ushort eint2) => (ushort)eint1.Value < eint2; + public static bool operator ==(EncInt eint1, short eint2) => (short)eint1.Value == eint2; + public static bool operator !=(EncInt eint1, short eint2) => (short)eint1.Value != eint2; + public static bool operator >(EncInt eint1, short eint2) => (short)eint1.Value > eint2; + public static bool operator <(EncInt eint1, short eint2) => (short)eint1.Value < eint2; + public static bool operator ==(EncInt eint1, byte eint2) => (byte)eint1.Value == eint2; public static bool operator !=(EncInt eint1, byte eint2) => (byte)eint1.Value != eint2; public static bool operator >(EncInt eint1, byte eint2) => (byte)eint1.Value > eint2; @@ -157,23 +164,33 @@ private double Decrypt(double value) public static bool operator >(EncInt eint1, sbyte eint2) => (sbyte)eint1.Value > eint2; public static bool operator <(EncInt eint1, sbyte eint2) => (sbyte)eint1.Value < eint2; - public static bool operator ==(EncInt eint1, EncInt eint2) => (int)eint1.Value == (int)eint2.Value; - public static bool operator !=(EncInt eint1, EncInt eint2) => (int)eint1.Value != (int)eint2.Value; - public static bool operator <(EncInt eint1, EncInt eint2) => (int)eint1.Value < (int)eint2.Value; - public static bool operator >(EncInt eint1, EncInt eint2) => (int)eint1.Value > (int)eint2.Value; + public static bool operator ==(EncInt eint1, decimal eint2) => (decimal)eint1.Value == eint2; + public static bool operator !=(EncInt eint1, decimal eint2) => (decimal)eint1.Value != eint2; + public static bool operator >(EncInt eint1, decimal eint2) => (decimal)eint1.Value > eint2; + public static bool operator <(EncInt eint1, decimal eint2) => (decimal)eint1.Value < eint2; + + public static bool operator ==(EncInt eint1, double eint2) => (double)eint1.Value == eint2; + public static bool operator !=(EncInt eint1, double eint2) => (double)eint1.Value != eint2; + public static bool operator >(EncInt eint1, double eint2) => (double)eint1.Value > eint2; + public static bool operator <(EncInt eint1, double eint2) => (double)eint1.Value < eint2; + + public static bool operator ==(EncInt eint1, float eint2) => (float)eint1.Value == eint2; + public static bool operator !=(EncInt eint1, float eint2) => (float)eint1.Value != eint2; + public static bool operator >(EncInt eint1, float eint2) => (float)eint1.Value > eint2; + public static bool operator <(EncInt eint1, float eint2) => (float)eint1.Value < eint2; /// assign public static implicit operator EncInt(int value) => EncInt.NewEncInt(value); - public static implicit operator int(EncInt eint1) => (int)eint1.Value; + public static explicit operator ulong(EncInt eint1) => (ulong)eint1.Value; public static implicit operator long(EncInt eint1) => (long)eint1.Value; public static explicit operator uint(EncInt eint1) => (uint)eint1.Value; - public static explicit operator ulong(EncInt eint1) => (ulong)eint1.Value; - public static explicit operator short(EncInt eint1) => (short)eint1.Value; + public static implicit operator int(EncInt eint1) => (int)eint1.Value; public static explicit operator ushort(EncInt eint1) => (ushort)eint1.Value; + public static explicit operator short(EncInt eint1) => (short)eint1.Value; public static explicit operator byte(EncInt eint1) => (byte)eint1.Value; public static explicit operator sbyte(EncInt eint1) => (sbyte)eint1.Value; public static explicit operator decimal(EncInt eint1) => (decimal)eint1.Value; - public static explicit operator double(EncInt eint1) => (double)eint1.Value; + public static explicit operator double(EncInt eint1) => eint1.Value; public static explicit operator float(EncInt eint1) => (float)eint1.Value; #endregion From 79b531c95c12922d625cef80728b9433efea1713 Mon Sep 17 00:00:00 2001 From: JosepeDev Date: Tue, 24 Nov 2020 15:18:02 +0200 Subject: [PATCH 08/15] Update EncLong.cs --- EncTypes/EncLong.cs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/EncTypes/EncLong.cs b/EncTypes/EncLong.cs index 2633dad..ccad7ac 100644 --- a/EncTypes/EncLong.cs +++ b/EncTypes/EncLong.cs @@ -180,14 +180,14 @@ private decimal Decrypt(decimal value) /// assign public static implicit operator EncLong(long value) => EncLong.NewEncLong(value); - public static implicit operator long(EncLong elong1) => (long)elong1.Value; public static explicit operator ulong(EncLong elong1) => (ulong)elong1.Value; + public static implicit operator long(EncLong elong1) => (long)elong1.Value; public static explicit operator uint(EncLong elong1) => (uint)elong1.Value; public static explicit operator int(EncLong elong1) => (int)elong1.Value; public static explicit operator ushort(EncLong elong1) => (ushort)elong1.Value; public static explicit operator short(EncLong elong1) => (short)elong1.Value; - public static explicit operator sbyte(EncLong elong1) => (sbyte)elong1.Value; public static explicit operator byte(EncLong elong1) => (byte)elong1.Value; + public static explicit operator sbyte(EncLong elong1) => (sbyte)elong1.Value; public static explicit operator decimal(EncLong elong1) => elong1.Value; public static explicit operator double(EncLong elong1) => (double)elong1.Value; public static explicit operator float(EncLong elong1) => (float)elong1.Value; From 81c519e71a43dc8eb64094f9ed2c65f1c98e9850 Mon Sep 17 00:00:00 2001 From: JosepeDev Date: Tue, 24 Nov 2020 15:43:48 +0200 Subject: [PATCH 09/15] Update EncString.cs --- EncTypes/EncString.cs | 29 +++++++++++++++-------------- 1 file changed, 15 insertions(+), 14 deletions(-) diff --git a/EncTypes/EncString.cs b/EncTypes/EncString.cs index 5d0f2f8..c252c05 100644 --- a/EncTypes/EncString.cs +++ b/EncTypes/EncString.cs @@ -124,21 +124,22 @@ public char this[int index] #region Constructors - public static EncString NewEncString(string value) - { - EncString encString = new EncString - { - _encryptionKey = RandomString(), - Value = value - }; - return encString; - } + public EncString(string value) => New(value, this); - public static EncString NewEncString(char[] characters) => NewEncString(new string(characters)); + public EncString(char[] value) + : this(new string(value)) { } - public static EncString NewEncString(char c, int count) => NewEncString(new string(c, count)); + public EncString(char c, int count) + : this(new string(c, count)) { } - public static EncString NewEncString(char[] value, int startIndex, int length) => NewEncString(new string(value, startIndex, length)); + public EncString(char[] value, int startIndex, int length) + : this(new string(value, startIndex, length)) { } + + private static void New(string value, EncString encString) + { + encString._encryptionKey = RandomString(); + encString.Value = value; + } #endregion @@ -212,7 +213,7 @@ public static string ReplaceAt(string input, int index, char newChar) #region Operators Overloading /// + - public static EncString operator +(EncString enc, string n) => NewEncString(enc.Value + n); + public static EncString operator +(EncString enc, string n) => new EncString(enc.Value + n); public static string operator +(string n, EncString enc) => enc.Value + n; /// == != < > @@ -220,7 +221,7 @@ public static string ReplaceAt(string input, int index, char newChar) public static bool operator !=(EncString es1, string es2) => es1.Value != es2; /// assign - public static implicit operator EncString(string value) => EncString.NewEncString(value); + public static implicit operator EncString(string value) => new EncString(value); public static implicit operator string(EncString encString) => encString.Value; #endregion From 47c522120dbdb73c57b12bea471a2eb4f12f6b27 Mon Sep 17 00:00:00 2001 From: JosepeDev Date: Tue, 24 Nov 2020 15:44:07 +0200 Subject: [PATCH 10/15] Update EncDecimal.cs --- EncTypes/EncDecimal.cs | 159 +++++++++++++++++++++++++++++++++++++---- 1 file changed, 145 insertions(+), 14 deletions(-) diff --git a/EncTypes/EncDecimal.cs b/EncTypes/EncDecimal.cs index f59abd2..7775f16 100644 --- a/EncTypes/EncDecimal.cs +++ b/EncTypes/EncDecimal.cs @@ -6,7 +6,7 @@ public struct EncDecimal /// In the memory it is saved as a different that is affected by random values. { encryptionKey1 & encryptionKey2 } /// Every time the value changes, the encryption keys change too. And it works exactly as an deciaml. /// - /// Wiki page: https://github.com/JosepeDev/VarEnc/wiki + /// WIKI & INFO: https://github.com/JosepeDev/VarEnc #region Variables And Properties @@ -18,7 +18,7 @@ public struct EncDecimal private decimal encryptedValue; // The decrypted value - private decimal Value + public decimal Value { set { @@ -30,6 +30,12 @@ private decimal Value } } + public Decimal MaxValue { get => Decimal.MaxValue; } + public Decimal MinValue { get => Decimal.MinValue; } + public Decimal MinusOne { get => Decimal.MinusOne; } + public Decimal One { get => Decimal.One; } + public Decimal Zero { get => Decimal.Zero; } + #endregion #region Methods @@ -47,7 +53,7 @@ private static EncDecimal NewEncDecimal(decimal value) // Encryption key generator static private Random random = new Random(); - public static decimal GetEncryptionKey() => (decimal)(random.NextDouble()); + private static decimal GetEncryptionKey() => (decimal)(random.NextDouble()); // Takes a given value and returns it encrypted private decimal Encrypt(decimal value) @@ -67,47 +73,172 @@ private decimal Decrypt(decimal value) return valueToReturn; } - // Returns the stored value as a string - public override string ToString() - { - return (Value).ToString(); - } + // Overrides + public int CompareTo(Decimal value) => Value.CompareTo(value); + public int CompareTo(object value) => Value.CompareTo(value); + public bool Equals(Decimal value) => Value.Equals(value); + public override bool Equals(object value) => Value.Equals(value); + public override int GetHashCode() => Value.GetHashCode(); + public TypeCode GetTypeCode() => Value.GetTypeCode(); + public string ToString(string format) => Value.ToString(format); + public string ToString(IFormatProvider provider) => Value.ToString(provider); + public override string ToString() => Value.ToString(); + public string ToString(string format, IFormatProvider provider) => Value.ToString(format, provider); #endregion #region Operators Overloading /// + - * / % + public static EncDecimal operator +(EncDecimal eint1, EncDecimal eint2) => EncDecimal.NewEncDecimal(eint1.Value + eint2.Value); public static EncDecimal operator -(EncDecimal eint1, EncDecimal eint2) => EncDecimal.NewEncDecimal(eint1.Value - eint2.Value); public static EncDecimal operator *(EncDecimal eint1, EncDecimal eint2) => EncDecimal.NewEncDecimal(eint1.Value * eint2.Value); public static EncDecimal operator /(EncDecimal eint1, EncDecimal eint2) => EncDecimal.NewEncDecimal(eint1.Value / eint2.Value); public static EncDecimal operator %(EncDecimal eint1, EncDecimal eint2) => EncDecimal.NewEncDecimal(eint1.Value % eint2.Value); + public static decimal operator +(EncDecimal edecimal1, ulong edecimal2) => edecimal1.Value + edecimal2; + public static decimal operator -(EncDecimal edecimal1, ulong edecimal2) => edecimal1.Value - edecimal2; + public static decimal operator *(EncDecimal edecimal1, ulong edecimal2) => edecimal1.Value * edecimal2; + public static decimal operator /(EncDecimal edecimal1, ulong edecimal2) => edecimal1.Value / edecimal2; + public static decimal operator %(EncDecimal edecimal1, ulong edecimal2) => edecimal1.Value % edecimal2; + + public static decimal operator +(EncDecimal edecimal1, long edecimal2) => edecimal1.Value + edecimal2; + public static decimal operator -(EncDecimal edecimal1, long edecimal2) => edecimal1.Value - edecimal2; + public static decimal operator *(EncDecimal edecimal1, long edecimal2) => edecimal1.Value * edecimal2; + public static decimal operator /(EncDecimal edecimal1, long edecimal2) => edecimal1.Value / edecimal2; + public static decimal operator %(EncDecimal edecimal1, long edecimal2) => edecimal1.Value % edecimal2; + + public static decimal operator +(EncDecimal edecimal1, uint edecimal2) => edecimal1.Value + edecimal2; + public static decimal operator -(EncDecimal edecimal1, uint edecimal2) => edecimal1.Value - edecimal2; + public static decimal operator *(EncDecimal edecimal1, uint edecimal2) => edecimal1.Value * edecimal2; + public static decimal operator /(EncDecimal edecimal1, uint edecimal2) => edecimal1.Value / edecimal2; + public static decimal operator %(EncDecimal edecimal1, uint edecimal2) => edecimal1.Value % edecimal2; + + public static decimal operator +(EncDecimal edecimal1, int edecimal2) => edecimal1.Value + edecimal2; + public static decimal operator -(EncDecimal edecimal1, int edecimal2) => edecimal1.Value - edecimal2; + public static decimal operator *(EncDecimal edecimal1, int edecimal2) => edecimal1.Value * edecimal2; + public static decimal operator /(EncDecimal edecimal1, int edecimal2) => edecimal1.Value / edecimal2; + public static decimal operator %(EncDecimal edecimal1, int edecimal2) => edecimal1.Value % edecimal2; + + public static decimal operator +(EncDecimal edecimal1, ushort edecimal2) => edecimal1.Value + edecimal2; + public static decimal operator -(EncDecimal edecimal1, ushort edecimal2) => edecimal1.Value - edecimal2; + public static decimal operator *(EncDecimal edecimal1, ushort edecimal2) => edecimal1.Value * edecimal2; + public static decimal operator /(EncDecimal edecimal1, ushort edecimal2) => edecimal1.Value / edecimal2; + public static decimal operator %(EncDecimal edecimal1, ushort edecimal2) => edecimal1.Value % edecimal2; + + public static decimal operator +(EncDecimal edecimal1, short edecimal2) => edecimal1.Value + edecimal2; + public static decimal operator -(EncDecimal edecimal1, short edecimal2) => edecimal1.Value - edecimal2; + public static decimal operator *(EncDecimal edecimal1, short edecimal2) => edecimal1.Value * edecimal2; + public static decimal operator /(EncDecimal edecimal1, short edecimal2) => edecimal1.Value / edecimal2; + public static decimal operator %(EncDecimal edecimal1, short edecimal2) => edecimal1.Value % edecimal2; + + public static decimal operator +(EncDecimal edecimal1, byte edecimal2) => edecimal1.Value + edecimal2; + public static decimal operator -(EncDecimal edecimal1, byte edecimal2) => edecimal1.Value - edecimal2; + public static decimal operator *(EncDecimal edecimal1, byte edecimal2) => edecimal1.Value * edecimal2; + public static decimal operator /(EncDecimal edecimal1, byte edecimal2) => edecimal1.Value / edecimal2; + public static decimal operator %(EncDecimal edecimal1, byte edecimal2) => edecimal1.Value % edecimal2; + + public static decimal operator +(EncDecimal edecimal1, sbyte edecimal2) => edecimal1.Value + edecimal2; + public static decimal operator -(EncDecimal edecimal1, sbyte edecimal2) => edecimal1.Value - edecimal2; + public static decimal operator *(EncDecimal edecimal1, sbyte edecimal2) => edecimal1.Value * edecimal2; + public static decimal operator /(EncDecimal edecimal1, sbyte edecimal2) => edecimal1.Value / edecimal2; + public static decimal operator %(EncDecimal edecimal1, sbyte edecimal2) => edecimal1.Value % edecimal2; + public static decimal operator +(EncDecimal edecimal1, decimal edecimal2) => edecimal1.Value + edecimal2; public static decimal operator -(EncDecimal edecimal1, decimal edecimal2) => edecimal1.Value - edecimal2; public static decimal operator *(EncDecimal edecimal1, decimal edecimal2) => edecimal1.Value * edecimal2; public static decimal operator /(EncDecimal edecimal1, decimal edecimal2) => edecimal1.Value / edecimal2; public static decimal operator %(EncDecimal edecimal1, decimal edecimal2) => edecimal1.Value % edecimal2; + public static decimal operator +(EncDecimal edecimal1, double edecimal2) => edecimal1.Value + (decimal)edecimal2; + public static decimal operator -(EncDecimal edecimal1, double edecimal2) => edecimal1.Value - (decimal)edecimal2; + public static decimal operator *(EncDecimal edecimal1, double edecimal2) => edecimal1.Value * (decimal)edecimal2; + public static decimal operator /(EncDecimal edecimal1, double edecimal2) => edecimal1.Value / (decimal)edecimal2; + public static decimal operator %(EncDecimal edecimal1, double edecimal2) => edecimal1.Value % (decimal)edecimal2; + + public static decimal operator +(EncDecimal edecimal1, float edecimal2) => edecimal1.Value + (decimal)edecimal2; + public static decimal operator -(EncDecimal edecimal1, float edecimal2) => edecimal1.Value - (decimal)edecimal2; + public static decimal operator *(EncDecimal edecimal1, float edecimal2) => edecimal1.Value * (decimal)edecimal2; + public static decimal operator /(EncDecimal edecimal1, float edecimal2) => edecimal1.Value / (decimal)edecimal2; + public static decimal operator %(EncDecimal edecimal1, float edecimal2) => edecimal1.Value % (decimal)edecimal2; + /// == != < > - public static bool operator ==(EncDecimal eint1, decimal eint2) => eint1.Value == eint2; - public static bool operator !=(EncDecimal eint1, decimal eint2) => eint1.Value != eint2; - public static bool operator >(EncDecimal eint1, decimal eint2) => eint1.Value > eint2; - public static bool operator <(EncDecimal eint1, decimal eint2) => eint1.Value < eint2; public static bool operator ==(EncDecimal eint1, EncDecimal eint2) => eint1.Value == eint2.Value; public static bool operator !=(EncDecimal eint1, EncDecimal eint2) => eint1.Value != eint2.Value; public static bool operator <(EncDecimal eint1, EncDecimal eint2) => eint1.Value < eint2.Value; public static bool operator >(EncDecimal eint1, EncDecimal eint2) => eint1.Value > eint2.Value; + public static bool operator ==(EncDecimal eint1, ulong eint2) => eint1.Value == eint2; + public static bool operator !=(EncDecimal eint1, ulong eint2) => eint1.Value != eint2; + public static bool operator >(EncDecimal eint1, ulong eint2) => eint1.Value > eint2; + public static bool operator <(EncDecimal eint1, ulong eint2) => eint1.Value < eint2; + + public static bool operator ==(EncDecimal eint1, long eint2) => eint1.Value == eint2; + public static bool operator !=(EncDecimal eint1, long eint2) => eint1.Value != eint2; + public static bool operator >(EncDecimal eint1, long eint2) => eint1.Value > eint2; + public static bool operator <(EncDecimal eint1, long eint2) => eint1.Value < eint2; + + public static bool operator ==(EncDecimal eint1, uint eint2) => eint1.Value == eint2; + public static bool operator !=(EncDecimal eint1, uint eint2) => eint1.Value != eint2; + public static bool operator >(EncDecimal eint1, uint eint2) => eint1.Value > eint2; + public static bool operator <(EncDecimal eint1, uint eint2) => eint1.Value < eint2; + + public static bool operator ==(EncDecimal eint1, int eint2) => eint1.Value == eint2; + public static bool operator !=(EncDecimal eint1, int eint2) => eint1.Value != eint2; + public static bool operator >(EncDecimal eint1, int eint2) => eint1.Value > eint2; + public static bool operator <(EncDecimal eint1, int eint2) => eint1.Value < eint2; + + public static bool operator ==(EncDecimal eint1, ushort eint2) => eint1.Value == eint2; + public static bool operator !=(EncDecimal eint1, ushort eint2) => eint1.Value != eint2; + public static bool operator >(EncDecimal eint1, ushort eint2) => eint1.Value > eint2; + public static bool operator <(EncDecimal eint1, ushort eint2) => eint1.Value < eint2; + + public static bool operator ==(EncDecimal eint1, short eint2) => eint1.Value == eint2; + public static bool operator !=(EncDecimal eint1, short eint2) => eint1.Value != eint2; + public static bool operator >(EncDecimal eint1, short eint2) => eint1.Value > eint2; + public static bool operator <(EncDecimal eint1, short eint2) => eint1.Value < eint2; + + public static bool operator ==(EncDecimal eint1, byte eint2) => eint1.Value == eint2; + public static bool operator !=(EncDecimal eint1, byte eint2) => eint1.Value != eint2; + public static bool operator >(EncDecimal eint1, byte eint2) => eint1.Value > eint2; + public static bool operator <(EncDecimal eint1, byte eint2) => eint1.Value < eint2; + + public static bool operator ==(EncDecimal eint1, sbyte eint2) => eint1.Value == eint2; + public static bool operator !=(EncDecimal eint1, sbyte eint2) => eint1.Value != eint2; + public static bool operator >(EncDecimal eint1, sbyte eint2) => eint1.Value > eint2; + public static bool operator <(EncDecimal eint1, sbyte eint2) => eint1.Value < eint2; + + public static bool operator ==(EncDecimal eint1, decimal eint2) => eint1.Value == eint2; + public static bool operator !=(EncDecimal eint1, decimal eint2) => eint1.Value != eint2; + public static bool operator >(EncDecimal eint1, decimal eint2) => eint1.Value > eint2; + public static bool operator <(EncDecimal eint1, decimal eint2) => eint1.Value < eint2; + + public static bool operator ==(EncDecimal eint1, double eint2) => eint1.Value == (decimal)eint2; + public static bool operator !=(EncDecimal eint1, double eint2) => eint1.Value != (decimal)eint2; + public static bool operator >(EncDecimal eint1, double eint2) => eint1.Value > (decimal)eint2; + public static bool operator <(EncDecimal eint1, double eint2) => eint1.Value < (decimal)eint2; + + public static bool operator ==(EncDecimal eint1, float eint2) => eint1.Value == (decimal)eint2; + public static bool operator !=(EncDecimal eint1, float eint2) => eint1.Value != (decimal)eint2; + public static bool operator >(EncDecimal eint1, float eint2) => eint1.Value > (decimal)eint2; + public static bool operator <(EncDecimal eint1, float eint2) => eint1.Value < (decimal)eint2; + /// assign + public static implicit operator EncDecimal(decimal value) => EncDecimal.NewEncDecimal(value); public static implicit operator decimal(EncDecimal eint1) => eint1.Value; - public static explicit operator float(EncDecimal eint1) => (float)eint1.Value; public static explicit operator double(EncDecimal eint1) => (double)eint1.Value; - public static explicit operator int(EncDecimal eint1) => (int)eint1.Value; + public static explicit operator float(EncDecimal eint1) => (float)eint1.Value; + public static explicit operator ulong(EncDecimal eint1) => (ulong)eint1.Value; public static explicit operator long(EncDecimal eint1) => (long)eint1.Value; + public static explicit operator uint(EncDecimal eint1) => (uint)eint1.Value; + public static explicit operator int(EncDecimal eint1) => (int)eint1.Value; + public static explicit operator ushort(EncDecimal eint1) => (ushort)eint1.Value; + public static explicit operator short(EncDecimal eint1) => (short)eint1.Value; + public static explicit operator byte(EncDecimal eint1) => (byte)eint1.Value; + public static explicit operator sbyte(EncDecimal eint1) => (sbyte)eint1.Value; #endregion } \ No newline at end of file From 71dabade3f55036cc751543304ce7c2683f90c87 Mon Sep 17 00:00:00 2001 From: JosepeDev Date: Tue, 24 Nov 2020 15:48:43 +0200 Subject: [PATCH 11/15] Update EncBool.cs --- EncTypes/EncBool.cs | 19 ++++++++++++++++--- 1 file changed, 16 insertions(+), 3 deletions(-) diff --git a/EncTypes/EncBool.cs b/EncTypes/EncBool.cs index 37203ce..c26b159 100644 --- a/EncTypes/EncBool.cs +++ b/EncTypes/EncBool.cs @@ -11,11 +11,15 @@ public struct EncBool #region Variables And Properties readonly bool _value; - bool Value + + public bool Value { get => Decrypt(_value); } + public static string FalseString { get => Boolean.FalseString; } + public static string TrueString { get => Boolean.TrueString; } + #endregion #region Constructors @@ -34,7 +38,16 @@ static bool Decrypt(bool boolVar) { return !boolVar; } - + + public int CompareTo(Boolean value) => Value.CompareTo(value); + public int CompareTo(object obj) => Value.CompareTo(obj); + public Boolean Equals(Boolean obj) => Value.Equals(obj); + public override Boolean Equals(object obj) => Value.Equals(obj); + public override int GetHashCode() => Value.GetHashCode(); + public TypeCode GetTypeCode() => Value.GetTypeCode(); + public override string ToString() => Value.ToString(); + public string ToString(IFormatProvider provider) => Value.ToString(provider); + #endregion #region Operators Overloading @@ -49,4 +62,4 @@ static bool Decrypt(bool boolVar) public static implicit operator bool(EncBool eint1) => eint1._value; #endregion -} +} \ No newline at end of file From 8ab26887ebbdf33792b230a8d55bc5504ab74da6 Mon Sep 17 00:00:00 2001 From: JosepeDev Date: Tue, 24 Nov 2020 15:57:28 +0200 Subject: [PATCH 12/15] Set encryption methods to private --- EncTypes/EncDecimal.cs | 2 +- EncTypes/EncFloat.cs | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/EncTypes/EncDecimal.cs b/EncTypes/EncDecimal.cs index 7775f16..c814dd2 100644 --- a/EncTypes/EncDecimal.cs +++ b/EncTypes/EncDecimal.cs @@ -53,7 +53,7 @@ private static EncDecimal NewEncDecimal(decimal value) // Encryption key generator static private Random random = new Random(); - private static decimal GetEncryptionKey() => (decimal)(random.NextDouble()); + static private decimal GetEncryptionKey() => (decimal)(random.NextDouble()); // Takes a given value and returns it encrypted private decimal Encrypt(decimal value) diff --git a/EncTypes/EncFloat.cs b/EncTypes/EncFloat.cs index 03d0d65..51949a9 100644 --- a/EncTypes/EncFloat.cs +++ b/EncTypes/EncFloat.cs @@ -54,7 +54,7 @@ private static EncFloat NewEncFloat(float value) // encryption key generator static private Random random = new Random(); - public static double GetEncryptionKey() => random.NextDouble(); + static private double GetEncryptionKey() => random.NextDouble(); // Takes a given value and returns it encrypted private double Encrypt(double value) From 7c858cc837f30bee0e480cf26f5276cd4fa19568 Mon Sep 17 00:00:00 2001 From: JosepeDev Date: Tue, 24 Nov 2020 16:01:23 +0200 Subject: [PATCH 13/15] Update VariableEncryption.dll --- Benchmark/VariableEncryption.dll | Bin 29184 -> 54272 bytes 1 file changed, 0 insertions(+), 0 deletions(-) diff --git a/Benchmark/VariableEncryption.dll b/Benchmark/VariableEncryption.dll index 68c1e1cb6164437a1df6887f706fb78ec7db8ac0..93c1a27a6b43a98480abfce206100155312c307b 100644 GIT binary patch literal 54272 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 A0RR91 literal 29184 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 From 195155f05999ea3ef13a1bba46e94eed34284bd1 Mon Sep 17 00:00:00 2001 From: Josepe <72740829+JosepeDev@users.noreply.github.com> Date: Tue, 24 Nov 2020 16:15:56 +0200 Subject: [PATCH 14/15] Update README.md --- README.md | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/README.md b/README.md index 1fc45cb..c7132a6 100644 --- a/README.md +++ b/README.md @@ -6,6 +6,8 @@ - [**Benchmark**](#benchmark) - [Example of usage](#example-of-usage) - [Files](#files) +- [**Documentations**](#documentations) + - [CSharp](#csharp) # EncTypes ![img](https://i.imgur.com/rIKRq3i.png) @@ -117,3 +119,14 @@ Be aware that the **shortest** benchmarks are the **least accurate**. ### Files You can lunch the benchmark executable from [here](https://github.com/JosepeDev/Variable-Encryption/tree/main/Benchmark) + +# Documentations +Every EncType contains the same methods and fields as its normal type. +So it'll link you to the official .NET documentaions for eash method/field. +## CSharp +- [EncInt](https://docs.microsoft.com/en-us/dotnet/api/system.int32?view=net-5.0) +- [EncLong](https://docs.microsoft.com/en-us/dotnet/api/system.int64?view=net-5.0) +- [EncFloat](https://docs.microsoft.com/en-us/dotnet/api/system.single?view=net-5.0) +- [EncDouble](https://docs.microsoft.com/en-us/dotnet/api/system.double?view=net-5.0) +- [EncDecimal](https://docs.microsoft.com/en-us/dotnet/api/system.decimal?view=net-5.0) +- [EncString](https://docs.microsoft.com/en-us/dotnet/api/system.string?view=net-5.0) From cd78234d2e3649edd72dcdff4cd362e4c7dbbfcc Mon Sep 17 00:00:00 2001 From: Josepe <72740829+JosepeDev@users.noreply.github.com> Date: Tue, 24 Nov 2020 16:16:21 +0200 Subject: [PATCH 15/15] Update README.md --- README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index c7132a6..6fbbdfe 100644 --- a/README.md +++ b/README.md @@ -121,8 +121,8 @@ Be aware that the **shortest** benchmarks are the **least accurate**. You can lunch the benchmark executable from [here](https://github.com/JosepeDev/Variable-Encryption/tree/main/Benchmark) # Documentations -Every EncType contains the same methods and fields as its normal type. -So it'll link you to the official .NET documentaions for eash method/field. +**Every EncType contains the same methods and fields as its normal type.** +**So it'll link you to the official .NET documentaions.** ## CSharp - [EncInt](https://docs.microsoft.com/en-us/dotnet/api/system.int32?view=net-5.0) - [EncLong](https://docs.microsoft.com/en-us/dotnet/api/system.int64?view=net-5.0)