SSDM-2581 : V3 AS API - English check - changed the report structure and refactored the code

SVN: 35007

openbis_api/sourceTest/java/ch/ethz/sis/openbis/v3/EnglishCheck.java

@@ -21,11 +21,16 @@ import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.Comparator;
+import java.util.HashMap;
 import java.util.LinkedList;
 import java.util.List;
+import java.util.Map;
+import java.util.Set;
 import java.util.TreeSet;
 
+import org.apache.commons.lang.StringUtils;
 import org.reflections.ReflectionUtils;
 import org.reflections.Reflections;
 import org.reflections.scanners.ResourcesScanner;
@@ -41,6 +46,8 @@ import com.google.common.collect.Collections2;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Multimap;
 
+import ch.systemsx.cisd.common.shared.basic.string.IgnoreCaseComparator;
+
 /**
  * @author pkupczyk
  */
@@ -52,14 +59,13 @@ public class EnglishCheck
             "ch.ethz.sis.openbis.generic.shared.api.v3"
     };
 
-    @Test(enabled = false)
+    @Test
     public void test() throws Exception
     {
         Report report = new Report();
-        report.setPrintCorrect(true);
-        report.setPrintIncorrect(true);
-        printClasses(report, getPublicClasses());
-        Assert.assertTrue(report.isCorrect(), report.getContent());
+        checkClasses(report, getPublicClasses());
+        System.out.println(new ReportFormat().showCorrect().showIncorrect().format(report));
+        Assert.assertEquals(new ReportFormat().showIncorrect().showOnlyWords().format(report), "");
     }
 
     private Collection<Class<?>> getPublicClasses()
@@ -94,7 +100,15 @@ public class EnglishCheck
                 }
             });
         Collection<String> uniqueClassNames = new TreeSet<String>(nonInnerClassNames);
-        return ImmutableSet.copyOf(ReflectionUtils.forNames(uniqueClassNames));
+        Collection<Class<?>> uniqueClasses = ImmutableSet.copyOf(ReflectionUtils.forNames(uniqueClassNames));
+
+        for (Class<?> uniqueClass : uniqueClasses)
+        {
+            System.out.println("Found V3 public class:\t" + uniqueClass.getName());
+        }
+        System.out.println();
+
+        return uniqueClasses;
     }
 
     private Collection<Field> getPublicFields(Class<?> clazz)
@@ -124,141 +138,209 @@ public class EnglishCheck
         return methods;
     }
 
-    private boolean isClassCorrect(Class<?> clazz)
+    private void checkClasses(Report report, Collection<Class<?>> classes)
     {
-        return EnglishDictionary.getInstance().contains(clazz.getSimpleName());
+        for (Class<?> clazz : classes)
+        {
+            report.add(new ClassEntry(clazz));
+            checkFields(report, getPublicFields(clazz));
+            checkMethods(report, getPublicMethods(clazz));
+        }
     }
 
-    private boolean isFieldCorrect(Field field)
+    private void checkFields(Report report, Collection<Field> fields)
     {
-        return EnglishDictionary.getInstance().contains(field.getName());
+        for (Field field : fields)
+        {
+            report.add(new FieldEntry(field));
+        }
     }
 
-    private boolean isMethodCorrect(Method method)
+    private void checkMethods(Report report, Collection<Method> methods)
     {
-        return EnglishDictionary.getInstance().contains(method.getName());
+        for (Method method : methods)
+        {
+            report.add(new MethodEntry(method));
+        }
     }
 
-    private void printClasses(Report report, Collection<Class<?>> classes)
+    static class Report
     {
-        Collection<Class<?>> sortedClasses = new TreeSet<Class<?>>(new Comparator<Class<?>>()
-            {
-                @Override
-                public int compare(Class<?> c1, Class<?> c2)
-                {
-                    return c1.getSimpleName().compareToIgnoreCase(c2.getSimpleName());
-                }
-            });
-        sortedClasses.addAll(classes);
 
-        for (Class<?> clazz : sortedClasses)
+        private List<Entry> entries = new LinkedList<Entry>();
+
+        public void add(Entry entry)
         {
-            report.println(clazz.getSimpleName(), isClassCorrect(clazz));
-            report.increaseIndentation();
-            printFields(report, getPublicFields(clazz));
-            printMethods(report, getPublicMethods(clazz));
-            report.decreaseIndentation();
+            entries.add(entry);
         }
+
+        public List<Entry> getEntries()
+        {
+            return entries;
+        }
+
     }
 
-    private void printFields(Report report, Collection<Field> fields)
+    static abstract class Entry
     {
-        Collection<Field> sortedFields = new TreeSet<Field>(new Comparator<Field>()
-            {
-                @Override
-                public int compare(Field f1, Field f2)
-                {
-                    return f1.getName().compareToIgnoreCase(f2.getName());
-                }
-            });
-        sortedFields.addAll(fields);
 
-        for (Field field : sortedFields)
-        {
-            report.println(field.getDeclaringClass().getSimpleName() + "  " + field.getName(), isFieldCorrect(field));
-        }
+        public abstract String getWord();
+
+        public abstract String getContext();
+
     }
 
-    private void printMethods(Report report, Collection<Method> methods)
+    static class ClassEntry extends Entry
     {
-        Collection<Method> sortedMethods = new TreeSet<Method>(new Comparator<Method>()
-            {
-                @Override
-                public int compare(Method m1, Method m2)
-                {
-                    return m1.getName().compareToIgnoreCase(m2.getName());
-                }
-            });
-        sortedMethods.addAll(methods);
 
-        for (Method method : sortedMethods)
+        private Class<?> clazz;
+
+        public ClassEntry(Class<?> clazz)
+        {
+            this.clazz = clazz;
+        }
+
+        @Override
+        public String getWord()
         {
-            report.println(method.getDeclaringClass().getSimpleName() + "  " + method.getName(), isMethodCorrect(method));
+            return clazz.getSimpleName();
         }
+
+        @Override
+        public String getContext()
+        {
+            return clazz.getSimpleName();
+        }
+
     }
 
-    private class Report
+    static class FieldEntry extends Entry
     {
 
-        private static final String INDENTATION = "   ";
+        private Field field;
 
-        private StringBuilder content = new StringBuilder();
+        public FieldEntry(Field field)
+        {
+            this.field = field;
+        }
 
-        private String indentation = "";
+        @Override
+        public String getWord()
+        {
+            return field.getName();
+        }
 
-        private boolean printCorrect;
+        @Override
+        public String getContext()
+        {
+            return field.getDeclaringClass().getSimpleName();
+        }
 
-        private boolean printIncorrect;
+    }
 
-        private boolean allCorrect = true;
+    static class MethodEntry extends Entry
+    {
 
-        public void println(String s, boolean correct)
-        {
-            allCorrect = allCorrect && correct;
+        private Method method;
 
-            if ((correct && printCorrect) || (false == correct && printIncorrect))
-            {
-                if (indentation != null)
-                {
-                    content.append(indentation);
-                }
-                content.append(s + " " + (correct ? " OK" : " WRONG") + "\n");
-            }
+        public MethodEntry(Method method)
+        {
+            this.method = method;
         }
 
-        public void setPrintCorrect(boolean printCorrect)
+        @Override
+        public String getWord()
         {
-            this.printCorrect = printCorrect;
+            return method.getName();
         }
 
-        public void setPrintIncorrect(boolean printIncorrect)
+        @Override
+        public String getContext()
         {
-            this.printIncorrect = printIncorrect;
+            return method.getDeclaringClass().getSimpleName();
         }
 
-        public void increaseIndentation()
+    }
+
+    static class ReportFormat
+    {
+
+        private boolean showCorrect;
+
+        private boolean showIncorrect;
+
+        private boolean showOnlyWords;
+
+        public ReportFormat showCorrect()
         {
-            indentation += INDENTATION;
+            this.showCorrect = true;
+            return this;
         }
 
-        public void decreaseIndentation()
+        public ReportFormat showIncorrect()
         {
-            if (indentation.length() - INDENTATION.length() >= 0)
-            {
-                indentation = indentation.substring(0, indentation.length() - INDENTATION.length());
-            }
+            this.showIncorrect = true;
+            return this;
         }
 
-        public boolean isCorrect()
+        public ReportFormat showOnlyWords()
         {
-            return allCorrect;
+            this.showOnlyWords = true;
+            return this;
         }
 
-        public String getContent()
+        public String format(Report report)
         {
+            Map<String, Set<String>> contextsMap = new HashMap<String, Set<String>>();
+
+            for (Entry entry : report.getEntries())
+            {
+                Set<String> contexts = contextsMap.get(entry.getWord());
+
+                if (contexts == null)
+                {
+                    contexts = new TreeSet<String>();
+                    contextsMap.put(entry.getWord(), contexts);
+                }
+
+                contexts.add(entry.getContext());
+            }
+
+            List<String> sortedWords = new ArrayList<String>(contextsMap.keySet());
+            Collections.sort(sortedWords, new IgnoreCaseComparator());
+
+            String longestWord = Collections.max(sortedWords, new Comparator<String>()
+                {
+                    @Override
+                    public int compare(String o1, String o2)
+                    {
+                        return Integer.valueOf(o1.length()).compareTo(Integer.valueOf(o2.length()));
+                    }
+                });
+
+            StringBuilder content = new StringBuilder();
+
+            for (String word : sortedWords)
+            {
+                Set<String> contexts = contextsMap.get(word);
+                boolean correct = EnglishDictionary.getInstance().contains(word);
+
+                if ((correct && showCorrect) || (false == correct && showIncorrect))
+                {
+                    if (showOnlyWords)
+                    {
+                        content.append(word);
+                    } else
+                    {
+                        content.append(StringUtils.rightPad(word, longestWord.length()) + "\t" + (correct ? "OK" : "WRONG") + " " + contexts);
+                    }
+
+                    content.append("\n");
+                }
+            }
+
             return content.toString();
         }
-
     }
 
 }

openbis_api/sourceTest/java/ch/ethz/sis/openbis/v3/dictionary.txt

-toString
+AbstractCollectionView
+AbstractComparator
+AbstractCompositeSearchCriteria
+AbstractDateObjectValue
+AbstractDateValue
+AbstractEntitySearchCriteria
+AbstractFieldSearchCriteria
+AbstractGenerator
+AbstractNumberValue
+AbstractObjectDeletionOptions
+AbstractObjectSearchCriteria
+AbstractSearchCriteria
+AbstractStringValue
+AbstractValue
+add
+addAll
+addAttachments
+addBooleanField
+addClassForImport
+addCode
+addComparators
+addDateField
+addDescription
+addExperiment
+addFetchedField
+addImplementedInterface
+addImplementedInterfaceGeneric
+addModificationDate
+addModifier
+addPermId
+addPluralFetchedField
+addProperties
+addRegistrationDate
+addRegistrator
+addSample
+addSimpleField
+addSpace
+addStringField
+addTags
+AND
+ANY_FIELD
+ANY_PROPERTY
+AnyFieldSearchCriteria
+AnyPropertySearchCriteria
+AnyStringValue
+ARCHIVE_PENDING
+ARCHIVED
+ArchivingStatus
+arePartsEqual
+asc
+ascii
+ast
+Attachment
+AttachmentCreation
+AttachmentFetchOptions
+AttachmentFileName
+AttachmentListUpdateValue
+AttachmentSortOptions
+ATTRIBUTE
+AVAILABLE
+BACKUP_PENDING
+BdsDirectoryStorageFormatPermId
+beautify
+CACHE
+CacheMode
+cacheMode
+CHILD
+CHILDREN
+clear
+close
+code
+CODE
+CodeComparator
+CodeSearchCriteria
+compare
+Complete
+confirmDeletions
+CONTAINED
+CONTAINER
+contains
+containsAll
+count
+createDataSets
+createExperiments
+CreateExperimentsOperation
+CreateExperimentsOperationResult
+createMaterials
+createProjects
+createSamples
+CreateSamplesOperation
+CreateSamplesResult
+createSpaces
+CreationId
+DATA_SET
+DATASET
+DataSet
+DataSetChildrenSearchCriteria
+DataSetContainerSearchCriteria
+DataSetCreation
+DataSetDeletionOptions
+DataSetFetchOptions
+DataSetFile
+DataSetFileDownload
+DataSetFileDownloadOptions
+DataSetFileDownloadReader
+DataSetFilePermId
+DataSetFileSearchCriteria
+DataSetKind
+DataSetParentsSearchCriteria
+DataSetPermId
+DataSetRelationType
+DataSetSearchCriteria
+DataSetSearchRelation
+DataSetSortOptions
+DataSetType
+DataSetTypeFetchOptions
+DataSetTypeSortOptions
+DataSetUpdate
+DataStore
+DataStoreFetchOptions
+DataStorePermId
+DataStoreSortOptions
+DateEarlierThanOrEqualToValue
+DateEqualToValue
+DateFieldSearchCriteria
+DateLaterThanOrEqualToValue
+DateObjectEarlierThanOrEqualToValue
+DateObjectEqualToValue
+DateObjectLaterThanOrEqualToValue
+DatePropertySearchCriteria
+deleteDataSets
+DeletedObject
+DeletedObjectFetchOptions
+deleteExperiments
+deleteMaterials
+deleteProjects
+deleteSamples
+deleteSpaces
+Deletion
+DeletionFetchOptions
+DeletionSortOptions
+DeletionTechId
+DeletionType
+desc
+downloadFiles
+DtoGenerator
+ECMAScriptEngineFactory
+EmptyFetchOptions
+EntitySortOptions
+EntityTypePermId
+EntityTypeSearchCriteria
 equals
-hashCode
\ No newline at end of file
+exec
+EXPERIMENT
+Experiment
+ExperimentCreation
+ExperimentDeletionOptions
+ExperimentFetchOptions
+ExperimentIdentifier
+ExperimentPermId
+ExperimentRelationType
+ExperimentSearchCriteria
+ExperimentSortOptions
+ExperimentType
+ExperimentTypeFetchOptions
+ExperimentTypeSortOptions
+ExperimentUpdate
+ExternalDms
+ExternalDmsFetchOptions
+ExternalDmsPermId
+ExternalDmsSortOptions
+extra
+FetchOptions
+FetchOptionsMatcher
+FetchOptionsMatcherTest
+FieldUpdateValue
+FileFormatType
+FileFormatTypeFetchOptions
+FileFormatTypePermId
+FileFormatTypeSortOptions
+from
+generateDTO
+generateDTOJS
+generateFetchOptions
+generateFetchOptionsJS
+Generator
+get
+getAccessDate
+getActions
+getAttachments
+getAuthor
+getCacheMode
+getChildIds
+getChildren
+getCode
+getComparator
+getComplete
+getContained
+getContainedIds
+getContainer
+getContainerId
+getContainerIds
+getContainers
+getContent
+getCount
+getCreationId
+getCreations
+getCriteria
+getDataSetFile
+getDataSetId
+getDataSetPermId
+getDataSets
+getDataStore
+getDataStoreId
+getDeletedObjects
+getDescription
+getDownloadUrl
+getECMAScriptEngine
+getEmail
+getExperiment
+getExperimentId
+getExperiments
+getExternalCode
+getExternalDms
+getExternalDmsId
+getFetchOptions
+getField
+getFieldName
+getFieldType
+getFieldValue
+getFileFormatType
+getFileFormatTypeId
+getFileName
+getFilePath
+getFirstName
+getFormat
+getFrom
+getGeneratedCodePrefix
+getHistory
+getHourOffset
+getId
+getIdentifier
+getInputStream
+getKind
+getLabel
+getLastName
+getLatestVersionPermlink
+getLeader
+getLeaderId
+getLimitedCollection
+getLinkedData
+getLocation
+getLocatorType
+getLocatorTypeId
+getMaterialId
+getMaterialProperties
+getModificationDate
+getModifier
+getObjectId
+getObjects
+getOperator
+getOrder
+getOrdinal
+getOriginalCollection
+getOwner
+getParentIds
+getParents
+getPath
+getPermId
+getPermIds
+getPermlink
+getPhysicalData
+getPreviousVersion
+getProject
+getProjectId
+getProjects
+getProperties
+getPropertyName
+getPropertyValue
+getReason
+getRegistrationDate
+getRegistrator
+getRelatedObjectId
+getRelation
+getRelationType
+getRemoteUrl
+getResourceReader
+getSample
+getSampleId
+getSamples
+getShareId
+getSize
+getSortBy
+getSortings
+getSpace
+getSpaceId
+getSpeedHint
+getStatus
+getStorageFormat
+getStorageFormatId
+getTagIds
+getTags
+getTechId
+getTimeZone
+getTitle
+getTotalCount
+getType
+getTypeCode
+getTypeId
+getUpdates
+getUrlTemplate
+getUserId
+getValidFrom
+getValidTo
+getValue
+getVersion
+getVocabulary
+hasActions
+hasAttachments
+hasAuthor
+hasChildren
+hasContained
+hasContainer
+hasContainers
+hasContent
+hasDataSets
+hasDataStore
+hasDeletedObjects
+hasExperiment
+hasExperiments
+hasExternalDms
+hasFileFormatType
+hashCode
+hasHistory
+hasLeader
+hasLinkedData
+hasLocatorType
+hasMaterialProperties
+hasModifier
+hasOwner
+hasParents
+hasPhysicalData
+hasPreviousVersion
+hasProject
+hasProjects
+hasProperties
+hasRegistrator
+hasSample
+hasSamples
+hasSpace
+hasStorageFormat
+hasTags
+hasType
+hasVocabulary
+HistoryEntry
+HistoryEntryFetchOptions
+HistoryEntrySortOptions
+IApplicationServerApi
+IAttachmentId
+IAttachmentsHolder
+ICodeHolder
+ICreationIdHolder
+IDataSetFileId
+IDataSetId
+IDataStoreId
+IDataStoreServerApi
+IDate
+IDateFormat
+IDeletionId
+IdListUpdateValue
+IdSearchCriteria
+IEntityTypeId
+IExperimentId
+IExternalDmsId
+IFileFormatTypeId
+ILocatorTypeId
+IMaterialId
+IModificationDateHolder
+IModifierHolder
+indent
+indexOf
+INTERNAL_SERVICE_NAME
+IObjectId
+IOperation
+IOperationResult
+IParentChildrenHolder
+IPermIdHolder
+IPersonId
+IProjectId
+IPropertiesHolder
+IRegistrationDateHolder
+IRegistratorHolder
+IRelationType
+isActive
+ISampleId
+isAsc
+isAutoGeneratedCode
+isDirectory
+ISearchCriteria
+isEmpty
+isListable
+isMeasured
+isModified
+isOfficial
+isOpenbis
+ISpaceHolder
+ISpaceId
+isPostRegistered
+isPresentInArchive
+isPrivate
+isRecursive
+isShowParentMetadata
+isStorageConfirmation
+isSubcodeUnique
+IStorageFormatId
+ITagId
+ITagsHolder
+iterator
+ITimeZone
+IVocabularyId
+IVocabularyTermId
+JSON_SERVICE_URL
+JsonPropertyUtil
+lastIndexOf
+LINK
+LinkedData
+LinkedDataCreation
+LinkedDataFetchOptions
+LinkedDataSortOptions
+LinkedDataUpdate
+listDeletions
+ListExperimentsOperation
+ListExperimentsOperationResult
+listIterator
+ListUpdateValue
+ListView
+LocatorType
+LocatorTypeFetchOptions
+LocatorTypePermId
+LocatorTypeSortOptions
+LOCKED
+login
+loginAs
+logout
+LongDateFormat
+main
+mangleToplevel
+mapDataSets
+mapExperiments
+mapMaterials
+mapProjects
+mapSamples
+mapSpaces
+Material
+MaterialCreation
+MaterialDeletionOptions
+MaterialFetchOptions
+MaterialPermId
+MaterialSearchCriteria
+MaterialSortOptions
+MaterialType
+MaterialTypeFetchOptions
+MaterialTypeSortOptions
+MaterialUpdate
+maxLineLen
+MODIFICATION_DATE
+modificationDate
+ModificationDateComparator
+ModificationDateSearchCriteria
+NO
+NO_CACHE
+noCopyright
+noDeadCode
+NoExperimentSearchCriteria
+noMangle
+NoProjectSearchCriteria
+NormalDateFormat
+NoSampleContainerSearchCriteria
+NoSampleSearchCriteria
+noSeqs
+noSqueeze
+NotFetchedException
+NumberEqualToValue
+NumberFieldSearchCriteria
+NumberGreaterThanOrEqualToValue
+NumberGreaterThanValue
+NumberLessThanOrEqualToValue
+NumberLessThanValue
+NumberPropertySearchCriteria
+ObjectIdentifier
+ObjectNotFoundException
+ObjectPermId
+ObjectTechId
+OR
+output
+overwrite
+PARENT
+PARENTS
+PERMANENT
+PermIdSearchCriteria
+Person
+PersonFetchOptions
+PersonPermId
+PersonSortOptions
+PHYSICAL
+PhysicalData
+PhysicalDataCreation
+PhysicalDataFetchOptions
+PhysicalDataSortOptions
+PhysicalDataUpdate
+Project
+PROJECT
+ProjectCreation
+ProjectDeletionOptions
+ProjectFetchOptions
+ProjectIdentifier
+ProjectPermId
+ProjectRelationType
+ProjectSearchCriteria
+ProjectSortOptions
+ProjectUpdate
+PROPERTY
+PropertyFetchOptions
+PropertyHistoryEntry
+ProprietaryStorageFormatPermId
+quoteKeys
+read
+REGISTRATION_DATE
+registrationDate
+RegistrationDateComparator
+RegistrationDateSearchCriteria
+RelationHistoryEntry
+RelativeLocationLocatorTypePermId
+RELOAD_AND_CACHE
+remove
+removeAll
+reservedNames
+retainAll
+revertDeletions
+SAMPLE
+Sample
+SampleChildrenSearchCriteria
+SampleContainerSearchCriteria
+SampleCreation
+SampleDeletionOptions
+SampleFetchOptions
+SampleIdentifier
+SampleParentsSearchCriteria
+SamplePermId
+SampleRelationType
+SampleSearchCriteria
+SampleSearchRelation
+SampleSortOptions
+SampleType
+SampleTypeFetchOptions
+SampleTypeSortOptions
+SampleUpdate
+SearchCriteriaToStringBuilder
+searchDataSets
+searchExperiments
+SearchFieldType
+searchFiles
+SearchForExperimentsOperation
+SearchForExperimentsOperationResult
+searchMaterials
+SearchOperator
+searchProjects
+SearchResult
+searchSamples
+searchSpaces
+ServerTimeZone
+SERVICE_NAME
+SERVICE_URL
+set
+setAccessDate
+setActions
+setActive
+setAttachments
+setAttachmentsActions
+setAuthor
+setAutoGeneratedCode
+setChildActions
+setChildIds
+setChildren
+setCode
+setComplete
+setContained
+setContainedActions
+setContainedIds
+setContainer
+setContainerActions
+setContainerId
+setContainerIds
+setContainers
+setContent
+setCreationId
+setCriteria
+setDataSetId
+setDataSetPermId
+setDataSets
+setDataStore
+setDataStoreId
+setDeletedObjects
+setDescription
+setDirectory
+setDownloadUrl
+setEmail
+setExperiment
+setExperimentId
+setExperiments
+setExternalCode
+setExternalDms
+setExternalDmsId
+setFetchOptions
+setFieldName
+setFieldValue
+setFileFormatType
+setFileFormatTypeId
+setFileName
+setFilePath
+setFirstName
+setGeneratedCodePrefix
+setHistory
+setId
+setIdentifier
+setKind
+setLabel
+setLastName
+setLatestVersionPermlink
+setLeader
+setLeaderId
+setLinkedData
+setListable
+setLocation
+setLocatorType
+setLocatorTypeId
+setMaterialId
+setMaterialProperties
+setMeasured
+setModificationDate
+setModifier
+setName
+setOfficial
+setOpenbis
+setOperator
+setOrdinal
+setOwner
+setParentActions
+setParentIds
+setParents
+setPath
+setPermId
+setPermlink
+setPhysicalData
+setPostRegistered
+setPresentInArchive
+setPreviousVersion
+setPrivate
+setProject
+setProjectId
+setProjects
+setProperties
+setProperty
+setPropertyName
+setPropertyValue
+setReason
+setRecursive
+setRegistrationDate
+setRegistrator
+setRelatedObjectId
+setRelationType
+setRemoteUrl
+setSample
+setSampleId
+setSamples
+setShareId
+setShowParentMetadata
+setSize
+setSpace
+setSpaceId
+setSpeedHint
+setStatus
+setStorageConfirmation
+setStorageFormat
+setStorageFormatId
+setSubcodeUnique
+setTagActions
+setTagIds
+setTags
+setTimeZone
+setTitle
+setToStringMethod
+setType
+setTypeCode
+setTypeId
+setUrlTemplate
+setUserId
+setValidFrom
+setValidTo
+setValue
+setVersion
+SetView
+setVocabulary
+ShortDateFormat
+size
+SortAndPage
+sortAndPage
+SortAndPageTest
+sortBy
+Sorting
+SortOptions
+SortOrder
+Space
+SPACE
+SpaceCreation
+SpaceDeletionOptions
+SpaceFetchOptions
+SpacePermId
+SpaceSearchCriteria
+SpaceSortOptions
+SpaceUpdate
+StorageFormat
+StorageFormatFetchOptions
+StorageFormatPermId
+StorageFormatSortOptions
+StringContainsValue
+StringEndsWithValue
+StringEqualToValue
+StringFieldSearchCriteria
+StringPropertySearchCriteria
+StringStartsWithValue
+subList
+Tag
+TagCode
+TagFetchOptions
+TagPermId
+TagSearchCriteria
+TagSortOptions
+TechIdSearchCriteria
+testMatchEmptyObjects
+testMatchObjectsWithDifferentMultiLevelParts
+testMatchObjectsWithDifferentParts
+testMatchObjectsWithDifferentSubLevelPaging
+testMatchObjectsWithDifferentSubLevelRecursiveParts
+testMatchObjectsWithDifferentTopLevelPaging
+testMatchObjectsWithDifferentTopLevelRecursiveParts
+testMatchObjectsWithSameMultiLevelParts
+testMatchObjectsWithSameSubLevelPaging
+testMatchObjectsWithSameSubLevelRecursiveParts
+testMatchObjectsWithSameTopLevelPaging
+testMatchObjectsWithSameTopLevelRecursiveParts
+testMatchObjectsWithTheSameParts
+testPartsTheSameObjects
+testSamePageMultipleTimes
+testSortByMultipleFields
+testSubLevel
+testSubLevelThroughSingleRelation
+testTopLevel
+thatContains
+thatEndsWith
+thatEquals
+thatIsEarlierThanOrEqualTo
+thatIsGreaterThan
+thatIsGreaterThanOrEqualTo
+thatIsLaterThanOrEqualTo
+thatIsLessThan
+thatIsLessThanOrEqualTo
+thatStartsWith
+TimeZone
+toArgList
+toArray
+toLongOrNull
+toString
+toStringOrNull
+TRASH
+uglify
+UglifyJS
+UglifyOptions
+UltimateJSEntityGenerator
+UNARCHIVE_PENDING
+UnauthorizedObjectAccessException
+UNKNOWN
+unsafe
+UnsupportedObjectIdException
+updateDataSets
+updateExperiments
+UpdateExperimentsOperation
+UpdateExperimentsOperationResult
+updateMaterials
+updateProjects
+updateSamples
+UpdateSamplesOperation
+updateSpaces
+valueOf
+values
+verbose
+Vocabulary
+VocabularyFetchOptions
+VocabularyFieldSearchCriteria
+VocabularyPermId
+VocabularyPropertySearchCriteria
+VocabularySortOptions
+VocabularyTerm
+VocabularyTermCode
+VocabularyTermFetchOptions
+VocabularyTermSortOptions
+withAndOperator
+withAnyField
+withAnyProperty
+withAttachments
+withAttachmentsUsing
+withAuthor
+withAuthorUsing
+withChildren
+withChildrenUsing
+withCode
+withContained
+withContainedUsing
+withContainer
+withContainers
+withContainersUsing
+withContainerUsing
+withContent
+withContentUsing
+withDataSet
+withDataSets
+withDataSetsUsing
+withDataStore
+withDataStoreUsing
+withDateProperty
+withDeletedObjects
+withDeletedObjectsUsing
+withExperiment
+withExperiments
+withExperimentsUsing
+withExperimentUsing
+withExternalDms
+withExternalDmsUsing
+withFileFormatType
+withFileFormatTypeUsing
+withHistory
+withHistoryUsing
+withId
+withLeader
+withLeaderUsing
+withLinkedData
+withLinkedDataUsing
+withLocatorType
+withLocatorTypeUsing
+withMaterialProperties
+withMaterialPropertiesUsing
+withModificationDate
+withModifier
+withModifierUsing
+withNumberProperty
+withOrOperator
+withoutContainer
+withoutExperiment
+withoutProject
+withoutSample
+withOwner
+withOwnerUsing
+withParents
+withParentsUsing
+withPermId
+withPhysicalData
+withPhysicalDataUsing
+withPreviousVersion
+withPreviousVersionUsing
+withProject
+withProjects
+withProjectsUsing
+withProjectUsing
+withProperties
+withPropertiesUsing
+withProperty
+withRegistrationDate
+withRegistrator
+withRegistratorUsing
+withSample
+withSamples
+withSamplesUsing
+withSampleUsing
+withServerTimeZone
+withSpace
+withSpaceUsing
+withStorageFormat
+withStorageFormatUsing
+withTag
+withTags
+withTagsUsing
+withTimeZone
+withType
+withTypeUsing
+withVocabulary
+withVocabularyUsing
+YES
\ No newline at end of file