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);
}
}
