public IListSource<LNode> Parse(IListSource<Token> input, ISourceFile file, IMessageSink msgs, Symbol inputType = null) { // For efficiency we'd prefer to re-use our _parser object, but // when parsing lazily, we can't re-use it because another parsing // operation could start before this one is finished. To force // greedy parsing, we can call ParseStmtsGreedy(), but the caller may // prefer lazy parsing, especially if the input is large. As a // compromise I'll check if the source file is larger than a // certain arbitrary size. Also, ParseExprs() is always greedy // so we can always re-use _parser in that case. bool exprMode = inputType == ParsingService.Exprs; char _ = '\0'; if (inputType == ParsingService.Exprs || file.Text.TryGet(255, ref _)) { EcsParser parser = _parser; if (parser == null) _parser = parser = new EcsParser(input, file, msgs); else { parser.ErrorSink = msgs ?? MessageSink.Current; parser.Reset(input, file); } if (inputType == ParsingService.Exprs) return parser.ParseExprs(); else return parser.ParseStmtsGreedy(); } else { var parser = new EcsParser(input, file, msgs); return parser.ParseStmtsLazy().Buffered(); } }
protected override VList<LNode> AttachTriviaTo(ref LNode node, IListSource<Token> trivia, TriviaLocation loc, LNode parent, int indexInParent) { int nli; if (loc == TriviaLocation.Trailing && indexInParent == 1 && parent != null && parent.Calls(CodeSymbols.If, 3) && (nli = trivia.LastIndexWhere(t => t.Type() == TokenType.Newline)) != -1) { // The 'else' keyword is invisible here, but it often appears on a line by // itself; remove a newline to avoid creating a blank line when printing. var triviaSans = new DList<Token>(trivia); triviaSans.RemoveAt(nli); trivia = triviaSans; } return base.AttachTriviaTo(ref node, trivia, loc, parent, indexInParent); }
/// <summary> /// 重写 <see cref="GridView"/>.OnDataBinding 事件 /// </summary> /// <param name="e"></param> protected override void OnDataBinding(EventArgs e) { IListSource listSource = this.DataSource as IListSource; if (listSource != null) { base.RecordCount = listSource.GetList().Count; } else { ICollection collection = this.DataSource as ICollection; if (collection != null) { base.RecordCount = collection.Count; } } base.OnDataBinding(e); }
public void WriteData(AMFWriter writer, object data) { if (data is IList) { IList list = data as IList; object[] array = new object[list.Count]; list.CopyTo(array, 0); writer.WriteArray(ObjectEncoding.AMF0, array); return; } #if !(SILVERLIGHT) IListSource listSource = data as IListSource; if (listSource != null) { IList list = listSource.GetList(); object[] array = new object[list.Count]; list.CopyTo(array, 0); writer.WriteArray(ObjectEncoding.AMF0, array); return; } #endif if (data is IDictionary) { writer.WriteAssociativeArray(ObjectEncoding.AMF0, data as IDictionary); return; } if (data is Exception) { writer.WriteASO(ObjectEncoding.AMF0, new ExceptionASO(data as Exception)); return; } if (data is IEnumerable) { List <object> tmp = new List <object>(); foreach (object element in (data as IEnumerable)) { tmp.Add(element); } writer.WriteArray(ObjectEncoding.AMF0, tmp.ToArray()); return; } writer.WriteObject(ObjectEncoding.AMF0, data); }
protected void DrawDataBoundMember(Graphics g, Brush brush, int index, Point point) { string text = string.Empty; if (DataSource != null) { IList list = null; // We coud be bound to an array list which implement the IList interface // or we could be bound to a DataSet which implements the IListSource from which // we can get the IList interface if (DataSource is IList) { // Assume this is an array object and try to get the data based // on this assumption list = (IList)DataSource; Debug.Assert(list != null, "ComboBox is bound to unrecognized DataSource"); // Now extract the actual text to be displayed object o = list[index]; Type objectType = o.GetType(); // Now invoke the method that is associate with the // Display name property of the ComboBox PropertyInfo pi = objectType.GetProperty(DisplayMember); text = (string)pi.GetValue(o, null); } else { // Data set object if (DataSource is IListSource) { IListSource ls = (IListSource)DataSource; list = ls.GetList(); Debug.Assert(list != null, "ComboBox is bound to unrecognized DataSource"); // This is a data set object, get the value under that assumption DataRowView dataRowView = (DataRowView)list[index]; DataRow dataRow = dataRowView.Row; object o = dataRow[DisplayMember]; text = o.ToString(); } } g.DrawString(text, Font, brush, point); } }
static void Main(string[] args) { Console.WriteLine( "Welcome to EC# parser demo.\n\n" + "Please type a valid C# or EC# statement such as x = 7; or class Man:Beast {}\n" + "or while(true) Console.WriteLine(\"I'm not crazy!\"); (or exit to quit).\n"); Console.WriteLine( "The parser produces Loyc trees, and they are printed out using the default\n" + "printer which is the LES printer.\n"); Console.WriteLine( "The parser was ripped out of Loyc.Ecs.dll for this demo. Loyc.Ecs.dll, unlike \n" + "this demo, also contains the EC# printer (which LLLPG uses to write output).\n"); Console.WriteLine( "Exercise for the reader: write a REPL for C#. Just kidding.\n"); string line; while ((line = Console.ReadLine()) != "exit") { while (line.EndsWith(" ")) // user can add additional lines this way { line += "\n" + Console.ReadLine(); } try { // Parse EC#! IListSource <LNode> stmts = EcsLanguageService.Value.Parse(line, MessageSink.Console); // If you'd like to parse LES instead of EC#, write this instead: // IListSource<LNode> stmts = Loyc.Syntax.Les.LesLanguageService.Value.Parse(line, MessageSink.Console); var c = Console.ForegroundColor; Console.ForegroundColor = ConsoleColor.Cyan; foreach (var stmt in stmts) { Console.WriteLine("Syntax tree (LES format): " + stmt.ToString()); } Console.ForegroundColor = c; } catch (Exception ex) { Console.WriteLine(ex.GetType().Name + ": " + ex.Message); } Console.WriteLine(); } }
public static IEnumerable GetDataMember(IListSource dataSource, string dataMember) { IEnumerable enumerable = null; IList list = dataSource.GetList(); if ((list != null) && (list is ITypedList)) { if (!dataSource.ContainsListCollection) { if ((dataMember != null) && (dataMember.Length != 0)) { throw new ArgumentException(System.Design.SR.GetString("DesignTimeData_BadDataMember")); } return(list); } PropertyDescriptorCollection itemProperties = ((ITypedList)list).GetItemProperties(new PropertyDescriptor[0]); if ((itemProperties == null) || (itemProperties.Count == 0)) { return(enumerable); } PropertyDescriptor descriptor = null; if ((dataMember == null) || (dataMember.Length == 0)) { descriptor = itemProperties[0]; } else { descriptor = itemProperties.Find(dataMember, true); } if (descriptor != null) { object component = list[0]; object obj3 = descriptor.GetValue(component); if ((obj3 != null) && (obj3 is IEnumerable)) { enumerable = (IEnumerable)obj3; } } } return(enumerable); }
protected virtual void OnSourceChanged(IListSource <T> source) { BeginUpdate(); Items.Clear(); if (_imageList != null) { _imageList.Images.Clear(); } if (_currentSource != null) { Bitmap bmp; int index = 0; T[] items = _currentSource.ListItems; if (items != null) { foreach (T item in items) { item.ImageIndex = -1; if (item is TextureDefinition) { if ((bmp = (item as TextureDefinition).Texture) != null) { ImageList.Images.Add(bmp); item.ImageIndex = index++; } } Items.Add(item); } } } else { SelectedResource = null; } EndUpdate(); }
public static IEnumerable GetSelectedDataSource(IComponent component, string dataSource, string dataMember) { IEnumerable enumerable = null; object selectedDataSource = GetSelectedDataSource(component, dataSource); if (selectedDataSource == null) { return(enumerable); } IListSource source = selectedDataSource as IListSource; if (source != null) { if (!source.ContainsListCollection) { return(source.GetList()); } return(GetDataMember(source, dataMember)); } return((IEnumerable)selectedDataSource); }
static void WriteData(ref TextBox text, IListSource sources) { text.Text = "正在加载数据...."; if (sources != null) { System.Collections.IList list = sources.GetList(); if (list != null && list.Count > 0) { StringBuilder sb = new StringBuilder(); for (int i = 0; i < list.Count; i++) { object obj = list[i]; if (obj != null) { sb.AppendLine(string.Format("{0}.{1}", i + 1, obj)); } } text.Text = sb.ToString(); } } }
public void OnListChanging(IListSource <T> sender, ListChangeInfo <T> e) { if (_parent is IListChanging <T> ) { (_parent as IListChanging <T>).OnListChanging(sender, e); } int addCount = e.NewItems.Count; int removeCount = addCount - e.SizeChange; for (int i = e.Index; i < e.Index + removeCount; i++) { try { _list[i].OnBeingRemoved(_parent); // could throw } catch { // Notify earlier items that changes are being "undone" for (int j = e.Index; j < i; j++) { try { _list[i].OnBeingAdded(_parent); } catch { } } throw; } } for (int i = 0; i < addCount; i++) { try { e.NewItems[i].OnBeingAdded(_parent); // could throw } catch { // Notify children that changes are being "undone" for (int j = 0; j < i; j++) { try { e.NewItems[j].OnBeingRemoved(_parent); } catch { } } for (int j = e.Index; j < e.Index + removeCount; j++) { try { _list[i].OnBeingAdded(_parent); } catch { } } throw; } } }
public IListSource <LNode> Parse(IListSource <Token> input, ISourceFile file, IMessageSink msgs, Symbol inputType = null) { // For efficiency we'd prefer to re-use our _parser object, but // when parsing lazily, we can't re-use it because another parsing // operation could start before this one is finished. To force // greedy parsing, we can call ParseStmtsGreedy(), but the caller may // prefer lazy parsing, especially if the input is large. As a // compromise I'll check if the source file is larger than a // certain arbitrary size. Also, ParseExprs() is always greedy // so we can always re-use _parser in that case. bool exprMode = inputType == ParsingService.Exprs; char _ = '\0'; if (inputType == ParsingService.Exprs || file.Text.TryGet(255, ref _)) { LesParser parser = _parser; if (parser == null) { _parser = parser = new LesParser(input, file, msgs); } else { parser.MessageSink = msgs; parser.Reset(input, file); } if (inputType == ParsingService.Exprs) { return(parser.ParseExprs()); } else { return(parser.ParseStmtsGreedy()); } } else { var parser = new LesParser(input, file, msgs); return(parser.ParseStmtsLazy().Buffered()); } }
public static IEnumerable GetDataMember(IListSource dataSource, string dataMember) { IEnumerable enumerable = null; IList list = dataSource.GetList(); if ((list != null) && (list is ITypedList)) { if (!dataSource.ContainsListCollection) { if ((dataMember != null) && (dataMember.Length != 0)) { throw new ArgumentException(System.Design.SR.GetString("DesignTimeData_BadDataMember")); } return list; } PropertyDescriptorCollection itemProperties = ((ITypedList) list).GetItemProperties(new PropertyDescriptor[0]); if ((itemProperties == null) || (itemProperties.Count == 0)) { return enumerable; } PropertyDescriptor descriptor = null; if ((dataMember == null) || (dataMember.Length == 0)) { descriptor = itemProperties[0]; } else { descriptor = itemProperties.Find(dataMember, true); } if (descriptor != null) { object component = list[0]; object obj3 = descriptor.GetValue(component); if ((obj3 != null) && (obj3 is IEnumerable)) { enumerable = (IEnumerable) obj3; } } } return enumerable; }
private List <string> GetColumns(object source) { List <string> result; // first handle DataSet/DataTable object innerSource; IListSource iListSource = source as IListSource; if (iListSource != null) { innerSource = iListSource.GetList(); } else { innerSource = source; } DataView dataView = innerSource as DataView; if (dataView != null) { result = ScanDataView(dataView); } else { // now handle lists/arrays/collections IEnumerable iEnumerable = innerSource as IEnumerable; if (iEnumerable != null) { Type childType = Utilities.GetChildItemType( innerSource.GetType()); result = ScanObject(childType); } else { // the source is a regular object result = ScanObject(innerSource.GetType()); } } return(result); }
public static IEnumerable ToIEnumerable(Object dataSource) { if (dataSource == null) { return(null); } if (dataSource is IListSource) { IListSource source = (IListSource)dataSource; IList list = source.GetList(); if (!source.ContainsListCollection) { return(list); } if ((list != null) && (list is ITypedList)) { PropertyDescriptorCollection itemProperties = ((ITypedList)list).GetItemProperties(new PropertyDescriptor[0]); if ((itemProperties == null) || (itemProperties.Count == 0)) { return(null); } PropertyDescriptor descriptor = itemProperties[0]; if (descriptor != null) { Object component = list[0]; Object value = descriptor.GetValue(component); if ((value != null) && (value is IEnumerable)) { return((IEnumerable)value); } } return(null); } } if (dataSource is IEnumerable) { return((IEnumerable)dataSource); } return(null); }
public IListSource <LNode> Parse(IListSource <Token> input, ISourceFile file, IMessageSink msgs, IParsingOptions options) { // For efficiency we'd prefer to re-use our _parser object, but // when parsing lazily, we can't re-use it because another parsing // operation could start before this one is finished. To force // greedy parsing, we can call ParseStmtsGreedy(), but the caller may // prefer lazy parsing, especially if the input is large. As a // compromise I'll check if the source file is larger than a // certain arbitrary size. Also, ParseExprs() is always greedy // so we can always re-use _parser in that case. bool exprMode = options.Mode == ParsingMode.Expressions; if (options.Mode == ParsingMode.Expressions || file.Text.TryGet(255).HasValue) { Les2Parser parser = _parser; if (parser == null) { _parser = parser = new Les2Parser(input, file, msgs); } else { parser.ErrorSink = msgs; parser.Reset(input.AsList(), file); } if (options.Mode == ParsingMode.Expressions) { return(parser.ExprList()); } else { return(parser.Start(new Holder <TokenType>(TokenType.Semicolon)).Buffered()); } } else { var parser = new Les2Parser(input, file, msgs); return(parser.Start(new Holder <TokenType>(TokenType.Semicolon)).Buffered()); } }
private List <string> GetColumns(object source) { List <string> result; object innerSource; IListSource iListSource = source as IListSource; if (iListSource != null) { innerSource = iListSource.GetList(); } else { innerSource = source; } DataView dataView = innerSource as DataView; if (dataView != null) { result = ScanDataView(dataView); } else { IEnumerable iEnumerable = innerSource as IEnumerable; if (iEnumerable != null) { Type childType = Utilities.GetChildItemType( innerSource.GetType()); result = ScanObject(childType); } else { result = ScanObject(innerSource.GetType()); } } return(result); }
// To recognize a scribble we require the simplified line to reverse // direction at least three times. There are separate criteria for // erasing a shape currently being drawn and for erasing existing // shapes. // // The key difference between an "erase scribble" and a "cancel // scribble" is that an erase scribble starts out as such, while // a cancel scribble indicates that the user changed his mind, so // the line will not appear to be a scribble at the beginning. // The difference is detected by timestamps. For example, the // following diagram represents an "erase" operation and a "cancel" // operation. Assume the input points are evenly spaced in time, // and that the dots represent points where the input reversed // direction. // // Input points .......................... // Reversals (erase) . . . . . . // Reversals (cancel) . . . . // // So, a scribble is considered an erasure if it satisfies t0 < t1, // where t0 is the time between mouse-down and the first reversal, // and t1 is the time between the first and third reversals. A cancel // operation satisfies t0 > t1 instead. // // Both kinds of scribble need to satisfy the formula LL*c > CHA, // where c is a constant factor in pixels, LL is the drawn line // length and CHA is the area of the Convex Hull that outlines the // drawn figure. This formula basically detects that the user // is convering the same ground repeatedly; if the pen reverses // direction repeatedly but goes to new places each time, it's not // considered an erasure scribble. For a cancel scribble, LL is // computed starting from the first reversal. IEnumerable <Shape> RecognizeScribbleForEraseOrCancel(DragState state, out bool cancel, out List <PointT> simplifiedSS) { cancel = false; simplifiedSS = null; var tolerance = state._inputTransform.Transform(new VectorT(0, 10)).Length(); var simplifiedMP = LineMath.SimplifyPolyline( state.UnfilteredMousePoints.Select(p => p.Point), tolerance); List <int> reversals = FindReversals(simplifiedMP, 3); if (reversals.Count >= 3) { simplifiedSS = simplifiedMP.Select(p => state._inputTransform.Transform(p)).ToList(); // 3 reversals confirmed. Now decide: erase or cancel? int[] timeStampsMs = FindTimeStamps(state.UnfilteredMousePoints, simplifiedMP); int t0 = timeStampsMs[reversals[0]], t1 = timeStampsMs[reversals[2]] - t0; cancel = t0 > t1 + 500; // Now test the formula LL*c > CHA as explained above IListSource <PointT> simplifiedMP_ = cancel ? simplifiedMP.Slice(reversals[0]) : simplifiedMP.AsListSource(); float LL = simplifiedMP_.AdjacentPairs().Sum(pair => pair.A.Sub(pair.B).Length()); var hull = PointMath.ComputeConvexHull(simplifiedMP); float CHA = PolygonMath.PolygonArea(hull); if (LL * EraseNubWidth > CHA) { // Erasure confirmed. if (cancel) { return(EmptyList <Shape> .Value); } // Figure out which shapes to erase. To do this, we compute for // each shape the amount of the scribble that overlaps that shape. var simplifiedSS_ = simplifiedSS; return(_doc.Shapes.Where(s => ShouldErase(s, simplifiedSS_)).ToList()); } } return(null); }
/// <summary> /// /// </summary> /// <param name="dataTable"></param> /// <returns></returns> protected virtual string CreateValuesString(IListSource dataTable) { DataTable dt = (DataTable)dataTable; var rowStrList = new List <string>(); foreach (var row in dt.Rows) { var colStrList = new List <string>(); foreach (var col in dt.Columns) { if (((DataColumn)col).DataType == typeof(String)) { colStrList.Add($"'{((DataRow)row)[((DataColumn)col).ColumnName].ToString()}'"); } else { colStrList.Add(((DataRow)row)[((DataColumn)col).ColumnName].ToString()); } } rowStrList.Add($"({string.Join(",", colStrList)})"); } return(string.Join(",", rowStrList)); }
public override AListNode <int, T> InsertRange(uint index, IListSource <T> source, ref int sourceIndex, out AListNode <int, T> splitRight, IAListTreeObserver <int, T> tob) { Debug.Assert(!IsFrozen); Entry e; int i = PrepareToInsertAt(index + (uint)sourceIndex, out e, tob); // Perform the insert int oldSourceIndex = sourceIndex; AListNode <int, T> splitLeft; do { splitLeft = e.Node.InsertRange(index - e.Index, source, ref sourceIndex, out splitRight, tob); } while (sourceIndex < source.Count && splitLeft == null); // Adjust base index of nodes that follow int change = sourceIndex - oldSourceIndex; AdjustIndexesAfter(i, change); // Handle child split return(splitLeft == null ? null : HandleChildSplit(i, splitLeft, ref splitRight, tob)); }
///<para>データをインサートします。</para> /// <para>指定したキーでデータが存在する場合、キー以外をアップデートする。</para> /// </summary> /// <param name="dataTable"></param> /// <returns>影響のあった行数(エラーの場合は-1を返却)</returns> public virtual int ExecuteDuplicateInsert(IListSource dataTable) { if (Status() != ConnectionState.Open) { if (Connect()) { return(-1); } } DataTable dt = (DataTable)dataTable; #region クエリ string query = $@"INSERT INTO {dt.TableName} ({CreateColumnsString(dataTable)}) VALUES {CreateValuesString(dataTable)} ON DUPLICATE KEY UPDATE {CreateDuplicateUpdateString(dataTable)};"; #endregion return(InsertOrUpdateOrDelete(query)); }
public static string[] GetDataMembers(object dataSource) { IListSource source = dataSource as IListSource; if ((source != null) && source.ContainsListCollection) { ITypedList list = ((IListSource)dataSource).GetList() as ITypedList; if (list != null) { PropertyDescriptorCollection itemProperties = list.GetItemProperties(new PropertyDescriptor[0]); if (itemProperties != null) { ArrayList list3 = new ArrayList(itemProperties.Count); foreach (PropertyDescriptor descriptor in itemProperties) { list3.Add(descriptor.Name); } return((string[])list3.ToArray(typeof(string))); } } } return(null); }
public static int CopyTo <T>(this IListSource <T> c, T[] array, int arrayIndex) { int space = array.Length - arrayIndex; int count = c.Count; if (space < count) { if ((uint)arrayIndex >= (uint)count) { throw new ArgumentOutOfRangeException("arrayIndex"); } else { throw new ArgumentException(string.Format("CopyTo: array is too small ({0} < {1})", space, count)); } } for (int i = 0; i < count; i++) { array[arrayIndex + i] = c[i]; } return(arrayIndex + count); }
public ListRegion(IListSource <T> source) { m_source = source; source.Updated += () => { m_scrollY = 0; SelectedSourceIndex = null; Layout(); }; OnWheel += (_, delta) => { if (delta < 0) { ScrollY += ItemHeight * 2; } else { ScrollY -= ItemHeight * 2; } if (ScrollY < 0) { ScrollY = 0; } else if (ScrollY > MaxScrollY) { ScrollY = MaxScrollY; } Layout(); }; ItemLeftClicked += (i, content) => { // Todo: select }; }
public EcsTriviaInjector(IListSource<Token> sortedTrivia, ISourceFile sourceFile, int newlineTypeInt, string mlCommentPrefix, string mlCommentSuffix, string slCommentPrefix) : base(sortedTrivia, sourceFile, newlineTypeInt, mlCommentPrefix, mlCommentSuffix, slCommentPrefix) { }
public ListSourceDataSourceItem(string dataSourceName, IListSource runtimeListSource) : base(dataSourceName, null) { this.runtimeListSource = runtimeListSource; }
public ReversedListSource(IListSource <T> list) { _list = list; }
public SelectNegListSources(IListSource <T> list) { _list = list; }
/// <summary>Inserts a list of items at the specified index. This method /// may not insert all items at once, so there is a sourceIndex parameter /// which points to the next item to be inserted. When sourceIndex reaches /// source.Count, the insertion is complete.</summary> /// <param name="index">The index at which to insert the contents of /// source. Important: if sourceIndex > 0, insertion of the remaining /// items starts at [index + sourceIndex].</param> /// <returns>Returns non-null if the node is split, as explained /// in the documentation of <see cref="Insert"/>.</returns> /// <remarks>This method can only be called for ALists, since other tree /// types don't allow insertion at a specific index.</remarks> /// <exception cref="NotSupportedException">This node does not allow insertion at an arbitrary location (e.g. BList node).</exception> public virtual AListNode <K, T> InsertRange(uint index, IListSource <T> source, ref int sourceIndex, out AListNode <K, T> splitRight, IAListTreeObserver <K, T> tob) { throw new NotSupportedException(); }
public ListSourceAsSparse(Loyc.Collections.IListSource <T> list) { _list = list; }
static LNode Single(IListSource<LNode> e) { LNode node = e.TryGet(0, null); if (node == null) throw new InvalidOperationException(Localize.Localized("ParseSingle: result was empty.")); if (e.TryGet(1, null) != null) // don't call Count because e is typically Buffered() throw new InvalidOperationException(Localize.Localized("ParseSingle: multiple parse results.")); return node; }
public IListSource<DragPoint> ToShapeSpace(IListSource<DragPoint> mousePoints) { return mousePoints.Select(dp => new DragPoint(dp, _inputTransform)); }
private static int[] FindTimeStamps(IListSource<DragPoint> original, List<PointT> simplified) { int o = -1, timeMs = 0; int[] times = new int[simplified.Count]; for (int s = 0; s < simplified.Count; s++) { var p = simplified[s]; do { o++; timeMs += original[o].MsecSincePrev; } while (original[o].Point != p); times[s] = timeMs; } return times; }
protected static void ExpectList <T>(IListSource <T> list, bool useEnumerator, params T[] expected) { ExpectList(list, expected as IList <T>, useEnumerator); }
/// <summary>Treats a non-sparse list as a read-only sparse list with no empty /// spaces.</summary> public static ListSourceAsSparse <T> AsSparse <T>(this IListSource <T> list) { return(new ListSourceAsSparse <T>(list)); }
public Vector(IListSource values) : this(values.GetList()) { }
public EcsTriviaInjector(IListSource <Token> sortedTrivia, ISourceFile sourceFile, int newlineTypeInt, string mlCommentPrefix, string mlCommentSuffix, string slCommentPrefix, bool topLevelIsBlock) : base(sortedTrivia, sourceFile, newlineTypeInt, mlCommentPrefix, mlCommentSuffix, slCommentPrefix, topLevelIsBlock) { }
public static IEnumerable GetDataMember (IListSource dataSource, string dataMember) { throw new NotImplementedException (); }
public static SelectNegListSources <T> NegLists <T>(this IListSource <T> source) { return(new SelectNegListSources <T>(source)); }
public SampleVector(IListSource values) : base(values) { }
// Resolves the "ambiguity" between IListSource[i] and IList[i]. protected static T At <T>(IListSource <T> list, int i) { return(list[i]); }
public IListSource<LNode> Parse(IListSource<Token> input, ISourceFile file, IMessageSink msgs, ParsingMode inputType = null) { // For efficiency we'd prefer to re-use our _parser object, but // when parsing lazily, we can't re-use it because another parsing // operation could start before this one is finished. To force // greedy parsing, we can call ParseStmtsGreedy(), but the caller may // prefer lazy parsing, especially if the input is large. As a // compromise I'll check if the source file is larger than a // certain arbitrary size. Also, ParseExprs() is always greedy // so we can always re-use _parser in that case. char _ = '\0'; if (file.Text.TryGet(255, ref _) || inputType == ParsingMode.FormalArguments || inputType == ParsingMode.Types || inputType == ParsingMode.Expressions) { EcsParser parser = _parser; if (parser == null) _parser = parser = new EcsParser(input, file, msgs); else { parser.ErrorSink = msgs ?? MessageSink.Default; parser.Reset(input, file); } if (inputType == ParsingMode.Expressions) return parser.ParseExprs(false, allowUnassignedVarDecl: false); else if (inputType == ParsingMode.FormalArguments) return parser.ParseExprs(false, allowUnassignedVarDecl: true); else if (inputType == ParsingMode.Types) return LNode.List(parser.DataType()); else return parser.ParseStmtsGreedy(); } else { var parser = new EcsParser(input, file, msgs); return parser.ParseStmtsLazy().Buffered(); } }
internal static IEnumerable GetResolvedDataSource(Object dataSource, String dataMember) { if (dataSource == null) { return(null); } IListSource listSource = dataSource as IListSource; if (listSource != null) { IList memberList = listSource.GetList(); if (listSource.ContainsListCollection == false) { // The returned list is itself the list we need to bind to. // (Ignore DataMember parameter.) return((IEnumerable)memberList); } if ((memberList != null) && (memberList is ITypedList)) { ITypedList typedMemberList = (ITypedList)memberList; PropertyDescriptorCollection propDescs = typedMemberList.GetItemProperties(new PropertyDescriptor[0]); if ((propDescs != null) && (propDescs.Count != 0)) { PropertyDescriptor listProperty = null; if ((dataMember == null) || (dataMember.Length == 0)) { listProperty = propDescs[0]; } else { listProperty = propDescs.Find(dataMember, true); } if (listProperty != null) { Object listRow = memberList[0]; Object list = listProperty.GetValue(listRow); if ((list != null) && (list is IEnumerable)) { return((IEnumerable)list); } } throw new ArgumentException( SR.GetString(SR.DataSourceHelper_MissingDataMember, dataMember)); } else { throw new ArgumentException( SR.GetString(SR.DataSourceHelper_DataSourceWithoutDataMember, "List DataSource")); } } } if (dataSource is IEnumerable) { return((IEnumerable)dataSource); } return(null); }
internal ListSourceDataSourceItem(string dataSourceName, IListSource runtimeListSource) : base(dataSourceName, null) { this._runtimeListSource = runtimeListSource; }