RoleFactory (Oracle Healthcare Data Repository v8.0 API)

java.lang.Object
- oracle.hsgbu.hdr.hl7.rim.factories.RoleFactory

```
public abstract class RoleFactory
extends Object
```
Factory for creating RIM Role objects. The behavior of this factory varies depending on whether or not a ServiceLocator is supplied. If a ServiceLocator is supplied, then the factories will assign an 'internal identifier' with the root specified by OIDService.getOID(OIDService.INTERNAL_ROOT) and a sequence generated extension text to every RIM object created with a newX method below. If no ServiceLocator is supplied, then allocation of the internal identifier is defered until RimService.submit(). In this case no roundtrips will every be performed by this class.

Constructor Summary

Constructors
Constructor and Description

RoleFactory()

Constructors
Constructor and Description
`RoleFactory()`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`static RoleFactory`	`getInstance()` Used by services to create an `Instance` of the `RoleFactory`.
`abstract Role`	`makeReference(ReferenceModifier modifier, CS roleClass, CE code, Entity player, Entity scoper, SET<II> id, int versionNumber)` Creates a reference to an object that is assumed to already exist in HDR.
`abstract Access`	`newAccess(CE code, Entity player, Entity scoper, SET<II> id)` ACCESS (access) Creates an access, a role in which the playing entity (material) provides access to another entity.
`abstract Role`	`newActiveIngredient(CE code, Entity player, Entity scoper, SET<II> id)` ACTI (active ingredient) Active ingredient, a therapeutically active ingredient (player) in a mixture (scoper), where the mixture is typically a manufactured pharmaceutical.
`abstract Role`	`newActiveIngredientBasisOfStrength(CE code, Entity player, Entity scoper, SET<II> id)` ACTIB (active ingredient - basis of strength) Active ingredient, where the ingredient substance (player) is itself the "basis of strength", i.e., where the Role.quantity specifies exactly the quantity of the player substance in the medicine formulation.
`abstract Role`	`newActiveIngredientMoietyIsBasisOfStrength(CE code, Entity player, Entity scoper, SET<II> id)` ACTIM (active ingredient - moiety is basis of strength) Active ingredient, where not the ingredient substance (player), but itaTMs active moiety is the "basis of strength", i.e., where the Role.quantity specifies the quantity of the player substance's active moiety in the medicine formulation
`abstract Role`	`newActiveIngredientReferenceSubstanceIsBasisOfStrength(CE code, Entity player, Entity scoper, SET<II> id)` ACTIR (active ingredient - reference substance is basis of strength) Active ingredient, where not the ingredient substance (player) but another reference substance with the same active moiety, is the "basis of strength", i.e., where the Role.quantity specifies the quantity of a reference substance, similar but different from the player substance's in the medicine formulation
`abstract Role`	`newActiveMoiety(CE code, Entity player, Entity scoper, SET<II> id)` ACTM (active moiety).
`abstract Role`	`newAdditive(CE code, Entity player, Entity scoper, SET<II> id)` ADTV (additive) Additive, an ingredient (player) that is added to a base (scoper), that amounts to a minor part of the overall mixture.
`abstract Role`	`newAdjacency(CE code, Entity player, Entity scoper, SET<II> id)` ADJY (adjacency) A physical association whereby two Entities are in some (even lose) spatial relationship with each other such that they touch each other in some way
`abstract Role`	`newAdjuvant(CE code, Entity player, Entity scoper, SET<II> id)` ADJV (adjuvant) A component (player) added to enhance the action of an active ingredient (scoper) (in the manner of a catalyst) but which has no active effect in and of itself.
`abstract Role`	`newAdministerableMaterial(CE code, Entity player, Entity scoper, SET<II> id)` ADMM (Administerable Material) A material (player) that can be administered to an Entity (scoper).
`abstract Role`	`newAffiliate(CE code, Entity player, Entity scoper, SET<II> id)` AFFL (affiliate) Player of the Affiliate role has a business/professional relationship with scoper.
`abstract Role`	`newAgent(CE code, Entity player, Entity scoper, SET<II> id)` AGNT (agent) Creates an entity (player) that acts or is authorized to act on behalf of another entity (scoper).
`abstract Role`	`newAliquot(CE code, Entity player, Entity scoper, SET<II> id)` ALQT (aliquot) Aliquot, a portion (player) of an original or source specimen (scoper) used for testing or transportation.
`abstract Role`	`newAssignedEntity(CE code, Entity player, Entity scoper, SET<II> id)` ASSIGNED (assigned entity) Create an assigned entity, an agent role in which the agent is an `Entity` acting in the employ of an organization.
`abstract Role`	`newBaseIngredient(CE code, Entity player, Entity scoper, SET<II> id)` BASE (base) A base ingredient (player) is what comprises the major part of a mixture (scoper).
`abstract Role`	`newBirthplace(CE code, Entity player, Entity scoper, SET<II> id)` BIRTHPL (birthplace) Creates a birthplace that relates a place (playing entity) as the location where a living subject (scoping Entity) was born.
`abstract Role`	`newBond(CE code, Entity player, Entity scoper, SET<II> id)` BOND (molecular bond) A connection between two atoms of a molecule.
`abstract Role`	`newCareGiver(CE code, Entity player, Entity scoper, SET<II> id)` CAREGIVER (caregiver) Role played by a person giving care to the scoper.
`abstract Role`	`newCaseSubject(CE code, Entity player, Entity scoper, SET<II> id)` CASESBJ (case subject) A person, non-person living subject, or place that is the subject of an investigation related to a notifiable condition (health circumstance that is reportable within the applicable public health jurisdiction).
`abstract Role`	`newCitizen(CE code, Entity player, Entity scoper, SET<II> id)` CIT (citizen) Creates the citizen of a political entity.
`abstract Role`	`newClaimant(CE code, Entity player, Entity scoper, SET<II> id)` CLAIM (claimant) A role played by a party making a claim for coverage under a policy or program.
`abstract Role`	`newColorAdditive(CE code, Entity player, Entity scoper, SET<II> id)` COLR (color additive) Color additive, a substance (player) influencing the optical aspect of material (scoper).
`abstract Role`	`newCommissioningParty(CE code, Entity player, Entity scoper, SET<II> id)` COMPAR (commissioning party) An Entity that is authorized to issue or instantiate permissions, privileges, credentials or other formal/legal authorizations.
`abstract Role`	`newConnection(CE code, Entity player, Entity scoper, SET<II> id)` CONC (connection) An adjacency of two Entities held together by a bond which attaches to each of the two entities.
`abstract Role`	`newContact(CE code, Entity player, Entity scoper, SET<II> id)` CON (contact) Creates a person or an organization (player) that provides or receives information regarding another entity (scoper).
`abstract Role`	`newContaminant(CE code, Entity player, Entity scoper, SET<II> id)` CNTM (contaminant ingredient) An ingredient whose presence is not intended but may not be reasonably avoided given the circumstances of the mixture's nature or origin.
`abstract Role`	`newContent(CE code, Entity player, Entity scoper, SET<II> id)` CONT (content) Content relates a material as the content (player) to a container (scoper).
`abstract Role`	`newContinuity(CE code, Entity player, Entity scoper, SET<II> id)` CONY (continuity) A connection between two regional parts.
`abstract Role`	`newCoveredParty(CE code, Entity player, Entity scoper, SET<II> id)` COVPTY (covered party) Creates a role class played by a person who receives benefit coverage under the terms of a particular insurance policy.
`abstract LicensedEntity`	`newDedicatedServiceDeliveryLocation(CE code, Entity player, Entity scoper, SET<II> id)` DSDLOC (dedicated service delivery location) Creates a dedicated service delivery location, a role of a place (player) that is intended to house the provision of services.
`abstract Role`	`newDependent(CE code, Entity player, Entity scoper, SET<II> id)` DEPEN (dependent) A role played by a person covered under a policy or program based on an association with a subscriber, which is recognized by the policy holder.
`abstract Role`	`newDistributedMaterial(CE code, Entity player, Entity scoper, SET<II> id)` DST (distributed material) Creates a material (player) distributed by a distributor (scoper) who functions between a manufacturer and a buyer or retailer.
`abstract Role`	`newEmergencyContact(CE code, Entity player, Entity scoper, SET<II> id)` ECON (emergency contact) Creates an entity to be contacted in the event of an emergency.
`abstract Employee`	`newEmployee(CE code, Entity player, Entity scoper, SET<II> id)` EMP (employee) Creates a relationship between a person or organization and a person or organization formed for the purpose of exchanging work for compensation.
`abstract Role`	`newEquivalentEntity(CE code, Entity player, Entity scoper, SET<II> id)` EQUIV (equivalent entity) Specifies the player Entity (the equivalent Entity) as an Entity that is considered to be equivalent to a reference Entity (scoper).
`abstract Role`	`newEventLocation(CE code, Entity player, Entity scoper, SET<II> id)` EXLOC (event location) A role played by a place at which the location of an event may be recorded.
`abstract Role`	`newExposedEntity(CE code, Entity player, Entity scoper, SET<II> id)` EXPR (exposed entity) Creates an exposed entity, a role played by an entity that has been exposed to a person or animal suffering a contagious disease, or with a location from which a toxin has been distributed.
`abstract Role`	`newExposureAgentCarrier(CE code, Entity player, Entity scoper, SET<II> id)` EXPAGTCAR (exposure agent carrier) An exposure agent carrier is an entity that is capable of conveying an exposure agent from one entity to another.
`abstract Role`	`newExposureVector(CE code, Entity player, Entity scoper, SET<II> id)` EXPVECTOR (exposure vector) An exposure agent carrier is an entity that is capable of conveying an exposure agent from one entity to another.
`abstract Role`	`newFlavorAdditive(CE code, Entity player, Entity scoper, SET<II> id)` FLVR (flavor additive) Flavor additive, a substance (player) added to a mixture (scoper) to make it taste a certain way.
`abstract Role`	`newFomite(CE code, Entity player, Entity scoper, SET<II> id)` FOMITE (fomite) A fomite is a non-living entity that is capable of conveying exposure agent from one entity to another.
`abstract Role`	`newGeneralization(CE code, Entity player, Entity scoper, SET<II> id)` GEN (has generalization) Has generalization relates a specialized material concept (player) to its generalization (scoper).
`abstract Role`	`newGeneric(CE code, Entity player, Entity scoper, SET<II> id)` GRIC (has generic) Has generic, a special link between pharmaceuticals indicating that the target (scoper) is a generic for the source (player).
`abstract Role`	`newGuarantor(CE code, Entity player, Entity scoper, SET<II> id)` GUAR (guarantor) Creates a person or organization (player) that serves as a financial guarantor for another person or organization (scoper).
`abstract Role`	`newGuardian(CE code, Entity player, Entity scoper, SET<II> id)` GUARD (guardian) Creates the guardian of a ward.
`abstract LicensedEntity`	`newHealthcareProvider(CE code, Entity player, Entity scoper, SET<II> id)` PROV (healthcare provider) Creates the role of an entity (player) that is authorized to provide healthcare services by some authorizing agency (scoper).
`abstract Role`	`newHealthChart(CE code, Entity player, Entity scoper, SET<II> id)` HLTHCHRT (health chart) Creates a health chart, the role of a material (player) that is the physical health chart belonging to an organization (scoper).
`abstract Role`	`newHeldEntity(CE code, Entity player, Entity scoper, SET<II> id)` HLD (held entity) Creates an entity that is currently in the possession of a holder (scoper), who holds, or uses it, usually based on some agreement with the owner.
`abstract Role`	`newIdentifiedEntity(CE code, Entity player, Entity scoper, SET<II> id)` IDENT (identified entity) Creates a role played by entities and scoped by entities that identify them for various purposes.
`abstract Role`	`newInactiveIngredient(CE code, Entity player, Entity scoper, SET<II> id)` IACT (inactive ingredient).
`abstract Role`	`newIncidentalServiceDeliveryLocation(CE code, Entity player, Entity scoper, SET<II> id)` ISDLOC (incidental service delivery location) Creates an incidental service delivery location, a role played by a place at which healthcare services may be provided without prior designation or authorization.
`abstract Role`	`newIndividual(CE code, Entity player, Entity scoper, SET<II> id)` INDIV (individual) A role played by a party covered under a policy as the policy holder.
`abstract Role`	`newIngredient(CE code, Entity player, Entity scoper, SET<II> id)` INGR (ingredient) Ingredient relates a component (player) to a mixture (scoper).
`abstract Role`	`newInstance(CE code, Entity player, Entity scoper, SET<II> id)` INST (instance) Instance is an individual piece of material (player) instantiating a class of material (scoper).
`abstract Role`	`newInvestigatedSubject(CE code, Entity player, Entity scoper, SET<II> id)` INVSBJ (investigated subject) An entity that is the subject of an investigation.
`abstract Role`	`newIsolate(CE code, Entity player, Entity scoper, SET<II> id)` ISLT (isolate) Isolate, a microorganism that has been isolated from other microorganisms or a source matrix.
`abstract LicensedEntity`	`newLicensedEntity(CE code, Entity player, Entity scoper, SET<II> id)` LIC (licensed entity) Creates a relationship in which the scoper certifies the player (example, a medical care giver, a medical device or a provider organization) to perform certain activities that fall under the jurisdiction of the scoper (example, a health authority licensing healthcare providers, a medical quality authority certifying healthcare professionals).
`abstract Role`	`newLocatedEntity(CE code, Entity player, Entity scoper, SET<II> id)` LOCE (located entity) Located entity relates an entity (player) to a location (scoper) at which it is present in some way.
`abstract Role`	`newMaintainedEntity(CE code, Entity player, Entity scoper, SET<II> id)` MNT (maintained entity) Creates an entity (player) that is maintained by another entity (scoper).
`abstract Role`	`newManufacturedProduct(CE code, Entity player, Entity scoper, SET<II> id)` MANU (manufactored product) Creates a manufactured product scoped by the manufacturer.
`abstract Role`	`newMechanicalIngredient(CE code, Entity player, Entity scoper, SET<II> id)` MECH (mechanical ingredient) An ingredient (player) of a medication (scoper) that is inseparable from the active ingredients, but has no intended chemical or pharmaceutical effect itself, but which may have some systemic effect on the patient.An example is a collagen matrix used as a base for transplanting skin cells.
`abstract Role`	`newMember(CE code, Entity player, Entity scoper, SET<II> id)` MBR (member) Creates a role played by an entity that is a member of a group.
`abstract Employee`	`newMilitaryPerson(CE code, Entity player, Entity scoper, SET<II> id)` MIL (military) Creates the role played by a member of a military service.
`abstract Role`	`newNamedInsured(CE code, Entity player, Entity scoper, SET<II> id)` NAMED (named insured) A role played by a party to an insurance policy to which the insurer agrees to indemnify for losses, provides benefits for, or renders services.
`abstract Role`	`newNextOfKin(CE code, Entity player, Entity scoper, SET<II> id)` NOK (next of kin) Creates an individual designated for notification as the next of kin for a given entity.
`abstract LicensedEntity`	`newNotaryPublic(CE code, Entity player, Entity scoper, SET<II> id)` NOT (notary public) Creates a notary public role.
`abstract Role`	`newOwnedEntity(CE code, Entity player, Entity scoper, SET<II> id)` OWN (owned entity) Creates an entity (player) for which someone (scoper) is granted by law the right to call the material (player) his own.
`abstract Role`	`newPart(CE code, Entity player, Entity scoper, SET<II> id)` PART (part) An association between two entities where the playing entity is considered in some way "part" of the scoping Entity, e.g., as a member, component, ingredient, or content.
`abstract Patient`	`newPatient(CE code, Entity player, Entity scoper, SET<II> id)` PAT (patient) Creates the patient of a provider.
`abstract Role`	`newPayee(CE code, Entity player, Entity scoper, SET<II> id)` PAYEE (payee) Creates the role of an organization or individual designated to receive payment for a claim against a particular coverage.
`abstract Role`	`newPayor(CE code, Entity player, Entity scoper, SET<II> id)` PAYOR (payor) Creates the role of an organization that undertakes to accept claims invoices, assess the coverage or payments due for those invoices and pay to the designated payees for those invoices.
`abstract Role`	`newPersonalRelationship(CE code, Entity player, Entity scoper, SET<II> id)` PRS (personal relationship) Creates the role that links two people in a personal relationship.
`abstract Role`	`newPlaceOfDeath(CE code, Entity player, Entity scoper, SET<II> id)` DEATHPLC (place of death) Relates a place (playing Entity) as the location where a living subject (scoping Entity) died
`abstract Role`	`newPolicyHolder(CE code, Entity player, Entity scoper, SET<II> id)` POLHOLD (policy holder) Creates the role played by an entity, usually an individual who holds an insurance policy.
`abstract Role`	`newPreservative(CE code, Entity player, Entity scoper, SET<II> id)` PRSV (preservative) Preservative, a substance (player) added to a mixture (scoper) to prevent microorganisms (fungi, bacteria) to spoil the mixture.
`abstract Role`	`newProgramEligible(CE code, Entity player, Entity scoper, SET<II> id)` PROG (program eligible) A role played by a party that meets the eligibility criteria for coverage under a program.
`abstract QualifiedEntity`	`newQualifiedEntity(CE code, Entity player, Entity scoper, SET<II> id)` QUAL (qualified entity) Creates the role of an entity (player) that has been recognized as having certain training/experience or other characteristics that would make said entity an appropriate performer for a certain activity.
`abstract Role`	`newRegulatedProduct(CE code, Entity player, Entity scoper, SET<II> id)` RGPR (regulated product) Creates a product regulated by some governmental organization.
`abstract Role`	`newResearchInvestigator(CE code, Entity player, Entity scoper, SET<II> id)` CRINV (clinical research investigator) Creates the role played by a provider, always a person, who has agency authority from a Clinical Research Sponsor to direct the conduct of a clinical research trial or study on behalf of the sponsor.
`abstract Role`	`newResearchSponsor(CE code, Entity player, Entity scoper, SET<II> id)` CRSPNSR (clinical research sponsor) Creates the role played by an entity, usually an organization, that is the sponsor of a clinical research trial or study.
`abstract Role`	`newResearchSubject(CE code, Entity player, Entity scoper, SET<II> id)` RESBJ (research subject) Creates the role of a living subject to whom, or on behalf of whom, the procedures of an experiment are applied.
`abstract Role`	`newRetailedMaterial(CE code, Entity player, Entity scoper, SET<II> id)` RET (retailed material) Creates a material (player) sold by a retailer (scoper), who also give advice to prospective buyers.
`abstract Role`	`newRole(CS roleClass, CE code, Entity player, Entity scoper, SET<II> id)` Used by applications where the class is passed in rather than determined Programmatically.
`abstract Role`	`newSame(CE code, Entity player, Entity scoper, SET<II> id)` SAME (same) The "same" roleclass asserts an identity between playing and scoping entities: that they are in fact instances of the same entity and, in the case of discrepancies (e.g different DOB, gender), that one or both are in error.
`abstract Role`	`newServiceDeliveryLocation(CE code, Entity player, Entity scoper, SET<II> id)` SDLOC (service delivery location) Creates a service delivery location, a role played by a place at which services may be provided.
`abstract Role`	`newSigningAuthority(CE code, Entity player, Entity scoper, SET<II> id)` SGNOFF (signing authority or officer) Creates the role of a person (player) who is the officer or signature authority for of a scoping entity, usually an organization (scoper).
`abstract Role`	`newSpecimen(CE code, Entity player, Entity scoper, SET<II> id)` SPEC (specimen) Specimen, a role played by a material entity that is a specimen for an act.
`abstract Role`	`newSponsor(CE code, Entity player, Entity scoper, SET<II> id)` SPNSR (sponsor) Creates the role played by an entity, usually an organization that is the sponsor of an insurance plan.
`abstract Role`	`newStabilizer(CE code, Entity player, Entity scoper, SET<II> id)` STBL (stabilizer) A stabilizer (player) added to a mixture (scoper) in order to prevent the molecular disintegration of the main substance.
`abstract Role`	`newStoredEntity(CE code, Entity player, Entity scoper, SET<II> id)` STOR (stored entity) Stored entity relates an entity (player), eg.
`abstract Role`	`newStudent(CE code, Entity player, Entity scoper, SET<II> id)` STD (student) Creates the role played by an individual who is a student of a school, which is the scoping entity.
`abstract Role`	`newSubscriber(CE code, Entity player, Entity scoper, SET<II> id)` SUBSCR (subscriber) A role played by a person covered under a policy based on association with a sponsor who is the policy holder, and whose association may provide for the eligibility of dependents for coverage.
`abstract Role`	`newSubsumedBy(CE code, Entity player, Entity scoper, SET<II> id)` SUBY (subsumed by) Subsumed by, relates a prevailing record of an `Entity` (scoper) with another record (player) that it subsumes.
`abstract Role`	`newSubsumer(CE code, Entity player, Entity scoper, SET<II> id)` SUBS (subsumer) Creates a subsumer, an entity that subsumes the identity of another.
`abstract Role`	`newTerritory(CE code, Entity player, Entity scoper, SET<II> id)` TERR (territory) Creates a territory of authority, which relates a place entity (player) as the region over which the scoper (typically an `Organization`) has certain authority (jurisdiction).
`abstract Role`	`newTherapeuticAgent(CE code, Entity player, Entity scoper, SET<II> id)` THER (therapeutic agent) Creates a manufactured material (player) that is used for its therapeutic properties.
`abstract Role`	`newUnderwriter(CE code, Entity player, Entity scoper, SET<II> id)` UNDWRT (underwriter) Creates the role played by an organization that underwrites or accepts fiscal responsibility for insurance plans and the policies created under those plans.
`abstract Role`	`newUsedEntity(CE code, Entity player, Entity scoper, SET<II> id)` USED (used entity) An entity (player) that is used by another entity (scoper).
`abstract Role`	`newWarrantedProduct(CE code, Entity player, Entity scoper, SET<II> id)` WRTE (warranted product) Creates a warranted product, a role a product plays when a guarantee is given to the purchaser by the seller (scoping entity) stating that the product is reliable and free from known defects and that the seller will repair or replace defective parts within a given time limit and under certain conditions.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - RoleFactory
```
public RoleFactory()
```
- Method Detail
  - getInstance
```
public static RoleFactory getInstance()
```
    Used by services to create an Instance of the RoleFactory.
    
    Returns:
    
    RoleFactory
  - newRole
```
public abstract Role newRole(CS roleClass,
                             CE code,
                             Entity player,
                             Entity scoper,
                             SET<II> id)
                      throws HDRRimException
```
    Used by applications where the class is passed in rather than determined Programmatically. Functionally identical to the individual class-specific factory methods except that the returned class may have to be cast to the specific subclass.
    
    Parameters:
    
    roleClass - RoleClass. This is a mandatory parameter
    
    code - Code for the Role. This is an optional parametere
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the Role, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The Role created
    
    Throws:
    
    HDRRimException - when the roleClass is passed as null.
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
  - newIdentifiedEntity
```
public abstract Role newIdentifiedEntity(CE code,
                                         Entity player,
                                         Entity scoper,
                                         SET<II> id)
                                  throws HDRRimException
```
    IDENT (identified entity) Creates a role played by entities and scoped by entities that identify them for various purposes.
    
    Parameters:
    
    code - Code for the IdentifiedEntity. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the IdentifiedEntity, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The IdentifiedEntity created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.IDENT
  - newPatient
```
public abstract Patient newPatient(CE code,
                                   Entity player,
                                   Entity scoper,
                                   SET<II> id)
                            throws HDRRimException
```
    PAT (patient) Creates the patient of a provider.
    
    Parameters:
    
    code - Code for the Patient. This is an optional parameter Detailed code specifying type of patient
    
    player - The entity (usually person) playing this role
    
    scoper - The entity (usually organization, provider) scoping this role
    
    id - One or more identifiers that this role is known by. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The Patient created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.PAT
  - newAssignedEntity
```
public abstract Role newAssignedEntity(CE code,
                                       Entity player,
                                       Entity scoper,
                                       SET<II> id)
                                throws HDRRimException
```
    ASSIGNED (assigned entity) Create an assigned entity, an agent role in which the agent is an Entity acting in the employ of an organization. The focus is on the functional role on behalf of the organization, unlike the Employee role where the focus is on the "Human Resources" relationship between the employee and the organization.
    
    Parameters:
    
    code - Code for the AssignedEntity. This is an optional parameter Detailed code specifying type of patient
    
    player - The entity (usually person) playing this role
    
    scoper - The entity (usually organization, provider) scoping this role
    
    id - One or more identifiers that this role is known by. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The AssignedEntity created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.ASSIGNED
  - newAgent
```
public abstract Role newAgent(CE code,
                              Entity player,
                              Entity scoper,
                              SET<II> id)
                       throws HDRRimException
```
    AGNT (agent) Creates an entity (player) that acts or is authorized to act on behalf of another entity (scoper).
    
    Parameters:
    
    code - Code for the Agent. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the Agent, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The Agent created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.AGNT
  - newContact
```
public abstract Role newContact(CE code,
                                Entity player,
                                Entity scoper,
                                SET<II> id)
                         throws HDRRimException
```
    CON (contact) Creates a person or an organization (player) that provides or receives information regarding another entity (scoper). Examples; patient NOK and emergency contacts; guarantor contact; employer contact.
    Oracle: This generic class is not persisted. Use next of kin or emergency contact.
    
    Parameters:
    
    code - Code for the Contact. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the Contact, may be null. However, HDR will always generate an internal identifier.The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The Contact created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.CON
  - newEmergencyContact
```
public abstract Role newEmergencyContact(CE code,
                                         Entity player,
                                         Entity scoper,
                                         SET<II> id)
                                  throws HDRRimException
```
    ECON (emergency contact) Creates an entity to be contacted in the event of an emergency.
    
    Parameters:
    
    code - Code for the EmergencyContact. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the EmergencyContact, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The EmergencyContact created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.ECON
  - newNextOfKin
```
public abstract Role newNextOfKin(CE code,
                                  Entity player,
                                  Entity scoper,
                                  SET<II> id)
                           throws HDRRimException
```
    NOK (next of kin) Creates an individual designated for notification as the next of kin for a given entity.
    
    Parameters:
    
    code - Code for the NextOfKin. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the NextOfKin, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The NextOfKin created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.NOK
  - newSigningAuthority
```
public abstract Role newSigningAuthority(CE code,
                                         Entity player,
                                         Entity scoper,
                                         SET<II> id)
                                  throws HDRRimException
```
    SGNOFF (signing authority or officer) Creates the role of a person (player) who is the officer or signature authority for of a scoping entity, usually an organization (scoper).
    
    Parameters:
    
    code - Code for the SigningAuthority. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the SigningAuthority, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The SigningAuthority created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.SGNOFF
  - newGuardian
```
public abstract Role newGuardian(CE code,
                                 Entity player,
                                 Entity scoper,
                                 SET<II> id)
                          throws HDRRimException
```
    GUARD (guardian) Creates the guardian of a ward.
    
    Parameters:
    
    code - Code for the Guardian. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the Guardian, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The Guardian created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.GUARD
  - newCitizen
```
public abstract Role newCitizen(CE code,
                                Entity player,
                                Entity scoper,
                                SET<II> id)
                         throws HDRRimException
```
    CIT (citizen) Creates the citizen of a political entity.
    
    Parameters:
    
    code - Code for the Citizen. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the Citizen, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The Citizen created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.CIT
  - newCoveredParty
```
public abstract Role newCoveredParty(CE code,
                                     Entity player,
                                     Entity scoper,
                                     SET<II> id)
                              throws HDRRimException
```
    COVPTY (covered party) Creates a role class played by a person who receives benefit coverage under the terms of a particular insurance policy. The underwriter of that policy is the scoping entity. The covered party receives coverage because of some contractual or other relationship with the holder of that policy. This reason for coverage is captured in Role.code and a relationship link with type code of indirect authority should be included using the policy holder role as the source, and the covered party role as the target.
    
    Parameters:
    
    code - Code for the CoveredParty. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the CoveredParty, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The CoveredParty created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.COVPTY
  - newResearchInvestigator
```
public abstract Role newResearchInvestigator(CE code,
                                             Entity player,
                                             Entity scoper,
                                             SET<II> id)
                                      throws HDRRimException
```
    CRINV (clinical research investigator) Creates the role played by a provider, always a person, who has agency authority from a Clinical Research Sponsor to direct the conduct of a clinical research trial or study on behalf of the sponsor.
    
    Parameters:
    
    code - Code for the ResearchInvestigator. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the ResearchInvestigator, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The ResearchInvestigator created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.CRINV
  - newResearchSponsor
```
public abstract Role newResearchSponsor(CE code,
                                        Entity player,
                                        Entity scoper,
                                        SET<II> id)
                                 throws HDRRimException
```
    CRSPNSR (clinical research sponsor) Creates the role played by an entity, usually an organization, that is the sponsor of a clinical research trial or study. The sponsor commissions the study, bears the expenses, is responsible for satisfying all legal requirements concerning subject safety and privacy, and is generally responsible for collection, storage and analysis of the data generated during the trial. No scoper is necessary, as a clinical research sponsor undertakes the role on its own authority and declaration. Clinical research sponsors are usually educational or other research organizations, government agencies or biopharmaceutical companies.
    
    Parameters:
    
    code - Code for the ResearchSponsor. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the ResearchSponsor, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The ResearchSponsor created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.CRSPNSR
  - newEmployee
```
public abstract Employee newEmployee(CE code,
                                     Entity player,
                                     Entity scoper,
                                     SET<II> id)
                              throws HDRRimException
```
    EMP (employee) Creates a relationship between a person or organization and a person or organization formed for the purpose of exchanging work for compensation. The purpose of the role is to identify the type of relationship the employee has to the employer, rather than the nature of the work actually performed. (Contrast with AssignedEntity.)
    
    Parameters:
    
    code - Code for the Employee. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the Employee, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The Employee created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.EMP
  - newMilitaryPerson
```
public abstract Employee newMilitaryPerson(CE code,
                                           Entity player,
                                           Entity scoper,
                                           SET<II> id)
                                    throws HDRRimException
```
    MIL (military) Creates the role played by a member of a military service. Scoper is the military service (example, Army, Navy, Air Force, etc.) or, more specifically, the unit (example, Company C, 3rd Battalion, 4th Division)
    
    Parameters:
    
    code - Code for the MilitaryPerson. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the MilitaryPerson, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The MilitaryPerson created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.MIL
  - newGuarantor
```
public abstract Role newGuarantor(CE code,
                                  Entity player,
                                  Entity scoper,
                                  SET<II> id)
                           throws HDRRimException
```
    GUAR (guarantor) Creates a person or organization (player) that serves as a financial guarantor for another person or organization (scoper).
    
    Parameters:
    
    code - Code for the Guarantor. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the Guarantor, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The Guarantor created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.GUAR
  - newLicensedEntity
```
public abstract LicensedEntity newLicensedEntity(CE code,
                                                 Entity player,
                                                 Entity scoper,
                                                 SET<II> id)
                                          throws HDRRimException
```
    LIC (licensed entity) Creates a relationship in which the scoper certifies the player (example, a medical care giver, a medical device or a provider organization) to perform certain activities that fall under the jurisdiction of the scoper (example, a health authority licensing healthcare providers, a medical quality authority certifying healthcare professionals).
    
    Parameters:
    
    code - Code for the LicensedEntity. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the LicensedEntity, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The LicensedEntity created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.LIC
  - newNotaryPublic
```
public abstract LicensedEntity newNotaryPublic(CE code,
                                               Entity player,
                                               Entity scoper,
                                               SET<II> id)
                                        throws HDRRimException
```
    NOT (notary public) Creates a notary public role.
    
    Parameters:
    
    code - Code for the NotaryPublic. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the NotaryPublic, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The NotaryPublic created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.NOT
  - newHealthcareProvider
```
public abstract LicensedEntity newHealthcareProvider(CE code,
                                                     Entity player,
                                                     Entity scoper,
                                                     SET<II> id)
                                              throws HDRRimException
```
    PROV (healthcare provider) Creates the role of an entity (player) that is authorized to provide healthcare services by some authorizing agency (scoper).
    
    Parameters:
    
    code - Code for the HealthcareProvider. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the HealthcareProvider, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The HealthcareProvider created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.PROV
  - newPayee
```
public abstract Role newPayee(CE code,
                              Entity player,
                              Entity scoper,
                              SET<II> id)
                       throws HDRRimException
```
    PAYEE (payee) Creates the role of an organization or individual designated to receive payment for a claim against a particular coverage. The scoping entity is the organization that is the submitter of the invoice in question.
    
    Parameters:
    
    code - Code for the Payee. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the Payee, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The Payee created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.PAYEE
  - newPayor
```
public abstract Role newPayor(CE code,
                              Entity player,
                              Entity scoper,
                              SET<II> id)
                       throws HDRRimException
```
    PAYOR (payor) Creates the role of an organization that undertakes to accept claims invoices, assess the coverage or payments due for those invoices and pay to the designated payees for those invoices. This role may be either the underwriter or a third-party organization authorized by the underwriter. The scoping entity is the organization that underwrites the claimed coverage.
    
    Parameters:
    
    code - Code for the Payor. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the Payor, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The Payor created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.PAYOR
  - newPolicyHolder
```
public abstract Role newPolicyHolder(CE code,
                                     Entity player,
                                     Entity scoper,
                                     SET<II> id)
                              throws HDRRimException
```
    POLHOLD (policy holder) Creates the role played by an entity, usually an individual who holds an insurance policy. The underwriter of that policy is the scoping entity. Equivalent terms are policy owner and subscriber. The identifier of the policy is captured in Role.id when the Role is a policy holder. A particular policy may cover several individuals one of whom may be, but need not be, the policy holder. The notion of covered party is a role that is distinct from that of the policy holder.
    
    Parameters:
    
    code - Code for the PolicyHolder. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the PolicyHolder, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The PolicyHolder created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.POLHOLD
  - newQualifiedEntity
```
public abstract QualifiedEntity newQualifiedEntity(CE code,
                                                   Entity player,
                                                   Entity scoper,
                                                   SET<II> id)
                                            throws HDRRimException
```
    QUAL (qualified entity) Creates the role of an entity (player) that has been recognized as having certain training/experience or other characteristics that would make said entity an appropriate performer for a certain activity. The scoper is an organization that educates or qualifies entities.
    
    Parameters:
    
    code - Code for the QualifiedEntity. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the QualifiedEntity, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The QualifiedEntity created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.QUAL
  - newResearchSubject
```
public abstract Role newResearchSubject(CE code,
                                        Entity player,
                                        Entity scoper,
                                        SET<II> id)
                                 throws HDRRimException
```
    RESBJ (research subject) Creates the role of a living subject to whom, or on behalf of whom, the procedures of an experiment are applied.
    
    Parameters:
    
    code - Code for the ResearchSubject. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the ResearchSubject, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The ResearchSubject created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.RESBJ
  - newSponsor
```
public abstract Role newSponsor(CE code,
                                Entity player,
                                Entity scoper,
                                SET<II> id)
                         throws HDRRimException
```
    SPNSR (sponsor) Creates the role played by an entity, usually an organization that is the sponsor of an insurance plan. The underwriter of that plan is the scoping entity. Examples include the case where a particular corporation may sponsor a plan for its employees, but the individual policies are a contractual obligation between the employees and the underwriter. In general, the role of the sponsor is to negotiate and establish the terms of the plan and to qualify individuals who may become policy holders under the plan.
    
    Parameters:
    
    code - Code for the Sponsor. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the Sponsor, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Throws:
    
    HDRRimException
  - newStudent
```
public abstract Role newStudent(CE code,
                                Entity player,
                                Entity scoper,
                                SET<II> id)
                         throws HDRRimException
```
    STD (student) Creates the role played by an individual who is a student of a school, which is the scoping entity.
    
    Parameters:
    
    code - Code for the Student. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the Student, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The Student created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.STD
  - newUnderwriter
```
public abstract Role newUnderwriter(CE code,
                                    Entity player,
                                    Entity scoper,
                                    SET<II> id)
                             throws HDRRimException
```
    UNDWRT (underwriter) Creates the role played by an organization that underwrites or accepts fiscal responsibility for insurance plans and the policies created under those plans.
    
    Parameters:
    
    code - Code for the Underwriter. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the Underwriter, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The Underwriter created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.UNDWRT
  - newPersonalRelationship
```
public abstract Role newPersonalRelationship(CE code,
                                             Entity player,
                                             Entity scoper,
                                             SET<II> id)
                                      throws HDRRimException
```
    PRS (personal relationship) Creates the role that links two people in a personal relationship. The character of the relationship must be defined by a PersonalRelationshipRoleType code. The player and scoper are determined by PersonalRelationshipRoleType code as well.
    
    Parameters:
    
    code - Code for the PersonalRelationship. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the PersonalRelationship, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The PersonalRelationship created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.PRS
  - newAccess
```
public abstract Access newAccess(CE code,
                                 Entity player,
                                 Entity scoper,
                                 SET<II> id)
                          throws HDRRimException
```
    ACCESS (access) Creates an access, a role in which the playing entity (material) provides access to another entity. The principal use case is intravenous (or other bodily) access lines that preexist and need to be referred to for medication routing instructions.
    
    Parameters:
    
    code - Code for the Access. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the Access, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The Access created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.ACCESS
  - newBirthplace
```
public abstract Role newBirthplace(CE code,
                                   Entity player,
                                   Entity scoper,
                                   SET<II> id)
                            throws HDRRimException
```
    BIRTHPL (birthplace) Creates a birthplace that relates a place (playing entity) as the location where a living subject (scoping Entity) was born.
    
    Parameters:
    
    code - Code for the Birthplace. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the Birthplace, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The Birthplace created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.BIRTHPL
  - newDistributedMaterial
```
public abstract Role newDistributedMaterial(CE code,
                                            Entity player,
                                            Entity scoper,
                                            SET<II> id)
                                     throws HDRRimException
```
    DST (distributed material) Creates a material (player) distributed by a distributor (scoper) who functions between a manufacturer and a buyer or retailer.
    
    Parameters:
    
    code - Code for the DistributedMaterial. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the DistributedMaterial, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The DistributedMaterial created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.DST
  - newRetailedMaterial
```
public abstract Role newRetailedMaterial(CE code,
                                         Entity player,
                                         Entity scoper,
                                         SET<II> id)
                                  throws HDRRimException
```
    RET (retailed material) Creates a material (player) sold by a retailer (scoper), who also give advice to prospective buyers.
    
    Parameters:
    
    code - Code for the RetailedMaterial. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the RetailedMaterial, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The RetailedMaterial created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.RET
  - newExposedEntity
```
public abstract Role newExposedEntity(CE code,
                                      Entity player,
                                      Entity scoper,
                                      SET<II> id)
                               throws HDRRimException
```
    EXPR (exposed entity) Creates an exposed entity, a role played by an entity that has been exposed to a person or animal suffering a contagious disease, or with a location from which a toxin has been distributed. The player of the role is normally a person or animal, but it is possible that other entity types could become exposed. The role is scoped by the source of the exposure, and it is quite possible for a person playing the role of exposed party to also become the scoper a role played by another person. That is to say, once a person has become infected, it is possible, perhaps likely, for that person to infect others.
    
    Management of exposures and tracking exposed parties is a key function within public health, and within most public health contexts - exposed parties are known as "contacts."
    
    Parameters:
    
    code - Code for the ExposedEntity. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the ExposedEntity, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The ExposedEntity created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.EXPR
  - newHeldEntity
```
public abstract Role newHeldEntity(CE code,
                                   Entity player,
                                   Entity scoper,
                                   SET<II> id)
                            throws HDRRimException
```
    HLD (held entity) Creates an entity that is currently in the possession of a holder (scoper), who holds, or uses it, usually based on some agreement with the owner.
    
    Parameters:
    
    code - Code for the HeldEntity. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the HeldEntity, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The HeldEntity created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.HLD
  - newHealthChart
```
public abstract Role newHealthChart(CE code,
                                    Entity player,
                                    Entity scoper,
                                    SET<II> id)
                             throws HDRRimException
```
    HLTHCHRT (health chart) Creates a health chart, the role of a material (player) that is the physical health chart belonging to an organization (scoper).
    
    Parameters:
    
    code - Code for the HealthChart. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the HealthChart, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The HealthChart created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.HLTHCHRT
  - newManufacturedProduct
```
public abstract Role newManufacturedProduct(CE code,
                                            Entity player,
                                            Entity scoper,
                                            SET<II> id)
                                     throws HDRRimException
```
    MANU (manufactored product) Creates a manufactured product scoped by the manufacturer.
    
    Parameters:
    
    code - Code for the ManufacturedProduct. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the ManufacturedProduct, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The ManufacturedProduct created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.MANU
  - newTherapeuticAgent
```
public abstract Role newTherapeuticAgent(CE code,
                                         Entity player,
                                         Entity scoper,
                                         SET<II> id)
                                  throws HDRRimException
```
    THER (therapeutic agent) Creates a manufactured material (player) that is used for its therapeutic properties. The manufacturer is the scoper.
    
    Parameters:
    
    code - Code for the TherapeuticAgent. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the TherapeuticAgent, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The TherapeuticAgent created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.THER
  - newMaintainedEntity
```
public abstract Role newMaintainedEntity(CE code,
                                         Entity player,
                                         Entity scoper,
                                         SET<II> id)
                                  throws HDRRimException
```
    MNT (maintained entity) Creates an entity (player) that is maintained by another entity (scoper). This is typical role held by durable equipment. The scoper assumes responsibility for proper operation, quality, and safety.
    
    Parameters:
    
    code - Code for the MaintainedEntity. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the MaintainedEntity, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The MaintainedEntity created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.MNT
  - newOwnedEntity
```
public abstract Role newOwnedEntity(CE code,
                                    Entity player,
                                    Entity scoper,
                                    SET<II> id)
                             throws HDRRimException
```
    OWN (owned entity) Creates an entity (player) for which someone (scoper) is granted by law the right to call the material (player) his own. This entitles the scoper to make decisions about the disposition of that material.
    
    Parameters:
    
    code - Code for the OwnedEntity. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the OwnedEntity, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The OwnedEntity created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.OWN
  - newRegulatedProduct
```
public abstract Role newRegulatedProduct(CE code,
                                         Entity player,
                                         Entity scoper,
                                         SET<II> id)
                                  throws HDRRimException
```
    RGPR (regulated product) Creates a product regulated by some governmental organization. The role is played by Material and scoped by Organization.
    
    Rationale: To support an entity clone used to identify the NDC number for a drug product.
    
    Parameters:
    
    code - Code for the RegulatedProduct. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the RegulatedProduct, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The RegulatedProduct created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.RGPR
  - newServiceDeliveryLocation
```
public abstract Role newServiceDeliveryLocation(CE code,
                                                Entity player,
                                                Entity scoper,
                                                SET<II> id)
                                         throws HDRRimException
```
    SDLOC (service delivery location) Creates a service delivery location, a role played by a place at which services may be provided.
    
    Parameters:
    
    code - Code for the ServiceDeliveryLocation. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the ServiceDeliveryLocation, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The ServiceDeliveryLocation created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.SDLOC
  - newDedicatedServiceDeliveryLocation
```
public abstract LicensedEntity newDedicatedServiceDeliveryLocation(CE code,
                                                                   Entity player,
                                                                   Entity scoper,
                                                                   SET<II> id)
                                                            throws HDRRimException
```
    DSDLOC (dedicated service delivery location) Creates a dedicated service delivery location, a role of a place (player) that is intended to house the provision of services. Scoper is the Entity (typically Organization) that provides these services. This is not synonymous with "ownership."
    
    Parameters:
    
    code - Code for the DedicatedServiceDeliveryLocation. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the DedicatedServiceDeliveryLocation, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The DedicatedServiceDeliveryLocation created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.DSDLOC
  - newIncidentalServiceDeliveryLocation
```
public abstract Role newIncidentalServiceDeliveryLocation(CE code,
                                                          Entity player,
                                                          Entity scoper,
                                                          SET<II> id)
                                                   throws HDRRimException
```
    ISDLOC (incidental service delivery location) Creates an incidental service delivery location, a role played by a place at which healthcare services may be provided without prior designation or authorization.
    
    Parameters:
    
    code - Code for the IncidentalServiceDeliveryLocation. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the IncidentalServiceDeliveryLocation, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The IncidentalServiceDeliveryLocation created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.ISDLOC
  - newTerritory
```
public abstract Role newTerritory(CE code,
                                  Entity player,
                                  Entity scoper,
                                  SET<II> id)
                           throws HDRRimException
```
    TERR (territory) Creates a territory of authority, which relates a place entity (player) as the region over which the scoper (typically an Organization) has certain authority (jurisdiction). For example, the Calgary Regional Health Authority (scoper) has authority over the territory "Region 4 of Alberta" (player) in matters of health.
    
    Parameters:
    
    code - Code for the Territory. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the Territory, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The Territory created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.TERR
  - newWarrantedProduct
```
public abstract Role newWarrantedProduct(CE code,
                                         Entity player,
                                         Entity scoper,
                                         SET<II> id)
                                  throws HDRRimException
```
    WRTE (warranted product) Creates a warranted product, a role a product plays when a guarantee is given to the purchaser by the seller (scoping entity) stating that the product is reliable and free from known defects and that the seller will repair or replace defective parts within a given time limit and under certain conditions.
    
    Parameters:
    
    code - Code for the WarrantedProduct. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the WarrantedProduct, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The WarrantedProduct created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.WRTE
  - newGeneralization
```
public abstract Role newGeneralization(CE code,
                                       Entity player,
                                       Entity scoper,
                                       SET<II> id)
                                throws HDRRimException
```
    GEN (has generalization) Has generalization relates a specialized material concept (player) to its generalization (scoper).
    
    Parameters:
    
    code - Code for the Generalization. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the Generalization, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The Generalization created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.GEN
  - newGeneric
```
public abstract Role newGeneric(CE code,
                                Entity player,
                                Entity scoper,
                                SET<II> id)
                         throws HDRRimException
```
    GRIC (has generic) Has generic, a special link between pharmaceuticals indicating that the target (scoper) is a generic for the source (player).
    
    Parameters:
    
    code - Code for the Generic. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the Generic, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The Generic created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.GRIC
  - newInstance
```
public abstract Role newInstance(CE code,
                                 Entity player,
                                 Entity scoper,
                                 SET<II> id)
                          throws HDRRimException
```
    INST (instance) Instance is an individual piece of material (player) instantiating a class of material (scoper).
    
    Parameters:
    
    code - Code for the Instance. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the Instance, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The Instance created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.INST
  - newSubsumer
```
public abstract Role newSubsumer(CE code,
                                 Entity player,
                                 Entity scoper,
                                 SET<II> id)
                          throws HDRRimException
```
    SUBS (subsumer) Creates a subsumer, an entity that subsumes the identity of another. Used in the context of merging documented entity instances. Both the player and scoper must have the same classCode.
    
    The use of this code is deprecated in favor of the term SUBY which is its inverse and is more ontologically correct.
    
    Parameters:
    
    code - Code for the Subsumer. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the Subsumer, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The Subsumer created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.SUBS
  - newSubsumedBy
```
public abstract Role newSubsumedBy(CE code,
                                   Entity player,
                                   Entity scoper,
                                   SET<II> id)
                            throws HDRRimException
```
    SUBY (subsumed by) Subsumed by, relates a prevailing record of an Entity (scoper) with another record (player) that it subsumes.
    
    Examples: Show a correct new Person object (scoper) that subsumes one or more duplicate Person objects that had accidentally been created for the same physical person.
    
    Constraints: Both the player and scoper must have the same classCode.
    
    Parameters:
    
    code - Code for the SubsumedBy. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the SubsumedBy, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The SubsumedBy created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.SUBY
  - newContent
```
public abstract Role newContent(CE code,
                                Entity player,
                                Entity scoper,
                                SET<II> id)
                         throws HDRRimException
```
    CONT (content) Content relates a material as the content (player) to a container (scoper). Unlike ingredients, the content and a container remain separate (not mixed) and the content can be removed from the container. A content is not part of an empty container.
    
    Parameters:
    
    code - Code for the Content. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the Content, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The Content created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.CONT
  - newIngredient
```
public abstract Role newIngredient(CE code,
                                   Entity player,
                                   Entity scoper,
                                   SET<II> id)
                            throws HDRRimException
```
    INGR (ingredient) Ingredient relates a component (player) to a mixture (scoper). Example, Glucose and Water are ingredients of D5W, latex may be an ingredient in a tracheal tube.
    
    Parameters:
    
    code - Code for the Ingredient. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the Ingredient, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The Ingredient created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.INGR
  - newActiveIngredient
```
public abstract Role newActiveIngredient(CE code,
                                         Entity player,
                                         Entity scoper,
                                         SET<II> id)
                                  throws HDRRimException
```
    ACTI (active ingredient) Active ingredient, a therapeutically active ingredient (player) in a mixture (scoper), where the mixture is typically a manufactured pharmaceutical.
    
    Parameters:
    
    code - Code for the ActiveIngredient. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the ActiveIngredient, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The ActiveIngredient created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.ACTI
  - newActiveMoiety
```
public abstract Role newActiveMoiety(CE code,
                                     Entity player,
                                     Entity scoper,
                                     SET<II> id)
                              throws HDRRimException
```
    ACTM (active moiety).
    
    Parameters:
    
    code - Code for the ActiveMoiety. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the ActiveMoiety, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The ActiveMoiety created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.ACTM
  - newAdditive
```
public abstract Role newAdditive(CE code,
                                 Entity player,
                                 Entity scoper,
                                 SET<II> id)
                          throws HDRRimException
```
    ADTV (additive) Additive, an ingredient (player) that is added to a base (scoper), that amounts to a minor part of the overall mixture.
    
    Parameters:
    
    code - Code for the Additive. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the Additive, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The Additive created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.ADTV
  - newBaseIngredient
```
public abstract Role newBaseIngredient(CE code,
                                       Entity player,
                                       Entity scoper,
                                       SET<II> id)
                                throws HDRRimException
```
    BASE (base) A base ingredient (player) is what comprises the major part of a mixture (scoper). E.g., Water in most i.v. solutions, or Vaseline in salves. Among all ingredients of a material, there should be only one base. A base substance can, in turn, be a mixture.
    
    Parameters:
    
    code - Code for the BaseIngredient. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the BaseIngredient, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The BaseIngredient created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.BASE
  - newInactiveIngredient
```
public abstract Role newInactiveIngredient(CE code,
                                           Entity player,
                                           Entity scoper,
                                           SET<II> id)
                                    throws HDRRimException
```
    IACT (inactive ingredient).
    
    Parameters:
    
    code - Code for the InactiveIngredient. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the InactiveIngredient, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The InactiveIngredient created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.IACT
  - newColorAdditive
```
public abstract Role newColorAdditive(CE code,
                                      Entity player,
                                      Entity scoper,
                                      SET<II> id)
                               throws HDRRimException
```
    COLR (color additive) Color additive, a substance (player) influencing the optical aspect of material (scoper).
    
    Parameters:
    
    code - Code for the ColorAdditive. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the ColorAdditive, may be null. However, HDR will always generate an internal identifier.
    
    Returns:
    
    The ColorAdditive created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.COLR
  - newFlavorAdditive
```
public abstract Role newFlavorAdditive(CE code,
                                       Entity player,
                                       Entity scoper,
                                       SET<II> id)
                                throws HDRRimException
```
    FLVR (flavor additive) Flavor additive, a substance (player) added to a mixture (scoper) to make it taste a certain way. In food the use is obvious, in pharmaceuticals flavors can hide disgusting taste of the active ingredient (important in pediatric treatments).
    
    Parameters:
    
    code - Code for the FlavorAdditive. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the FlavorAdditive, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The FlavorAdditive created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.FLVR
  - newPreservative
```
public abstract Role newPreservative(CE code,
                                     Entity player,
                                     Entity scoper,
                                     SET<II> id)
                              throws HDRRimException
```
    PRSV (preservative) Preservative, a substance (player) added to a mixture (scoper) to prevent microorganisms (fungi, bacteria) to spoil the mixture.
    
    Parameters:
    
    code - Code for the Preservative. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the Preservative, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The Preservative created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.PRSV
  - newStabilizer
```
public abstract Role newStabilizer(CE code,
                                   Entity player,
                                   Entity scoper,
                                   SET<II> id)
                            throws HDRRimException
```
    STBL (stabilizer) A stabilizer (player) added to a mixture (scoper) in order to prevent the molecular disintegration of the main substance.
    
    Parameters:
    
    code - Code for the Stabilizer. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the Stabilizer, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The Stabilizer created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.STBL
  - newLocatedEntity
```
public abstract Role newLocatedEntity(CE code,
                                      Entity player,
                                      Entity scoper,
                                      SET<II> id)
                               throws HDRRimException
```
    LOCE (located entity) Located entity relates an entity (player) to a location (scoper) at which it is present in some way. This presence may be limited in time.
    
    Parameters:
    
    code - Code for the LocatedEntity. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the LocatedEntity, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The LocatedEntity created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.LOCE
  - newStoredEntity
```
public abstract Role newStoredEntity(CE code,
                                     Entity player,
                                     Entity scoper,
                                     SET<II> id)
                              throws HDRRimException
```
    STOR (stored entity) Stored entity relates an entity (player), eg. a device, to a location (scoper) at which it is normally found or stored when not used.
    
    Parameters:
    
    code - Code for the StoredEntity. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the StoredEntity, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The StoredEntity created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.STOR
  - newMember
```
public abstract Role newMember(CE code,
                               Entity player,
                               Entity scoper,
                               SET<II> id)
                        throws HDRRimException
```
    MBR (member) Creates a role played by an entity that is a member of a group. The group provides the scope for this role.
    
    Among other uses, groups as used in insurance (groups of covered individuals) and in scheduling where resources may be grouped for scheduling and logistical purposes.
    
    Parameters:
    
    code - Code for the Member. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the Member, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The Member created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.MBR
  - newPart
```
public abstract Role newPart(CE code,
                             Entity player,
                             Entity scoper,
                             SET<II> id)
                      throws HDRRimException
```
    PART (part) An association between two entities where the playing entity is considered in some way "part" of the scoping Entity, e.g., as a member, component, ingredient, or content. Being "part" in the broadest sense of the word can mean anything from being an integral structural component to a mere incidental temporary association of a playing Entity with a (generally larger) scoping Entity.
    
    Parameters:
    
    code - Code for the Part. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the Part, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The Part created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.PART
  - newSpecimen
```
public abstract Role newSpecimen(CE code,
                                 Entity player,
                                 Entity scoper,
                                 SET<II> id)
                          throws HDRRimException
```
    SPEC (specimen) Specimen, a role played by a material entity that is a specimen for an act. It is scoped by the source of the specimen.
    
    Parameters:
    
    code - Code for the Specimen. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the Specimen, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The Specimen created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.SPEC
  - newAliquot
```
public abstract Role newAliquot(CE code,
                                Entity player,
                                Entity scoper,
                                SET<II> id)
                         throws HDRRimException
```
    ALQT (aliquot) Aliquot, a portion (player) of an original or source specimen (scoper) used for testing or transportation.
    
    Parameters:
    
    code - Code for the Aliquot. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the Aliquot, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The Aliquot created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.ALQT
  - newIsolate
```
public abstract Role newIsolate(CE code,
                                Entity player,
                                Entity scoper,
                                SET<II> id)
                         throws HDRRimException
```
    ISLT (isolate) Isolate, a microorganism that has been isolated from other microorganisms or a source matrix.
    
    Parameters:
    
    code - Code for the Isolate. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the Isolate, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The Isolate created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.ISLT
  - newCareGiver
```
public abstract Role newCareGiver(CE code,
                                  Entity player,
                                  Entity scoper,
                                  SET<II> id)
                           throws HDRRimException
```
    CAREGIVER (caregiver) Role played by a person giving care to the scoper. This role is frequently used to represent a family member caring for a patient at home.
    
    Parameters:
    
    code - Code for the CareGiver. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the CareGiver, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The CareGiver created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.CAREGIVER
  - newCaseSubject
```
public abstract Role newCaseSubject(CE code,
                                    Entity player,
                                    Entity scoper,
                                    SET<II> id)
                             throws HDRRimException
```
    CASESBJ (case subject) A person, non-person living subject, or place that is the subject of an investigation related to a notifiable condition (health circumstance that is reportable within the applicable public health jurisdiction).
    
    Parameters:
    
    code - Code for the CaseSubject. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the CaseSubject, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The CaseSubject created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.CASESBJ
  - newInvestigatedSubject
```
public abstract Role newInvestigatedSubject(CE code,
                                            Entity player,
                                            Entity scoper,
                                            SET<II> id)
                                     throws HDRRimException
```
    INVSBJ (investigated subject) An entity that is the subject of an investigation. This role is scoped by the party responsible for the investigation.
    
    Parameters:
    
    code - Code for the InvestigatedSubject. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the InvestigatedSubject, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The InvestigatedSubject created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.INVSBJ
  - newAdministerableMaterial
```
public abstract Role newAdministerableMaterial(CE code,
                                               Entity player,
                                               Entity scoper,
                                               SET<II> id)
                                        throws HDRRimException
```
    ADMM (Administerable Material) A material (player) that can be administered to an Entity (scoper).
    
    Parameters:
    
    code - Code for the AdministerableMaterial. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the AdministerableMaterial, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The AdministerableMaterial created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.ADMM
  - newAffiliate
```
public abstract Role newAffiliate(CE code,
                                  Entity player,
                                  Entity scoper,
                                  SET<II> id)
                           throws HDRRimException
```
    AFFL (affiliate) Player of the Affiliate role has a business/professional relationship with scoper. Player and scoper may be persons or organization. The Affiliate relationship does not imply membership in a group, nor does it exist for resource scheduling purposes.
    
    Parameters:
    
    code - Code for the Affiliate. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the Affiliate, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The Affiliate created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.AFFL
  - newCommissioningParty
```
public abstract Role newCommissioningParty(CE code,
                                           Entity player,
                                           Entity scoper,
                                           SET<II> id)
                                    throws HDRRimException
```
    COMPAR (commissioning party) An Entity that is authorized to issue or instantiate permissions, privileges, credentials or other formal/legal authorizations.
    
    Parameters:
    
    code - Code for the CommissioningParty. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the CommissioningParty, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The CommissioningParty created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.COMPAR
  - newSame
```
public abstract Role newSame(CE code,
                             Entity player,
                             Entity scoper,
                             SET<II> id)
                      throws HDRRimException
```
    SAME (same) The "same" roleclass asserts an identity between playing and scoping entities: that they are in fact instances of the same entity and, in the case of discrepancies (e.g different DOB, gender), that one or both are in error.
    
    Parameters:
    
    code - Code for the Same. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the Same, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    The Same created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.SAME
  - newPlaceOfDeath
```
public abstract Role newPlaceOfDeath(CE code,
                                     Entity player,
                                     Entity scoper,
                                     SET<II> id)
                              throws HDRRimException
```
    DEATHPLC (place of death) Relates a place (playing Entity) as the location where a living subject (scoping Entity) died
    
    Parameters:
    
    code - Code for the place of death. This is an optional parameter
    
    player - The Entity playing this Role
    
    scoper - The Entity scoping this Role
    
    id - Identification of the place of death, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
    
    Returns:
    
    the place of death created
    
    Throws:
    
    HDRRimException - when the id passed is same as INTERNAL_ROOT.
    
    See Also:
    
    RoleClass.DEATHPLC
  - makeReference
```
public abstract Role makeReference(ReferenceModifier modifier,
                                   CS roleClass,
                                   CE code,
                                   Entity player,
                                   Entity scoper,
                                   SET<II> id,
                                   int versionNumber)
                            throws HDRRimException
```
    Creates a reference to an object that is assumed to already exist in HDR. Only the first and last argument are mandatory.
    Parameters:
    modifier - Controls the behavior of the reference when submitted. Possible values include:
    
    MustExist - The referenced object must be found in the database. All but the class and II are ignored.
    
    CreateIf - If the object does not exist, the object is used to create the object in the database. Otherwise, the contents of the object are ignored.
    
    CreateOrOverlay - If the object does not exist, it is created. If it does exist, it is updated thus incrementing the version number of the object. Any attributes not set in the object will also be cleared in the new version. Use this variation to simulate Inbound Message Processor behavior.
    
    CreateOrUpdate - If the object does not already exist, it is created. If it does exist it will be updated thus incrementing the current version of the object. Any attributes not set in the object will be retained from the existing database object. Use this variation to update one or more attributes without having to query the existing object first. Where there are duplicates, the "new" entries replace the old attribute. If more control is needed, the application should query the object and call newVersion.
    
    Overlay - Identical to CreateOrOverlay, but will not create an object that does not already exist.
    
    Update - As for CreateOrUpdate, but will not create an object that does not already exist.
  roleClass - Class Code of the Role. This parameter must be specified for CreateIf, CreateOrOverlay, CreateOrUpdate, and Overlay modifiers.
  
  code - role code. This parameter may be null. However a null value may result in validation failures for Overlay or CreateOrOverlay references if an attempt is made to modify an object that has a code.
  
  player - This parameter is optional
  
  scoper - This parameter is optional
  
  id - Identification of the position, which is mandatory and cannot be an empty set. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
  
  versionNumber - Zero or a valid positive integer. If it is zero, then the current version will be used. For positive integer values the behavior will vary depending on the modifier. It is ignored for CREATE_IF references. For MUST_EXIST references, the specified versionNumber must correspond to a version in the database. For UPDATE or OVERLAY references the specified versionNumber must correspond to a version in the database and be the current version at the time of submission. CREATE_OR_OVERLAY and CREATE_OR_UPDATE references will behave like CREATE_IF or UPDATE/OVERLAY depending on whether an object exists in the database.
  
  Returns:
  
  The Role object which is being referenced here. This can be downcasted to the proper sub class of Role based on the class code passed.
  
  Throws:
  
  HDRRimException
- newActiveIngredientBasisOfStrength
```
public abstract Role newActiveIngredientBasisOfStrength(CE code,
                                                        Entity player,
                                                        Entity scoper,
                                                        SET<II> id)
                                                 throws HDRRimException
```
  ACTIB (active ingredient - basis of strength) Active ingredient, where the ingredient substance (player) is itself the "basis of strength", i.e., where the Role.quantity specifies exactly the quantity of the player substance in the medicine formulation.
  
  Parameters:
  
  code - Code for the ActiveIngredientBasisOfStrength. This is an optional parameter
  
  player - The Entity playing this Role
  
  scoper - The Entity scoping this Role
  
  id - Identification of the ActiveIngredientBasisOfStrength, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
  
  Returns:
  
  The ActiveIngredientBasisOfStrength created
  
  Throws:
  
  HDRRimException - when the id passed is same as INTERNAL_ROOT.
  
  See Also:
  
  RoleClass.ACTIB
- newActiveIngredientMoietyIsBasisOfStrength
```
public abstract Role newActiveIngredientMoietyIsBasisOfStrength(CE code,
                                                                Entity player,
                                                                Entity scoper,
                                                                SET<II> id)
                                                         throws HDRRimException
```
  ACTIM (active ingredient - moiety is basis of strength) Active ingredient, where not the ingredient substance (player), but itaTMs active moiety is the "basis of strength", i.e., where the Role.quantity specifies the quantity of the player substance's active moiety in the medicine formulation
  
  Parameters:
  
  code - Code for the ActiveIngredientMoietyIsBasisOfStrength. This is an optional parameter
  
  player - The Entity playing this Role
  
  scoper - The Entity scoping this Role
  
  id - Identification of the ActiveIngredientMoietyIsBasisOfStrength, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
  
  Returns:
  
  The ActiveIngredientMoietyIsBasisOfStrength created
  
  Throws:
  
  HDRRimException - when the id passed is same as INTERNAL_ROOT.
  
  See Also:
  
  RoleClass.ACTIM
- newActiveIngredientReferenceSubstanceIsBasisOfStrength
```
public abstract Role newActiveIngredientReferenceSubstanceIsBasisOfStrength(CE code,
                                                                            Entity player,
                                                                            Entity scoper,
                                                                            SET<II> id)
                                                                     throws HDRRimException
```
  ACTIR (active ingredient - reference substance is basis of strength) Active ingredient, where not the ingredient substance (player) but another reference substance with the same active moiety, is the "basis of strength", i.e., where the Role.quantity specifies the quantity of a reference substance, similar but different from the player substance's in the medicine formulation
  
  Parameters:
  
  code - Code for the ActiveIngredientReferenceSubstanceIsBasisOfStrength. This is an optional parameter
  
  player - The Entity playing this Role
  
  scoper - The Entity scoping this Role
  
  id - Identification of the ActiveIngredientReferenceSubstanceIsBasisOfStrength, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
  
  Returns:
  
  The ActiveIngredientReferenceSubstanceIsBasisOfStrength created
  
  Throws:
  
  HDRRimException - when the id passed is same as INTERNAL_ROOT.
  
  See Also:
  
  RoleClass.ACTIR
- newAdjuvant
```
public abstract Role newAdjuvant(CE code,
                                 Entity player,
                                 Entity scoper,
                                 SET<II> id)
                          throws HDRRimException
```
  ADJV (adjuvant) A component (player) added to enhance the action of an active ingredient (scoper) (in the manner of a catalyst) but which has no active effect in and of itself. Such ingredients are significant in defining equivalence of products in a way that inactive ingredients are not
  
  Parameters:
  
  code - Code for the Adjuvant. This is an optional parameter
  
  player - The Entity playing this Role
  
  scoper - The Entity scoping this Role
  
  id - Identification of the Adjuvant, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
  
  Returns:
  
  The Adjuvant created
  
  Throws:
  
  HDRRimException - when the id passed is same as INTERNAL_ROOT.
  
  See Also:
  
  RoleClass.ADJV
- newAdjacency
```
public abstract Role newAdjacency(CE code,
                                  Entity player,
                                  Entity scoper,
                                  SET<II> id)
                           throws HDRRimException
```
  ADJY (adjacency) A physical association whereby two Entities are in some (even lose) spatial relationship with each other such that they touch each other in some way
  
  Parameters:
  
  code - Code for the Adjacency. This is an optional parameter
  
  player - The Entity playing this Role
  
  scoper - The Entity scoping this Role
  
  id - Identification of the Adjacency, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
  
  Returns:
  
  The Adjacency created
  
  Throws:
  
  HDRRimException - when the id passed is same as INTERNAL_ROOT.
  
  See Also:
  
  RoleClass.ADJY
- newBond
```
public abstract Role newBond(CE code,
                             Entity player,
                             Entity scoper,
                             SET<II> id)
                      throws HDRRimException
```
  BOND (molecular bond) A connection between two atoms of a molecule.
  
  Parameters:
  
  code - Code for the Bond. This is an optional parameter
  
  player - The Entity playing this Role
  
  scoper - The Entity scoping this Role
  
  id - Identification of the Bond, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
  
  Returns:
  
  The Bond created
  
  Throws:
  
  HDRRimException - when the id passed is same as INTERNAL_ROOT.
  
  See Also:
  
  RoleClass.BOND
- newClaimant
```
public abstract Role newClaimant(CE code,
                                 Entity player,
                                 Entity scoper,
                                 SET<II> id)
                          throws HDRRimException
```
  CLAIM (claimant) A role played by a party making a claim for coverage under a policy or program. A claimant must be either a person or organization, or a group of persons or organizations. A claimant is not a named insured or a program eligible.
  
  Parameters:
  
  code - Code for the Claimant. This is an optional parameter
  
  player - The Entity playing this Role
  
  scoper - The Entity scoping this Role
  
  id - Identification of the Claimant, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
  
  Returns:
  
  The Claimant created
  
  Throws:
  
  HDRRimException - when the id passed is same as INTERNAL_ROOT.
  
  See Also:
  
  RoleClass.CLAIM
- newContaminant
```
public abstract Role newContaminant(CE code,
                                    Entity player,
                                    Entity scoper,
                                    SET<II> id)
                             throws HDRRimException
```
  CNTM (contaminant ingredient) An ingredient whose presence is not intended but may not be reasonably avoided given the circumstances of the mixture's nature or origin.
  
  Parameters:
  
  code - Code for the Contaminant. This is an optional parameter
  
  player - The Entity playing this Role
  
  scoper - The Entity scoping this Role
  
  id - Identification of the Contaminant, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
  
  Returns:
  
  The Contaminant created
  
  Throws:
  
  HDRRimException - when the id passed is same as INTERNAL_ROOT.
  
  See Also:
  
  RoleClass.CNTM
- newConnection
```
public abstract Role newConnection(CE code,
                                   Entity player,
                                   Entity scoper,
                                   SET<II> id)
                            throws HDRRimException
```
  CONC (connection) An adjacency of two Entities held together by a bond which attaches to each of the two entities.
  
  Parameters:
  
  code - Code for the Connection. This is an optional parameter
  
  player - The Entity playing this Role
  
  scoper - The Entity scoping this Role
  
  id - Identification of the Connection, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
  
  Returns:
  
  The Connection created
  
  Throws:
  
  HDRRimException - when the id passed is same as INTERNAL_ROOT.
  
  See Also:
  
  RoleClass.CONC
- newContinuity
```
public abstract Role newContinuity(CE code,
                                   Entity player,
                                   Entity scoper,
                                   SET<II> id)
                            throws HDRRimException
```
  CONY (continuity) A connection between two regional parts.
  
  Parameters:
  
  code - Code for the Continuity. This is an optional parameter
  
  player - The Entity playing this Role
  
  scoper - The Entity scoping this Role
  
  id - Identification of the Continuity, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
  
  Returns:
  
  The Continuity created
  
  Throws:
  
  HDRRimException - when the id passed is same as INTERNAL_ROOT.
  
  See Also:
  
  RoleClass.CONY
- newDependent
```
public abstract Role newDependent(CE code,
                                  Entity player,
                                  Entity scoper,
                                  SET<II> id)
                           throws HDRRimException
```
  DEPEN (dependent) A role played by a person covered under a policy or program based on an association with a subscriber, which is recognized by the policy holder.
  
  Parameters:
  
  code - Code for the Dependent. This is an optional parameter
  
  player - The Entity playing this Role
  
  scoper - The Entity scoping this Role
  
  id - Identification of the Dependent, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
  
  Returns:
  
  The Dependent created
  
  Throws:
  
  HDRRimException - when the id passed is same as INTERNAL_ROOT.
  
  See Also:
  
  RoleClass.DEPEN
- newEquivalentEntity
```
public abstract Role newEquivalentEntity(CE code,
                                         Entity player,
                                         Entity scoper,
                                         SET<II> id)
                                  throws HDRRimException
```
  EQUIV (equivalent entity) Specifies the player Entity (the equivalent Entity) as an Entity that is considered to be equivalent to a reference Entity (scoper). The equivalence is in principle a symmetric relationship, however, it is expected that the scoper is a reference entity which serves as reference entity for multiple different equivalent entities.
  
  Parameters:
  
  code - Code for the EquivalentEntity. This is an optional parameter
  
  player - The Entity playing this Role
  
  scoper - The Entity scoping this Role
  
  id - Identification of the EquivalentEntity, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
  
  Returns:
  
  The EquivalentEntity created
  
  Throws:
  
  HDRRimException - when the id passed is same as INTERNAL_ROOT.
  
  See Also:
  
  RoleClass.EQUIV
- newEventLocation
```
public abstract Role newEventLocation(CE code,
                                      Entity player,
                                      Entity scoper,
                                      SET<II> id)
                               throws HDRRimException
```
  EXLOC (event location) A role played by a place at which the location of an event may be recorded.
  
  Parameters:
  
  code - Code for the EventLocation. This is an optional parameter
  
  player - The Entity playing this Role
  
  scoper - The Entity scoping this Role
  
  id - Identification of the EventLocation, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
  
  Returns:
  
  The EventLocation created
  
  Throws:
  
  HDRRimException - when the id passed is same as INTERNAL_ROOT.
  
  See Also:
  
  RoleClass.EXLOC
- newExposureAgentCarrier
```
public abstract Role newExposureAgentCarrier(CE code,
                                             Entity player,
                                             Entity scoper,
                                             SET<II> id)
                                      throws HDRRimException
```
  EXPAGTCAR (exposure agent carrier) An exposure agent carrier is an entity that is capable of conveying an exposure agent from one entity to another. The scoper of the role must be the exposure agent (e.g., pathogen).
  
  Parameters:
  
  code - Code for the ExposureAgentCarrier. This is an optional parameter
  
  player - The Entity playing this Role
  
  scoper - The Entity scoping this Role
  
  id - Identification of the ExposureAgentCarrier, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
  
  Returns:
  
  The ExposureAgentCarrier created
  
  Throws:
  
  HDRRimException - when the id passed is same as INTERNAL_ROOT.
  
  See Also:
  
  RoleClass.EXPAGTCAR
- newExposureVector
```
public abstract Role newExposureVector(CE code,
                                       Entity player,
                                       Entity scoper,
                                       SET<II> id)
                                throws HDRRimException
```
  EXPVECTOR (exposure vector) An exposure agent carrier is an entity that is capable of conveying an exposure agent from one entity to another. The scoper of the role must be the exposure agent (e.g., pathogen).
  
  Parameters:
  
  code - Code for the ExposureVector. This is an optional parameter
  
  player - The Entity playing this Role
  
  scoper - The Entity scoping this Role
  
  id - Identification of the ExposureVector, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
  
  Returns:
  
  The ExposureVector created
  
  Throws:
  
  HDRRimException - when the id passed is same as INTERNAL_ROOT.
  
  See Also:
  
  RoleClass.EXPVECTOR
- newFomite
```
public abstract Role newFomite(CE code,
                               Entity player,
                               Entity scoper,
                               SET<II> id)
                        throws HDRRimException
```
  FOMITE (fomite) A fomite is a non-living entity that is capable of conveying exposure agent from one entity to another. A doorknob contaminated with a Norovirus is an example of a fomite. Anyone touching the doorknob would be exposed to the virus. The scoper of the role must be the exposure agent (e.g., pathogen).
  
  Parameters:
  
  code - Code for the Fomite. This is an optional parameter
  
  player - The Entity playing this Role
  
  scoper - The Entity scoping this Role
  
  id - Identification of the Fomite, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
  
  Returns:
  
  The Fomite created
  
  Throws:
  
  HDRRimException - when the id passed is same as INTERNAL_ROOT.
  
  See Also:
  
  RoleClass.FOMITE
- newIndividual
```
public abstract Role newIndividual(CE code,
                                   Entity player,
                                   Entity scoper,
                                   SET<II> id)
                            throws HDRRimException
```
  INDIV (individual) A role played by a party covered under a policy as the policy holder. An individual may be either a person or an organization.
  
  Parameters:
  
  code - Code for the Individual. This is an optional parameter
  
  player - The Entity playing this Role
  
  scoper - The Entity scoping this Role
  
  id - Identification of the Individual, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
  
  Returns:
  
  The Individual created
  
  Throws:
  
  HDRRimException - when the id passed is same as INTERNAL_ROOT.
  
  See Also:
  
  RoleClass.INDIV
- newMechanicalIngredient
```
public abstract Role newMechanicalIngredient(CE code,
                                             Entity player,
                                             Entity scoper,
                                             SET<II> id)
                                      throws HDRRimException
```
  MECH (mechanical ingredient) An ingredient (player) of a medication (scoper) that is inseparable from the active ingredients, but has no intended chemical or pharmaceutical effect itself, but which may have some systemic effect on the patient.An example is a collagen matrix used as a base for transplanting skin cells. The collagen matrix can be left permanently in the graft site. Because it is of bovine origin, the patient may exhibit allergies or may have cultural objections to its use.
  
  Parameters:
  
  code - Code for the MechanicalIngredient. This is an optional parameter
  
  player - The Entity playing this Role
  
  scoper - The Entity scoping this Role
  
  id - Identification of the MechanicalIngredient, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
  
  Returns:
  
  The MechanicalIngredient created
  
  Throws:
  
  HDRRimException - when the id passed is same as INTERNAL_ROOT.
  
  See Also:
  
  RoleClass.MECH
- newNamedInsured
```
public abstract Role newNamedInsured(CE code,
                                     Entity player,
                                     Entity scoper,
                                     SET<II> id)
                              throws HDRRimException
```
  NAMED (named insured) A role played by a party to an insurance policy to which the insurer agrees to indemnify for losses, provides benefits for, or renders services. A named insured may be either a person, non-person living subject, or an organization, or a group of persons, non-person living subjects, or organizations.
  
  Parameters:
  
  code - Code for the NamedInsured. This is an optional parameter
  
  player - The Entity playing this Role
  
  scoper - The Entity scoping this Role
  
  id - Identification of the NamedInsured, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
  
  Returns:
  
  The NamedInsured created
  
  Throws:
  
  HDRRimException - when the id passed is same as INTERNAL_ROOT.
  
  See Also:
  
  RoleClass.NAMED
- newProgramEligible
```
public abstract Role newProgramEligible(CE code,
                                        Entity player,
                                        Entity scoper,
                                        SET<II> id)
                                 throws HDRRimException
```
  PROG (program eligible) A role played by a party that meets the eligibility criteria for coverage under a program. A program eligible may be either a person, non-person living subject, or an organization, or a group of persons, non-person living subjects, or organizations.
  
  Parameters:
  
  code - Code for the ProgramEligible. This is an optional parameter
  
  player - The Entity playing this Role
  
  scoper - The Entity scoping this Role
  
  id - Identification of the ProgramEligible, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
  
  Returns:
  
  The ProgramEligible created
  
  Throws:
  
  HDRRimException - when the id passed is same as INTERNAL_ROOT.
  
  See Also:
  
  RoleClass.PROG
- newSubscriber
```
public abstract Role newSubscriber(CE code,
                                   Entity player,
                                   Entity scoper,
                                   SET<II> id)
                            throws HDRRimException
```
  SUBSCR (subscriber) A role played by a person covered under a policy based on association with a sponsor who is the policy holder, and whose association may provide for the eligibility of dependents for coverage.
  
  Parameters:
  
  code - Code for the Subscriber. This is an optional parameter
  
  player - The Entity playing this Role
  
  scoper - The Entity scoping this Role
  
  id - Identification of the Subscriber, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
  
  Returns:
  
  The Subscriber created
  
  Throws:
  
  HDRRimException - when the id passed is same as INTERNAL_ROOT.
  
  See Also:
  
  RoleClass.SUBSCR
- newUsedEntity
```
public abstract Role newUsedEntity(CE code,
                                   Entity player,
                                   Entity scoper,
                                   SET<II> id)
                            throws HDRRimException
```
  USED (used entity) An entity (player) that is used by another entity (scoper).
  
  Parameters:
  
  code - Code for the UsedEntity. This is an optional parameter
  
  player - The Entity playing this Role
  
  scoper - The Entity scoping this Role
  
  id - Identification of the UsedEntity, may be null. However, HDR will always generate an internal identifier. The II is unique across a broad class (Act, Entity, non-owned Role) rather than across the finer grained classes of HL7.
  
  Returns:
  
  The UsedEntity created
  
  Throws:
  
  HDRRimException - when the id passed is same as INTERNAL_ROOT.
  
  See Also:
  
  RoleClass.USED

Class RoleFactory

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

RoleFactory

Method Detail

getInstance

newRole

newIdentifiedEntity

newPatient

newAssignedEntity

newAgent

newContact

newEmergencyContact

newNextOfKin

newSigningAuthority

newGuardian

newCitizen

newCoveredParty

newResearchInvestigator

newResearchSponsor

newEmployee

newMilitaryPerson

newGuarantor

newLicensedEntity

newNotaryPublic

newHealthcareProvider

newPayee

newPayor

newPolicyHolder

newQualifiedEntity

newResearchSubject

newSponsor

newStudent

newUnderwriter

newPersonalRelationship

newAccess

newBirthplace

newDistributedMaterial

newRetailedMaterial

newExposedEntity

newHeldEntity

newHealthChart

newManufacturedProduct

newTherapeuticAgent

newMaintainedEntity

newOwnedEntity

newRegulatedProduct

newServiceDeliveryLocation

newDedicatedServiceDeliveryLocation

newIncidentalServiceDeliveryLocation

newTerritory

newWarrantedProduct

newGeneralization

newGeneric

newInstance

newSubsumer

newSubsumedBy

newContent

newIngredient

newActiveIngredient

newActiveMoiety

newAdditive

newBaseIngredient

newInactiveIngredient

newColorAdditive

newFlavorAdditive

newPreservative

newStabilizer

newLocatedEntity

newStoredEntity

newMember

newPart

newSpecimen

newAliquot

newIsolate

newCareGiver

newCaseSubject

newInvestigatedSubject