private static Guid[] GetChainFromStrings(SequenceParserType parent, string[] strings) { List <Guid> reference = new List <Guid>(); if (parent != null) { if (strings.Length == 0) { throw new ArgumentException(CANAPE.Parser.Properties.Resources.MemberEntryReference_InvalidChain); } foreach (string s in strings) { MemberEntry entry = parent.FindMember(s); if (entry != null) { reference.Add(entry.Uuid); } else { // Could not find entry throw new ArgumentException(String.Format(CANAPE.Parser.Properties.Resources.MemberEntryReference_CouldNotFindMember, s)); } } } else { throw new ArgumentNullException("parent"); } return(reference.ToArray()); }
internal ParserType GetReference(string reference) { ParserType ret = null; string[] vals = reference.Split('/'); if (Parent != null) { SequenceParserType currParent = Parent; for (int i = 0; i < vals.Length - 1; ++i) { MemberEntry ent = currParent.FindMember(vals[i]); SequenceParserType s = ent.BaseType as SequenceParserType; if (s == null) { currParent = null; break; } else { currParent = s; } } if (currParent != null) { MemberEntry ent = currParent.FindMember(vals[vals.Length - 1]); } } return(ret); }
/// <summary> /// Replace an exist member /// </summary> /// <param name="oldEntry">The old entry to replace</param> /// <param name="newEntry">The new entry to replace with</param> public void ReplaceMember(MemberEntry oldEntry, MemberEntry newEntry) { if (oldEntry.Parent == this) { int index = _members.IndexOf(oldEntry); if (newEntry.Parent != null) { throw new ArgumentException(String.Format(CANAPE.Parser.Properties.Resources.SequenceParserType_MemberAlreadyParented, newEntry.Name)); } if (index >= 0) { oldEntry.Parent = null; oldEntry.DirtyChanged -= entry_DirtyChanged; newEntry.Parent = this; newEntry.DirtyChanged += entry_DirtyChanged; _members[index] = newEntry; OnDirty(); } } else { throw new ArgumentException(CANAPE.Parser.Properties.Resources.SequenceParserType_NotOurMember); } }
/// <summary> /// Get list of standard values /// </summary> /// <param name="context">Converter context</param> /// <returns>The list of standard values</returns> public override TypeConverter.StandardValuesCollection GetStandardValues(ITypeDescriptorContext context) { List <string> names = new List <string>(); MemberEntry entry = context.Instance as MemberEntry; MemberEntryReference memberRef = GetReference(context); if ((entry != null) && (entry.Parent != null)) { foreach (MemberEntry currEntry in entry.Parent.Members) { // For now we only support length fields which come before the array if (currEntry == entry) { break; } if (memberRef.IsValidType(currEntry)) { names.Add(currEntry.Name); } } } return(new StandardValuesCollection(names.ToArray())); }
/// <summary> /// Is this member entry valid to end the chain? /// </summary> /// <param name="entry">The entry to test</param> /// <returns>True if a valid type (i.e. an integer type of some kind)</returns> public bool IsValidType(MemberEntry entry) { Type currType = entry.GetType(); foreach (Type t in _validTypes) { if (t.IsAssignableFrom(currType)) { return(true); } } return(false); }
/// <summary> /// Remove a member entry /// </summary> /// <param name="entry">The entry to remove</param> public void RemoveMember(MemberEntry entry) { if (entry.Parent == this) { entry.Parent = null; entry.DirtyChanged -= entry_DirtyChanged; _members.Remove(entry); OnDirty(); } else { throw new ArgumentException(CANAPE.Parser.Properties.Resources.SequenceParserType_NotOurMember); } }
private MemberEntry[] GetEntries(SequenceParserType parent, Guid[] reference) { List <MemberEntry> entries = new List <MemberEntry>(); if (parent != null) { if (reference.Length == 0) { throw new ArgumentException(CANAPE.Parser.Properties.Resources.MemberEntryReference_InvalidChain); } for (int i = 0; i < reference.Length; ++i) { MemberEntry entry = parent.FindMember(reference[i]); if (entry != null) { entries.Add(entry); if (entry.BaseType is SequenceParserType) { if (i < (reference.Length - 1)) { parent = (SequenceParserType)((SequenceMemberEntry)entry).BaseType; } else { throw new ArgumentException(CANAPE.Parser.Properties.Resources.MemberEntryReference_InvalidChainMustStartWithSequences); } } else if ((i != reference.Length - 1) || !IsValidType(entry)) { throw new ArgumentException(CANAPE.Parser.Properties.Resources.MemberEntryReference_InvalidChainMustEndWithTypes); } } else { // Could not find entry throw new ArgumentException(String.Format(CANAPE.Parser.Properties.Resources.MemberEntryReference_CouldNotFindMember, reference[i])); } } } else { throw new ArgumentNullException("parent"); } return(entries.ToArray()); }
/// <summary> /// Add a new member entry /// </summary> /// <param name="entry">The entry to add</param> /// <exception cref="ArgumentException">Thrown if the member name already exists</exception> public void AddMember(MemberEntry entry) { if (FindMember(entry.Name) != null) { throw new ArgumentException(String.Format(CANAPE.Parser.Properties.Resources.SequenceParserType_NameExists, entry.Name)); } if (entry.Parent != null) { throw new ArgumentException(String.Format(CANAPE.Parser.Properties.Resources.SequenceParserType_MemberAlreadyParented, entry.Name)); } entry.Parent = this; entry.DirtyChanged += new EventHandler(entry_DirtyChanged); _members.Add(entry); OnDirty(); }
/// <summary> /// Moves a member in the order down a location /// </summary> /// <param name="entry">The entry to move</param> public void MoveMemberDown(MemberEntry entry) { if (entry.Parent == this) { int index = _members.IndexOf(entry); if ((index >= 0) && (index < (_members.Count - 1))) { _members.RemoveAt(index); _members.Insert(index + 1, entry); } OnDirty(); } else { throw new ArgumentException(CANAPE.Parser.Properties.Resources.SequenceParserType_NotOurMember); } }
/// <summary> /// Constructor, uses default list of valid members for reference /// </summary> /// <param name="container">The member entry which /// contains this reference</param> public MemberEntryReference(MemberEntry container) : this(container, typeof(IntegerPrimitiveMemberEntry)) { }
/// <summary> /// Constructor /// </summary> /// <param name="baseType">The base type of the member</param> protected ContainerMemberEntry(MemberEntry baseEntry) : base(baseEntry.Name, baseEntry.BaseType) { _baseEntry = baseEntry; _baseEntry.DirtyChanged += new EventHandler(_baseEntry_DirtyChanged); }
/// <summary> /// Replace an exist member /// </summary> /// <param name="oldEntry">The old entry to replace</param> /// <param name="newEntry">The new entry to replace with</param> public void ReplaceMember(MemberEntry oldEntry, MemberEntry newEntry) { if (oldEntry.Parent == this) { int index = _members.IndexOf(oldEntry); if (newEntry.Parent != null) { throw new ArgumentException(String.Format(CANAPE.Parser.Properties.Resources.SequenceParserType_MemberAlreadyParented, newEntry.Name)); } if (index >= 0) { oldEntry.Parent = null; oldEntry.DirtyChanged -= entry_DirtyChanged; newEntry.Parent = this; newEntry.DirtyChanged += entry_DirtyChanged; _members[index] = newEntry; OnDirty(); } } else { throw new ArgumentException(CANAPE.Parser.Properties.Resources.SequenceParserType_NotOurMember); } }
/// <summary> /// Constructor /// </summary> /// <param name="container">The member entry which /// contains this reference</param> /// <param name="validTypes">Valid types which terminate the reference</param> public MemberEntryReference(MemberEntry container, params Type[] validTypes) { _container = container; _reference = new Guid[0]; _validTypes = validTypes; }
/// <summary> /// Constructor, uses default list of valid members for reference /// </summary> /// <param name="container">The member entry which /// contains this reference</param> public MemberEntryReference(MemberEntry container) : this(container, typeof(IntegerPrimitiveMemberEntry)) { }
/// <summary> /// Is this member entry valid to end the chain? /// </summary> /// <param name="entry">The entry to test</param> /// <returns>True if a valid type (i.e. an integer type of some kind)</returns> public bool IsValidType(MemberEntry entry) { Type currType = entry.GetType(); foreach (Type t in _validTypes) { if (t.IsAssignableFrom(currType)) { return true; } } return false; }
/// <summary> /// Remove a member entry /// </summary> /// <param name="entry">The entry to remove</param> public void RemoveMember(MemberEntry entry) { if (entry.Parent == this) { entry.Parent = null; entry.DirtyChanged -= entry_DirtyChanged; _members.Remove(entry); OnDirty(); } else { throw new ArgumentException(CANAPE.Parser.Properties.Resources.SequenceParserType_NotOurMember); } }
private ListViewItem AddMember(MemberEntry entry, bool editName) { ListViewItem item = listViewEntries.Items.Add(entry.Name); item.SubItems.Add(entry.TypeName); item.SubItems.Add(entry.GetSize().ToString()); item.Tag = entry; if (editName) { item.BeginEdit(); } return item; }
/// <summary> /// Constructor /// </summary> /// <param name="baseType">The base type of the member</param> protected ContainerMemberEntry(MemberEntry baseEntry) : base(baseEntry.Name, baseEntry.BaseType) { _baseEntry = baseEntry; _baseEntry.DirtyChanged += new EventHandler(_baseEntry_DirtyChanged); }
/// <summary> /// Constructor /// </summary> /// <param name="container">The member entry which /// contains this reference</param> /// <param name="validTypes">Valid types which terminate the reference</param> public MemberEntryReference(MemberEntry container, params Type[] validTypes) { _container = container; _reference = new Guid[0]; _validTypes = validTypes; }
/// <summary> /// Add a new member entry /// </summary> /// <param name="entry">The entry to add</param> /// <exception cref="ArgumentException">Thrown if the member name already exists</exception> public void AddMember(MemberEntry entry) { if (FindMember(entry.Name) != null) { throw new ArgumentException(String.Format(CANAPE.Parser.Properties.Resources.SequenceParserType_NameExists, entry.Name)); } if (entry.Parent != null) { throw new ArgumentException(String.Format(CANAPE.Parser.Properties.Resources.SequenceParserType_MemberAlreadyParented, entry.Name)); } entry.Parent = this; entry.DirtyChanged += new EventHandler(entry_DirtyChanged); _members.Add(entry); OnDirty(); }
/// <summary> /// Constructor /// </summary> /// <param name="baseType">The base type of the member</param> protected ArrayMemberEntry(MemberEntry baseEntry) : base(baseEntry) { }
/// <summary> /// Constructor /// </summary> /// <param name="baseType">The base type of the member</param> protected ArrayMemberEntry(MemberEntry baseEntry) : base(baseEntry) { }
/// <summary> /// Moves a member in the order up a location /// </summary> /// <param name="entry">The entry to move</param> public void MoveMemberUp(MemberEntry entry) { if (entry.Parent == this) { int index = _members.IndexOf(entry); if (index > 0) { _members.RemoveAt(index); _members.Insert(index - 1, entry); } OnDirty(); } else { throw new ArgumentException(CANAPE.Parser.Properties.Resources.SequenceParserType_NotOurMember); } }