public static Obj_AI_Hero GetTarget(this Spell spell,
bool ignoreShields = true,
Vector3 from = default(Vector3),
IEnumerable<Obj_AI_Hero> ignoredChampions = null)
{
return TargetSelector.GetTarget(spell, ignoreShields, from, ignoredChampions);
}
/// <summary>
/// Repeats the specified <see cref="Action"/> the number of times.
/// </summary>
/// <param name="input">The number of times to repeat the <see cref="Action"/>.</param>
/// <param name="action">The <see cref="Action"/> to repeat.</param>
public static void Times(this int input, Action action)
{
while (input-- > 0)
{
action();
}
}
public static MouseButton ToOpenTKSingle(this MouseButtons buttons)
{
if ((buttons & MouseButtons.Left) != MouseButtons.None) return MouseButton.Left;
else if ((buttons & MouseButtons.Right) != MouseButtons.None) return MouseButton.Right;
else if ((buttons & MouseButtons.Middle) != MouseButtons.None) return MouseButton.Middle;
else return MouseButton.LastButton;
}
public static void DeserializeObject(this Stream stream, object obj, List<string> nameTable)
{
while (stream.Position < stream.Length)
{
stream.ReadAndMapProperty(obj, nameTable);
}
}
public static IServiceCollection AddFromAssembly(this IServiceCollection serviceCollection, Assembly assembly)
{
var builder = new ServiceDescriptorsBuilder().AddSourceAssembly(assembly);
BuildAndFill(serviceCollection, builder);
return serviceCollection;
}
public static SmtpClient GenerateSmtpClient(this SmtpConfigurationEntity config)
{
if (config.DeliveryMethod != SmtpDeliveryMethod.Network)
{
return new SmtpClient
{
DeliveryFormat = config.DeliveryFormat,
DeliveryMethod = config.DeliveryMethod,
PickupDirectoryLocation = config.PickupDirectoryLocation,
};
}
else
{
SmtpClient client = EmailLogic.SafeSmtpClient(config.Network.Host, config.Network.Port);
client.DeliveryFormat = config.DeliveryFormat;
client.UseDefaultCredentials = config.Network.UseDefaultCredentials;
client.Credentials = config.Network.Username.HasText() ? new NetworkCredential(config.Network.Username, config.Network.Password) : null;
client.EnableSsl = config.Network.EnableSSL;
foreach (var cc in config.Network.ClientCertificationFiles)
{
client.ClientCertificates.Add(cc.CertFileType == CertFileType.CertFile ?
X509Certificate.CreateFromCertFile(cc.FullFilePath)
: X509Certificate.CreateFromSignedFile(cc.FullFilePath));
}
return client;
}
}
/// <summary>
/// Appends key=value to the string.
/// Does not append ? or & before key=value.
/// </summary>
public static StringBuilder AppendQueryParam(this StringBuilder sb, string key, string value)
{
Debug.Assert(!string.IsNullOrWhiteSpace(key));
Debug.Assert(value != null);
return sb.Append(key).Append('=').Append(value);
}
// Create an md5 sum string of this string
public static string GetMd5Sum(this string str)
{
// First we need to convert the string into bytes, which
// means using a text encoder.
Encoder enc = System.Text.Encoding.Unicode.GetEncoder();
// Create a buffer large enough to hold the string
byte[] unicodeText = new byte[str.Length * 2];
enc.GetBytes(str.ToCharArray(), 0, str.Length, unicodeText, 0, true);
// Now that we have a byte array we can ask the CSP to hash it
MD5 md5 = new MD5CryptoServiceProvider();
byte[] result = md5.ComputeHash(unicodeText);
// Build the final string by converting each byte
// into hex and appending it to a StringBuilder
var sb = new StringBuilder();
for (int i = 0; i < result.Length; i++)
{
sb.Append(result[i].ToString("X2"));
}
// And return it
return sb.ToString();
}
/// <summary>
/// Sets the time on the specified DateTime value using the specified time zone.
/// </summary>
/// <param name = "datetimeOff">The base date.</param>
/// <param name = "timespan">The TimeSpan to be applied.</param>
/// <param name = "localTimeZone">The local time zone.</param>
/// <returns>/// The DateTimeOffset including the new time value/// </returns>
public static DateTimeOffset SetTime(this DateTimeOffset datetimeOff, TimeSpan timespan,
TimeZoneInfo localTimeZone)
{
var localDate = datetimeOff.ToLocalDateTime(localTimeZone);
localDate.SetTime(timespan);
return localDate.ToDateTimeOffset(localTimeZone);
}
public static bool IsLegalSize(this int size, KeySizes[] legalSizes, out bool validatedByZeroSkipSizeKeySizes)
{
validatedByZeroSkipSizeKeySizes = false;
for (int i = 0; i < legalSizes.Length; i++)
{
KeySizes currentSizes = legalSizes[i];
// If a cipher has only one valid key size, MinSize == MaxSize and SkipSize will be 0
if (currentSizes.SkipSize == 0)
{
if (currentSizes.MinSize == size)
{
// Signal that we were validated by a 0-skipsize KeySizes entry. Needed to preserve a very obscure
// piece of back-compat behavior.
validatedByZeroSkipSizeKeySizes = true;
return true;
}
}
else if (size >= currentSizes.MinSize && size <= currentSizes.MaxSize)
{
// If the number is in range, check to see if it's a legal increment above MinSize
int delta = size - currentSizes.MinSize;
// While it would be unusual to see KeySizes { 10, 20, 5 } and { 11, 14, 1 }, it could happen.
// So don't return false just because this one doesn't match.
if (delta % currentSizes.SkipSize == 0)
{
return true;
}
}
}
return false;
}
/// <summary>
/// Return the substring up to but not including the first instance of 'c'.
/// If 'c' is not found, the entire string is returned.
/// </summary>
public static string SubstringBefore (this String src, char c) {
if (String.IsNullOrEmpty(src)) return "";
int idx = Math.Min(src.Length, src.IndexOf(c));
if (idx < 0) return src;
return src.Substring(0, idx);
}
public static void Dump(this IMix mix, string name = null)
{
Console.WriteLine("-------------------------------------------------------");
if (name != null)
{
Console.WriteLine(name);
Console.WriteLine("-------------------------------------------------------");
}
for (int i = 0; i < mix.Count; i++)
{
IMixItem item = mix[i];
Transition transition = item.Transition;
string strategy = transition.Strategy == null
? "<null strategy>"
: transition.Strategy.Description;
Console.WriteLine(">>> {0} --> {1} using {2}", transition.FromKey, transition.ToKey, strategy);
Console.WriteLine("{0}. {1}/{2:0.#}bpm {3}", i, item.ActualKey, item.ActualBpm, item.Track);
}
Console.WriteLine("{0} tracks total.", mix.Count);
Console.WriteLine("-------------------------------------------------------");
}
public static Type GetEntityType(this Type type)
{
if (!type.IsCrudController()) return null;
var @interface = type.FindInterfaceThatCloses(typeof(CrudController<,>));
return @interface.GetGenericArguments()[0];
}
public static void AssertNotNullOrEmpty(this string source, string message = null)
{
if (string.IsNullOrEmpty(source))
{
throw new Exception("Assertion failed: " + (message ?? "expected to not be null or empty"));
}
}
public static string CreateAutoCompleteDictionaryEntryHash(this string entry, bool log = true)
{
if (!string.IsNullOrWhiteSpace(entry))
{
//Trim white space
string hash = entry.Trim();
//Hashes are stored without diacritics (accents etc)
hash = hash.RemoveDiacritics();
//Hashes are stored as uppercase
hash = hash.ToUpper();
if (!string.IsNullOrWhiteSpace(hash))
{
if (log)
{
Log.DebugFormat("Entry of '{0}' hashed to '{1}'", entry, hash);
}
return hash;
}
}
return null;
}
public static LEAP_VECTOR ToCVector(this Vector3 vector) {
LEAP_VECTOR cVector = new LEAP_VECTOR();
cVector.x = vector.x;
cVector.y = vector.y;
cVector.z = vector.z;
return cVector;
}
public static string Decrypt(this string stringToDecrypt, string key)
{
if (string.IsNullOrEmpty(stringToDecrypt))
{
throw new ArgumentException("An empty string value cannot be encrypted.");
}
if (string.IsNullOrEmpty(key))
{
throw new ArgumentException("Cannot decrypt using an empty key. Please supply a decryption key.");
}
//var cspp = new CspParameters { KeyContainerName = key };
var cspp = new CspParameters { KeyContainerName = key, Flags = CspProviderFlags.UseMachineKeyStore };
var rsa = new RSACryptoServiceProvider(cspp) { PersistKeyInCsp = true };
var decryptArray = stringToDecrypt.Split(new[] { "-" }, StringSplitOptions.None);
var decryptByteArray = Array.ConvertAll(decryptArray, (s => Convert.ToByte(byte.Parse(s, System.Globalization.NumberStyles.HexNumber))));
byte[] bytes = rsa.Decrypt(decryptByteArray, true);
string result = System.Text.Encoding.UTF8.GetString(bytes);
return result;
}
/// <summary>
/// Return the substring after to but not including the last instance of 'c'.
/// If 'c' is not found, the entire string is returned.
/// </summary>
public static string SubstringAfterLast (this String src, char c) {
if (String.IsNullOrEmpty(src)) return "";
int idx = Math.Min(src.Length - 1, src.LastIndexOf(c) + 1);
if (idx < 0) return src;
return src.Substring(idx);
}
public static void DisposeIfNotNull(this IDisposable disposable)
{
if (disposable != null)
{
disposable.Dispose();
}
}
public static StringBuilder AppendEscapedXml(this StringBuilder builder, string value)
{
if (value == null) return builder;
builder.EnsureCapacity(builder.Length + value.Length + 10);
for (var i = 0; i < value.Length; i++)
{
switch (value[i])
{
case '&':
builder.Append("&");
break;
case '<':
builder.Append("<");
break;
case '>':
builder.Append(">");
break;
case '"':
builder.Append(""");
break;
case '\'':
builder.Append("'");
break;
default:
builder.Append(value[i]);
break;
}
}
return builder;
}
public static UITextureAtlas GetInfoTooltip(this AssetManager assetManager, string infoTooltipName, string infoTooltipPath)
{
var infoTooltipAtlas = ScriptableObject.CreateInstance<UITextureAtlas>();
infoTooltipAtlas.padding = 0;
infoTooltipAtlas.name = infoTooltipName;
var shader = Shader.Find("UI/Default UI Shader");
if (shader != null) infoTooltipAtlas.material = new Material(shader);
var texture = assetManager.GetTexture(infoTooltipPath);
infoTooltipAtlas.material.mainTexture = texture;
const int ittW = 535;
const int ittH = 150;
var sprite = new UITextureAtlas.SpriteInfo
{
name = string.Format(infoTooltipName.ToUpper()),
region = new Rect(0f, 0f, 1f, 1f),
texture = new Texture2D(ittW, ittH, TextureFormat.ARGB32, false)
};
infoTooltipAtlas.AddSprite(sprite);
return infoTooltipAtlas;
}
/*public static float NextFloat(this Random rand, float maxValue = 1.0f, float minValue=0.0f)
{
return (float)rand.NextDouble() * (maxValue - minValue) + minValue;
}*/
public static Vector2 NextVector2(this Random rand, float maxLength = 1.0f, float minLength = 1.0f)
{
double theta = rand.NextDouble() * 2 * Math.PI;
float length = rand.NextFloat(minLength, maxLength);
return new Vector2(length * (float)Math.Cos(theta), length * (float)Math.Sin(theta));
}
public static IIntermediarySocket AsIntermediary(this EasyZMqConfigurer configurer, string backendAddress)
{
var frontendAddressBinder = configurer.AddressBinder;
var backendAddressBinder = new BindAddressBinder(new Uri(backendAddress));
return CreateIntermediarySocket(frontendAddressBinder, backendAddressBinder);
}
/// <summary>
/// Returns maximum spell range based on hitbox of unit.
/// </summary>
/// <param name="spell"></param>
/// <param name="unit"></param>
/// <returns>Maximum spell range</returns>
public static float ActualMaxRange(this WoWSpell spell, WoWUnit unit)
{
if (spell.MaxRange == 0)
return 0;
// 0.3 margin for error
return unit != null ? spell.MaxRange + unit.CombatReach + 1f : spell.MaxRange;
}
public static string FQN(this XElement element)
{
if (element == null)
return string.Empty;
var ns = element.Name.NamespaceName;
var prefix = element.Document.Root.GetPrefixOfNamespace(ns);
if (string.IsNullOrWhiteSpace(prefix))
{
var nsRoot = element.Document.Root.GetDefaultNamespace().NamespaceName;
if (!string.IsNullOrWhiteSpace(nsRoot))
{
if (string.IsNullOrWhiteSpace(prefix) && nsRoot.Equals(ns))
{
prefix = Common.DefaultNamespace;
}
}
}
if (!string.IsNullOrWhiteSpace(prefix))
prefix = prefix + ":";
return prefix + element.Name.LocalName;
}
public static string FQN(this XAttribute element)
{
if (element == null)
return string.Empty;
return "@" + element.Name.LocalName;
}
public static string Series(this UrlHelper helper, int seriesId, string seriesSlug)
{
return helper.Action(
MVC.Posts.ActionNames.Series,
MVC.Posts.Name,
new { seriesId, seriesSlug });
}
private static void TraceMessage(this Message message)
{
Console.WriteLine("\tTime: {0}", DateTime.Now.ToString("HH:mm:ss.ffffff"));
Console.WriteLine("\tMessage ID: {0}", message.Id);
Console.WriteLine("\tCorrel. ID: {0}", message.CorrelationId);
Console.WriteLine("\tContents: {0}", message.Body);
}
public static Field.Index GetIndex(this IndexDefinition self, string name, Field.Index? defaultIndex)
{
if (self.Indexes == null)
return defaultIndex ?? Field.Index.ANALYZED_NO_NORMS;
FieldIndexing value;
if (self.Indexes.TryGetValue(name, out value) == false)
{
if (self.Indexes.TryGetValue(Constants.AllFields, out value) == false)
{
string ignored;
if (self.Analyzers.TryGetValue(name, out ignored) ||
self.Analyzers.TryGetValue(Constants.AllFields, out ignored))
{
return Field.Index.ANALYZED; // if there is a custom analyzer, the value should be analyzed
}
return defaultIndex ?? Field.Index.ANALYZED_NO_NORMS;
}
}
switch (value)
{
case FieldIndexing.No:
return Field.Index.NO;
case FieldIndexing.Analyzed:
return Field.Index.ANALYZED_NO_NORMS;
case FieldIndexing.NotAnalyzed:
return Field.Index.NOT_ANALYZED_NO_NORMS;
case FieldIndexing.Default:
return defaultIndex ?? Field.Index.ANALYZED_NO_NORMS;
default:
throw new ArgumentOutOfRangeException();
}
}
public static AttributeGroup FixedDates(this AttributeGroup group)
{
group.UtcCreated = FixedSystemDate;
group.UtcModified = FixedSystemDate;
group.UtcStatusChanged = FixedSystemDate;
return group;
}
public (long, error) Write(slice <byte> p) => s_WriteByRef?.Invoke(ref this, p) ?? s_WriteByVal?.Invoke(this, p) ?? WriteCloser?.Write(p) ?? throw new PanicException(RuntimeErrorPanic.NilPointerDereference);
public static float AddDT(ref this float val)
{
return(val += Time.deltaTime);
}
public static unsafe bool Read(ref this BufferReader <byte> r, out B x)
internal static BitArray ReadBitArray(ref this SequenceReader <byte> reader, int length, bool defaultValue = false)
public static void SetAlpha(ref this RgbaFloat color, float alpha)
public static void WriteVarInt <TBufferWriter>(ref this Writer <TBufferWriter> writer, sbyte value) where TBufferWriter : IBufferWriter <byte> => WriteVarInt(ref writer, ZigZagEncode(value));
public static int Add(ref this int value, int operand) => Interlocked.Add(ref value, operand);
// 構造体(値型)は OK
public static void M(ref this int x)
{
}
public static JobHandle ScheduleRef <T>(ref this T str, JobHandle dependsOn = default) where T : unmanaged, IJob
public static void SetValuesFromArray(ref this Matrix4x4 matrix, float[] array)
internal static unsafe void WriteAsciiNoValidation(ref this BufferWriter <PipeWriter> buffer, string data)
public static ref UnsafePtrList ListData(ref this UnsafeArchetypePtrList from) => ref UnsafeUtilityEx.As <UnsafeArchetypePtrList, UnsafePtrList>(ref from);
public static ref UnsafePtrList ListData(ref this UnsafeEntityQueryDataPtrList from) => ref UnsafeUtilityEx.As <UnsafeEntityQueryDataPtrList, UnsafePtrList>(ref from);
internal static unsafe bool TryRead <T>(ref this SequenceReader <byte> reader, out T value)
public static bool CompareAndSet(ref this int value, int expected, int update) => Interlocked.CompareExchange(ref value, update, expected) == expected;
public static ScopedIValueLockEntry <TLock> EnterScoped <TLock>(ref this TLock @lock) where TLock : struct, IValueLock
{
return(new ScopedIValueLockEntry <TLock>(ref @lock));
}
public static int DecrementAndGet(ref this int value) => Interlocked.Decrement(ref value);
public static ref UnsafeList ListData(ref this UnsafeUintList from) => ref UnsafeUtilityEx.As <UnsafeUintList, UnsafeList>(ref from);
public static int SetAndGet(ref this int value, int update)
{
VolatileWrite(ref value, update);
return(update);
}
// Special case so we don't *need* to use SpinLockWrapped
public static ScopedIValueLockEntry EnterScoped(ref this SpinLock @lock)
{
return(new ScopedIValueLockEntry(ref @lock));
}
public static int GetAndSet(ref this int value, int update) => Interlocked.Exchange(ref value, update);
public static unsafe NativeArray <T> SkipFirst <T>(ref this NativeArray <T> array) where T : struct
public static string ReadString(ref this SequenceReader <byte> reader, long length = 0)
public static void AddDependency(ref this JobHandle self, JobHandle handle0)
public static unsafe bool TryParse(ref this BufferReader <byte> reader, out bool value)
public static void Clamp <T>(ref this T val, T min, T max) where T : struct, IComparable <T>
// 制約が付いていないとダメ。コンパイル エラー
public static void M1 <T>(ref this T x)
{
}
/// <summary> /// Adds or removes a flag. /// </summary> /// <param name="t"></param> /// <param name="flag">One or more flags to add or remove.</param> /// <param name="add">If true, adds flag, else removes flag.</param> public static unsafe void SetFlag <T>(ref this T t, T flag, bool add) where T : unmanaged, Enum
// クラス(参照型)はダメ。コンパイル エラー
public static void M(ref this string x)
{
}
// struct 制約が付いていれば OK
public static void M2 <T>(ref this T x) where T : struct
{
}
