/// <summary> Adds a new item to the Structure. </summary> /// <exception cref="HL7Exception">Thrown when the named Structure is not part of this group /// or if the structure is not repeatable and an item already exists. </exception> public virtual IStructure AddStructure(String name) { AbstractGroupItem item = GetGroupItem(name); if (item == null) { throw new HL7Exception(name + " does not exist in the group " + GetType().FullName, ErrorCode.APPLICATION_INTERNAL_ERROR); } // Verify that Structure is repeating ... bool repeats = item.IsRepeating; if (!repeats && item.Structures.Count > 0) { throw new HL7Exception( "Can't create repetition of Structure " + name + " - this Structure is non-repeating and this Structure already has an item present.", ErrorCode.APPLICATION_INTERNAL_ERROR); } // Create a new Structure, add it to the list, and return it Type classType = item.ClassType; var ret = tryToInstantiateStructure(classType, name); item.Structures.Add(ret); return(ret); }
/// <summary> Returns the number of existing repetitions of the named structure.</summary> public virtual int currentReps(System.String name) { AbstractGroupItem item = GetGroupItem(name); if (item == null) { throw new HL7Exception("The structure " + name + " does not exist in the group " + this.GetType().FullName, HL7Exception.APPLICATION_INTERNAL_ERROR); } return(item.Structures.Count); }
/// <summary> Returns true if the named structure is required. </summary> public virtual bool IsRepeating(String name) { AbstractGroupItem item = GetGroupItem(name); if (item == null) { throw new HL7Exception("The structure " + name + " does not exist in the group " + GetType().FullName, ErrorCode.APPLICATION_INTERNAL_ERROR); } return(item.IsRepeating); }
/// <summary> Returns true if the class name is already being used. </summary> private bool nameExists(String name) { bool exists = false; AbstractGroupItem item = GetGroupItem(name); if (item != null) { exists = true; } return(exists); }
/// <summary> Removes the given structure from the named Structure. </summary> /// <exception cref="HL7Exception">Thrown when the named Structure is not part of this Group.</exception> public virtual void RemoveStructure(String name, IStructure toRemove) { AbstractGroupItem item = GetGroupItem(name); if (item == null) { throw new HL7Exception(name + " does not exist in the group " + GetType().FullName, ErrorCode.APPLICATION_INTERNAL_ERROR); } item.Structures.Remove(toRemove); }
/// <summary> Returns true if the named structure is required. </summary> /// /// <exception cref="HL7Exception"> Thrown when a HL 7 error condition occurs. </exception> /// /// <param name="name"> The name of the group item. </param> /// /// <returns> true if required, false if not. </returns> public virtual bool IsRequired(System.String name) { AbstractGroupItem item = this.GetGroupItem(name); if (item == null) { throw new HL7Exception( "The structure " + name + " does not exist in the group " + this.GetType().FullName, HL7Exception.APPLICATION_INTERNAL_ERROR); } return(item.IsRequired); }
/// <summary> /// Gets a group item by name /// </summary> /// <param name="name">The name of the group item</param> /// <returns>Group item if found, null otherwise</returns> protected AbstractGroupItem GetGroupItem(string name) { AbstractGroupItem ret = null; foreach (AbstractGroupItem item in _items) { if (item.Name.Equals(name)) { ret = item; break; } } return(ret); }
/// <summary> Returns an array of Structure objects by name. For example, if the Group contains /// an MSH segment and "MSH" is supplied then this call would return a 1-element array /// containing the MSH segment. Multiple elements are returned when the segment or /// group repeats. The array may be empty if no repetitions have been accessed /// yet using the get(...) methods. /// </summary> /// <throws> HL7Exception if the named Structure is not part of this Group. </throws> public virtual IStructure[] GetAll(System.String name) { AbstractGroupItem item = GetGroupItem(name); if (item == null) { throw new HL7Exception("The structure " + name + " does not exist in the group " + this.GetType().FullName, HL7Exception.APPLICATION_INTERNAL_ERROR); } IStructure[] all = new IStructure[item.Structures.Count]; for (int i = 0; i < item.Structures.Count; i++) { all[i] = item.Structures[i]; } return(all); }
/// <summary> Returns a particular repetition of the named Structure. If the given repetition /// number is one greater than the existing number of repetitions then a new /// Structure is created. </summary> /// <summary> if the structure is not repeatable and the given rep is > 0, /// or if the given repetition number is more than one greater than the existing /// number of repetitions. </summary> /// /// <exception cref="HL7Exception"> Thrown when a HL 7 error condition occurs. </exception> /// /// <param name="name"> an optional name of the structure (used by Generic structures; may be /// null) </param> /// <param name="rep"> The rep. </param> /// /// <returns> The structure. </returns> public virtual IStructure GetStructure(System.String name, int rep) { AbstractGroupItem item = this.GetGroupItem(name); if (item == null) { throw new HL7Exception( name + " does not exist in the group " + this.GetType().FullName, HL7Exception.APPLICATION_INTERNAL_ERROR); } IStructure ret; if (rep < item.Structures.Count) { // return existng Structure if it exists ret = item.Structures[rep]; } else if (rep == item.Structures.Count) { //verify that Structure is repeating ... bool repeats = item.IsRepeating; if (!repeats && item.Structures.Count > 0) { throw new HL7Exception( "Can't create repetition #" + rep + " of Structure " + name + " - this Structure is non-repeating", HL7Exception.APPLICATION_INTERNAL_ERROR); } //create a new Structure, add it to the list, and return it System.Type classType = item.ClassType; ret = this.tryToInstantiateStructure(classType, name); item.Structures.Add(ret); } else { throw new HL7Exception( "Can't return repetition #" + rep + " of " + name + " - there are only " + this._items.Count + " repetitions.", HL7Exception.APPLICATION_INTERNAL_ERROR); } return(ret); }
/// <summary> Inserts the given structure into this group, at the /// indicated index number. This method is used to support handling /// of unexpected segments (e.g. Z-segments). In contrast, specification /// of the group's normal children should be done at construction time, using the /// add(...) method. /// </summary> private String insert(Type classType, bool required, bool repeating, int index, String name) { //see if there is already something by this name and make a new name if necessary ... if (nameExists(name)) { int version = 2; String newName = name; while (nameExists(newName)) { newName = name + version++; } name = newName; } AbstractGroupItem item = new AbstractGroupItem(name, required, repeating, classType); _items.Insert(index, item); return(name); }
/// <summary> Removes the structure at the given index from the named Structure. </summary> /// <exception cref = "HL7Exception" > Thrown when the named Structure is not part of this Group /// or an index greater than the number of items in the structure is supplied. /// </exception> public virtual void RemoveRepetition(String name, int rep) { AbstractGroupItem item = GetGroupItem(name); if (item == null) { throw new HL7Exception("The structure " + name + " does not exist in the group " + GetType().FullName, ErrorCode.APPLICATION_INTERNAL_ERROR); } if (rep >= item.Structures.Count) { throw new HL7Exception( "The structure " + name + " does not have " + rep + " repetitions. ", ErrorCode.APPLICATION_INTERNAL_ERROR); } item.Structures.RemoveAt(rep); }
/// <summary> Inserts the given structure into this group, at the /// indicated index number. This method is used to support handling /// of unexpected segments (e.g. Z-segments). In contrast, specification /// of the group's normal children should be done at construction time, using the /// add(...) method. /// </summary> private string Insert(Type classType, bool required, bool repeating, bool choiceElement, int index, string name) { // see if there is already something by this name and make a new name if necessary ... if (NameExists(name)) { var version = 2; var newName = name; while (NameExists(newName)) { newName = name + version++; } name = newName; } var item = new AbstractGroupItem(name, required, repeating, choiceElement, classType); items.Insert(index, item); return(name); }
/// <summary> Returns the Class of the Structure at the given name index. </summary> public virtual Type GetClass(String name) { AbstractGroupItem item = GetGroupItem(name); return(item.ClassType); }
/// <summary> Returns the Class of the Structure at the given name index. </summary> /// /// <param name="name"> an optional name of the structure (used by Generic structures; may be /// null) </param> /// /// <returns> The class. </returns> public virtual System.Type GetClass(System.String name) { AbstractGroupItem item = this.GetGroupItem(name); return(item.ClassType); }
/// <summary> Inserts the given structure into this group, at the /// indicated index number. This method is used to support handling /// of unexpected segments (e.g. Z-segments). In contrast, specification /// of the group's normal children should be done at construction time, using the /// add(...) method. /// </summary> private System.String insert(System.Type classType, bool required, bool repeating, int index, System.String name) { //see if there is already something by this name and make a new name if necessary ... if (nameExists(name)) { int version = 2; System.String newName = name; while (nameExists(newName)) { newName = name + version++; } name = newName; } AbstractGroupItem item = new AbstractGroupItem(name, required, repeating, classType); _items.Insert(index, item); return name; }