Java 类org.hibernate.annotations.SortType 实例源码

@ManyToMany(fetch = FetchType.LAZY, cascade = { CascadeType.PERSIST, CascadeType.MERGE })
@JoinTable(name = "cellUpdateActivity",
           joinColumns = @JoinColumn(name = "cellId", nullable = false, updatable = false),
           inverseJoinColumns = @JoinColumn(name = "updateActivityId", nullable = false, updatable = false, unique = true))
@org.hibernate.annotations.Cascade(value = { org.hibernate.annotations.CascadeType.SAVE_UPDATE })
@Sort(type = SortType.NATURAL)
@ToMany(singularPropertyName = "updateActivity", hasNonconventionalMutation = true /*
                                                                                    * model testing framework doesn't
                                                                                    * understand this is a containment
                                                                                    * relationship, and so requires
                                                                                    * addUpdateActivity() method
                                                                                    */)
@Override
public SortedSet<AdministrativeActivity> getUpdateActivities()
{
  return _updateActivities;
}

@ManyToMany(fetch = FetchType.LAZY, cascade = { CascadeType.PERSIST, CascadeType.MERGE })
@JoinTable(name = "copyUpdateActivity",
           joinColumns = @JoinColumn(name = "copyId", nullable = false, updatable = false),
           inverseJoinColumns = @JoinColumn(name = "updateActivityId", nullable = false, updatable = false, unique = true))
@org.hibernate.annotations.Cascade(value = { org.hibernate.annotations.CascadeType.SAVE_UPDATE })
@Sort(type = SortType.NATURAL)
@ToMany(singularPropertyName = "updateActivity", hasNonconventionalMutation = true /*
                                                                                    * model testing framework doesn't
                                                                                    * understand this is a containment
                                                                                    * relationship, and so requires
                                                                                    * addUpdateActivity() method
                                                                                    */)
@Override
public SortedSet<AdministrativeActivity> getUpdateActivities()
{
  return _updateActivities;
}

/**
 * Get the set of checklist item events.
 * @return the checklist item events
 */
@OneToMany(mappedBy = "screeningRoomUser", cascade = { CascadeType.ALL }, orphanRemoval = true)
@Sort(type=SortType.NATURAL)
public SortedSet<ChecklistItemEvent> getChecklistItemEvents()
{
  return _checklistItemEvents;
}

@OneToMany(mappedBy = "servicedUser")
@edu.harvard.med.screensaver.model.annotations.ToMany(singularPropertyName = "serviceActivity")
@Sort(type = SortType.NATURAL)
public SortedSet<ServiceActivity> getServiceActivities()
{
  return _serviceActivities;
}

@OneToMany(mappedBy="expedientTipus", cascade={CascadeType.ALL}, fetch=FetchType.EAGER)
@Fetch(value = FetchMode.SUBSELECT)
@MapKey(name = "any")
@Sort(type = SortType.NATURAL)
public SortedMap<Integer, SequenciaAny> getSequenciaAny() {
    return sequenciaAny;
}

@OneToMany(mappedBy="expedientTipus", cascade={CascadeType.ALL}, fetch=FetchType.EAGER)
@Fetch(value = FetchMode.SUBSELECT)
@MapKey(name = "any")
@Sort(type = SortType.NATURAL)
public SortedMap<Integer, SequenciaDefaultAny> getSequenciaDefaultAny() {
    return sequenciaDefaultAny;
}

/**
    * <p>Getter for the field <code>classpaths</code>.</p>
    *
    * @return a {@link java.util.SortedSet} object.
    */
   @CollectionOfElements
@JoinTable( name="RUNNER_CLASSPATHS", joinColumns={@JoinColumn(name="RUNNER_ID")} )
@Column(name = "elt", nullable = true, length=255)
@Sort(type = SortType.COMPARATOR, comparator = ClasspathComparator.class)
public SortedSet<String> getClasspaths()
   {
       return classpaths;
   }

/**
    * <p>Getter for the field <code>fixtureClasspaths</code>.</p>
    *
    * @return a {@link java.util.SortedSet} object.
    */
   @CollectionOfElements
@JoinTable( name="SUT_FIXTURE_CLASSPATHS", joinColumns={@JoinColumn(name="SUT_ID")} )
@Column(name = "elt", nullable = true, length=255)
@Sort(type = SortType.COMPARATOR, comparator = ClasspathComparator.class)
public SortedSet<String> getFixtureClasspaths()
   {
       return fixtureClasspaths;
   }

/**
    * <p>Getter for the field <code>sutClasspaths</code>.</p>
    *
    * @return a {@link java.util.SortedSet} object.
    */
   @CollectionOfElements
@JoinTable( name="SUT_CLASSPATHS", joinColumns={@JoinColumn(name="SUT_ID")} )
@Column(name = "elt", nullable = true, length=255)
@Sort(type = SortType.COMPARATOR, comparator = ClasspathComparator.class)
public SortedSet<String> getSutClasspaths()
   {
       return sutClasspaths;
   }

/**
    * <p>Getter for the field <code>targetedSystemUnderTests</code>.</p>
    *
    * @return a {@link java.util.SortedSet} object.
    */
   @ManyToMany( targetEntity= SystemUnderTest.class, cascade={CascadeType.PERSIST, CascadeType.MERGE} )
   @JoinTable( name="SUT_SPECIFICATION", joinColumns={@JoinColumn(name="SPECIFICATION_ID")}, inverseJoinColumns={@JoinColumn(name="SUT_ID")} )
@Sort(type=SortType.COMPARATOR, comparator=SystemUnderTestByNameComparator.class)
   public SortedSet<SystemUnderTest> getTargetedSystemUnderTests()
   {
       return targetedSystemUnderTests;
   }

/**
 * @return the houseNumbers associated to that street
 */
@OneToMany(cascade = { CascadeType.ALL }, mappedBy = "street")
   @Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
   @Fetch(FetchMode.SELECT)
@Sort(comparator=HouseNumberComparator.class,type=SortType.COMPARATOR)
public SortedSet<HouseNumber> getHouseNumbers() {
    return houseNumbers;
}

/**
 *
 * @return Return the subjects that this content is about.
 */
@ElementCollection
@Column(name = "type")
@Enumerated(EnumType.STRING)
@Sort(type = SortType.NATURAL)
public SortedSet<DescriptionType> getTypes() {
    return types;
}

@CollectionOfElements
@JoinTable( name="RUNNER_CLASSPATHS", joinColumns={@JoinColumn(name="RUNNER_ID")} )
@Column(name = "elt", nullable = true, length=255)
@Sort(type = SortType.COMPARATOR, comparator = ClasspathComparator.class)
public SortedSet<String> getClasspaths()
   {
       return classpaths;
   }

@CollectionOfElements
@JoinTable( name="SUT_FIXTURE_CLASSPATHS", joinColumns={@JoinColumn(name="SUT_ID")} )
@Column(name = "elt", nullable = true, length=255)
@Sort(type = SortType.COMPARATOR, comparator = ClasspathComparator.class)
public SortedSet<String> getFixtureClasspaths()
   {
       return fixtureClasspaths;
   }

@CollectionOfElements
@JoinTable( name="SUT_CLASSPATHS", joinColumns={@JoinColumn(name="SUT_ID")} )
@Column(name = "elt", nullable = true, length=255)
@Sort(type = SortType.COMPARATOR, comparator = ClasspathComparator.class)
public SortedSet<String> getSutClasspaths()
   {
       return sutClasspaths;
   }

@ManyToMany( targetEntity= SystemUnderTest.class, cascade={CascadeType.PERSIST, CascadeType.MERGE} )
   @JoinTable( name="SUT_SPECIFICATION", joinColumns={@JoinColumn(name="SPECIFICATION_ID")}, inverseJoinColumns={@JoinColumn(name="SUT_ID")} )
@Sort(type=SortType.COMPARATOR, comparator=SystemUnderTestByNameComparator.class)
   public SortedSet<SystemUnderTest> getTargetedSystemUnderTests()
   {
       return targetedSystemUnderTests;
   }

/**
     * Get the list of Results
     */
    // resultsPK
    @OneToMany(mappedBy = "submits", cascade = CascadeType.REMOVE)
//    @OrderBy(clause = "id asc")
    @Sort(type = SortType.NATURAL)
    public SortedSet<Results> getResultss() {
        return this.resultss;
    }

/**
     * Get the list of Submits
     */
    // submitsPK
    @OneToMany(mappedBy = "problems", cascade = CascadeType.REMOVE)
//    @OrderBy(value = "testorder")
    @Sort(type = SortType.NATURAL)
    public SortedSet<Tests> getTestss() {
        return this.testss;
    }

/**
 */
@OneToMany(mappedBy = "cell", cascade = { CascadeType.ALL }, orphanRemoval = true)
@org.hibernate.annotations.Sort(type=org.hibernate.annotations.SortType.NATURAL)
@org.hibernate.annotations.ForeignKey(name = "fk_experimental_cell_information_link_to_cell")
public SortedSet<ExperimentalCellInformation> getExperimentalCellInformationSet()
{
  return experimentalCellInformationSet;
}

/**
 * Get the set of wells.
 *
 * @return the wells
 */
@OneToMany(mappedBy = "library", cascade = { CascadeType.ALL })
@Sort(type = SortType.NATURAL)
public SortedSet<Well> getWells()
{
  return _wells;
}

/**
 * Get the copies.
 *
 * @return the copies
 */
@OneToMany(mappedBy = "library", cascade = { CascadeType.ALL })
@Sort(type = SortType.NATURAL)
public SortedSet<Copy> getCopies()
{
  return _copies;
}

@ManyToMany(fetch = FetchType.LAZY, cascade = { CascadeType.ALL })
@JoinTable(name = "plateUpdateActivity",
           joinColumns = @JoinColumn(name = "plateId", nullable = false, updatable = false),
           inverseJoinColumns = @JoinColumn(name = "updateActivityId", nullable = false, updatable = false, unique = true))
@org.hibernate.annotations.Cascade(value = { org.hibernate.annotations.CascadeType.SAVE_UPDATE })
@Sort(type = SortType.NATURAL)
// hasNonconventionalMutation: model testing framework doesn't understand this is a containment relationship, and so requires addUpdateActivity() method
@ToMany(singularPropertyName = "updateActivity", hasNonconventionalMutation = true)
@Override
public SortedSet<AdministrativeActivity> getUpdateActivities()
{
  return _updateActivities;
}

/**
 * Get the ordered set of all {@link DataColumn}s for this screen result.
 * @return the ordered set of all {@link DataColumn}s for this screen
 * result.
 */
@OneToMany(mappedBy = "screenResult", cascade = { CascadeType.ALL }, orphanRemoval = true)
@org.hibernate.annotations.Sort(type=org.hibernate.annotations.SortType.NATURAL)
public SortedSet<DataColumn> getDataColumns()
{
  return _dataColumns;
}

/**
 * Get the set of activities performed by this user.
 * @return the set of activities performed by this user
 */
@OneToMany(mappedBy = "performedBy")
@edu.harvard.med.screensaver.model.annotations.ToMany(singularPropertyName="activityPerformed")
@edu.harvard.med.screensaver.model.annotations.Column(hasNonconventionalSetterMethod=true)
@Sort(type = SortType.NATURAL)
public SortedSet<Activity> getActivitiesPerformed()
{
  return _activitiesPerformed;
}

/**
 * Get the cherry pick screening activity that recorded the screening of this assay plate.
 */
@ManyToMany
@JoinTable(name = "cherryPickAssayPlateScreeningLink",
           joinColumns = @JoinColumn(name = "cherryPickAssayPlateId"),
           inverseJoinColumns = @JoinColumn(name = "cherryPickScreeningId"))
/* has constraint that isPlated() == true */
@edu.harvard.med.screensaver.model.annotations.ToMany(inverseProperty = "screensCollaborated", hasNonconventionalMutation = true)
@Sort(type = SortType.NATURAL)
public SortedSet<CherryPickScreening> getCherryPickScreenings()
{
  return _cherryPickScreenings;
}

/**
 * Get the set of cherry pick assay plates.
 * @return the set of cherry pick assay plates
 */
@OneToMany(
  mappedBy="cherryPickRequest",
  cascade = { CascadeType.ALL },
  fetch=FetchType.LAZY
)
@org.hibernate.annotations.Sort(type=org.hibernate.annotations.SortType.NATURAL)
@org.hibernate.annotations.Cascade(value={
  org.hibernate.annotations.CascadeType.SAVE_UPDATE,
  org.hibernate.annotations.CascadeType.DELETE
})
public SortedSet<CherryPickAssayPlate> getCherryPickAssayPlates()
{
  return _cherryPickAssayPlates;
}

/**
 * Get the status items. A Screen may only contain one status with a given
 * {@link ScreenStatus#getRank() rank} value (StatusItems with the same rank are mutually
 * exclusive). Ordering of StatusItems must be equivalent whether by
 * {@link ScreenStatus#getRank() rank} or {@link StatusItem#getStatusDate() date}.
 *
 * @return the status items
 */
@ElementCollection(fetch=FetchType.EAGER)
@JoinTable(name = "screen_status_item",
           joinColumns = @JoinColumn(name = "screen_id"))
@Sort(type=SortType.NATURAL)
public SortedSet<StatusItem> getStatusItems()
{
  return _statusItems;
}

/**
 * Get the lab activities.
 * @return the lab activities
 */
@OneToMany(mappedBy = "screen", cascade = { CascadeType.ALL })
@Sort(type=SortType.NATURAL)
@edu.harvard.med.screensaver.model.annotations.ToMany(singularPropertyName="labActivity", 
                                                      hasNonconventionalMutation=true /* uses createLibraryScreening() and createRNAiCherryPickScreening */)
public SortedSet<LabActivity> getLabActivities()
{
  return _labActivities;
}