public void Send(System.Collections.Generic.IEnumerable <SyslogMessage> messages, ISyslogMessageSerializer serializer)
{
// Slightly tricky, since we need to get the appName out of the first message before
// looping, so we can't just use foreach(). Using an explicit iterator works, though.
System.IntPtr ident = System.IntPtr.Zero;
using (System.Collections.Generic.IEnumerator <SyslogMessage> iterator = messages.GetEnumerator())
{
try
{
if (iterator.MoveNext())
{
SyslogMessage message = iterator.Current;
ident = MarshalIdent(message.AppName);
openlog(ident, (int)SyslogOptions.LogPid, CalculatePriorityValue(message.Facility, 0));
SendToSyslog(message, serializer);
}
while (iterator.MoveNext())
{
SendToSyslog(iterator.Current, serializer);
}
}
finally
{
closelog();
DisposeOfIdent(ident);
}
}
}
private static void _FillArray <T>(T[] array, System.Collections.Generic.IEnumerable <T> items, System.Func <T> func_default)
{
if (array == null)
{
throw new System.ArgumentNullException("array");
}
if (items == null)
{
throw new System.ArgumentNullException("items");
}
if (func_default == null)
{
throw new System.ArgumentNullException("func_default");
}
using (var e = items.GetEnumerator())
{
for (int i = 0; i < array.Length; i++)
{
bool move_ok = e.MoveNext();
if (move_ok)
{
array[i] = e.Current;
}
else
{
array[i] = func_default();
}
}
}
}
// the method is mostly copied from
// https://github.com/dotnet/runtime/blob/c0840723b382bcfa67b35839af8572fcd38f1d13/src/libraries/System.Linq/src/System/Linq/Single.cs#L86
public static TSource SingleOrDefault <TSource>(System.Collections.Generic.IEnumerable <TSource> source)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
if (source is System.Collections.Generic.IList <TSource> list)
{
switch (list.Count)
{
case 0:
return(default);
case 1:
return(list[0]);
}
}
else
{
using (System.Collections.Generic.IEnumerator <TSource> e = source.GetEnumerator())
{
if (!e.MoveNext())
{
return(default);
// Constructs a List, copying the contents of the given collection. The
// size and capacity of the new list will both be equal to the size of the
// given collection.
//
public List(System.Collections.Generic.IEnumerable <T> collection)
{
if (collection == null)
{
throw new Exception();
}
System.Collections.Generic.ICollection <T> c = collection as System.Collections.Generic.ICollection <T>;
if (c != null)
{
int count = c.Count;
_items = new T[count];
c.CopyTo(_items, 0);
_size = count;
}
else
{
_size = 0;
_items = new T[_defaultCapacity];
using (System.Collections.Generic.IEnumerator <T> en = collection.GetEnumerator())
{
while (en.MoveNext())
{
Add(en.Current);
}
}
}
}
public void AddRange(System.Collections.Generic.IEnumerable <T> collection)
{
if (collection == null)
{
throw new System.ArgumentNullException(nameof(collection));
}
if (collection is System.Collections.Generic.ICollection <T> c)
{
int count = c.Count;
if (count > 0)
{
var index = _size;
EnsureCapacity(count + index);
c.CopyTo(_items, index);
_size += count;
}
}
else
{
// This enumerable could be empty. Let Add allocate a new array, if needed.
// Note it will also go to _defaultCapacity first, not 1, then 2, etc.
using (System.Collections.Generic.IEnumerator <T> en = collection.GetEnumerator())
{
while (en.MoveNext())
{
Add(en.Current);
}
}
}
}
static void SetObjRecursively(GameObject rootObj, Material mat)
{
if (null != rootObj.renderer)
{
Debug.Log(rootObj.renderer.name);
}
if (null != rootObj.particleSystem)
{
Debug.Log(rootObj.particleSystem.name);
if (null != rootObj.particleSystem.renderer)
{
if ("Default-Particle (Instance)" == rootObj.particleSystem.renderer.material.name)
{
rootObj.particleSystem.renderer.material = mat;
}
}
}
System.Collections.Generic.IEnumerable <GameObject> subObj = rootObj.GetDirectChildren();
System.Collections.Generic.IEnumerator <GameObject> e = subObj.GetEnumerator();
if (null != rootObj)
{
while (e.MoveNext())
{
SetObjRecursively(e.Current, mat);
}
}
}
public static bool SequenceEquals <T>(this System.Collections.Generic.IEnumerable <T> left, System.Collections.Generic.IEnumerable <T> right)
{
if (object.ReferenceEquals(left, null))
{
return(object.ReferenceEquals(right, null));
}
try
{
using (var weird = left.GetEnumerator())
{
using (var strnage = right.GetEnumerator())
{
while (weird.MoveNext())
{
if (strnage.MoveNext().Equals(false) ||
weird.Current.Equals(strnage.Current).Equals(false))
{
return(false);
}
}
return(true);
}
}
}
catch
{
throw;
}
}
public async System.Threading.Tasks.Task <string> GetPlaceID(string placeName)
{
string placeID = String.Empty;
// request for place
PlacesFindSearchRequest request = new PlacesFindSearchRequest();
request.Key = _googleAPIKey;
request.Input = placeName;
try
{
// response for place
PlacesFindSearchResponse response = await GooglePlaces.FindSearch.QueryAsync(request);
System.Collections.Generic.IEnumerable <Candidate> list = response.Candidates;
System.Collections.Generic.IEnumerator <Candidate> Enumerator = list.GetEnumerator();
Candidate candidate = new Candidate();
if (Enumerator.MoveNext())
{
candidate = Enumerator.Current;
}
placeID = candidate.PlaceId;
}
catch (Exception e)
{
string message = e.Message;
}
return(placeID);
}
/// <summary>
/// Instiate a new list using all members of the given IEnumerable
/// </summary>
/// <param name="initial">to use as initial members</param>
public List(System.Collections.Generic.IEnumerable <T> initial) : base()
{
System.Collections.Generic.IEnumerator <T> enumerator = initial.GetEnumerator();
while (enumerator.MoveNext())
{
Add(enumerator.Current);
}
}
/// <summary>
/// Tries to remove every given item
/// </summary>
/// <param name="toRemove">items to remove</param>
public void RemoveAll(System.Collections.Generic.IEnumerable <T> toRemove)
{
System.Collections.Generic.IEnumerator <T> enumerator = toRemove.GetEnumerator();
while (enumerator.MoveNext())
{
Remove(enumerator.Current);
}
}
/// <summary>
/// Tries to add every item
/// </summary>
/// <param name="toAdd">items to add</param>
public void AddAll(System.Collections.Generic.IEnumerable <T> toAdd)
{
System.Collections.Generic.IEnumerator <T> enumerator = toAdd.GetEnumerator();
while (enumerator.MoveNext())
{
Add(enumerator.Current);
}
}
//public static implicit operator System.Collections.Generic.IEnumerable<System.Exception>(AggregateException aggregate){
// return aggregate.Aggregates;
//}
public System.Collections.Generic.IEnumerator <System.Exception> GetExceptions()
{
if (Common.IDisposedExtensions.IsNullOrDisposed(this))
{
throw new System.ObjectDisposedException("The instance is disposed.", this);
}
return(Aggregates.GetEnumerator());
}
public FilteredEnumerator(System.Collections.Generic.IEnumerable <T> enumerable, System.Func <T, bool> filter)
{
if (enumerable == null)
{
throw new System.ArgumentNullException();
}
this.enumerator = enumerable.GetEnumerator();
this.filter = filter; // could be null for unconditional enumeration.
}
public static System.Collections.Generic.IEnumerable <Video> Sort(this System.Collections.Generic.IEnumerable <Video> collectionToSort)
{
var readOnlySortCollection = collectionToSort.ToList().AsReadOnly();
for (var video = collectionToSort.GetEnumerator(); video.MoveNext();)
{
video.Current.Position = readOnlySortCollection.IndexOf(video.Current);
}
return(collectionToSort);
}
/// <summary>
/// Helper function for transforming Enumerable to an Array
/// </summary>
/// <param name="Enumerable">Enumerable object to transform into Array</param>
/// <returns>Transformed Array from given Enumerable</returns>
private static string[] EnumeratorToArray(System.Collections.Generic.IEnumerable <string> Enumerable)
{
System.Collections.Generic.List <string> TempList = new System.Collections.Generic.List <string>();
System.Collections.Generic.IEnumerator <string> Enumerator = Enumerable.GetEnumerator();
while (Enumerator.MoveNext())
{
TempList.Add(Enumerator.Current);
}
return(TempList.ToArray());
}
// Inserts the elements of the given collection at a given index. If
// required, the capacity of the list is increased to twice the previous
// capacity or the new size, whichever is larger. Ranges may be added
// to the end of the list by setting index to the List's size.
//
public void InsertRange(int index, System.Collections.Generic.IEnumerable <T> collection)
{
if (collection == null)
{
throw new Exception();
}
if ((uint)index > (uint)_size)
{
throw new Exception();
}
System.Collections.Generic.ICollection <T> c = collection as System.Collections.Generic.ICollection <T>;
if (c != null)
{ // if collection is System.Collections.Generic.ICollection<T>
int count = c.Count;
if (count > 0)
{
EnsureCapacity(_size + count);
if (index < _size)
{
Array.Copy(_items, index, _items, index + count, _size - index);
}
// If we're inserting a List into itself, we want to be able to deal with that.
if (this == c)
{
// Copy first part of _items to insert location
Array.Copy(_items, 0, _items, index, index);
// Copy last part of _items back to inserted location
Array.Copy(_items, index + count, _items, index * 2, _size - index);
}
else
{
T[] itemsToInsert = new T[count];
c.CopyTo(itemsToInsert, 0);
itemsToInsert.CopyTo(_items, index);
}
_size += count;
}
}
else
{
using (System.Collections.Generic.IEnumerator <T> en = collection.GetEnumerator())
{
while (en.MoveNext())
{
Insert(index++, en.Current);
}
}
}
_version++;
}
//
// Join
//
public static string Join(string separator, System.Collections.Generic.IEnumerable <string> values)
{
var @enum = values.GetEnumerator();
return(system.text.StringBuilder.Join(separator, (ref bool done) =>
{
if (@enum.MoveNext())
{
return @enum.Current;
}
done = true;
return null;
}));
}
static StackObject *GetEnumerator_0(ILIntepreter __intp, StackObject *__esp, IList <object> __mStack, CLRMethod __method, bool isNewObj)
{
ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
StackObject *ptr_of_this_method;
StackObject *__ret = ILIntepreter.Minus(__esp, 1);
ptr_of_this_method = ILIntepreter.Minus(__esp, 1);
System.Collections.Generic.IEnumerable <System.Collections.Generic.KeyValuePair <System.String, ILRuntime.Runtime.Intepreter.ILTypeInstance> > instance_of_this_method = (System.Collections.Generic.IEnumerable <System.Collections.Generic.KeyValuePair <System.String, ILRuntime.Runtime.Intepreter.ILTypeInstance> >) typeof(System.Collections.Generic.IEnumerable <System.Collections.Generic.KeyValuePair <System.String, ILRuntime.Runtime.Intepreter.ILTypeInstance> >).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack));
__intp.Free(ptr_of_this_method);
var result_of_this_method = instance_of_this_method.GetEnumerator();
return(ILIntepreter.PushObject(__ret, __mStack, result_of_this_method));
}
public void InsertRange(int index, System.Collections.Generic.IEnumerable <T> collection)
{
int count = Count;
if (index > count || index < 0)
{
throw new System.ArgumentOutOfRangeException("index", index, "invalid index");
}
if (index == count)
{
var tailIter = collection.GetEnumerator();
while (tailIter.MoveNext())
{
AddLast(tailIter.Current);
}
tailIter.Dispose();
return;
}
int i = 0;
System.Collections.Generic.LinkedListNode <T> node = First;
while (node != null && i++ < index)
{
node = node.Next;
}
var iter = collection.GetEnumerator();
while (iter.MoveNext())
{
AddBefore(node, iter.Current);
}
iter.Dispose();
}
/// <summary>
/// Determines whether a sequence contains any elements.
/// </summary>
/// <typeparam name="T">The type of the elements in the collection.</typeparam>
/// <param name="collection">The collection.</param>
/// <returns><c>true</c> if the collection contains at least one element; otherwise <c>false</c>.</returns>
/// <exception cref="System.ArgumentNullException">collection is null.</exception>
public static bool Any <T>(this System.Collections.Generic.IEnumerable <T> collection)
{
if (collection == null)
{
throw new ArgumentNullException("collection", "collection is null.");
}
using (var enumerator = collection.GetEnumerator())
{
if (enumerator.MoveNext())
{
return(true);
}
}
return(false);
}
static StackObject *GetEnumerator_0(ILIntepreter __intp, StackObject *__esp, IList <object> __mStack, CLRMethod __method, bool isNewObj)
{
ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
StackObject *ptr_of_this_method;
StackObject *__ret = ILIntepreter.Minus(__esp, 1);
ptr_of_this_method = ILIntepreter.Minus(__esp, 1);
System.Collections.Generic.IEnumerable <ETModel.Card> instance_of_this_method = (System.Collections.Generic.IEnumerable <ETModel.Card>) typeof(System.Collections.Generic.IEnumerable <ETModel.Card>).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack));
__intp.Free(ptr_of_this_method);
var result_of_this_method = instance_of_this_method.GetEnumerator();
object obj_result_of_this_method = result_of_this_method;
if (obj_result_of_this_method is CrossBindingAdaptorType)
{
return(ILIntepreter.PushObject(__ret, __mStack, ((CrossBindingAdaptorType)obj_result_of_this_method).ILInstance));
}
return(ILIntepreter.PushObject(__ret, __mStack, result_of_this_method));
}
public HashCode AndEach <T>(System.Collections.Generic.IEnumerable <T> items)
{
// int hashCode = items.Select(GetHashCode).Aggregate(CombineHashCodes);
int hashCode = 0;
using (System.Collections.Generic.IEnumerator <T> e = items.GetEnumerator())
{
if (!e.MoveNext())
{
throw new System.Exception("NoElements");
}
hashCode = GetHashCode(e.Current);
while (e.MoveNext())
{
hashCode = CombineHashCodes(hashCode, GetHashCode(e.Current));
}
} // End Using e
return(new HashCode(CombineHashCodes(this.value, hashCode)));
}
/// <summary>
/// Constructs a List, copying the contents of the given collection. The
/// size and capacity of the new list will both be equal to the size of the
/// given collection.
/// </summary>
/// <param name="collection">The collection whose elements are copied to the new list</param>
/// <exception cref="System.ArgumentNullException">capacity is less than 0.</exception>
public List(System.Collections.Generic.IEnumerable <T> collection)
{
if (collection == null)
{
throw new System.ArgumentNullException(nameof(collection));
}
if (collection is System.Collections.Generic.ICollection <T> c)
{
int count = c.Count;
if (count == 0)
{
_items = _emptyArray;
}
else
{
_items = new T[count];
c.CopyTo(_items, 0);
_size = count;
}
}
else
{
_size = 0;
_items = _emptyArray;
// This enumerable could be empty. Let Add allocate a new array, if needed.
// Note it will also go to _defaultCapacity first, not 1, then 2, etc.
using (var en = collection.GetEnumerator())
{
while (en.MoveNext())
{
Add(en.Current);
}
}
}
}
private static Boolean CleanArray(ref Object obj)
{
Boolean result = false;
if (obj == null)
{
return(false);
}
if (obj.GetType().GetProperties().Length <= 0)
{
return(false);
}
// if (obj.GetType() == typeof(String)) return false;
else
{
if (typeof(IEnumerable).IsAssignableFrom(obj.GetType()))
{
if ((obj.GetType().IsGenericType) || (obj.GetType().IsArray))
{
System.Collections.Generic.IEnumerable <Object> listObj = (System.Collections.Generic.IEnumerable <Object>)obj;
if (listObj.GetEnumerator().MoveNext())
{
return(false);
}
else
{
obj = null;
return(true);
}
}
}
else
{
MemberInfo[] mis = obj.GetType().GetMembers();
for (int j = 0; j < mis.Length; j++)
{
MemberInfo pi = obj.GetType().GetMember(mis[j].Name)[0];
if (pi.MemberType == MemberTypes.Property)
{
try
{
Object subObj = ((PropertyInfo)pi).GetValue(obj, null);
if (subObj != null)
{
if (subObj.GetType() != obj.GetType())
{
if (CleanArray(ref subObj))
{
((PropertyInfo)pi).SetValue(obj, subObj, null);
result = true;
}
}
}
}
catch (Exception e) { Console.WriteLine(e.Message); };
}
}
/*
* PropertyInfo[] pros = obj.GetType().GetProperties();
* for (int i = 0; i < pros.Length; i++)
* {
* for (int j = 0; j < pros[i].GetAccessors().Length; j++)
* {
* MethodInfo mi = pros[i].GetAccessors()[j];
* Object subObj= mi.Invoke(obj,null);
* CleanArray(subObj);
* }
* }
*/
}
}
return(result);
}
public override void Execute(TriggerBase trigger)
{
if (trigger.IsArgumentDefined("target"))
{
Character character = trigger.Get <Character>("target");
System.Collections.Generic.IEnumerable <BasePlayerItem> itemsByPattern = Singleton <ItemManager> .Instance.GetItemsByPattern(trigger.Get <string>("pattern"), character.Inventory);
using (System.Collections.Generic.IEnumerator <BasePlayerItem> enumerator = itemsByPattern.GetEnumerator())
{
while (enumerator.MoveNext())
{
BasePlayerItem current = enumerator.Current;
trigger.Reply("'{0}'({1}) Amount:{2} Guid:{3}", new object[]
{
current.Template.Name,
current.Template.Id,
current.Stack,
current.Guid
});
}
return;
}
}
System.Collections.Generic.IEnumerable <ItemTemplate> itemsByPattern2 = Singleton <ItemManager> .Instance.GetItemsByPattern(trigger.Get <string>("pattern"));
int num = trigger.Get <int>("page") * ItemRemoveCommand.ItemListCommand.LimitItemList;
int num2 = 0;
System.Collections.Generic.IEnumerator <ItemTemplate> enumerator2 = itemsByPattern2.GetEnumerator();
int num3 = 0;
while (enumerator2.MoveNext())
{
if (num3 >= num)
{
ItemTemplate current2 = enumerator2.Current;
if (num2 < ItemRemoveCommand.ItemListCommand.LimitItemList)
{
trigger.Reply("'{0}'({1})", new object[]
{
current2.Name,
current2.Id
});
num2++;
}
else
{
trigger.Reply("... (limit reached : {0})", new object[]
{
ItemRemoveCommand.ItemListCommand.LimitItemList
});
if (num2 == 0)
{
trigger.Reply("No results");
return;
}
return;
}
}
num3++;
}
}
//
// IEnumerable<object> methods. We need this because System.Array implement this (implicitly) if it is castable to object[]
//
System.Collections.Generic.IEnumerator <object> System.Collections.Generic.IEnumerable <object> .GetEnumerator()
{
return(_enumerableOfObject.GetEnumerator());
}
public static System.Collections.Generic.List <ServiceStack.Translators.Generator.Tests.Support.DataContract.Customer> ToDtoCustomers(this System.Collections.Generic.IEnumerable <ServiceStack.Translators.Generator.Tests.Support.Model.Customer> from)
{
if ((from == null))
{
return(null);
}
System.Collections.Generic.List <ServiceStack.Translators.Generator.Tests.Support.DataContract.Customer> to = new System.Collections.Generic.List <ServiceStack.Translators.Generator.Tests.Support.DataContract.Customer>();
for (System.Collections.Generic.IEnumerator <ServiceStack.Translators.Generator.Tests.Support.Model.Customer> iter = from.GetEnumerator(); iter.MoveNext();
)
{
ServiceStack.Translators.Generator.Tests.Support.Model.Customer item = iter.Current;
to.Add(item.ToDtoCustomer());
}
return(to);
}
/// <summary>Compares the contents of a <see cref="IEnumerable{T}"/>
/// implementation to another one to determine equality.</summary>
/// <remarks>Thinking of the <see cref="IEnumerable{T}"/> implementation as
/// a string with any number of characters, the algorithm checks
/// each item in each list. If any item of the list is not equal (or
/// one list contains all the elements of another list), then that list
/// element is compared to the other list element to see which
/// list is greater.</remarks>
/// <param name="x">The <see cref="IEnumerable{T}"/> implementation
/// that is considered the left hand side.</param>
/// <param name="y">The <see cref="IEnumerable{T}"/> implementation
/// that is considered the right hand side.</param>
/// <returns>True if the items are equal, false otherwise.</returns>
private static bool Equals(System.Collections.Generic.IEnumerable <T> x,
System.Collections.Generic.IEnumerable <T> y)
{
// If x and y are null, then return true, they are the same.
if (x == null && y == null)
{
// They are the same, return 0.
return(true);
}
// If one is null, then return a value based on whether or not
// one is null or not.
if (x == null || y == null)
{
// Return false, one is null, the other is not.
return(false);
}
// Check to see if the counts on the IEnumerable implementations are equal.
// This is a shortcut, if they are not equal, then the lists are not equal.
// If the result is indeterminate, then get out.
bool?enumerableCountsEqual = EnumerableCountsEqual(x, y);
// If the enumerable counts have been able to be calculated (indicated by
// a non-null value) and it is false, then no need to iterate through the items.
if (enumerableCountsEqual != null && !enumerableCountsEqual.Value)
{
// The sequences are not equal.
return(false);
}
// The counts of the items in the enumerations are equal, or indeterminate
// so a full iteration needs to be made to compare each item.
// Get the default comparer for T first.
System.Collections.Generic.EqualityComparer <T> defaultComparer =
System.Collections.Generic.EqualityComparer <T> .Default;
// Get the enumerator for y.
System.Collections.Generic.IEnumerator <T> otherEnumerator = y.GetEnumerator();
// Call Dispose on IDisposable if there is an implementation on the
// IEnumerator<T> returned by a call to y.GetEnumerator().
using (otherEnumerator as IDisposable)
{
// Cycle through the items in this list.
foreach (T item in x)
{
// If there isn't an item to get, then this has more
// items than that, they are not equal.
if (!otherEnumerator.MoveNext())
{
// Return false.
return(false);
}
// Perform a comparison. Must check this on the left hand side
// and that on the right hand side.
bool comparison = defaultComparer.Equals(item, otherEnumerator.Current);
// If the value is false, return false.
if (!comparison)
{
// Return the value.
return(comparison);
}
}
// If there are no more items, then return true, the sequences
// are equal.
if (!otherEnumerator.MoveNext())
{
// The sequences are equal.
return(true);
}
// The other sequence has more items than this one, return
// false, these are not equal.
return(false);
}
}
public static System.Collections.Generic.List <ServiceStack.Translators.Generator.Tests.Support.Model.Address> ToDomainModelAddresss(this System.Collections.Generic.IEnumerable <ServiceStack.Translators.Generator.Tests.Support.DataContract.Address> from)
{
if ((from == null))
{
return(null);
}
System.Collections.Generic.List <ServiceStack.Translators.Generator.Tests.Support.Model.Address> to = new System.Collections.Generic.List <ServiceStack.Translators.Generator.Tests.Support.Model.Address>();
for (System.Collections.Generic.IEnumerator <ServiceStack.Translators.Generator.Tests.Support.DataContract.Address> iter = from.GetEnumerator(); iter.MoveNext();
)
{
ServiceStack.Translators.Generator.Tests.Support.DataContract.Address item = iter.Current;
if ((item != null))
{
to.Add(item.ToDomainModelAddress());
}
}
return(to);
}
/// <summary>
/// Takes an IEnumerable-char input, and calls Append(...) on each character, appending a child element for each character to a root xml document.
/// </summary>
/// <param name="input"></param>
public void Append(System.Collections.Generic.IEnumerable <char> input)
{
this.Append(input.GetEnumerator());
}