MegaBites-AI/Windows-powershell
0308
1/* ****************************************************************************2 *3 * Copyright (c) Microsoft Corporation.4 *5 * This source code is subject to terms and conditions of the Microsoft Public License. A6 * copy of the license can be found in the License.html file at the root of this distribution. If7 * you cannot locate the Microsoft Public License, please send an email to8 * dlr@microsoft.com. By using this source code in any fashion, you are agreeing to be bound9 * by the terms of the Microsoft Public License.10 *11 * You must not remove this notice, or any other, from this software.12 *13 *14 * ***************************************************************************/15 16using System.Collections;17using System.Globalization;18using System.Linq;19using System.Linq.Expressions;20using System.CodeDom.Compiler;21using System.Collections.Concurrent;22using System.Collections.Generic;23using System.Management.Automation.Language;24using System.Reflection;25 26namespace System.Management.Automation27{28 using DynamicNull = System.Management.Automation.LanguagePrimitives.Null;29 30 internal abstract class MutableTuple31 {32 private const int MaxSize = 128;33 34 private static readonly Dictionary<Type, int> s_sizeDict = new Dictionary<Type, int>();35 36 private int _size;37 protected BitArray _valuesSet;38 private Dictionary<string, int> _nameToIndexMap;39 40 internal bool IsValueSet(int index)41 {42 if (_size < MutableTuple.MaxSize)43 {44 // fast path45 return _valuesSet[index];46 }47 48 // slow path49 MutableTuple nestedTuple = this;50 var accessPath = GetAccessPath(_size, index).ToArray();51 int length = accessPath.Length;52 for (int i = 0; i < length - 1; ++i)53 {54 nestedTuple = (MutableTuple)nestedTuple.GetValueImpl(accessPath[i]);55 }56 57 return nestedTuple._valuesSet[accessPath[length - 1]];58 }59 60 internal void SetAutomaticVariable(AutomaticVariable auto, object value, ExecutionContext context)61 {62 if (context._debuggingMode > 0)63 {64 context.Debugger.CheckVariableWrite(SpecialVariables.AutomaticVariables[(int)auto]);65 }66 67 SetValue((int)auto, value);68 }69 70 internal object GetAutomaticVariable(AutomaticVariable auto)71 {72 return GetValue((int)auto);73 }74 75 internal void SetPreferenceVariable(PreferenceVariable pref, object value)76 {77 SetValue((int)pref, value);78 }79 80 internal bool TryGetLocalVariable(string name, bool fromNewOrSet, out PSVariable result)81 {82 int index;83 name = VariableAnalysis.GetUnaliasedVariableName(name);84 if (_nameToIndexMap.TryGetValue(name, out index) && (fromNewOrSet || IsValueSet(index)))85 {86 result = new LocalVariable(name, this, index);87 return true;88 }89 90 result = null;91 return false;92 }93 94 internal bool TrySetParameter(string name, object value)95 {96 int index;97 name = VariableAnalysis.GetUnaliasedVariableName(name);98 if (_nameToIndexMap.TryGetValue(name, out index))99 {100 SetValue(index, value);101 return true;102 }103 104 return false;105 }106 107 internal PSVariable TrySetVariable(string name, object value)108 {109 int index;110 name = VariableAnalysis.GetUnaliasedVariableName(name);111 if (_nameToIndexMap.TryGetValue(name, out index))112 {113 SetValue(index, value);114 return new LocalVariable(name, this, index);115 }116 117 return null;118 }119 120 internal void GetVariableTable(Dictionary<string, PSVariable> result, bool includePrivate)121 {122 // We could cache this array if it was a perf problem.123 var orderedNames = (from keyValuePairs in _nameToIndexMap124 orderby keyValuePairs.Value125 select keyValuePairs.Key).ToArray();126 127 for (int i = 0; i < orderedNames.Length; ++i)128 {129 var name = orderedNames[i];130 if (IsValueSet(i) && !result.ContainsKey(name))131 {132 result.Add(name, new LocalVariable(name, this, i));133 if (SpecialVariables.IsUnderbar(name))134 {135 result.Add(SpecialVariables.PSItem, new LocalVariable(SpecialVariables.PSItem, this, i));136 }137 }138 }139 }140 141 public object GetValue(int index)142 {143 return GetNestedValue(_size, index);144 }145 146 public void SetValue(int index, object value)147 {148 SetNestedValue(_size, index, value);149 }150 151 protected abstract object GetValueImpl(int index);152 153 protected abstract void SetValueImpl(int index, object value);154 155 /// <summary>156 /// Sets the value at the given index for a tuple of the given size. This set supports157 /// walking through nested tuples to get the correct final index.158 /// </summary>159 private void SetNestedValue(int size, int index, object value)160 {161 if (size < MutableTuple.MaxSize)162 {163 // fast path164 SetValueImpl(index, value);165 }166 else167 {168 // slow path169 MutableTuple res = this;170 int lastAccess = -1;171 foreach (int i in GetAccessPath(size, index))172 {173 if (lastAccess != -1)174 {175 res = (MutableTuple)res.GetValueImpl(lastAccess);176 }177 178 lastAccess = i;179 }180 181 res.SetValueImpl(lastAccess, value);182 }183 }184 185 /// <summary>186 /// Gets the value at the given index for a tuple of the given size. This get187 /// supports walking through nested tuples to get the correct final index.188 /// </summary>189 private object GetNestedValue(int size, int index)190 {191 if (size < MutableTuple.MaxSize)192 {193 // fast path194 return GetValueImpl(index);195 }196 else197 {198 // slow path199 object res = this;200 foreach (int i in GetAccessPath(size, index))201 {202 res = ((MutableTuple)res).GetValueImpl(i);203 }204 205 return res;206 }207 }208 209 /// <summary>210 /// Gets the unbound generic Tuple type which has at lease size slots or null if a large enough tuple is not available.211 /// </summary>212 private static Type GetTupleType(int size)213 {214 #region Generated Tuple Get From Size215 216 // *** BEGIN GENERATED CODE ***217 // generated by function: gen_get_size from: generate_tuples.py218 219 if (size <= MutableTuple.MaxSize)220 {221 if (size <= 1)222 {223 return typeof(MutableTuple<>);224 }225 else if (size <= 2)226 {227 return typeof(MutableTuple<,>);228 }229 else if (size <= 4)230 {231 return typeof(MutableTuple<,,,>);232 }233 else if (size <= 8)234 {235 return typeof(MutableTuple<,,,,,,,>);236 }237 else if (size <= 16)238 {239 return typeof(MutableTuple<,,,,,,,,,,,,,,,>);240 }241 else if (size <= 32)242 {243 return typeof(MutableTuple<,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,>);244 }245 else if (size <= 64)246 {247 return typeof(MutableTuple<,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,>);248 }249 else250 {251 return typeof(MutableTuple<,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,>);252 }253 }254 255 // *** END GENERATED CODE ***256 257 #endregion258 259 return null;260 }261 262 /// <summary>263 /// Creates a generic tuple with the specified types.264 ///265 /// If the number of slots fits within the maximum tuple size then we simply266 /// create a single tuple. If it's greater then we create nested tuples267 /// (e.g. a Tuple`2 which contains a Tuple`128 and a Tuple`8 if we had a size of 136).268 /// </summary>269 public static Type MakeTupleType(params Type[] types)270 {271 // ContractUtils.RequiresNotNull(types, "types");272 273 return MakeTupleType(types, 0, types.Length);274 }275 276 /// <summary>277 /// Gets the number of usable slots in the provided Tuple type including slots available in nested tuples.278 /// </summary>279 public static int GetSize(Type tupleType)280 {281 // ContractUtils.RequiresNotNull(tupleType, "tupleType");282 283 int count = 0;284 lock (s_sizeDict) if (s_sizeDict.TryGetValue(tupleType, out count))285 {286 return count;287 }288 289 Stack<Type> types = new Stack<Type>(tupleType.GetGenericArguments());290 291 while (types.Count != 0)292 {293 Type t = types.Pop();294 295 if (typeof(MutableTuple).IsAssignableFrom(t))296 {297 foreach (Type subtype in t.GetGenericArguments())298 {299 types.Push(subtype);300 }301 302 continue;303 }304 305 if (t == typeof(DynamicNull))306 {307 continue;308 }309 310 count++;311 }312 313 lock (s_sizeDict) s_sizeDict[tupleType] = count;314 return count;315 }316 317 private static readonly ConcurrentDictionary<Type, Func<MutableTuple>> s_tupleCreators =318 new ConcurrentDictionary<Type, Func<MutableTuple>>(concurrencyLevel: 3, capacity: 100);319 320 public static Func<MutableTuple> TupleCreator(Type type)321 {322 return s_tupleCreators.GetOrAdd(type,323 t =>324 {325 var newExpr = Expression.New(t);326 return Expression.Lambda<Func<MutableTuple>>(newExpr.Cast(typeof(MutableTuple))).Compile();327 });328 }329 330 /// <summary>331 /// Creates a new instance of tupleType with the specified args. If the tuple is a nested332 /// tuple the values are added in their nested forms.333 /// </summary>334 public static MutableTuple MakeTuple(Type tupleType, Dictionary<string, int> nameToIndexMap, Func<MutableTuple> creator = null)335 {336 // ContractUtils.RequiresNotNull(tupleType, "tupleType");337 // ContractUtils.RequiresNotNull(args, "args");338 339 int size = GetSize(tupleType);340 var bitArray = new BitArray(size);341 MutableTuple res = MakeTuple(creator, tupleType, size, bitArray);342 res._nameToIndexMap = nameToIndexMap;343 return res;344 }345 346 /// <summary>347 /// Gets the values from a tuple including unpacking nested values.348 /// </summary>349 public static object[] GetTupleValues(MutableTuple tuple)350 {351 // ContractUtils.RequiresNotNull(tuple, "tuple");352 353 List<object> res = new List<object>();354 355 GetTupleValues(tuple, res);356 357 return res.ToArray();358 }359 360 /// <summary>361 /// Gets the series of properties that needs to be accessed to access a logical item in a potentially nested tuple.362 /// </summary>363 public static IEnumerable<PropertyInfo> GetAccessPath(Type tupleType, int index)364 {365 return GetAccessProperties(tupleType, GetSize(tupleType), index);366 }367 368 /// <summary>369 /// Gets the series of properties that needs to be accessed to access a logical item in a potentially nested tuple.370 /// </summary>371 internal static IEnumerable<PropertyInfo> GetAccessProperties(Type tupleType, int size, int index)372 {373 // ContractUtils.RequiresNotNull(tupleType, "tupleType");374 375 if (index < 0 || index >= size) throw new ArgumentException("index");376 377 foreach (int curIndex in GetAccessPath(size, index))378 {379 PropertyInfo pi = tupleType.GetProperty("Item" + string.Create(CultureInfo.InvariantCulture, $"{curIndex:D3}"));380 Diagnostics.Assert(pi != null, "reflection should always find Item");381 yield return pi;382 tupleType = pi.PropertyType;383 }384 }385 386 internal static IEnumerable<int> GetAccessPath(int size, int index)387 {388 // We get the final index by breaking the index into groups of bits. The more significant bits389 // represent the indexes into the outermost tuples and the least significant bits index into the390 // inner most tuples. The mask is initialized to mask the upper bits and adjust is initialized391 // and adjust is the value we need to divide by to get the index in the least significant bits.392 // As we go through we shift the mask and adjust down each loop to pull out the inner slot. Logically393 // everything in here is shifting bits (not multiplying or dividing) because NewTuple.MaxSize is a394 // power of 2.395 int depth = 0;396 int mask = MutableTuple.MaxSize - 1;397 int adjust = 1;398 int count = size;399 while (count > MutableTuple.MaxSize)400 {401 depth++;402 count /= MutableTuple.MaxSize;403 mask *= MutableTuple.MaxSize;404 adjust *= MutableTuple.MaxSize;405 }406 407 while (depth-- >= 0)408 {409 Diagnostics.Assert(mask != 0, "mask should never be 0.");410 411 int curIndex = (index & mask) / adjust;412 413 yield return curIndex;414 415 mask /= MutableTuple.MaxSize;416 adjust /= MutableTuple.MaxSize;417 }418 }419 420 private static void GetTupleValues(MutableTuple tuple, List<object> args)421 {422 Type[] types = tuple.GetType().GetGenericArguments();423 for (int i = 0; i < types.Length; i++)424 {425 if (typeof(MutableTuple).IsAssignableFrom(types[i]))426 {427 GetTupleValues((MutableTuple)tuple.GetValue(i), args);428 }429 else if (types[i] != typeof(DynamicNull))430 {431 args.Add(tuple.GetValue(i));432 }433 }434 }435 436 private static MutableTuple MakeTuple(Func<MutableTuple> creator, Type tupleType, int size, BitArray bitArray)437 {438 MutableTuple res = (creator ?? MutableTuple.TupleCreator(tupleType))();439 res._size = size;440 res._valuesSet = bitArray;441 if (size > MutableTuple.MaxSize)442 {443 while (size > MutableTuple.MaxSize)444 {445 size = (size + MutableTuple.MaxSize - 1) / MutableTuple.MaxSize;446 }447 448 for (int i = 0; i < size; i++)449 {450 PropertyInfo pi = tupleType.GetProperty("Item" + string.Create(CultureInfo.InvariantCulture, $"{i:D3}"));451 res.SetValueImpl(i, MakeTuple(pi.PropertyType, null, null));452 }453 }454 455 return res;456 }457 458 private static Type MakeTupleType(Type[] types, int start, int end)459 {460 int size = end - start;461 462 Type type = GetTupleType(size);463 if (type != null)464 {465 Type[] typeArr = new Type[type.GetGenericArguments().Length];466 int index = 0;467 for (int i = start; i < end; i++)468 {469 typeArr[index++] = types[i];470 }471 while (index < typeArr.Length)472 {473 typeArr[index++] = typeof(DynamicNull);474 }475 476 return type.MakeGenericType(typeArr);477 }478 479 int multiplier = 1;480 while (size > MutableTuple.MaxSize)481 {482 size = (size + MutableTuple.MaxSize - 1) / MutableTuple.MaxSize;483 multiplier *= MutableTuple.MaxSize;484 }485 486 type = MutableTuple.GetTupleType(size);487 Diagnostics.Assert(type != null, "type cannot be null");488 Type[] nestedTypes = new Type[type.GetGenericArguments().Length];489 for (int i = 0; i < size; i++)490 {491 int newStart = start + (i * multiplier);492 int newEnd = System.Math.Min(end, start + ((i + 1) * multiplier));493 nestedTypes[i] = MakeTupleType(types, newStart, newEnd);494 }495 496 for (int i = size; i < nestedTypes.Length; i++)497 {498 nestedTypes[i] = typeof(DynamicNull);499 }500 501 return type.MakeGenericType(nestedTypes);502 }503 504 public abstract int Capacity505 {506 get;507 }508 509 /// <summary>510 /// Provides an expression for creating a tuple with the specified values.511 /// </summary>512 public static Expression Create(params Expression[] values)513 {514 return CreateNew(MakeTupleType(values.Select(static x => x.Type).ToArray()), 0, values.Length, values);515 }516 517 private static int PowerOfTwoRound(int value)518 {519 int res = 1;520 while (value > res)521 {522 res <<= 1;523 }524 525 return res;526 }527 528 internal static Expression CreateNew(Type tupleType, int start, int end, Expression[] values)529 {530 int size = end - start;531 Diagnostics.Assert(tupleType != null, "tupleType cannot be null");532 Diagnostics.Assert(tupleType.IsSubclassOf(typeof(MutableTuple)), "tupleType must be derived from MutableTuple");533 534 Expression[] newValues;535 if (size > MutableTuple.MaxSize)536 {537 int multiplier = 1;538 while (size > MutableTuple.MaxSize)539 {540 size = (size + MutableTuple.MaxSize - 1) / MutableTuple.MaxSize;541 multiplier *= MutableTuple.MaxSize;542 }543 544 newValues = new Expression[PowerOfTwoRound(size)];545 for (int i = 0; i < size; i++)546 {547 int newStart = start + (i * multiplier);548 int newEnd = System.Math.Min(end, start + ((i + 1) * multiplier));549 550 PropertyInfo pi = tupleType.GetProperty("Item" + string.Create(CultureInfo.InvariantCulture, $"{i:D3}"));551 552 newValues[i] = CreateNew(pi.PropertyType, newStart, newEnd, values);553 }554 555 for (int i = size; i < newValues.Length; i++)556 {557 newValues[i] = Expression.Constant(null, typeof(DynamicNull));558 }559 }560 else561 {562 newValues = new Expression[PowerOfTwoRound(size)];563 for (int i = 0; i < size; i++)564 {565 newValues[i] = values[i + start];566 }567 568 for (int i = size; i < newValues.Length; i++)569 {570 newValues[i] = Expression.Constant(null, typeof(DynamicNull));571 }572 }573 574 return Expression.New(tupleType.GetConstructor(newValues.Select(static x => x.Type).ToArray()), newValues);575 }576 }577 578 #region Generated Tuples579 580 // *** BEGIN GENERATED CODE ***581 // generated by function: gen_tuples from: generate_tuples.py582 583 [GeneratedCode("DLR", "2.0")]584 internal class MutableTuple<T0> : MutableTuple585 {586 public MutableTuple() { }587 588 public MutableTuple(T0 item0)589 : base()590 {591 _item0 = item0;592 }593 594 private T0 _item0;595 596 public T0 Item000597 {598 get { return _item0; }599 600 set { _item0 = value; _valuesSet[0] = true; }601 }602 603 protected override object GetValueImpl(int index)604 {605 switch (index)606 {607 case 0: return Item000;608 default: throw new ArgumentOutOfRangeException("index");609 }610 }611 612 protected override void SetValueImpl(int index, object value)613 {614 switch (index)615 {616 case 0: Item000 = LanguagePrimitives.ConvertTo<T0>(value); break;617 default: throw new ArgumentOutOfRangeException("index");618 }619 }620 621 public override int Capacity622 {623 get624 {625 return 1;626 }627 }628 }629 630 [GeneratedCode("DLR", "2.0")]631 internal class MutableTuple<T0, T1> : MutableTuple<T0>632 {633 public MutableTuple() { }634 635 public MutableTuple(T0 item0, T1 item1)636 : base(item0)637 {638 _item1 = item1;639 }640 641 private T1 _item1;642 643 public T1 Item001644 {645 get { return _item1; }646 647 set { _item1 = value; _valuesSet[1] = true; }648 }649 650 protected override object GetValueImpl(int index)651 {652 switch (index)653 {654 case 0: return Item000;655 case 1: return Item001;656 default: throw new ArgumentOutOfRangeException("index");657 }658 }659 660 protected override void SetValueImpl(int index, object value)661 {662 switch (index)663 {664 case 0: Item000 = LanguagePrimitives.ConvertTo<T0>(value); break;665 case 1: Item001 = LanguagePrimitives.ConvertTo<T1>(value); break;666 default: throw new ArgumentOutOfRangeException("index");667 }668 }669 670 public override int Capacity671 {672 get673 {674 return 2;675 }676 }677 }678 679 [GeneratedCode("DLR", "2.0")]680 internal class MutableTuple<T0, T1, T2, T3> : MutableTuple<T0, T1>681 {682 public MutableTuple() { }683 684 public MutableTuple(T0 item0, T1 item1, T2 item2, T3 item3)685 : base(item0, item1)686 {687 _item2 = item2;688 _item3 = item3;689 }690 691 private T2 _item2;692 private T3 _item3;693 694 public T2 Item002695 {696 get { return _item2; }697 698 set { _item2 = value; _valuesSet[2] = true; }699 }700 701 public T3 Item003702 {703 get { return _item3; }704 705 set { _item3 = value; _valuesSet[3] = true; }706 }707 708 protected override object GetValueImpl(int index)709 {710 switch (index)711 {712 case 0: return Item000;713 case 1: return Item001;714 case 2: return Item002;715 case 3: return Item003;716 default: throw new ArgumentOutOfRangeException("index");717 }718 }719 720 protected override void SetValueImpl(int index, object value)721 {722 switch (index)723 {724 case 0: Item000 = LanguagePrimitives.ConvertTo<T0>(value); break;725 case 1: Item001 = LanguagePrimitives.ConvertTo<T1>(value); break;726 case 2: Item002 = LanguagePrimitives.ConvertTo<T2>(value); break;727 case 3: Item003 = LanguagePrimitives.ConvertTo<T3>(value); break;728 default: throw new ArgumentOutOfRangeException("index");729 }730 }731 732 public override int Capacity733 {734 get735 {736 return 4;737 }738 }739 }740 741 [GeneratedCode("DLR", "2.0")]742 internal class MutableTuple<T0, T1, T2, T3, T4, T5, T6, T7> : MutableTuple<T0, T1, T2, T3>743 {744 public MutableTuple() { }745 746 public MutableTuple(T0 item0, T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7)747 : base(item0, item1, item2, item3)748 {749 _item4 = item4;750 _item5 = item5;751 _item6 = item6;752 _item7 = item7;753 }754 755 private T4 _item4;756 private T5 _item5;757 private T6 _item6;758 private T7 _item7;759 760 public T4 Item004761 {762 get { return _item4; }763 764 set { _item4 = value; _valuesSet[4] = true; }765 }766 767 public T5 Item005768 {769 get { return _item5; }770 771 set { _item5 = value; _valuesSet[5] = true; }772 }773 774 public T6 Item006775 {776 get { return _item6; }777 778 set { _item6 = value; _valuesSet[6] = true; }779 }780 781 public T7 Item007782 {783 get { return _item7; }784 785 set { _item7 = value; _valuesSet[7] = true; }786 }787 788 protected override object GetValueImpl(int index)789 {790 switch (index)791 {792 case 0: return Item000;793 case 1: return Item001;794 case 2: return Item002;795 case 3: return Item003;796 case 4: return Item004;797 case 5: return Item005;798 case 6: return Item006;799 case 7: return Item007;800 default: throw new ArgumentOutOfRangeException("index");801 }802 }803 804 protected override void SetValueImpl(int index, object value)805 {806 switch (index)807 {808 case 0: Item000 = LanguagePrimitives.ConvertTo<T0>(value); break;809 case 1: Item001 = LanguagePrimitives.ConvertTo<T1>(value); break;810 case 2: Item002 = LanguagePrimitives.ConvertTo<T2>(value); break;811 case 3: Item003 = LanguagePrimitives.ConvertTo<T3>(value); break;812 case 4: Item004 = LanguagePrimitives.ConvertTo<T4>(value); break;813 case 5: Item005 = LanguagePrimitives.ConvertTo<T5>(value); break;814 case 6: Item006 = LanguagePrimitives.ConvertTo<T6>(value); break;815 case 7: Item007 = LanguagePrimitives.ConvertTo<T7>(value); break;816 default: throw new ArgumentOutOfRangeException("index");817 }818 }819 820 public override int Capacity821 {822 get823 {824 return 8;825 }826 }827 }828 829 [GeneratedCode("DLR", "2.0")]830 internal class MutableTuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> : MutableTuple<T0, T1, T2, T3, T4, T5, T6, T7>831 {832 public MutableTuple() { }833 834 public MutableTuple(T0 item0, T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7, T8 item8, T9 item9, T10 item10, T11 item11, T12 item12, T13 item13, T14 item14, T15 item15)835 : base(item0, item1, item2, item3, item4, item5, item6, item7)836 {837 _item8 = item8;838 _item9 = item9;839 _item10 = item10;840 _item11 = item11;841 _item12 = item12;842 _item13 = item13;843 _item14 = item14;844 _item15 = item15;845 }846 847 private T8 _item8;848 private T9 _item9;849 private T10 _item10;850 private T11 _item11;851 private T12 _item12;852 private T13 _item13;853 private T14 _item14;854 private T15 _item15;855 856 public T8 Item008857 {858 get { return _item8; }859 860 set { _item8 = value; _valuesSet[8] = true; }861 }862 863 public T9 Item009864 {865 get { return _item9; }866 867 set { _item9 = value; _valuesSet[9] = true; }868 }869 870 public T10 Item010871 {872 get { return _item10; }873 874 set { _item10 = value; _valuesSet[10] = true; }875 }876 877 public T11 Item011878 {879 get { return _item11; }880 881 set { _item11 = value; _valuesSet[11] = true; }882 }883 884 public T12 Item012885 {886 get { return _item12; }887 888 set { _item12 = value; _valuesSet[12] = true; }889 }890 891 public T13 Item013892 {893 get { return _item13; }894 895 set { _item13 = value; _valuesSet[13] = true; }896 }897 898 public T14 Item014899 {900 get { return _item14; }901 902 set { _item14 = value; _valuesSet[14] = true; }903 }904 905 public T15 Item015906 {907 get { return _item15; }908 909 set { _item15 = value; _valuesSet[15] = true; }910 }911 912 protected override object GetValueImpl(int index)913 {914 switch (index)915 {916 case 0: return Item000;917 case 1: return Item001;918 case 2: return Item002;919 case 3: return Item003;920 case 4: return Item004;921 case 5: return Item005;922 case 6: return Item006;923 case 7: return Item007;924 case 8: return Item008;925 case 9: return Item009;926 case 10: return Item010;927 case 11: return Item011;928 case 12: return Item012;929 case 13: return Item013;930 case 14: return Item014;931 case 15: return Item015;932 default: throw new ArgumentOutOfRangeException("index");933 }934 }935 936 protected override void SetValueImpl(int index, object value)937 {938 switch (index)939 {940 case 0: Item000 = LanguagePrimitives.ConvertTo<T0>(value); break;941 case 1: Item001 = LanguagePrimitives.ConvertTo<T1>(value); break;942 case 2: Item002 = LanguagePrimitives.ConvertTo<T2>(value); break;943 case 3: Item003 = LanguagePrimitives.ConvertTo<T3>(value); break;944 case 4: Item004 = LanguagePrimitives.ConvertTo<T4>(value); break;945 case 5: Item005 = LanguagePrimitives.ConvertTo<T5>(value); break;946 case 6: Item006 = LanguagePrimitives.ConvertTo<T6>(value); break;947 case 7: Item007 = LanguagePrimitives.ConvertTo<T7>(value); break;948 case 8: Item008 = LanguagePrimitives.ConvertTo<T8>(value); break;949 case 9: Item009 = LanguagePrimitives.ConvertTo<T9>(value); break;950 case 10: Item010 = LanguagePrimitives.ConvertTo<T10>(value); break;951 case 11: Item011 = LanguagePrimitives.ConvertTo<T11>(value); break;952 case 12: Item012 = LanguagePrimitives.ConvertTo<T12>(value); break;953 case 13: Item013 = LanguagePrimitives.ConvertTo<T13>(value); break;954 case 14: Item014 = LanguagePrimitives.ConvertTo<T14>(value); break;955 case 15: Item015 = LanguagePrimitives.ConvertTo<T15>(value); break;956 default: throw new ArgumentOutOfRangeException("index");957 }958 }959 960 public override int Capacity961 {962 get963 {964 return 16;965 }966 }967 }968 969 [GeneratedCode("DLR", "2.0")]970 internal class MutableTuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31> : MutableTuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>971 {972 public MutableTuple() { }973 974 public MutableTuple(T0 item0, T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7, T8 item8, T9 item9, T10 item10, T11 item11, T12 item12, T13 item13, T14 item14, T15 item15, T16 item16, T17 item17, T18 item18, T19 item19, T20 item20, T21 item21, T22 item22, T23 item23, T24 item24, T25 item25, T26 item26, T27 item27, T28 item28, T29 item29, T30 item30, T31 item31)975 : base(item0, item1, item2, item3, item4, item5, item6, item7, item8, item9, item10, item11, item12, item13, item14, item15)976 {977 _item16 = item16;978 _item17 = item17;979 _item18 = item18;980 _item19 = item19;981 _item20 = item20;982 _item21 = item21;983 _item22 = item22;984 _item23 = item23;985 _item24 = item24;986 _item25 = item25;987 _item26 = item26;988 _item27 = item27;989 _item28 = item28;990 _item29 = item29;991 _item30 = item30;992 _item31 = item31;993 }994 995 private T16 _item16;996 private T17 _item17;997 private T18 _item18;998 private T19 _item19;999 private T20 _item20;1000 private T21 _item21;1001 private T22 _item22;1002 private T23 _item23;1003 private T24 _item24;1004 private T25 _item25;1005 private T26 _item26;1006 private T27 _item27;1007 private T28 _item28;1008 private T29 _item29;1009 private T30 _item30;1010 private T31 _item31;1011 1012 public T16 Item0161013 {1014 get { return _item16; }1015 1016 set { _item16 = value; _valuesSet[16] = true; }1017 }1018 1019 public T17 Item0171020 {1021 get { return _item17; }1022 1023 set { _item17 = value; _valuesSet[17] = true; }1024 }1025 1026 public T18 Item0181027 {1028 get { return _item18; }1029 1030 set { _item18 = value; _valuesSet[18] = true; }1031 }1032 1033 public T19 Item0191034 {1035 get { return _item19; }1036 1037 set { _item19 = value; _valuesSet[19] = true; }1038 }1039 1040 public T20 Item0201041 {1042 get { return _item20; }1043 1044 set { _item20 = value; _valuesSet[20] = true; }1045 }1046 1047 public T21 Item0211048 {1049 get { return _item21; }1050 1051 set { _item21 = value; _valuesSet[21] = true; }1052 }1053 1054 public T22 Item0221055 {1056 get { return _item22; }1057 1058 set { _item22 = value; _valuesSet[22] = true; }1059 }1060 1061 public T23 Item0231062 {1063 get { return _item23; }1064 1065 set { _item23 = value; _valuesSet[23] = true; }1066 }1067 1068 public T24 Item0241069 {1070 get { return _item24; }1071 1072 set { _item24 = value; _valuesSet[24] = true; }1073 }1074 1075 public T25 Item0251076 {1077 get { return _item25; }1078 1079 set { _item25 = value; _valuesSet[25] = true; }1080 }1081 1082 public T26 Item0261083 {1084 get { return _item26; }1085 1086 set { _item26 = value; _valuesSet[26] = true; }1087 }1088 1089 public T27 Item0271090 {1091 get { return _item27; }1092 1093 set { _item27 = value; _valuesSet[27] = true; }1094 }1095 1096 public T28 Item0281097 {1098 get { return _item28; }1099 1100 set { _item28 = value; _valuesSet[28] = true; }1101 }1102 1103 public T29 Item0291104 {1105 get { return _item29; }1106 1107 set { _item29 = value; _valuesSet[29] = true; }1108 }1109 1110 public T30 Item0301111 {1112 get { return _item30; }1113 1114 set { _item30 = value; _valuesSet[30] = true; }1115 }1116 1117 public T31 Item0311118 {1119 get { return _item31; }1120 1121 set { _item31 = value; _valuesSet[31] = true; }1122 }1123 1124 protected override object GetValueImpl(int index)1125 {1126 switch (index)1127 {1128 case 0: return Item000;1129 case 1: return Item001;1130 case 2: return Item002;1131 case 3: return Item003;1132 case 4: return Item004;1133 case 5: return Item005;1134 case 6: return Item006;1135 case 7: return Item007;1136 case 8: return Item008;1137 case 9: return Item009;1138 case 10: return Item010;1139 case 11: return Item011;1140 case 12: return Item012;1141 case 13: return Item013;1142 case 14: return Item014;1143 case 15: return Item015;1144 case 16: return Item016;1145 case 17: return Item017;1146 case 18: return Item018;1147 case 19: return Item019;1148 case 20: return Item020;1149 case 21: return Item021;1150 case 22: return Item022;1151 case 23: return Item023;1152 case 24: return Item024;1153 case 25: return Item025;1154 case 26: return Item026;1155 case 27: return Item027;1156 case 28: return Item028;1157 case 29: return Item029;1158 case 30: return Item030;1159 case 31: return Item031;1160 default: throw new ArgumentOutOfRangeException("index");1161 }1162 }1163 1164 protected override void SetValueImpl(int index, object value)1165 {1166 switch (index)1167 {1168 case 0: Item000 = LanguagePrimitives.ConvertTo<T0>(value); break;1169 case 1: Item001 = LanguagePrimitives.ConvertTo<T1>(value); break;1170 case 2: Item002 = LanguagePrimitives.ConvertTo<T2>(value); break;1171 case 3: Item003 = LanguagePrimitives.ConvertTo<T3>(value); break;1172 case 4: Item004 = LanguagePrimitives.ConvertTo<T4>(value); break;1173 case 5: Item005 = LanguagePrimitives.ConvertTo<T5>(value); break;1174 case 6: Item006 = LanguagePrimitives.ConvertTo<T6>(value); break;1175 case 7: Item007 = LanguagePrimitives.ConvertTo<T7>(value); break;1176 case 8: Item008 = LanguagePrimitives.ConvertTo<T8>(value); break;1177 case 9: Item009 = LanguagePrimitives.ConvertTo<T9>(value); break;1178 case 10: Item010 = LanguagePrimitives.ConvertTo<T10>(value); break;1179 case 11: Item011 = LanguagePrimitives.ConvertTo<T11>(value); break;1180 case 12: Item012 = LanguagePrimitives.ConvertTo<T12>(value); break;1181 case 13: Item013 = LanguagePrimitives.ConvertTo<T13>(value); break;1182 case 14: Item014 = LanguagePrimitives.ConvertTo<T14>(value); break;1183 case 15: Item015 = LanguagePrimitives.ConvertTo<T15>(value); break;1184 case 16: Item016 = LanguagePrimitives.ConvertTo<T16>(value); break;1185 case 17: Item017 = LanguagePrimitives.ConvertTo<T17>(value); break;1186 case 18: Item018 = LanguagePrimitives.ConvertTo<T18>(value); break;1187 case 19: Item019 = LanguagePrimitives.ConvertTo<T19>(value); break;1188 case 20: Item020 = LanguagePrimitives.ConvertTo<T20>(value); break;1189 case 21: Item021 = LanguagePrimitives.ConvertTo<T21>(value); break;1190 case 22: Item022 = LanguagePrimitives.ConvertTo<T22>(value); break;1191 case 23: Item023 = LanguagePrimitives.ConvertTo<T23>(value); break;1192 case 24: Item024 = LanguagePrimitives.ConvertTo<T24>(value); break;1193 case 25: Item025 = LanguagePrimitives.ConvertTo<T25>(value); break;1194 case 26: Item026 = LanguagePrimitives.ConvertTo<T26>(value); break;1195 case 27: Item027 = LanguagePrimitives.ConvertTo<T27>(value); break;1196 case 28: Item028 = LanguagePrimitives.ConvertTo<T28>(value); break;1197 case 29: Item029 = LanguagePrimitives.ConvertTo<T29>(value); break;1198 case 30: Item030 = LanguagePrimitives.ConvertTo<T30>(value); break;1199 case 31: Item031 = LanguagePrimitives.ConvertTo<T31>(value); break;1200 default: throw new ArgumentOutOfRangeException("index");