Package omero.api

Class IContainerPrxHelper

    • Field Detail

      • __ids

        public static final java.lang.String[] __ids

    • Constructor Detail

      • IContainerPrxHelper

        public IContainerPrxHelper()

    • Method Detail

      • createDataObject

        public IObject createDataObject​(IObject obj,
                                Parameters options)
                         throws ServerError
        Description copied from interface: IContainerPrx
        Creates the specified data object.

        A placeholder parent object is created if the data object is to be put in a collection.

        For example, if the object is a Dataset, we first create a Project as parent then we set the Dataset parent as follows: //pseudo-code TODO Project p = new Project(id,false); dataset.addProject(p); then for each parent relationship a DataObject ILink is created.

        Specified by:
        createDataObject in interface IContainerPrx
        Parameters:
        obj - IObject. Supported: Project, Dataset, Annotation, Group, Experimenter. Not null.
        options - Parameters as above.
        Returns:
        the created object
        Throws:
        ServerError

      • createDataObject

        public IObject createDataObject​(IObject obj,
                                Parameters options,
                                java.util.Map<java.lang.String,​java.lang.String> __ctx)
                         throws ServerError
        Description copied from interface: IContainerPrx
        Creates the specified data object.

        A placeholder parent object is created if the data object is to be put in a collection.

        For example, if the object is a Dataset, we first create a Project as parent then we set the Dataset parent as follows: //pseudo-code TODO Project p = new Project(id,false); dataset.addProject(p); then for each parent relationship a DataObject ILink is created.

        Specified by:
        createDataObject in interface IContainerPrx
        Parameters:
        obj - IObject. Supported: Project, Dataset, Annotation, Group, Experimenter. Not null.
        options - Parameters as above.
        __ctx - The Context map to send with the invocation.
        Returns:
        the created object
        Throws:
        ServerError

      • begin_createDataObject

        public Ice.AsyncResult begin_createDataObject​(IObject obj,
                                              Parameters options)
        Description copied from interface: IContainerPrx
        Creates the specified data object.

        A placeholder parent object is created if the data object is to be put in a collection.

        For example, if the object is a Dataset, we first create a Project as parent then we set the Dataset parent as follows: //pseudo-code TODO Project p = new Project(id,false); dataset.addProject(p); then for each parent relationship a DataObject ILink is created.

        Specified by:
        begin_createDataObject in interface IContainerPrx
        Parameters:
        obj - IObject. Supported: Project, Dataset, Annotation, Group, Experimenter. Not null.
        options - Parameters as above.
        Returns:
        The asynchronous result object.

      • begin_createDataObject

        public Ice.AsyncResult begin_createDataObject​(IObject obj,
                                              Parameters options,
                                              java.util.Map<java.lang.String,​java.lang.String> __ctx)
        Description copied from interface: IContainerPrx
        Creates the specified data object.

        A placeholder parent object is created if the data object is to be put in a collection.

        For example, if the object is a Dataset, we first create a Project as parent then we set the Dataset parent as follows: //pseudo-code TODO Project p = new Project(id,false); dataset.addProject(p); then for each parent relationship a DataObject ILink is created.

        Specified by:
        begin_createDataObject in interface IContainerPrx
        Parameters:
        obj - IObject. Supported: Project, Dataset, Annotation, Group, Experimenter. Not null.
        options - Parameters as above.
        __ctx - The Context map to send with the invocation.
        Returns:
        The asynchronous result object.

      • begin_createDataObject

        public Ice.AsyncResult begin_createDataObject​(IObject obj,
                                              Parameters options,
                                              Ice.Callback __cb)
        Description copied from interface: IContainerPrx
        Creates the specified data object.

        A placeholder parent object is created if the data object is to be put in a collection.

        For example, if the object is a Dataset, we first create a Project as parent then we set the Dataset parent as follows: //pseudo-code TODO Project p = new Project(id,false); dataset.addProject(p); then for each parent relationship a DataObject ILink is created.

        Specified by:
        begin_createDataObject in interface IContainerPrx
        Parameters:
        obj - IObject. Supported: Project, Dataset, Annotation, Group, Experimenter. Not null.
        options - Parameters as above.
        __cb - The asynchronous callback object.
        Returns:
        The asynchronous result object.

      • begin_createDataObject

        public Ice.AsyncResult begin_createDataObject​(IObject obj,
                                              Parameters options,
                                              java.util.Map<java.lang.String,​java.lang.String> __ctx,
                                              Ice.Callback __cb)
        Description copied from interface: IContainerPrx
        Creates the specified data object.

        A placeholder parent object is created if the data object is to be put in a collection.

        For example, if the object is a Dataset, we first create a Project as parent then we set the Dataset parent as follows: //pseudo-code TODO Project p = new Project(id,false); dataset.addProject(p); then for each parent relationship a DataObject ILink is created.

        Specified by:
        begin_createDataObject in interface IContainerPrx
        Parameters:
        obj - IObject. Supported: Project, Dataset, Annotation, Group, Experimenter. Not null.
        options - Parameters as above.
        __ctx - The Context map to send with the invocation.
        __cb - The asynchronous callback object.
        Returns:
        The asynchronous result object.

      • begin_createDataObject

        public Ice.AsyncResult begin_createDataObject​(IObject obj,
                                              Parameters options,
                                              Callback_IContainer_createDataObject __cb)
        Description copied from interface: IContainerPrx
        Creates the specified data object.

        A placeholder parent object is created if the data object is to be put in a collection.

        For example, if the object is a Dataset, we first create a Project as parent then we set the Dataset parent as follows: //pseudo-code TODO Project p = new Project(id,false); dataset.addProject(p); then for each parent relationship a DataObject ILink is created.

        Specified by:
        begin_createDataObject in interface IContainerPrx
        Parameters:
        obj - IObject. Supported: Project, Dataset, Annotation, Group, Experimenter. Not null.
        options - Parameters as above.
        __cb - The asynchronous callback object.
        Returns:
        The asynchronous result object.

      • begin_createDataObject

        public Ice.AsyncResult begin_createDataObject​(IObject obj,
                                              Parameters options,
                                              java.util.Map<java.lang.String,​java.lang.String> __ctx,
                                              Callback_IContainer_createDataObject __cb)
        Description copied from interface: IContainerPrx
        Creates the specified data object.

        A placeholder parent object is created if the data object is to be put in a collection.

        For example, if the object is a Dataset, we first create a Project as parent then we set the Dataset parent as follows: //pseudo-code TODO Project p = new Project(id,false); dataset.addProject(p); then for each parent relationship a DataObject ILink is created.

        Specified by:
        begin_createDataObject in interface IContainerPrx
        Parameters:
        obj - IObject. Supported: Project, Dataset, Annotation, Group, Experimenter. Not null.
        options - Parameters as above.
        __ctx - The Context map to send with the invocation.
        __cb - The asynchronous callback object.
        Returns:
        The asynchronous result object.

      • begin_createDataObject

        public Ice.AsyncResult begin_createDataObject​(IObject obj,
                                              Parameters options,
                                              java.util.Map<java.lang.String,​java.lang.String> __ctx,
                                              IceInternal.Functional_GenericCallback1<IObject> __responseCb,
                                              IceInternal.Functional_GenericCallback1<Ice.UserException> __userExceptionCb,
                                              IceInternal.Functional_GenericCallback1<Ice.Exception> __exceptionCb)
        Description copied from interface: IContainerPrx
        Creates the specified data object.

        A placeholder parent object is created if the data object is to be put in a collection.

        For example, if the object is a Dataset, we first create a Project as parent then we set the Dataset parent as follows: //pseudo-code TODO Project p = new Project(id,false); dataset.addProject(p); then for each parent relationship a DataObject ILink is created.

        Specified by:
        begin_createDataObject in interface IContainerPrx
        Parameters:
        obj - IObject. Supported: Project, Dataset, Annotation, Group, Experimenter. Not null.
        options - Parameters as above.
        __ctx - The Context map to send with the invocation.
        __responseCb - The lambda response callback.
        __userExceptionCb - The lambda user exception callback.
        __exceptionCb - The lambda exception callback.
        Returns:
        The asynchronous result object.

      • end_createDataObject

        public IObject end_createDataObject​(Ice.AsyncResult __iresult)
                             throws ServerError
        Description copied from interface: IContainerPrx
        Creates the specified data object.

        A placeholder parent object is created if the data object is to be put in a collection.

        For example, if the object is a Dataset, we first create a Project as parent then we set the Dataset parent as follows: //pseudo-code TODO Project p = new Project(id,false); dataset.addProject(p); then for each parent relationship a DataObject ILink is created.

        Specified by:
        end_createDataObject in interface IContainerPrx
        Parameters:
        __iresult - The asynchronous result object.
        Returns:
        the created object
        Throws:
        ServerError

      • begin_createDataObjects

        public Ice.AsyncResult begin_createDataObjects​(java.util.List<IObject> dataObjects,
                                               Parameters options)
        Description copied from interface: IContainerPrx
        Convenience method to save network calls. Loops over the array of IObjects calling createDataObject.
        Specified by:
        begin_createDataObjects in interface IContainerPrx
        Parameters:
        dataObjects - Array of Omero IObjects
        options - Parameters as above.
        Returns:
        The asynchronous result object.

      • begin_createDataObjects

        public Ice.AsyncResult begin_createDataObjects​(java.util.List<IObject> dataObjects,
                                               Parameters options,
                                               java.util.Map<java.lang.String,​java.lang.String> __ctx)
        Description copied from interface: IContainerPrx
        Convenience method to save network calls. Loops over the array of IObjects calling createDataObject.
        Specified by:
        begin_createDataObjects in interface IContainerPrx
        Parameters:
        dataObjects - Array of Omero IObjects
        options - Parameters as above.
        __ctx - The Context map to send with the invocation.
        Returns:
        The asynchronous result object.

      • begin_createDataObjects

        public Ice.AsyncResult begin_createDataObjects​(java.util.List<IObject> dataObjects,
                                               Parameters options,
                                               Ice.Callback __cb)
        Description copied from interface: IContainerPrx
        Convenience method to save network calls. Loops over the array of IObjects calling createDataObject.
        Specified by:
        begin_createDataObjects in interface IContainerPrx
        Parameters:
        dataObjects - Array of Omero IObjects
        options - Parameters as above.
        __cb - The asynchronous callback object.
        Returns:
        The asynchronous result object.

      • begin_createDataObjects

        public Ice.AsyncResult begin_createDataObjects​(java.util.List<IObject> dataObjects,
                                               Parameters options,
                                               java.util.Map<java.lang.String,​java.lang.String> __ctx,
                                               Ice.Callback __cb)
        Description copied from interface: IContainerPrx
        Convenience method to save network calls. Loops over the array of IObjects calling createDataObject.
        Specified by:
        begin_createDataObjects in interface IContainerPrx
        Parameters:
        dataObjects - Array of Omero IObjects
        options - Parameters as above.
        __ctx - The Context map to send with the invocation.
        __cb - The asynchronous callback object.
        Returns:
        The asynchronous result object.

      • begin_createDataObjects

        public Ice.AsyncResult begin_createDataObjects​(java.util.List<IObject> dataObjects,
                                               Parameters options,
                                               java.util.Map<java.lang.String,​java.lang.String> __ctx,
                                               Callback_IContainer_createDataObjects __cb)
        Description copied from interface: IContainerPrx
        Convenience method to save network calls. Loops over the array of IObjects calling createDataObject.
        Specified by:
        begin_createDataObjects in interface IContainerPrx
        Parameters:
        dataObjects - Array of Omero IObjects
        options - Parameters as above.
        __ctx - The Context map to send with the invocation.
        __cb - The asynchronous callback object.
        Returns:
        The asynchronous result object.

      • findContainerHierarchies

        public java.util.List<IObject> findContainerHierarchies​(java.lang.String rootType,
                                                        java.util.List<java.lang.Long> imageIds,
                                                        Parameters options)
                                                 throws ServerError
        Description copied from interface: IContainerPrx
        Retrieves hierarchy trees in various hierarchies that contain the specified Images.

        This method will look for all the containers containing the specified Images and then for all containers containing those containers and on up the container hierarchy.

        This method returns a Set with all root nodes that were found. Every root node is linked to the found objects and so on until the leaf nodes, which are Image objects. Note that the type of any root node in the returned set can be the given rootNodeType, any of its containees or an Image.

        For example, say that you pass in the ids of six Images: i1, i2, i3, i4, i5, i6. If the P/D/I hierarchy in the DB looks like this: 

         |                  __p1__                     
 |                 /      \                    
 |               _d1_    _d2_      d3          
 |              /    \  /    \     |           
 |             i1     i2     i3    i4    i5  i6

        Then the returned set will contain p1, d3, i5, i6. All objects will be properly linked up.

        Finally, this method will only retrieve the nodes that are connected in a tree to the specified leaf image nodes. Back to the previous example, if d1 contained image img500, then the returned object would not contain img500. In a similar way, if p1 contained ds300 and this dataset weren't linked to any of the i1, i2, i3, i4, i5, i6 images, then ds300 would not be part of the returned tree rooted by p1.

        Specified by:
        findContainerHierarchies in interface IContainerPrx
        Parameters:
        rootType - top-most type which will be searched for Can be Project. Not null.
        imageIds - Contains the ids of the Images that sit at the bottom of the trees. Not null.
        options - Parameters as above. annotator used. experimenter|group may be applied at the top-level only or at each level in the hierarchy, but will not apply to the leaf (Image) level.
        Returns:
        A Set with all root nodes that were found.
        Throws:
        ServerError

      • findContainerHierarchies

        public java.util.List<IObject> findContainerHierarchies​(java.lang.String rootType,
                                                        java.util.List<java.lang.Long> imageIds,
                                                        Parameters options,
                                                        java.util.Map<java.lang.String,​java.lang.String> __ctx)
                                                 throws ServerError
        Description copied from interface: IContainerPrx
        Retrieves hierarchy trees in various hierarchies that contain the specified Images.

        This method will look for all the containers containing the specified Images and then for all containers containing those containers and on up the container hierarchy.

        This method returns a Set with all root nodes that were found. Every root node is linked to the found objects and so on until the leaf nodes, which are Image objects. Note that the type of any root node in the returned set can be the given rootNodeType, any of its containees or an Image.

        For example, say that you pass in the ids of six Images: i1, i2, i3, i4, i5, i6. If the P/D/I hierarchy in the DB looks like this: 

         |                  __p1__                     
 |                 /      \                    
 |               _d1_    _d2_      d3          
 |              /    \  /    \     |           
 |             i1     i2     i3    i4    i5  i6

        Then the returned set will contain p1, d3, i5, i6. All objects will be properly linked up.

        Finally, this method will only retrieve the nodes that are connected in a tree to the specified leaf image nodes. Back to the previous example, if d1 contained image img500, then the returned object would not contain img500. In a similar way, if p1 contained ds300 and this dataset weren't linked to any of the i1, i2, i3, i4, i5, i6 images, then ds300 would not be part of the returned tree rooted by p1.

        Specified by:
        findContainerHierarchies in interface IContainerPrx
        Parameters:
        rootType - top-most type which will be searched for Can be Project. Not null.
        imageIds - Contains the ids of the Images that sit at the bottom of the trees. Not null.
        options - Parameters as above. annotator used. experimenter|group may be applied at the top-level only or at each level in the hierarchy, but will not apply to the leaf (Image) level.
        __ctx - The Context map to send with the invocation.
        Returns:
        A Set with all root nodes that were found.
        Throws:
        ServerError

      • begin_findContainerHierarchies

        public Ice.AsyncResult begin_findContainerHierarchies​(java.lang.String rootType,
                                                      java.util.List<java.lang.Long> imageIds,
                                                      Parameters options)
        Description copied from interface: IContainerPrx
        Retrieves hierarchy trees in various hierarchies that contain the specified Images.

        This method will look for all the containers containing the specified Images and then for all containers containing those containers and on up the container hierarchy.

        This method returns a Set with all root nodes that were found. Every root node is linked to the found objects and so on until the leaf nodes, which are Image objects. Note that the type of any root node in the returned set can be the given rootNodeType, any of its containees or an Image.

        For example, say that you pass in the ids of six Images: i1, i2, i3, i4, i5, i6. If the P/D/I hierarchy in the DB looks like this: 

         |                  __p1__                     
 |                 /      \                    
 |               _d1_    _d2_      d3          
 |              /    \  /    \     |           
 |             i1     i2     i3    i4    i5  i6

        Then the returned set will contain p1, d3, i5, i6. All objects will be properly linked up.

        Finally, this method will only retrieve the nodes that are connected in a tree to the specified leaf image nodes. Back to the previous example, if d1 contained image img500, then the returned object would not contain img500. In a similar way, if p1 contained ds300 and this dataset weren't linked to any of the i1, i2, i3, i4, i5, i6 images, then ds300 would not be part of the returned tree rooted by p1.

        Specified by:
        begin_findContainerHierarchies in interface IContainerPrx
        Parameters:
        rootType - top-most type which will be searched for Can be Project. Not null.
        imageIds - Contains the ids of the Images that sit at the bottom of the trees. Not null.
        options - Parameters as above. annotator used. experimenter|group may be applied at the top-level only or at each level in the hierarchy, but will not apply to the leaf (Image) level.
        Returns:
        The asynchronous result object.

      • begin_findContainerHierarchies

        public Ice.AsyncResult begin_findContainerHierarchies​(java.lang.String rootType,
                                                      java.util.List<java.lang.Long> imageIds,
                                                      Parameters options,
                                                      java.util.Map<java.lang.String,​java.lang.String> __ctx)
        Description copied from interface: IContainerPrx
        Retrieves hierarchy trees in various hierarchies that contain the specified Images.

        This method will look for all the containers containing the specified Images and then for all containers containing those containers and on up the container hierarchy.

        This method returns a Set with all root nodes that were found. Every root node is linked to the found objects and so on until the leaf nodes, which are Image objects. Note that the type of any root node in the returned set can be the given rootNodeType, any of its containees or an Image.

        For example, say that you pass in the ids of six Images: i1, i2, i3, i4, i5, i6. If the P/D/I hierarchy in the DB looks like this: 

         |                  __p1__                     
 |                 /      \                    
 |               _d1_    _d2_      d3          
 |              /    \  /    \     |           
 |             i1     i2     i3    i4    i5  i6

        Then the returned set will contain p1, d3, i5, i6. All objects will be properly linked up.

        Finally, this method will only retrieve the nodes that are connected in a tree to the specified leaf image nodes. Back to the previous example, if d1 contained image img500, then the returned object would not contain img500. In a similar way, if p1 contained ds300 and this dataset weren't linked to any of the i1, i2, i3, i4, i5, i6 images, then ds300 would not be part of the returned tree rooted by p1.

        Specified by:
        begin_findContainerHierarchies in interface IContainerPrx
        Parameters:
        rootType - top-most type which will be searched for Can be Project. Not null.
        imageIds - Contains the ids of the Images that sit at the bottom of the trees. Not null.
        options - Parameters as above. annotator used. experimenter|group may be applied at the top-level only or at each level in the hierarchy, but will not apply to the leaf (Image) level.
        __ctx - The Context map to send with the invocation.
        Returns:
        The asynchronous result object.

      • begin_findContainerHierarchies

        public Ice.AsyncResult begin_findContainerHierarchies​(java.lang.String rootType,
                                                      java.util.List<java.lang.Long> imageIds,
                                                      Parameters options,
                                                      Ice.Callback __cb)
        Description copied from interface: IContainerPrx
        Retrieves hierarchy trees in various hierarchies that contain the specified Images.

        This method will look for all the containers containing the specified Images and then for all containers containing those containers and on up the container hierarchy.

        This method returns a Set with all root nodes that were found. Every root node is linked to the found objects and so on until the leaf nodes, which are Image objects. Note that the type of any root node in the returned set can be the given rootNodeType, any of its containees or an Image.

        For example, say that you pass in the ids of six Images: i1, i2, i3, i4, i5, i6. If the P/D/I hierarchy in the DB looks like this: 

         |                  __p1__                     
 |                 /      \                    
 |               _d1_    _d2_      d3          
 |              /    \  /    \     |           
 |             i1     i2     i3    i4    i5  i6

        Then the returned set will contain p1, d3, i5, i6. All objects will be properly linked up.

        Finally, this method will only retrieve the nodes that are connected in a tree to the specified leaf image nodes. Back to the previous example, if d1 contained image img500, then the returned object would not contain img500. In a similar way, if p1 contained ds300 and this dataset weren't linked to any of the i1, i2, i3, i4, i5, i6 images, then ds300 would not be part of the returned tree rooted by p1.

        Specified by:
        begin_findContainerHierarchies in interface IContainerPrx
        Parameters:
        rootType - top-most type which will be searched for Can be Project. Not null.
        imageIds - Contains the ids of the Images that sit at the bottom of the trees. Not null.
        options - Parameters as above. annotator used. experimenter|group may be applied at the top-level only or at each level in the hierarchy, but will not apply to the leaf (Image) level.
        __cb - The asynchronous callback object.
        Returns:
        The asynchronous result object.

      • begin_findContainerHierarchies

        public Ice.AsyncResult begin_findContainerHierarchies​(java.lang.String rootType,
                                                      java.util.List<java.lang.Long> imageIds,
                                                      Parameters options,
                                                      java.util.Map<java.lang.String,​java.lang.String> __ctx,
                                                      Ice.Callback __cb)
        Description copied from interface: IContainerPrx
        Retrieves hierarchy trees in various hierarchies that contain the specified Images.

        This method will look for all the containers containing the specified Images and then for all containers containing those containers and on up the container hierarchy.

        This method returns a Set with all root nodes that were found. Every root node is linked to the found objects and so on until the leaf nodes, which are Image objects. Note that the type of any root node in the returned set can be the given rootNodeType, any of its containees or an Image.

        For example, say that you pass in the ids of six Images: i1, i2, i3, i4, i5, i6. If the P/D/I hierarchy in the DB looks like this: 

         |                  __p1__                     
 |                 /      \                    
 |               _d1_    _d2_      d3          
 |              /    \  /    \     |           
 |             i1     i2     i3    i4    i5  i6

        Then the returned set will contain p1, d3, i5, i6. All objects will be properly linked up.

        Finally, this method will only retrieve the nodes that are connected in a tree to the specified leaf image nodes. Back to the previous example, if d1 contained image img500, then the returned object would not contain img500. In a similar way, if p1 contained ds300 and this dataset weren't linked to any of the i1, i2, i3, i4, i5, i6 images, then ds300 would not be part of the returned tree rooted by p1.

        Specified by:
        begin_findContainerHierarchies in interface IContainerPrx
        Parameters:
        rootType - top-most type which will be searched for Can be Project. Not null.
        imageIds - Contains the ids of the Images that sit at the bottom of the trees. Not null.
        options - Parameters as above. annotator used. experimenter|group may be applied at the top-level only or at each level in the hierarchy, but will not apply to the leaf (Image) level.
        __ctx - The Context map to send with the invocation.
        __cb - The asynchronous callback object.
        Returns:
        The asynchronous result object.

      • begin_findContainerHierarchies

        public Ice.AsyncResult begin_findContainerHierarchies​(java.lang.String rootType,
                                                      java.util.List<java.lang.Long> imageIds,
                                                      Parameters options,
                                                      Callback_IContainer_findContainerHierarchies __cb)
        Description copied from interface: IContainerPrx
        Retrieves hierarchy trees in various hierarchies that contain the specified Images.

        This method will look for all the containers containing the specified Images and then for all containers containing those containers and on up the container hierarchy.

        This method returns a Set with all root nodes that were found. Every root node is linked to the found objects and so on until the leaf nodes, which are Image objects. Note that the type of any root node in the returned set can be the given rootNodeType, any of its containees or an Image.

        For example, say that you pass in the ids of six Images: i1, i2, i3, i4, i5, i6. If the P/D/I hierarchy in the DB looks like this: 

         |                  __p1__                     
 |                 /      \                    
 |               _d1_    _d2_      d3          
 |              /    \  /    \     |           
 |             i1     i2     i3    i4    i5  i6

        Then the returned set will contain p1, d3, i5, i6. All objects will be properly linked up.

        Finally, this method will only retrieve the nodes that are connected in a tree to the specified leaf image nodes. Back to the previous example, if d1 contained image img500, then the returned object would not contain img500. In a similar way, if p1 contained ds300 and this dataset weren't linked to any of the i1, i2, i3, i4, i5, i6 images, then ds300 would not be part of the returned tree rooted by p1.

        Specified by:
        begin_findContainerHierarchies in interface IContainerPrx
        Parameters:
        rootType - top-most type which will be searched for Can be Project. Not null.
        imageIds - Contains the ids of the Images that sit at the bottom of the trees. Not null.
        options - Parameters as above. annotator used. experimenter|group may be applied at the top-level only or at each level in the hierarchy, but will not apply to the leaf (Image) level.
        __cb - The asynchronous callback object.
        Returns:
        The asynchronous result object.

      • begin_findContainerHierarchies

        public Ice.AsyncResult begin_findContainerHierarchies​(java.lang.String rootType,
                                                      java.util.List<java.lang.Long> imageIds,
                                                      Parameters options,
                                                      java.util.Map<java.lang.String,​java.lang.String> __ctx,
                                                      Callback_IContainer_findContainerHierarchies __cb)
        Description copied from interface: IContainerPrx
        Retrieves hierarchy trees in various hierarchies that contain the specified Images.

        This method will look for all the containers containing the specified Images and then for all containers containing those containers and on up the container hierarchy.

        This method returns a Set with all root nodes that were found. Every root node is linked to the found objects and so on until the leaf nodes, which are Image objects. Note that the type of any root node in the returned set can be the given rootNodeType, any of its containees or an Image.

        For example, say that you pass in the ids of six Images: i1, i2, i3, i4, i5, i6. If the P/D/I hierarchy in the DB looks like this: 

         |                  __p1__                     
 |                 /      \                    
 |               _d1_    _d2_      d3          
 |              /    \  /    \     |           
 |             i1     i2     i3    i4    i5  i6

        Then the returned set will contain p1, d3, i5, i6. All objects will be properly linked up.

        Finally, this method will only retrieve the nodes that are connected in a tree to the specified leaf image nodes. Back to the previous example, if d1 contained image img500, then the returned object would not contain img500. In a similar way, if p1 contained ds300 and this dataset weren't linked to any of the i1, i2, i3, i4, i5, i6 images, then ds300 would not be part of the returned tree rooted by p1.

        Specified by:
        begin_findContainerHierarchies in interface IContainerPrx
        Parameters:
        rootType - top-most type which will be searched for Can be Project. Not null.
        imageIds - Contains the ids of the Images that sit at the bottom of the trees. Not null.
        options - Parameters as above. annotator used. experimenter|group may be applied at the top-level only or at each level in the hierarchy, but will not apply to the leaf (Image) level.
        __ctx - The Context map to send with the invocation.
        __cb - The asynchronous callback object.
        Returns:
        The asynchronous result object.

      • begin_findContainerHierarchies

        public Ice.AsyncResult begin_findContainerHierarchies​(java.lang.String rootType,
                                                      java.util.List<java.lang.Long> imageIds,
                                                      Parameters options,
                                                      IceInternal.Functional_GenericCallback1<java.util.List<IObject>> __responseCb,
                                                      IceInternal.Functional_GenericCallback1<Ice.UserException> __userExceptionCb,
                                                      IceInternal.Functional_GenericCallback1<Ice.Exception> __exceptionCb)
        Description copied from interface: IContainerPrx
        Retrieves hierarchy trees in various hierarchies that contain the specified Images.

        This method will look for all the containers containing the specified Images and then for all containers containing those containers and on up the container hierarchy.

        This method returns a Set with all root nodes that were found. Every root node is linked to the found objects and so on until the leaf nodes, which are Image objects. Note that the type of any root node in the returned set can be the given rootNodeType, any of its containees or an Image.

        For example, say that you pass in the ids of six Images: i1, i2, i3, i4, i5, i6. If the P/D/I hierarchy in the DB looks like this: 

         |                  __p1__                     
 |                 /      \                    
 |               _d1_    _d2_      d3          
 |              /    \  /    \     |           
 |             i1     i2     i3    i4    i5  i6

        Then the returned set will contain p1, d3, i5, i6. All objects will be properly linked up.

        Finally, this method will only retrieve the nodes that are connected in a tree to the specified leaf image nodes. Back to the previous example, if d1 contained image img500, then the returned object would not contain img500. In a similar way, if p1 contained ds300 and this dataset weren't linked to any of the i1, i2, i3, i4, i5, i6 images, then ds300 would not be part of the returned tree rooted by p1.

        Specified by:
        begin_findContainerHierarchies in interface IContainerPrx
        Parameters:
        rootType - top-most type which will be searched for Can be Project. Not null.
        imageIds - Contains the ids of the Images that sit at the bottom of the trees. Not null.
        options - Parameters as above. annotator used. experimenter|group may be applied at the top-level only or at each level in the hierarchy, but will not apply to the leaf (Image) level.
        __responseCb - The lambda response callback.
        __userExceptionCb - The lambda user exception callback.
        __exceptionCb - The lambda exception callback.
        Returns:
        The asynchronous result object.

      • begin_findContainerHierarchies

        public Ice.AsyncResult begin_findContainerHierarchies​(java.lang.String rootType,
                                                      java.util.List<java.lang.Long> imageIds,
                                                      Parameters options,
                                                      IceInternal.Functional_GenericCallback1<java.util.List<IObject>> __responseCb,
                                                      IceInternal.Functional_GenericCallback1<Ice.UserException> __userExceptionCb,
                                                      IceInternal.Functional_GenericCallback1<Ice.Exception> __exceptionCb,
                                                      IceInternal.Functional_BoolCallback __sentCb)
        Description copied from interface: IContainerPrx
        Retrieves hierarchy trees in various hierarchies that contain the specified Images.

        This method will look for all the containers containing the specified Images and then for all containers containing those containers and on up the container hierarchy.

        This method returns a Set with all root nodes that were found. Every root node is linked to the found objects and so on until the leaf nodes, which are Image objects. Note that the type of any root node in the returned set can be the given rootNodeType, any of its containees or an Image.

        For example, say that you pass in the ids of six Images: i1, i2, i3, i4, i5, i6. If the P/D/I hierarchy in the DB looks like this: 

         |                  __p1__                     
 |                 /      \                    
 |               _d1_    _d2_      d3          
 |              /    \  /    \     |           
 |             i1     i2     i3    i4    i5  i6

        Then the returned set will contain p1, d3, i5, i6. All objects will be properly linked up.

        Finally, this method will only retrieve the nodes that are connected in a tree to the specified leaf image nodes. Back to the previous example, if d1 contained image img500, then the returned object would not contain img500. In a similar way, if p1 contained ds300 and this dataset weren't linked to any of the i1, i2, i3, i4, i5, i6 images, then ds300 would not be part of the returned tree rooted by p1.

        Specified by:
        begin_findContainerHierarchies in interface IContainerPrx
        Parameters:
        rootType - top-most type which will be searched for Can be Project. Not null.
        imageIds - Contains the ids of the Images that sit at the bottom of the trees. Not null.
        options - Parameters as above. annotator used. experimenter|group may be applied at the top-level only or at each level in the hierarchy, but will not apply to the leaf (Image) level.
        __responseCb - The lambda response callback.
        __userExceptionCb - The lambda user exception callback.
        __exceptionCb - The lambda exception callback.
        __sentCb - The lambda sent callback.
        Returns:
        The asynchronous result object.

      • begin_findContainerHierarchies

        public Ice.AsyncResult begin_findContainerHierarchies​(java.lang.String rootType,
                                                      java.util.List<java.lang.Long> imageIds,
                                                      Parameters options,
                                                      java.util.Map<java.lang.String,​java.lang.String> __ctx,
                                                      IceInternal.Functional_GenericCallback1<java.util.List<IObject>> __responseCb,
                                                      IceInternal.Functional_GenericCallback1<Ice.UserException> __userExceptionCb,
                                                      IceInternal.Functional_GenericCallback1<Ice.Exception> __exceptionCb)
        Description copied from interface: IContainerPrx
        Retrieves hierarchy trees in various hierarchies that contain the specified Images.

        This method will look for all the containers containing the specified Images and then for all containers containing those containers and on up the container hierarchy.

        This method returns a Set with all root nodes that were found. Every root node is linked to the found objects and so on until the leaf nodes, which are Image objects. Note that the type of any root node in the returned set can be the given rootNodeType, any of its containees or an Image.

        For example, say that you pass in the ids of six Images: i1, i2, i3, i4, i5, i6. If the P/D/I hierarchy in the DB looks like this: 

         |                  __p1__                     
 |                 /      \                    
 |               _d1_    _d2_      d3          
 |              /    \  /    \     |           
 |             i1     i2     i3    i4    i5  i6

        Then the returned set will contain p1, d3, i5, i6. All objects will be properly linked up.

        Finally, this method will only retrieve the nodes that are connected in a tree to the specified leaf image nodes. Back to the previous example, if d1 contained image img500, then the returned object would not contain img500. In a similar way, if p1 contained ds300 and this dataset weren't linked to any of the i1, i2, i3, i4, i5, i6 images, then ds300 would not be part of the returned tree rooted by p1.

        Specified by:
        begin_findContainerHierarchies in interface IContainerPrx
        Parameters:
        rootType - top-most type which will be searched for Can be Project. Not null.
        imageIds - Contains the ids of the Images that sit at the bottom of the trees. Not null.
        options - Parameters as above. annotator used. experimenter|group may be applied at the top-level only or at each level in the hierarchy, but will not apply to the leaf (Image) level.
        __ctx - The Context map to send with the invocation.
        __responseCb - The lambda response callback.
        __userExceptionCb - The lambda user exception callback.
        __exceptionCb - The lambda exception callback.
        Returns:
        The asynchronous result object.

      • begin_findContainerHierarchies

        public Ice.AsyncResult begin_findContainerHierarchies​(java.lang.String rootType,
                                                      java.util.List<java.lang.Long> imageIds,
                                                      Parameters options,
                                                      java.util.Map<java.lang.String,​java.lang.String> __ctx,
                                                      IceInternal.Functional_GenericCallback1<java.util.List<IObject>> __responseCb,
                                                      IceInternal.Functional_GenericCallback1<Ice.UserException> __userExceptionCb,
                                                      IceInternal.Functional_GenericCallback1<Ice.Exception> __exceptionCb,
                                                      IceInternal.Functional_BoolCallback __sentCb)
        Description copied from interface: IContainerPrx
        Retrieves hierarchy trees in various hierarchies that contain the specified Images.

        This method will look for all the containers containing the specified Images and then for all containers containing those containers and on up the container hierarchy.

        This method returns a Set with all root nodes that were found. Every root node is linked to the found objects and so on until the leaf nodes, which are Image objects. Note that the type of any root node in the returned set can be the given rootNodeType, any of its containees or an Image.

        For example, say that you pass in the ids of six Images: i1, i2, i3, i4, i5, i6. If the P/D/I hierarchy in the DB looks like this: 

         |                  __p1__                     
 |                 /      \                    
 |               _d1_    _d2_      d3          
 |              /    \  /    \     |           
 |             i1     i2     i3    i4    i5  i6

        Then the returned set will contain p1, d3, i5, i6. All objects will be properly linked up.

        Finally, this method will only retrieve the nodes that are connected in a tree to the specified leaf image nodes. Back to the previous example, if d1 contained image img500, then the returned object would not contain img500. In a similar way, if p1 contained ds300 and this dataset weren't linked to any of the i1, i2, i3, i4, i5, i6 images, then ds300 would not be part of the returned tree rooted by p1.

        Specified by:
        begin_findContainerHierarchies in interface IContainerPrx
        Parameters:
        rootType - top-most type which will be searched for Can be Project. Not null.
        imageIds - Contains the ids of the Images that sit at the bottom of the trees. Not null.
        options - Parameters as above. annotator used. experimenter|group may be applied at the top-level only or at each level in the hierarchy, but will not apply to the leaf (Image) level.
        __ctx - The Context map to send with the invocation.
        __responseCb - The lambda response callback.
        __userExceptionCb - The lambda user exception callback.
        __exceptionCb - The lambda exception callback.
        __sentCb - The lambda sent callback.
        Returns:
        The asynchronous result object.

      • end_findContainerHierarchies

        public java.util.List<IObject> end_findContainerHierarchies​(Ice.AsyncResult __iresult)
                                                     throws ServerError
        Description copied from interface: IContainerPrx
        Retrieves hierarchy trees in various hierarchies that contain the specified Images.

        This method will look for all the containers containing the specified Images and then for all containers containing those containers and on up the container hierarchy.

        This method returns a Set with all root nodes that were found. Every root node is linked to the found objects and so on until the leaf nodes, which are Image objects. Note that the type of any root node in the returned set can be the given rootNodeType, any of its containees or an Image.

        For example, say that you pass in the ids of six Images: i1, i2, i3, i4, i5, i6. If the P/D/I hierarchy in the DB looks like this: 

         |                  __p1__                     
 |                 /      \                    
 |               _d1_    _d2_      d3          
 |              /    \  /    \     |           
 |             i1     i2     i3    i4    i5  i6

        Then the returned set will contain p1, d3, i5, i6. All objects will be properly linked up.

        Finally, this method will only retrieve the nodes that are connected in a tree to the specified leaf image nodes. Back to the previous example, if d1 contained image img500, then the returned object would not contain img500. In a similar way, if p1 contained ds300 and this dataset weren't linked to any of the i1, i2, i3, i4, i5, i6 images, then ds300 would not be part of the returned tree rooted by p1.

        Specified by:
        end_findContainerHierarchies in interface IContainerPrx
        Parameters:
        __iresult - The asynchronous result object.
        Returns:
        A Set with all root nodes that were found.
        Throws:
        ServerError

      • getCollectionCount

        public java.util.Map<java.lang.Long,​java.lang.Long> getCollectionCount​(java.lang.String type,
                                                                             java.lang.String property,
                                                                             java.util.List<java.lang.Long> ids,
                                                                             Parameters options)
                                                                      throws ServerError
        Description copied from interface: IContainerPrx
        Counts the number of members in a collection for a given object. For example, if you wanted to retrieve the number of Images contained in a Dataset you would pass TODO.
        Specified by:
        getCollectionCount in interface IContainerPrx
        Parameters:
        type - The fully-qualified classname of the object to be tested
        property - Name of the property on that class, omitting getters and setters.
        ids - Set of Longs, the ids of the objects to test
        options - Parameters. Unused.
        Returns:
        A map from id integer to count integer
        Throws:
        ServerError

      • getCollectionCount

        public java.util.Map<java.lang.Long,​java.lang.Long> getCollectionCount​(java.lang.String type,
                                                                             java.lang.String property,
                                                                             java.util.List<java.lang.Long> ids,
                                                                             Parameters options,
                                                                             java.util.Map<java.lang.String,​java.lang.String> __ctx)
                                                                      throws ServerError
        Description copied from interface: IContainerPrx
        Counts the number of members in a collection for a given object. For example, if you wanted to retrieve the number of Images contained in a Dataset you would pass TODO.
        Specified by:
        getCollectionCount in interface IContainerPrx
        Parameters:
        type - The fully-qualified classname of the object to be tested
        property - Name of the property on that class, omitting getters and setters.
        ids - Set of Longs, the ids of the objects to test
        options - Parameters. Unused.
        __ctx - The Context map to send with the invocation.
        Returns:
        A map from id integer to count integer
        Throws:
        ServerError

      • begin_getCollectionCount

        public Ice.AsyncResult begin_getCollectionCount​(java.lang.String type,
                                                java.lang.String property,
                                                java.util.List<java.lang.Long> ids,
                                                Parameters options)
        Description copied from interface: IContainerPrx
        Counts the number of members in a collection for a given object. For example, if you wanted to retrieve the number of Images contained in a Dataset you would pass TODO.
        Specified by:
        begin_getCollectionCount in interface IContainerPrx
        Parameters:
        type - The fully-qualified classname of the object to be tested
        property - Name of the property on that class, omitting getters and setters.
        ids - Set of Longs, the ids of the objects to test
        options - Parameters. Unused.
        Returns:
        The asynchronous result object.

      • begin_getCollectionCount

        public Ice.AsyncResult begin_getCollectionCount​(java.lang.String type,
                                                java.lang.String property,
                                                java.util.List<java.lang.Long> ids,
                                                Parameters options,
                                                java.util.Map<java.lang.String,​java.lang.String> __ctx)
        Description copied from interface: IContainerPrx
        Counts the number of members in a collection for a given object. For example, if you wanted to retrieve the number of Images contained in a Dataset you would pass TODO.
        Specified by:
        begin_getCollectionCount in interface IContainerPrx
        Parameters:
        type - The fully-qualified classname of the object to be tested
        property - Name of the property on that class, omitting getters and setters.
        ids - Set of Longs, the ids of the objects to test
        options - Parameters. Unused.
        __ctx - The Context map to send with the invocation.
        Returns:
        The asynchronous result object.

      • begin_getCollectionCount

        public Ice.AsyncResult begin_getCollectionCount​(java.lang.String type,
                                                java.lang.String property,
                                                java.util.List<java.lang.Long> ids,
                                                Parameters options,
                                                Ice.Callback __cb)
        Description copied from interface: IContainerPrx
        Counts the number of members in a collection for a given object. For example, if you wanted to retrieve the number of Images contained in a Dataset you would pass TODO.
        Specified by:
        begin_getCollectionCount in interface IContainerPrx
        Parameters:
        type - The fully-qualified classname of the object to be tested
        property - Name of the property on that class, omitting getters and setters.
        ids - Set of Longs, the ids of the objects to test
        options - Parameters. Unused.
        __cb - The asynchronous callback object.
        Returns:
        The asynchronous result object.

      • begin_getCollectionCount

        public Ice.AsyncResult begin_getCollectionCount​(java.lang.String type,
                                                java.lang.String property,
                                                java.util.List<java.lang.Long> ids,
                                                Parameters options,
                                                java.util.Map<java.lang.String,​java.lang.String> __ctx,
                                                Ice.Callback __cb)
        Description copied from interface: IContainerPrx
        Counts the number of members in a collection for a given object. For example, if you wanted to retrieve the number of Images contained in a Dataset you would pass TODO.
        Specified by:
        begin_getCollectionCount in interface IContainerPrx
        Parameters:
        type - The fully-qualified classname of the object to be tested
        property - Name of the property on that class, omitting getters and setters.
        ids - Set of Longs, the ids of the objects to test
        options - Parameters. Unused.
        __ctx - The Context map to send with the invocation.
        __cb - The asynchronous callback object.
        Returns:
        The asynchronous result object.

      • begin_getCollectionCount

        public Ice.AsyncResult begin_getCollectionCount​(java.lang.String type,
                                                java.lang.String property,
                                                java.util.List<java.lang.Long> ids,
                                                Parameters options,
                                                Callback_IContainer_getCollectionCount __cb)
        Description copied from interface: IContainerPrx
        Counts the number of members in a collection for a given object. For example, if you wanted to retrieve the number of Images contained in a Dataset you would pass TODO.
        Specified by:
        begin_getCollectionCount in interface IContainerPrx
        Parameters:
        type - The fully-qualified classname of the object to be tested
        property - Name of the property on that class, omitting getters and setters.
        ids - Set of Longs, the ids of the objects to test
        options - Parameters. Unused.
        __cb - The asynchronous callback object.
        Returns:
        The asynchronous result object.

      • begin_getCollectionCount

        public Ice.AsyncResult begin_getCollectionCount​(java.lang.String type,
                                                java.lang.String property,
                                                java.util.List<java.lang.Long> ids,
                                                Parameters options,
                                                java.util.Map<java.lang.String,​java.lang.String> __ctx,
                                                Callback_IContainer_getCollectionCount __cb)
        Description copied from interface: IContainerPrx
        Counts the number of members in a collection for a given object. For example, if you wanted to retrieve the number of Images contained in a Dataset you would pass TODO.
        Specified by:
        begin_getCollectionCount in interface IContainerPrx
        Parameters:
        type - The fully-qualified classname of the object to be tested
        property - Name of the property on that class, omitting getters and setters.
        ids - Set of Longs, the ids of the objects to test
        options - Parameters. Unused.
        __ctx - The Context map to send with the invocation.
        __cb - The asynchronous callback object.
        Returns:
        The asynchronous result object.

      • begin_getCollectionCount

        public Ice.AsyncResult begin_getCollectionCount​(java.lang.String type,
                                                java.lang.String property,
                                                java.util.List<java.lang.Long> ids,
                                                Parameters options,
                                                IceInternal.Functional_GenericCallback1<java.util.Map<java.lang.Long,​java.lang.Long>> __responseCb,
                                                IceInternal.Functional_GenericCallback1<Ice.UserException> __userExceptionCb,
                                                IceInternal.Functional_GenericCallback1<Ice.Exception> __exceptionCb)
        Description copied from interface: IContainerPrx
        Counts the number of members in a collection for a given object. For example, if you wanted to retrieve the number of Images contained in a Dataset you would pass TODO.
        Specified by:
        begin_getCollectionCount in interface IContainerPrx
        Parameters:
        type - The fully-qualified classname of the object to be tested
        property - Name of the property on that class, omitting getters and setters.
        ids - Set of Longs, the ids of the objects to test
        options - Parameters. Unused.
        __responseCb - The lambda response callback.
        __userExceptionCb - The lambda user exception callback.
        __exceptionCb - The lambda exception callback.
        Returns:
        The asynchronous result object.

      • begin_getCollectionCount

        public Ice.AsyncResult begin_getCollectionCount​(java.lang.String type,
                                                java.lang.String property,
                                                java.util.List<java.lang.Long> ids,
                                                Parameters options,
                                                java.util.Map<java.lang.String,​java.lang.String> __ctx,
                                                IceInternal.Functional_GenericCallback1<java.util.Map<java.lang.Long,​java.lang.Long>> __responseCb,
                                                IceInternal.Functional_GenericCallback1<Ice.UserException> __userExceptionCb,
                                                IceInternal.Functional_GenericCallback1<Ice.Exception> __exceptionCb)
        Description copied from interface: IContainerPrx
        Counts the number of members in a collection for a given object. For example, if you wanted to retrieve the number of Images contained in a Dataset you would pass TODO.
        Specified by:
        begin_getCollectionCount in interface IContainerPrx
        Parameters:
        type - The fully-qualified classname of the object to be tested
        property - Name of the property on that class, omitting getters and setters.
        ids - Set of Longs, the ids of the objects to test
        options - Parameters. Unused.
        __ctx - The Context map to send with the invocation.
        __responseCb - The lambda response callback.
        __userExceptionCb - The lambda user exception callback.
        __exceptionCb - The lambda exception callback.
        Returns:
        The asynchronous result object.

      • begin_getCollectionCount

        public Ice.AsyncResult begin_getCollectionCount​(java.lang.String type,
                                                java.lang.String property,
                                                java.util.List<java.lang.Long> ids,
                                                Parameters options,
                                                java.util.Map<java.lang.String,​java.lang.String> __ctx,
                                                IceInternal.Functional_GenericCallback1<java.util.Map<java.lang.Long,​java.lang.Long>> __responseCb,
                                                IceInternal.Functional_GenericCallback1<Ice.UserException> __userExceptionCb,
                                                IceInternal.Functional_GenericCallback1<Ice.Exception> __exceptionCb,
                                                IceInternal.Functional_BoolCallback __sentCb)
        Description copied from interface: IContainerPrx
        Counts the number of members in a collection for a given object. For example, if you wanted to retrieve the number of Images contained in a Dataset you would pass TODO.
        Specified by:
        begin_getCollectionCount in interface IContainerPrx
        Parameters:
        type - The fully-qualified classname of the object to be tested
        property - Name of the property on that class, omitting getters and setters.
        ids - Set of Longs, the ids of the objects to test
        options - Parameters. Unused.
        __ctx - The Context map to send with the invocation.
        __responseCb - The lambda response callback.
        __userExceptionCb - The lambda user exception callback.
        __exceptionCb - The lambda exception callback.
        __sentCb - The lambda sent callback.
        Returns:
        The asynchronous result object.

      • end_getCollectionCount

        public java.util.Map<java.lang.Long,​java.lang.Long> end_getCollectionCount​(Ice.AsyncResult __iresult)
                                                                          throws ServerError
        Description copied from interface: IContainerPrx
        Counts the number of members in a collection for a given object. For example, if you wanted to retrieve the number of Images contained in a Dataset you would pass TODO.
        Specified by:
        end_getCollectionCount in interface IContainerPrx
        Parameters:
        __iresult - The asynchronous result object.
        Returns:
        A map from id integer to count integer
        Throws:
        ServerError

      • __getCollectionCount_completed

        public static void __getCollectionCount_completed​(Ice.TwowayCallbackArg1UE<java.util.Map<java.lang.Long,​java.lang.Long>> __cb,
                                                  Ice.AsyncResult __result)

      • getImages

        public java.util.List<Image> getImages​(java.lang.String rootType,
                                       java.util.List<java.lang.Long> rootIds,
                                       Parameters options)
                                throws ServerError
        Description copied from interface: IContainerPrx
        Retrieve a user's (or all users') images within any given container. For example, all images in project, applying temporal filtering or pagination.
        Specified by:
        getImages in interface IContainerPrx
        Parameters:
        rootType - A Class which will have its hierarchy searched for Images. Not null.
        rootIds - A set of ids of type rootNodeType Not null.
        options - Parameters as above. No notion of leaves. experimenter|group apply at the Image level. OPTIONS: - startTime and/or endTime should be Timestamp.valueOf("YYYY-MM-DD hh:mm:ss.ms");

        limit and offset are applied at the Image-level. That is, calling with Dataset.class, limit == 10 and offset == 0 will first perform one query to get an effective set of rootNodeIds, then getImages will be called with an effective rootNodeType of Image.class and the new ids.

        acquisition data is only relevant for images.
        Returns:
        A set of images.
        Throws:
        ServerError

      • getImages

        public java.util.List<Image> getImages​(java.lang.String rootType,
                                       java.util.List<java.lang.Long> rootIds,
                                       Parameters options,
                                       java.util.Map<java.lang.String,​java.lang.String> __ctx)
                                throws ServerError
        Description copied from interface: IContainerPrx
        Retrieve a user's (or all users') images within any given container. For example, all images in project, applying temporal filtering or pagination.
        Specified by:
        getImages in interface IContainerPrx
        Parameters:
        rootType - A Class which will have its hierarchy searched for Images. Not null.
        rootIds - A set of ids of type rootNodeType Not null.
        options - Parameters as above. No notion of leaves. experimenter|group apply at the Image level. OPTIONS: - startTime and/or endTime should be Timestamp.valueOf("YYYY-MM-DD hh:mm:ss.ms");

        limit and offset are applied at the Image-level. That is, calling with Dataset.class, limit == 10 and offset == 0 will first perform one query to get an effective set of rootNodeIds, then getImages will be called with an effective rootNodeType of Image.class and the new ids.

        acquisition data is only relevant for images.
        __ctx - The Context map to send with the invocation.
        Returns:
        A set of images.
        Throws:
        ServerError

      • begin_getImages

        public Ice.AsyncResult begin_getImages​(java.lang.String rootType,
                                       java.util.List<java.lang.Long> rootIds,
                                       Parameters options)
        Description copied from interface: IContainerPrx
        Retrieve a user's (or all users') images within any given container. For example, all images in project, applying temporal filtering or pagination.
        Specified by:
        begin_getImages in interface IContainerPrx
        Parameters:
        rootType - A Class which will have its hierarchy searched for Images. Not null.
        rootIds - A set of ids of type rootNodeType Not null.
        options - Parameters as above. No notion of leaves. experimenter|group apply at the Image level. OPTIONS: - startTime and/or endTime should be Timestamp.valueOf("YYYY-MM-DD hh:mm:ss.ms");

        limit and offset are applied at the Image-level. That is, calling with Dataset.class, limit == 10 and offset == 0 will first perform one query to get an effective set of rootNodeIds, then getImages will be called with an effective rootNodeType of Image.class and the new ids.

        acquisition data is only relevant for images.
        Returns:
        The asynchronous result object.

      • begin_getImages

        public Ice.AsyncResult begin_getImages​(java.lang.String rootType,
                                       java.util.List<java.lang.Long> rootIds,
                                       Parameters options,
                                       java.util.Map<java.lang.String,​java.lang.String> __ctx)
        Description copied from interface: IContainerPrx
        Retrieve a user's (or all users') images within any given container. For example, all images in project, applying temporal filtering or pagination.
        Specified by:
        begin_getImages in interface IContainerPrx
        Parameters:
        rootType - A Class which will have its hierarchy searched for Images. Not null.
        rootIds - A set of ids of type rootNodeType Not null.
        options - Parameters as above. No notion of leaves. experimenter|group apply at the Image level. OPTIONS: - startTime and/or endTime should be Timestamp.valueOf("YYYY-MM-DD hh:mm:ss.ms");

        limit and offset are applied at the Image-level. That is, calling with Dataset.class, limit == 10 and offset == 0 will first perform one query to get an effective set of rootNodeIds, then getImages will be called with an effective rootNodeType of Image.class and the new ids.

        acquisition data is only relevant for images.
        __ctx - The Context map to send with the invocation.
        Returns:
        The asynchronous result object.

      • begin_getImages

        public Ice.AsyncResult begin_getImages​(java.lang.String rootType,
                                       java.util.List<java.lang.Long> rootIds,
                                       Parameters options,
                                       Ice.Callback __cb)
        Description copied from interface: IContainerPrx
        Retrieve a user's (or all users') images within any given container. For example, all images in project, applying temporal filtering or pagination.
        Specified by:
        begin_getImages in interface IContainerPrx
        Parameters:
        rootType - A Class which will have its hierarchy searched for Images. Not null.
        rootIds - A set of ids of type rootNodeType Not null.
        options - Parameters as above. No notion of leaves. experimenter|group apply at the Image level. OPTIONS: - startTime and/or endTime should be Timestamp.valueOf("YYYY-MM-DD hh:mm:ss.ms");

        limit and offset are applied at the Image-level. That is, calling with Dataset.class, limit == 10 and offset == 0 will first perform one query to get an effective set of rootNodeIds, then getImages will be called with an effective rootNodeType of Image.class and the new ids.

        acquisition data is only relevant for images.
        __cb - The asynchronous callback object.
        Returns:
        The asynchronous result object.

      • begin_getImages

        public Ice.AsyncResult begin_getImages​(java.lang.String rootType,
                                       java.util.List<java.lang.Long> rootIds,
                                       Parameters options,
                                       java.util.Map<java.lang.String,​java.lang.String> __ctx,
                                       Ice.Callback __cb)
        Description copied from interface: IContainerPrx
        Retrieve a user's (or all users') images within any given container. For example, all images in project, applying temporal filtering or pagination.
        Specified by:
        begin_getImages in interface IContainerPrx
        Parameters:
        rootType - A Class which will have its hierarchy searched for Images. Not null.
        rootIds - A set of ids of type rootNodeType Not null.
        options - Parameters as above. No notion of leaves. experimenter|group apply at the Image level. OPTIONS: - startTime and/or endTime should be Timestamp.valueOf("YYYY-MM-DD hh:mm:ss.ms");

        limit and offset are applied at the Image-level. That is, calling with Dataset.class, limit == 10 and offset == 0 will first perform one query to get an effective set of rootNodeIds, then getImages will be called with an effective rootNodeType of Image.class and the new ids.

        acquisition data is only relevant for images.
        __ctx - The Context map to send with the invocation.
        __cb - The asynchronous callback object.
        Returns:
        The asynchronous result object.

      • begin_getImages

        public Ice.AsyncResult begin_getImages​(java.lang.String rootType,
                                       java.util.List<java.lang.Long> rootIds,
                                       Parameters options,
                                       Callback_IContainer_getImages __cb)
        Description copied from interface: IContainerPrx
        Retrieve a user's (or all users') images within any given container. For example, all images in project, applying temporal filtering or pagination.
        Specified by:
        begin_getImages in interface IContainerPrx
        Parameters:
        rootType - A Class which will have its hierarchy searched for Images. Not null.
        rootIds - A set of ids of type rootNodeType Not null.
        options - Parameters as above. No notion of leaves. experimenter|group apply at the Image level. OPTIONS: - startTime and/or endTime should be Timestamp.valueOf("YYYY-MM-DD hh:mm:ss.ms");

        limit and offset are applied at the Image-level. That is, calling with Dataset.class, limit == 10 and offset == 0 will first perform one query to get an effective set of rootNodeIds, then getImages will be called with an effective rootNodeType of Image.class and the new ids.

        acquisition data is only relevant for images.
        __cb - The asynchronous callback object.
        Returns:
        The asynchronous result object.

      • begin_getImages

        public Ice.AsyncResult begin_getImages​(java.lang.String rootType,
                                       java.util.List<java.lang.Long> rootIds,
                                       Parameters options,
                                       java.util.Map<java.lang.String,​java.lang.String> __ctx,
                                       Callback_IContainer_getImages __cb)
        Description copied from interface: IContainerPrx
        Retrieve a user's (or all users') images within any given container. For example, all images in project, applying temporal filtering or pagination.
        Specified by:
        begin_getImages in interface IContainerPrx
        Parameters:
        rootType - A Class which will have its hierarchy searched for Images. Not null.
        rootIds - A set of ids of type rootNodeType Not null.
        options - Parameters as above. No notion of leaves. experimenter|group apply at the Image level. OPTIONS: - startTime and/or endTime should be Timestamp.valueOf("YYYY-MM-DD hh:mm:ss.ms");

        limit and offset are applied at the Image-level. That is, calling with Dataset.class, limit == 10 and offset == 0 will first perform one query to get an effective set of rootNodeIds, then getImages will be called with an effective rootNodeType of Image.class and the new ids.

        acquisition data is only relevant for images.
        __ctx - The Context map to send with the invocation.
        __cb - The asynchronous callback object.
        Returns:
        The asynchronous result object.

      • begin_getImages

        public Ice.AsyncResult begin_getImages​(java.lang.String rootType,
                                       java.util.List<java.lang.Long> rootIds,
                                       Parameters options,
                                       IceInternal.Functional_GenericCallback1<java.util.List<Image>> __responseCb,
                                       IceInternal.Functional_GenericCallback1<Ice.UserException> __userExceptionCb,
                                       IceInternal.Functional_GenericCallback1<Ice.Exception> __exceptionCb)
        Description copied from interface: IContainerPrx
        Retrieve a user's (or all users') images within any given container. For example, all images in project, applying temporal filtering or pagination.
        Specified by:
        begin_getImages in interface IContainerPrx
        Parameters:
        rootType - A Class which will have its hierarchy searched for Images. Not null.
        rootIds - A set of ids of type rootNodeType Not null.
        options - Parameters as above. No notion of leaves. experimenter|group apply at the Image level. OPTIONS: - startTime and/or endTime should be Timestamp.valueOf("YYYY-MM-DD hh:mm:ss.ms");

        limit and offset are applied at the Image-level. That is, calling with Dataset.class, limit == 10 and offset == 0 will first perform one query to get an effective set of rootNodeIds, then getImages will be called with an effective rootNodeType of Image.class and the new ids.

        acquisition data is only relevant for images.
        __responseCb - The lambda response callback.
        __userExceptionCb - The lambda user exception callback.
        __exceptionCb - The lambda exception callback.
        Returns:
        The asynchronous result object.

      • begin_getImages

        public Ice.AsyncResult begin_getImages​(java.lang.String rootType,
                                       java.util.List<java.lang.Long> rootIds,
                                       Parameters options,
                                       IceInternal.Functional_GenericCallback1<java.util.List<Image>> __responseCb,
                                       IceInternal.Functional_GenericCallback1<Ice.UserException> __userExceptionCb,
                                       IceInternal.Functional_GenericCallback1<Ice.Exception> __exceptionCb,
                                       IceInternal.Functional_BoolCallback __sentCb)
        Description copied from interface: IContainerPrx
        Retrieve a user's (or all users') images within any given container. For example, all images in project, applying temporal filtering or pagination.
        Specified by:
        begin_getImages in interface IContainerPrx
        Parameters:
        rootType - A Class which will have its hierarchy searched for Images. Not null.
        rootIds - A set of ids of type rootNodeType Not null.
        options - Parameters as above. No notion of leaves. experimenter|group apply at the Image level. OPTIONS: - startTime and/or endTime should be Timestamp.valueOf("YYYY-MM-DD hh:mm:ss.ms");

        limit and offset are applied at the Image-level. That is, calling with Dataset.class, limit == 10 and offset == 0 will first perform one query to get an effective set of rootNodeIds, then getImages will be called with an effective rootNodeType of Image.class and the new ids.

        acquisition data is only relevant for images.
        __responseCb - The lambda response callback.
        __userExceptionCb - The lambda user exception callback.
        __exceptionCb - The lambda exception callback.
        __sentCb - The lambda sent callback.
        Returns:
        The asynchronous result object.

      • begin_getImages

        public Ice.AsyncResult begin_getImages​(java.lang.String rootType,
                                       java.util.List<java.lang.Long> rootIds,
                                       Parameters options,
                                       java.util.Map<java.lang.String,​java.lang.String> __ctx,
                                       IceInternal.Functional_GenericCallback1<java.util.List<Image>> __responseCb,
                                       IceInternal.Functional_GenericCallback1<Ice.UserException> __userExceptionCb,
                                       IceInternal.Functional_GenericCallback1<Ice.Exception> __exceptionCb)
        Description copied from interface: IContainerPrx
        Retrieve a user's (or all users') images within any given container. For example, all images in project, applying temporal filtering or pagination.
        Specified by:
        begin_getImages in interface IContainerPrx
        Parameters:
        rootType - A Class which will have its hierarchy searched for Images. Not null.
        rootIds - A set of ids of type rootNodeType Not null.
        options - Parameters as above. No notion of leaves. experimenter|group apply at the Image level. OPTIONS: - startTime and/or endTime should be Timestamp.valueOf("YYYY-MM-DD hh:mm:ss.ms");

        limit and offset are applied at the Image-level. That is, calling with Dataset.class, limit == 10 and offset == 0 will first perform one query to get an effective set of rootNodeIds, then getImages will be called with an effective rootNodeType of Image.class and the new ids.

        acquisition data is only relevant for images.
        __ctx - The Context map to send with the invocation.
        __responseCb - The lambda response callback.
        __userExceptionCb - The lambda user exception callback.
        __exceptionCb - The lambda exception callback.
        Returns:
        The asynchronous result object.

      • begin_getImages

        public Ice.AsyncResult begin_getImages​(java.lang.String rootType,
                                       java.util.List<java.lang.Long> rootIds,
                                       Parameters options,
                                       java.util.Map<java.lang.String,​java.lang.String> __ctx,
                                       IceInternal.Functional_GenericCallback1<java.util.List<Image>> __responseCb,
                                       IceInternal.Functional_GenericCallback1<Ice.UserException> __userExceptionCb,
                                       IceInternal.Functional_GenericCallback1<Ice.Exception> __exceptionCb,
                                       IceInternal.Functional_BoolCallback __sentCb)
        Description copied from interface: IContainerPrx
        Retrieve a user's (or all users') images within any given container. For example, all images in project, applying temporal filtering or pagination.
        Specified by:
        begin_getImages in interface IContainerPrx
        Parameters:
        rootType - A Class which will have its hierarchy searched for Images. Not null.
        rootIds - A set of ids of type rootNodeType Not null.
        options - Parameters as above. No notion of leaves. experimenter|group apply at the Image level. OPTIONS: - startTime and/or endTime should be Timestamp.valueOf("YYYY-MM-DD hh:mm:ss.ms");

        limit and offset are applied at the Image-level. That is, calling with Dataset.class, limit == 10 and offset == 0 will first perform one query to get an effective set of rootNodeIds, then getImages will be called with an effective rootNodeType of Image.class and the new ids.

        acquisition data is only relevant for images.
        __ctx - The Context map to send with the invocation.
        __responseCb - The lambda response callback.
        __userExceptionCb - The lambda user exception callback.
        __exceptionCb - The lambda exception callback.
        __sentCb - The lambda sent callback.
        Returns:
        The asynchronous result object.

      • end_getImages

        public java.util.List<Image> end_getImages​(Ice.AsyncResult __iresult)
                                    throws ServerError
        Description copied from interface: IContainerPrx
        Retrieve a user's (or all users') images within any given container. For example, all images in project, applying temporal filtering or pagination.
        Specified by:
        end_getImages in interface IContainerPrx
        Parameters:
        __iresult - The asynchronous result object.
        Returns:
        A set of images.
        Throws:
        ServerError

      • getImagesByOptions

        public java.util.List<Image> getImagesByOptions​(Parameters options)
                                         throws ServerError
        Description copied from interface: IContainerPrx
        Retrieves images by options.
        Specified by:
        getImagesByOptions in interface IContainerPrx
        Parameters:
        options - Parameters as above. No notion of leaves. experimenter|group apply at the Image level and must be present. OPTIONS: - startTime and/or endTime should be Timestamp.valueOf("YYYY-MM-DD hh:mm:ss.ms"). acquisition data is only relevant for images.
        Returns:
        A set of images.
        Throws:
        ServerError

      • getImagesByOptions

        public java.util.List<Image> getImagesByOptions​(Parameters options,
                                                java.util.Map<java.lang.String,​java.lang.String> __ctx)
                                         throws ServerError
        Description copied from interface: IContainerPrx
        Retrieves images by options.
        Specified by:
        getImagesByOptions in interface IContainerPrx
        Parameters:
        options - Parameters as above. No notion of leaves. experimenter|group apply at the Image level and must be present. OPTIONS: - startTime and/or endTime should be Timestamp.valueOf("YYYY-MM-DD hh:mm:ss.ms"). acquisition data is only relevant for images.
        __ctx - The Context map to send with the invocation.
        Returns:
        A set of images.
        Throws:
        ServerError

      • begin_getImagesByOptions

        public Ice.AsyncResult begin_getImagesByOptions​(Parameters options)
        Description copied from interface: IContainerPrx
        Retrieves images by options.
        Specified by:
        begin_getImagesByOptions in interface IContainerPrx
        Parameters:
        options - Parameters as above. No notion of leaves. experimenter|group apply at the Image level and must be present. OPTIONS: - startTime and/or endTime should be Timestamp.valueOf("YYYY-MM-DD hh:mm:ss.ms"). acquisition data is only relevant for images.
        Returns:
        The asynchronous result object.

      • begin_getImagesByOptions

        public Ice.AsyncResult begin_getImagesByOptions​(Parameters options,
                                                java.util.Map<java.lang.String,​java.lang.String> __ctx)
        Description copied from interface: IContainerPrx
        Retrieves images by options.
        Specified by:
        begin_getImagesByOptions in interface IContainerPrx
        Parameters:
        options - Parameters as above. No notion of leaves. experimenter|group apply at the Image level and must be present. OPTIONS: - startTime and/or endTime should be Timestamp.valueOf("YYYY-MM-DD hh:mm:ss.ms"). acquisition data is only relevant for images.
        __ctx - The Context map to send with the invocation.
        Returns:
        The asynchronous result object.

      • begin_getImagesByOptions

        public Ice.AsyncResult begin_getImagesByOptions​(Parameters options,
                                                Ice.Callback __cb)
        Description copied from interface: IContainerPrx
        Retrieves images by options.
        Specified by:
        begin_getImagesByOptions in interface IContainerPrx
        Parameters:
        options - Parameters as above. No notion of leaves. experimenter|group apply at the Image level and must be present. OPTIONS: - startTime and/or endTime should be Timestamp.valueOf("YYYY-MM-DD hh:mm:ss.ms"). acquisition data is only relevant for images.
        __cb - The asynchronous callback object.
        Returns:
        The asynchronous result object.

      • begin_getImagesByOptions

        public Ice.AsyncResult begin_getImagesByOptions​(Parameters options,
                                                java.util.Map<java.lang.String,​java.lang.String> __ctx,
                                                Ice.Callback __cb)
        Description copied from interface: IContainerPrx
        Retrieves images by options.
        Specified by:
        begin_getImagesByOptions in interface IContainerPrx
        Parameters:
        options - Parameters as above. No notion of leaves. experimenter|group apply at the Image level and must be present. OPTIONS: - startTime and/or endTime should be Timestamp.valueOf("YYYY-MM-DD hh:mm:ss.ms"). acquisition data is only relevant for images.
        __ctx - The Context map to send with the invocation.
        __cb - The asynchronous callback object.
        Returns:
        The asynchronous result object.

      • begin_getImagesByOptions

        public Ice.AsyncResult begin_getImagesByOptions​(Parameters options,
                                                Callback_IContainer_getImagesByOptions __cb)
        Description copied from interface: IContainerPrx
        Retrieves images by options.
        Specified by:
        begin_getImagesByOptions in interface IContainerPrx
        Parameters:
        options - Parameters as above. No notion of leaves. experimenter|group apply at the Image level and must be present. OPTIONS: - startTime and/or endTime should be Timestamp.valueOf("YYYY-MM-DD hh:mm:ss.ms"). acquisition data is only relevant for images.
        __cb - The asynchronous callback object.
        Returns:
        The asynchronous result object.

      • begin_getImagesByOptions

        public Ice.AsyncResult begin_getImagesByOptions​(Parameters options,
                                                java.util.Map<java.lang.String,​java.lang.String> __ctx,
                                                Callback_IContainer_getImagesByOptions __cb)
        Description copied from interface: IContainerPrx
        Retrieves images by options.
        Specified by:
        begin_getImagesByOptions in interface IContainerPrx
        Parameters:
        options - Parameters as above. No notion of leaves. experimenter|group apply at the Image level and must be present. OPTIONS: - startTime and/or endTime should be Timestamp.valueOf("YYYY-MM-DD hh:mm:ss.ms"). acquisition data is only relevant for images.
        __ctx - The Context map to send with the invocation.
        __cb - The asynchronous callback object.
        Returns:
        The asynchronous result object.

      • getImagesBySplitFilesets

        public java.util.Map<java.lang.Long,​java.util.Map<java.lang.Boolean,​java.util.List<java.lang.Long>>> getImagesBySplitFilesets​(java.util.Map<java.lang.String,​java.util.List<java.lang.Long>> included,
                                                                                                                                          Parameters options)
                                                                                                                                   throws ServerError
        Description copied from interface: IContainerPrx
        Given a list of IDs of certain entity types, calculates which filesets are split such that a non-empty proper subset of their images are referenced, directly or indirectly, as being included. The return value lists both the fileset IDs and the image IDs in ascending order, the image ID lists separated by if they were included. Warning: following discussion in trac ticket 11019 the return type may be changed.
        Specified by:
        getImagesBySplitFilesets in interface IContainerPrx
        Parameters:
        included - the entities included
        options - parameters, presently ignored
        Returns:
        the partially included filesets
        Throws:
        ServerError

      • getImagesBySplitFilesets

        public java.util.Map<java.lang.Long,​java.util.Map<java.lang.Boolean,​java.util.List<java.lang.Long>>> getImagesBySplitFilesets​(java.util.Map<java.lang.String,​java.util.List<java.lang.Long>> included,
                                                                                                                                          Parameters options,
                                                                                                                                          java.util.Map<java.lang.String,​java.lang.String> __ctx)
                                                                                                                                   throws ServerError
        Description copied from interface: IContainerPrx
        Given a list of IDs of certain entity types, calculates which filesets are split such that a non-empty proper subset of their images are referenced, directly or indirectly, as being included. The return value lists both the fileset IDs and the image IDs in ascending order, the image ID lists separated by if they were included. Warning: following discussion in trac ticket 11019 the return type may be changed.
        Specified by:
        getImagesBySplitFilesets in interface IContainerPrx
        Parameters:
        included - the entities included
        options - parameters, presently ignored
        __ctx - The Context map to send with the invocation.
        Returns:
        the partially included filesets
        Throws:
        ServerError

      • begin_getImagesBySplitFilesets

        public Ice.AsyncResult begin_getImagesBySplitFilesets​(java.util.Map<java.lang.String,​java.util.List<java.lang.Long>> included,
                                                      Parameters options)
        Description copied from interface: IContainerPrx
        Given a list of IDs of certain entity types, calculates which filesets are split such that a non-empty proper subset of their images are referenced, directly or indirectly, as being included. The return value lists both the fileset IDs and the image IDs in ascending order, the image ID lists separated by if they were included. Warning: following discussion in trac ticket 11019 the return type may be changed.
        Specified by:
        begin_getImagesBySplitFilesets in interface IContainerPrx
        Parameters:
        included - the entities included
        Returns:
        The asynchronous result object.

      • begin_getImagesBySplitFilesets

        public Ice.AsyncResult begin_getImagesBySplitFilesets​(java.util.Map<java.lang.String,​java.util.List<java.lang.Long>> included,
                                                      Parameters options,
                                                      java.util.Map<java.lang.String,​java.lang.String> __ctx)
        Description copied from interface: IContainerPrx
        Given a list of IDs of certain entity types, calculates which filesets are split such that a non-empty proper subset of their images are referenced, directly or indirectly, as being included. The return value lists both the fileset IDs and the image IDs in ascending order, the image ID lists separated by if they were included. Warning: following discussion in trac ticket 11019 the return type may be changed.
        Specified by:
        begin_getImagesBySplitFilesets in interface IContainerPrx
        Parameters:
        included - the entities included
        __ctx - The Context map to send with the invocation.
        Returns:
        The asynchronous result object.

      • begin_getImagesBySplitFilesets

        public Ice.AsyncResult begin_getImagesBySplitFilesets​(java.util.Map<java.lang.String,​java.util.List<java.lang.Long>> included,
                                                      Parameters options,
                                                      Ice.Callback __cb)
        Description copied from interface: IContainerPrx
        Given a list of IDs of certain entity types, calculates which filesets are split such that a non-empty proper subset of their images are referenced, directly or indirectly, as being included. The return value lists both the fileset IDs and the image IDs in ascending order, the image ID lists separated by if they were included. Warning: following discussion in trac ticket 11019 the return type may be changed.
        Specified by:
        begin_getImagesBySplitFilesets in interface IContainerPrx
        Parameters:
        included - the entities included
        __cb - The asynchronous callback object.
        Returns:
        The asynchronous result object.

      • begin_getImagesBySplitFilesets

        public Ice.AsyncResult begin_getImagesBySplitFilesets​(java.util.Map<java.lang.String,​java.util.List<java.lang.Long>> included,
                                                      Parameters options,
                                                      java.util.Map<java.lang.String,​java.lang.String> __ctx,
                                                      Ice.Callback __cb)
        Description copied from interface: IContainerPrx
        Given a list of IDs of certain entity types, calculates which filesets are split such that a non-empty proper subset of their images are referenced, directly or indirectly, as being included. The return value lists both the fileset IDs and the image IDs in ascending order, the image ID lists separated by if they were included. Warning: following discussion in trac ticket 11019 the return type may be changed.
        Specified by:
        begin_getImagesBySplitFilesets in interface IContainerPrx
        Parameters:
        included - the entities included
        __ctx - The Context map to send with the invocation.
        __cb - The asynchronous callback object.
        Returns:
        The asynchronous result object.

      • begin_getImagesBySplitFilesets

        public Ice.AsyncResult begin_getImagesBySplitFilesets​(java.util.Map<java.lang.String,​java.util.List<java.lang.Long>> included,
                                                      Parameters options,
                                                      Callback_IContainer_getImagesBySplitFilesets __cb)
        Description copied from interface: IContainerPrx
        Given a list of IDs of certain entity types, calculates which filesets are split such that a non-empty proper subset of their images are referenced, directly or indirectly, as being included. The return value lists both the fileset IDs and the image IDs in ascending order, the image ID lists separated by if they were included. Warning: following discussion in trac ticket 11019 the return type may be changed.
        Specified by:
        begin_getImagesBySplitFilesets in interface IContainerPrx
        Parameters:
        included - the entities included
        __cb - The asynchronous callback object.
        Returns:
        The asynchronous result object.

      • begin_getImagesBySplitFilesets

        public Ice.AsyncResult begin_getImagesBySplitFilesets​(java.util.Map<java.lang.String,​java.util.List<java.lang.Long>> included,
                                                      Parameters options,
                                                      java.util.Map<java.lang.String,​java.lang.String> __ctx,
                                                      Callback_IContainer_getImagesBySplitFilesets __cb)
        Description copied from interface: IContainerPrx
        Given a list of IDs of certain entity types, calculates which filesets are split such that a non-empty proper subset of their images are referenced, directly or indirectly, as being included. The return value lists both the fileset IDs and the image IDs in ascending order, the image ID lists separated by if they were included. Warning: following discussion in trac ticket 11019 the return type may be changed.
        Specified by:
        begin_getImagesBySplitFilesets in interface IContainerPrx
        Parameters:
        included - the entities included
        __ctx - The Context map to send with the invocation.
        __cb - The asynchronous callback object.
        Returns:
        The asynchronous result object.

      • begin_getImagesBySplitFilesets

        public Ice.AsyncResult begin_getImagesBySplitFilesets​(java.util.Map<java.lang.String,​java.util.List<java.lang.Long>> included,
                                                      Parameters options,
                                                      IceInternal.Functional_GenericCallback1<java.util.Map<java.lang.Long,​java.util.Map<java.lang.Boolean,​java.util.List<java.lang.Long>>>> __responseCb,
                                                      IceInternal.Functional_GenericCallback1<Ice.UserException> __userExceptionCb,
                                                      IceInternal.Functional_GenericCallback1<Ice.Exception> __exceptionCb)
        Description copied from interface: IContainerPrx
        Given a list of IDs of certain entity types, calculates which filesets are split such that a non-empty proper subset of their images are referenced, directly or indirectly, as being included. The return value lists both the fileset IDs and the image IDs in ascending order, the image ID lists separated by if they were included. Warning: following discussion in trac ticket 11019 the return type may be changed.
        Specified by:
        begin_getImagesBySplitFilesets in interface IContainerPrx
        Parameters:
        included - the entities included
        __responseCb - The lambda response callback.
        __userExceptionCb - The lambda user exception callback.
        __exceptionCb - The lambda exception callback.
        Returns:
        The asynchronous result object.

      • begin_getImagesBySplitFilesets

        public Ice.AsyncResult begin_getImagesBySplitFilesets​(java.util.Map<java.lang.String,​java.util.List<java.lang.Long>> included,
                                                      Parameters options,
                                                      IceInternal.Functional_GenericCallback1<java.util.Map<java.lang.Long,​java.util.Map<java.lang.Boolean,​java.util.List<java.lang.Long>>>> __responseCb,
                                                      IceInternal.Functional_GenericCallback1<Ice.UserException> __userExceptionCb,
                                                      IceInternal.Functional_GenericCallback1<Ice.Exception> __exceptionCb,
                                                      IceInternal.Functional_BoolCallback __sentCb)
        Description copied from interface: IContainerPrx
        Given a list of IDs of certain entity types, calculates which filesets are split such that a non-empty proper subset of their images are referenced, directly or indirectly, as being included. The return value lists both the fileset IDs and the image IDs in ascending order, the image ID lists separated by if they were included. Warning: following discussion in trac ticket 11019 the return type may be changed.
        Specified by:
        begin_getImagesBySplitFilesets in interface IContainerPrx
        Parameters:
        included - the entities included
        __responseCb - The lambda response callback.
        __userExceptionCb - The lambda user exception callback.
        __exceptionCb - The lambda exception callback.
        __sentCb - The lambda sent callback.
        Returns:
        The asynchronous result object.

      • begin_getImagesBySplitFilesets

        public Ice.AsyncResult begin_getImagesBySplitFilesets​(java.util.Map<java.lang.String,​java.util.List<java.lang.Long>> included,
                                                      Parameters options,
                                                      java.util.Map<java.lang.String,​java.lang.String> __ctx,
                                                      IceInternal.Functional_GenericCallback1<java.util.Map<java.lang.Long,​java.util.Map<java.lang.Boolean,​java.util.List<java.lang.Long>>>> __responseCb,
                                                      IceInternal.Functional_GenericCallback1<Ice.UserException> __userExceptionCb,
                                                      IceInternal.Functional_GenericCallback1<Ice.Exception> __exceptionCb)
        Description copied from interface: IContainerPrx
        Given a list of IDs of certain entity types, calculates which filesets are split such that a non-empty proper subset of their images are referenced, directly or indirectly, as being included. The return value lists both the fileset IDs and the image IDs in ascending order, the image ID lists separated by if they were included. Warning: following discussion in trac ticket 11019 the return type may be changed.
        Specified by:
        begin_getImagesBySplitFilesets in interface IContainerPrx
        Parameters:
        included - the entities included
        __ctx - The Context map to send with the invocation.
        __responseCb - The lambda response callback.
        __userExceptionCb - The lambda user exception callback.
        __exceptionCb - The lambda exception callback.
        Returns:
        The asynchronous result object.

      • begin_getImagesBySplitFilesets

        public Ice.AsyncResult begin_getImagesBySplitFilesets​(java.util.Map<java.lang.String,​java.util.List<java.lang.Long>> included,
                                                      Parameters options,
                                                      java.util.Map<java.lang.String,​java.lang.String> __ctx,
                                                      IceInternal.Functional_GenericCallback1<java.util.Map<java.lang.Long,​java.util.Map<java.lang.Boolean,​java.util.List<java.lang.Long>>>> __responseCb,
                                                      IceInternal.Functional_GenericCallback1<Ice.UserException> __userExceptionCb,
                                                      IceInternal.Functional_GenericCallback1<Ice.Exception> __exceptionCb,
                                                      IceInternal.Functional_BoolCallback __sentCb)
        Description copied from interface: IContainerPrx
        Given a list of IDs of certain entity types, calculates which filesets are split such that a non-empty proper subset of their images are referenced, directly or indirectly, as being included. The return value lists both the fileset IDs and the image IDs in ascending order, the image ID lists separated by if they were included. Warning: following discussion in trac ticket 11019 the return type may be changed.
        Specified by:
        begin_getImagesBySplitFilesets in interface IContainerPrx
        Parameters:
        included - the entities included
        __ctx - The Context map to send with the invocation.
        __responseCb - The lambda response callback.
        __userExceptionCb - The lambda user exception callback.
        __exceptionCb - The lambda exception callback.
        __sentCb - The lambda sent callback.
        Returns:
        The asynchronous result object.

      • end_getImagesBySplitFilesets

        public java.util.Map<java.lang.Long,​java.util.Map<java.lang.Boolean,​java.util.List<java.lang.Long>>> end_getImagesBySplitFilesets​(Ice.AsyncResult __iresult)
                                                                                                                                       throws ServerError
        Description copied from interface: IContainerPrx
        Given a list of IDs of certain entity types, calculates which filesets are split such that a non-empty proper subset of their images are referenced, directly or indirectly, as being included. The return value lists both the fileset IDs and the image IDs in ascending order, the image ID lists separated by if they were included. Warning: following discussion in trac ticket 11019 the return type may be changed.
        Specified by:
        end_getImagesBySplitFilesets in interface IContainerPrx
        Parameters:
        __iresult - The asynchronous result object.
        Returns:
        the partially included filesets
        Throws:
        ServerError

      • __getImagesBySplitFilesets_completed

        public static void __getImagesBySplitFilesets_completed​(Ice.TwowayCallbackArg1UE<java.util.Map<java.lang.Long,​java.util.Map<java.lang.Boolean,​java.util.List<java.lang.Long>>>> __cb,
                                                        Ice.AsyncResult __result)

      • getUserImages

        public java.util.List<Image> getUserImages​(Parameters options)
                                    throws ServerError
        Description copied from interface: IContainerPrx
        Retrieves a user's images.
        Specified by:
        getUserImages in interface IContainerPrx
        Parameters:
        options - Parameters as above. No notion of leaves. experimenter|group apply at the Image level and must be present.
        Returns:
        A set of images.
        Throws:
        ServerError

      • getUserImages

        public java.util.List<Image> getUserImages​(Parameters options,
                                           java.util.Map<java.lang.String,​java.lang.String> __ctx)
                                    throws ServerError
        Description copied from interface: IContainerPrx
        Retrieves a user's images.
        Specified by:
        getUserImages in interface IContainerPrx
        Parameters:
        options - Parameters as above. No notion of leaves. experimenter|group apply at the Image level and must be present.
        __ctx - The Context map to send with the invocation.
        Returns:
        A set of images.
        Throws:
        ServerError

      • begin_getUserImages

        public Ice.AsyncResult begin_getUserImages​(Parameters options)
        Description copied from interface: IContainerPrx
        Retrieves a user's images.
        Specified by:
        begin_getUserImages in interface IContainerPrx
        Parameters:
        options - Parameters as above. No notion of leaves. experimenter|group apply at the Image level and must be present.
        Returns:
        The asynchronous result object.

      • begin_getUserImages

        public Ice.AsyncResult begin_getUserImages​(Parameters options,
                                           java.util.Map<java.lang.String,​java.lang.String> __ctx)
        Description copied from interface: IContainerPrx
        Retrieves a user's images.
        Specified by:
        begin_getUserImages in interface IContainerPrx
        Parameters:
        options - Parameters as above. No notion of leaves. experimenter|group apply at the Image level and must be present.
        __ctx - The Context map to send with the invocation.
        Returns:
        The asynchronous result object.

      • begin_getUserImages

        public Ice.AsyncResult begin_getUserImages​(Parameters options,
                                           Ice.Callback __cb)
        Description copied from interface: IContainerPrx
        Retrieves a user's images.
        Specified by:
        begin_getUserImages in interface IContainerPrx
        Parameters:
        options - Parameters as above. No notion of leaves. experimenter|group apply at the Image level and must be present.
        __cb - The asynchronous callback object.
        Returns:
        The asynchronous result object.

      • begin_getUserImages

        public Ice.AsyncResult begin_getUserImages​(Parameters options,
                                           java.util.Map<java.lang.String,​java.lang.String> __ctx,
                                           Ice.Callback __cb)
        Description copied from interface: IContainerPrx
        Retrieves a user's images.
        Specified by:
        begin_getUserImages in interface IContainerPrx
        Parameters:
        options - Parameters as above. No notion of leaves. experimenter|group apply at the Image level and must be present.
        __ctx - The Context map to send with the invocation.
        __cb - The asynchronous callback object.
        Returns:
        The asynchronous result object.

      • begin_getUserImages

        public Ice.AsyncResult begin_getUserImages​(Parameters options,
                                           java.util.Map<java.lang.String,​java.lang.String> __ctx,
                                           Callback_IContainer_getUserImages __cb)
        Description copied from interface: IContainerPrx
        Retrieves a user's images.
        Specified by:
        begin_getUserImages in interface IContainerPrx
        Parameters:
        options - Parameters as above. No notion of leaves. experimenter|group apply at the Image level and must be present.
        __ctx - The Context map to send with the invocation.
        __cb - The asynchronous callback object.
        Returns:
        The asynchronous result object.

      • link

        public java.util.List<IObject> link​(java.util.List<IObject> links,
                                    Parameters options)
                             throws ServerError
        Description copied from interface: IContainerPrx
        Convenience method for creating links. Functionality also available from createDataObject
        Specified by:
        link in interface IContainerPrx
        Parameters:
        links - Array of links to be created.
        options - Parameters as above.
        Returns:
        the created links
        Throws:
        ServerError

      • link

        public java.util.List<IObject> link​(java.util.List<IObject> links,
                                    Parameters options,
                                    java.util.Map<java.lang.String,​java.lang.String> __ctx)
                             throws ServerError
        Description copied from interface: IContainerPrx
        Convenience method for creating links. Functionality also available from createDataObject
        Specified by:
        link in interface IContainerPrx
        Parameters:
        links - Array of links to be created.
        options - Parameters as above.
        __ctx - The Context map to send with the invocation.
        Returns:
        the created links
        Throws:
        ServerError

      • begin_link

        public Ice.AsyncResult begin_link​(java.util.List<IObject> links,
                                  Parameters options)
        Description copied from interface: IContainerPrx
        Convenience method for creating links. Functionality also available from createDataObject
        Specified by:
        begin_link in interface IContainerPrx
        Parameters:
        links - Array of links to be created.
        Returns:
        The asynchronous result object.

      • begin_link

        public Ice.AsyncResult begin_link​(java.util.List<IObject> links,
                                  Parameters options,
                                  java.util.Map<java.lang.String,​java.lang.String> __ctx)
        Description copied from interface: IContainerPrx
        Convenience method for creating links. Functionality also available from createDataObject
        Specified by:
        begin_link in interface IContainerPrx
        Parameters:
        links - Array of links to be created.
        __ctx - The Context map to send with the invocation.
        Returns:
        The asynchronous result object.

      • begin_link

        public Ice.AsyncResult begin_link​(java.util.List<IObject> links,
                                  Parameters options,
                                  Ice.Callback __cb)
        Description copied from interface: IContainerPrx
        Convenience method for creating links. Functionality also available from createDataObject
        Specified by:
        begin_link in interface IContainerPrx
        Parameters:
        links - Array of links to be created.
        __cb - The asynchronous callback object.
        Returns:
        The asynchronous result object.

      • begin_link

        public Ice.AsyncResult begin_link​(java.util.List<IObject> links,
                                  Parameters options,
                                  java.util.Map<java.lang.String,​java.lang.String> __ctx,
                                  Ice.Callback __cb)
        Description copied from interface: IContainerPrx
        Convenience method for creating links. Functionality also available from createDataObject
        Specified by:
        begin_link in interface IContainerPrx
        Parameters:
        links - Array of links to be created.
        __ctx - The Context map to send with the invocation.
        __cb - The asynchronous callback object.
        Returns:
        The asynchronous result object.

      • begin_link

        public Ice.AsyncResult begin_link​(java.util.List<IObject> links,
                                  Parameters options,
                                  Callback_IContainer_link __cb)
        Description copied from interface: IContainerPrx
        Convenience method for creating links. Functionality also available from createDataObject
        Specified by:
        begin_link in interface IContainerPrx
        Parameters:
        links - Array of links to be created.
        __cb - The asynchronous callback object.
        Returns:
        The asynchronous result object.

      • begin_link

        public Ice.AsyncResult begin_link​(java.util.List<IObject> links,
                                  Parameters options,
                                  java.util.Map<java.lang.String,​java.lang.String> __ctx,
                                  Callback_IContainer_link __cb)
        Description copied from interface: IContainerPrx
        Convenience method for creating links. Functionality also available from createDataObject
        Specified by:
        begin_link in interface IContainerPrx
        Parameters:
        links - Array of links to be created.
        __ctx - The Context map to send with the invocation.
        __cb - The asynchronous callback object.
        Returns:
        The asynchronous result object.

      • end_link

        public java.util.List<IObject> end_link​(Ice.AsyncResult __iresult)
                                 throws ServerError
        Description copied from interface: IContainerPrx
        Convenience method for creating links. Functionality also available from createDataObject
        Specified by:
        end_link in interface IContainerPrx
        Parameters:
        __iresult - The asynchronous result object.
        Returns:
        the created links
        Throws:
        ServerError

      • loadContainerHierarchy

        public java.util.List<IObject> loadContainerHierarchy​(java.lang.String rootType,
                                                      java.util.List<java.lang.Long> rootIds,
                                                      Parameters options)
                                               throws ServerError
        Description copied from interface: IContainerPrx
        Retrieves hierarchy trees rooted by a given node (unless orphan is specified -- See below)

        This method also retrieves the Experimenters linked to the objects in the tree. Similarly, all Images will be linked to their Pixel objects if included.

        Note that objects are never duplicated. For example, if an Experimenter owns all the objects in the retrieved tree, then those objects will be linked to the same instance of Experimenter. Or if an Image is contained in more than one Dataset in the retrieved tree, then all enclosing Dataset objects will point to the same Image object. And so on.

        Specified by:
        loadContainerHierarchy in interface IContainerPrx
        Parameters:
        rootType - The type of the root node. Can be Project, Dataset, Screen or Plate. Cannot be null.
        rootIds - The ids of the root nodes. Can be null if an Experimenter is specified in options, otherwise an Exception is thrown to prevent all images in the entire database from being downloaded.
        options - Parameters as above. annotator, leaves, orphan, acquisition data used. acquisition data is only relevant for images and taken into account if the images are loaded. If rootNodeIds==null, experimenter|group must be set and filtering will be applied at the Class-level; e.g. to retrieve a user's Projects, or user's Datasets. If rootNodeIds!=null, the result will be filtered by the experimenter|group at the Image and intermediate levels if available. Due to the amount of data potentially linked a Screen/Plate, the leaves option is not taken into account when the root node is a Screen. orphan implies that objects which are not contained in an object of rootNodeType should also be returned.
        Returns:
        a set of hierarchy trees. The requested node as root and all of its descendants. The type of the returned value will be rootNodeType, unless orphan is specified in which case objects of type rootNodeType and below may be returned.
        Throws:
        ServerError

      • loadContainerHierarchy

        public java.util.List<IObject> loadContainerHierarchy​(java.lang.String rootType,
                                                      java.util.List<java.lang.Long> rootIds,
                                                      Parameters options,
                                                      java.util.Map<java.lang.String,​java.lang.String> __ctx)
                                               throws ServerError
        Description copied from interface: IContainerPrx
        Retrieves hierarchy trees rooted by a given node (unless orphan is specified -- See below)

        This method also retrieves the Experimenters linked to the objects in the tree. Similarly, all Images will be linked to their Pixel objects if included.

        Note that objects are never duplicated. For example, if an Experimenter owns all the objects in the retrieved tree, then those objects will be linked to the same instance of Experimenter. Or if an Image is contained in more than one Dataset in the retrieved tree, then all enclosing Dataset objects will point to the same Image object. And so on.

        Specified by:
        loadContainerHierarchy in interface IContainerPrx
        Parameters:
        rootType - The type of the root node. Can be Project, Dataset, Screen or Plate. Cannot be null.
        rootIds - The ids of the root nodes. Can be null if an Experimenter is specified in options, otherwise an Exception is thrown to prevent all images in the entire database from being downloaded.
        options - Parameters as above. annotator, leaves, orphan, acquisition data used. acquisition data is only relevant for images and taken into account if the images are loaded. If rootNodeIds==null, experimenter|group must be set and filtering will be applied at the Class-level; e.g. to retrieve a user's Projects, or user's Datasets. If rootNodeIds!=null, the result will be filtered by the experimenter|group at the Image and intermediate levels if available. Due to the amount of data potentially linked a Screen/Plate, the leaves option is not taken into account when the root node is a Screen. orphan implies that objects which are not contained in an object of rootNodeType should also be returned.
        __ctx - The Context map to send with the invocation.
        Returns:
        a set of hierarchy trees. The requested node as root and all of its descendants. The type of the returned value will be rootNodeType, unless orphan is specified in which case objects of type rootNodeType and below may be returned.
        Throws:
        ServerError

      • begin_loadContainerHierarchy

        public Ice.AsyncResult begin_loadContainerHierarchy​(java.lang.String rootType,
                                                    java.util.List<java.lang.Long> rootIds,
                                                    Parameters options)
        Description copied from interface: IContainerPrx
        Retrieves hierarchy trees rooted by a given node (unless orphan is specified -- See below)

        This method also retrieves the Experimenters linked to the objects in the tree. Similarly, all Images will be linked to their Pixel objects if included.

        Note that objects are never duplicated. For example, if an Experimenter owns all the objects in the retrieved tree, then those objects will be linked to the same instance of Experimenter. Or if an Image is contained in more than one Dataset in the retrieved tree, then all enclosing Dataset objects will point to the same Image object. And so on.

        Specified by:
        begin_loadContainerHierarchy in interface IContainerPrx
        Parameters:
        rootType - The type of the root node. Can be Project, Dataset, Screen or Plate. Cannot be null.
        rootIds - The ids of the root nodes. Can be null if an Experimenter is specified in options, otherwise an Exception is thrown to prevent all images in the entire database from being downloaded.
        options - Parameters as above. annotator, leaves, orphan, acquisition data used. acquisition data is only relevant for images and taken into account if the images are loaded. If rootNodeIds==null, experimenter|group must be set and filtering will be applied at the Class-level; e.g. to retrieve a user's Projects, or user's Datasets. If rootNodeIds!=null, the result will be filtered by the experimenter|group at the Image and intermediate levels if available. Due to the amount of data potentially linked a Screen/Plate, the leaves option is not taken into account when the root node is a Screen. orphan implies that objects which are not contained in an object of rootNodeType should also be returned.
        Returns:
        The asynchronous result object.

      • begin_loadContainerHierarchy

        public Ice.AsyncResult begin_loadContainerHierarchy​(java.lang.String rootType,
                                                    java.util.List<java.lang.Long> rootIds,
                                                    Parameters options,
                                                    java.util.Map<java.lang.String,​java.lang.String> __ctx)
        Description copied from interface: IContainerPrx
        Retrieves hierarchy trees rooted by a given node (unless orphan is specified -- See below)

        This method also retrieves the Experimenters linked to the objects in the tree. Similarly, all Images will be linked to their Pixel objects if included.

        Note that objects are never duplicated. For example, if an Experimenter owns all the objects in the retrieved tree, then those objects will be linked to the same instance of Experimenter. Or if an Image is contained in more than one Dataset in the retrieved tree, then all enclosing Dataset objects will point to the same Image object. And so on.

        Specified by:
        begin_loadContainerHierarchy in interface IContainerPrx
        Parameters:
        rootType - The type of the root node. Can be Project, Dataset, Screen or Plate. Cannot be null.
        rootIds - The ids of the root nodes. Can be null if an Experimenter is specified in options, otherwise an Exception is thrown to prevent all images in the entire database from being downloaded.
        options - Parameters as above. annotator, leaves, orphan, acquisition data used. acquisition data is only relevant for images and taken into account if the images are loaded. If rootNodeIds==null, experimenter|group must be set and filtering will be applied at the Class-level; e.g. to retrieve a user's Projects, or user's Datasets. If rootNodeIds!=null, the result will be filtered by the experimenter|group at the Image and intermediate levels if available. Due to the amount of data potentially linked a Screen/Plate, the leaves option is not taken into account when the root node is a Screen. orphan implies that objects which are not contained in an object of rootNodeType should also be returned.
        __ctx - The Context map to send with the invocation.
        Returns:
        The asynchronous result object.

      • begin_loadContainerHierarchy

        public Ice.AsyncResult begin_loadContainerHierarchy​(java.lang.String rootType,
                                                    java.util.List<java.lang.Long> rootIds,
                                                    Parameters options,
                                                    Ice.Callback __cb)
        Description copied from interface: IContainerPrx
        Retrieves hierarchy trees rooted by a given node (unless orphan is specified -- See below)

        This method also retrieves the Experimenters linked to the objects in the tree. Similarly, all Images will be linked to their Pixel objects if included.

        Note that objects are never duplicated. For example, if an Experimenter owns all the objects in the retrieved tree, then those objects will be linked to the same instance of Experimenter. Or if an Image is contained in more than one Dataset in the retrieved tree, then all enclosing Dataset objects will point to the same Image object. And so on.

        Specified by:
        begin_loadContainerHierarchy in interface IContainerPrx
        Parameters:
        rootType - The type of the root node. Can be Project, Dataset, Screen or Plate. Cannot be null.
        rootIds - The ids of the root nodes. Can be null if an Experimenter is specified in options, otherwise an Exception is thrown to prevent all images in the entire database from being downloaded.
        options - Parameters as above. annotator, leaves, orphan, acquisition data used. acquisition data is only relevant for images and taken into account if the images are loaded. If rootNodeIds==null, experimenter|group must be set and filtering will be applied at the Class-level; e.g. to retrieve a user's Projects, or user's Datasets. If rootNodeIds!=null, the result will be filtered by the experimenter|group at the Image and intermediate levels if available. Due to the amount of data potentially linked a Screen/Plate, the leaves option is not taken into account when the root node is a Screen. orphan implies that objects which are not contained in an object of rootNodeType should also be returned.
        __cb - The asynchronous callback object.
        Returns:
        The asynchronous result object.

      • begin_loadContainerHierarchy

        public Ice.AsyncResult begin_loadContainerHierarchy​(java.lang.String rootType,
                                                    java.util.List<java.lang.Long> rootIds,
                                                    Parameters options,
                                                    java.util.Map<java.lang.String,​java.lang.String> __ctx,
                                                    Ice.Callback __cb)
        Description copied from interface: IContainerPrx
        Retrieves hierarchy trees rooted by a given node (unless orphan is specified -- See below)

        This method also retrieves the Experimenters linked to the objects in the tree. Similarly, all Images will be linked to their Pixel objects if included.

        Note that objects are never duplicated. For example, if an Experimenter owns all the objects in the retrieved tree, then those objects will be linked to the same instance of Experimenter. Or if an Image is contained in more than one Dataset in the retrieved tree, then all enclosing Dataset objects will point to the same Image object. And so on.

        Specified by:
        begin_loadContainerHierarchy in interface IContainerPrx
        Parameters:
        rootType - The type of the root node. Can be Project, Dataset, Screen or Plate. Cannot be null.
        rootIds - The ids of the root nodes. Can be null if an Experimenter is specified in options, otherwise an Exception is thrown to prevent all images in the entire database from being downloaded.
        options - Parameters as above. annotator, leaves, orphan, acquisition data used. acquisition data is only relevant for images and taken into account if the images are loaded. If rootNodeIds==null, experimenter|group must be set and filtering will be applied at the Class-level; e.g. to retrieve a user's Projects, or user's Datasets. If rootNodeIds!=null, the result will be filtered by the experimenter|group at the Image and intermediate levels if available. Due to the amount of data potentially linked a Screen/Plate, the leaves option is not taken into account when the root node is a Screen. orphan implies that objects which are not contained in an object of rootNodeType should also be returned.
        __ctx - The Context map to send with the invocation.
        __cb - The asynchronous callback object.
        Returns:
        The asynchronous result object.

      • begin_loadContainerHierarchy

        public Ice.AsyncResult begin_loadContainerHierarchy​(java.lang.String rootType,
                                                    java.util.List<java.lang.Long> rootIds,
                                                    Parameters options,
                                                    Callback_IContainer_loadContainerHierarchy __cb)
        Description copied from interface: IContainerPrx
        Retrieves hierarchy trees rooted by a given node (unless orphan is specified -- See below)

        This method also retrieves the Experimenters linked to the objects in the tree. Similarly, all Images will be linked to their Pixel objects if included.

        Note that objects are never duplicated. For example, if an Experimenter owns all the objects in the retrieved tree, then those objects will be linked to the same instance of Experimenter. Or if an Image is contained in more than one Dataset in the retrieved tree, then all enclosing Dataset objects will point to the same Image object. And so on.

        Specified by:
        begin_loadContainerHierarchy in interface IContainerPrx
        Parameters:
        rootType - The type of the root node. Can be Project, Dataset, Screen or Plate. Cannot be null.
        rootIds - The ids of the root nodes. Can be null if an Experimenter is specified in options, otherwise an Exception is thrown to prevent all images in the entire database from being downloaded.
        options - Parameters as above. annotator, leaves, orphan, acquisition data used. acquisition data is only relevant for images and taken into account if the images are loaded. If rootNodeIds==null, experimenter|group must be set and filtering will be applied at the Class-level; e.g. to retrieve a user's Projects, or user's Datasets. If rootNodeIds!=null, the result will be filtered by the experimenter|group at the Image and intermediate levels if available. Due to the amount of data potentially linked a Screen/Plate, the leaves option is not taken into account when the root node is a Screen. orphan implies that objects which are not contained in an object of rootNodeType should also be returned.
        __cb - The asynchronous callback object.
        Returns:
        The asynchronous result object.

      • begin_loadContainerHierarchy

        public Ice.AsyncResult begin_loadContainerHierarchy​(java.lang.String rootType,
                                                    java.util.List<java.lang.Long> rootIds,
                                                    Parameters options,
                                                    java.util.Map<java.lang.String,​java.lang.String> __ctx,
                                                    Callback_IContainer_loadContainerHierarchy __cb)
        Description copied from interface: IContainerPrx
        Retrieves hierarchy trees rooted by a given node (unless orphan is specified -- See below)

        This method also retrieves the Experimenters linked to the objects in the tree. Similarly, all Images will be linked to their Pixel objects if included.

        Note that objects are never duplicated. For example, if an Experimenter owns all the objects in the retrieved tree, then those objects will be linked to the same instance of Experimenter. Or if an Image is contained in more than one Dataset in the retrieved tree, then all enclosing Dataset objects will point to the same Image object. And so on.

        Specified by:
        begin_loadContainerHierarchy in interface IContainerPrx
        Parameters:
        rootType - The type of the root node. Can be Project, Dataset, Screen or Plate. Cannot be null.
        rootIds - The ids of the root nodes. Can be null if an Experimenter is specified in options, otherwise an Exception is thrown to prevent all images in the entire database from being downloaded.
        options - Parameters as above. annotator, leaves, orphan, acquisition data used. acquisition data is only relevant for images and taken into account if the images are loaded. If rootNodeIds==null, experimenter|group must be set and filtering will be applied at the Class-level; e.g. to retrieve a user's Projects, or user's Datasets. If rootNodeIds!=null, the result will be filtered by the experimenter|group at the Image and intermediate levels if available. Due to the amount of data potentially linked a Screen/Plate, the leaves option is not taken into account when the root node is a Screen. orphan implies that objects which are not contained in an object of rootNodeType should also be returned.
        __ctx - The Context map to send with the invocation.
        __cb - The asynchronous callback object.
        Returns:
        The asynchronous result object.

      • begin_loadContainerHierarchy

        public Ice.AsyncResult begin_loadContainerHierarchy​(java.lang.String rootType,
                                                    java.util.List<java.lang.Long> rootIds,
                                                    Parameters options,
                                                    IceInternal.Functional_GenericCallback1<java.util.List<IObject>> __responseCb,
                                                    IceInternal.Functional_GenericCallback1<Ice.UserException> __userExceptionCb,
                                                    IceInternal.Functional_GenericCallback1<Ice.Exception> __exceptionCb)
        Description copied from interface: IContainerPrx
        Retrieves hierarchy trees rooted by a given node (unless orphan is specified -- See below)

        This method also retrieves the Experimenters linked to the objects in the tree. Similarly, all Images will be linked to their Pixel objects if included.

        Note that objects are never duplicated. For example, if an Experimenter owns all the objects in the retrieved tree, then those objects will be linked to the same instance of Experimenter. Or if an Image is contained in more than one Dataset in the retrieved tree, then all enclosing Dataset objects will point to the same Image object. And so on.

        Specified by:
        begin_loadContainerHierarchy in interface IContainerPrx
        Parameters:
        rootType - The type of the root node. Can be Project, Dataset, Screen or Plate. Cannot be null.
        rootIds - The ids of the root nodes. Can be null if an Experimenter is specified in options, otherwise an Exception is thrown to prevent all images in the entire database from being downloaded.
        options - Parameters as above. annotator, leaves, orphan, acquisition data used. acquisition data is only relevant for images and taken into account if the images are loaded. If rootNodeIds==null, experimenter|group must be set and filtering will be applied at the Class-level; e.g. to retrieve a user's Projects, or user's Datasets. If rootNodeIds!=null, the result will be filtered by the experimenter|group at the Image and intermediate levels if available. Due to the amount of data potentially linked a Screen/Plate, the leaves option is not taken into account when the root node is a Screen. orphan implies that objects which are not contained in an object of rootNodeType should also be returned.
        __responseCb - The lambda response callback.
        __userExceptionCb - The lambda user exception callback.
        __exceptionCb - The lambda exception callback.
        Returns:
        The asynchronous result object.

      • begin_loadContainerHierarchy

        public Ice.AsyncResult begin_loadContainerHierarchy​(java.lang.String rootType,
                                                    java.util.List<java.lang.Long> rootIds,
                                                    Parameters options,
                                                    IceInternal.Functional_GenericCallback1<java.util.List<IObject>> __responseCb,
                                                    IceInternal.Functional_GenericCallback1<Ice.UserException> __userExceptionCb,
                                                    IceInternal.Functional_GenericCallback1<Ice.Exception> __exceptionCb,
                                                    IceInternal.Functional_BoolCallback __sentCb)
        Description copied from interface: IContainerPrx
        Retrieves hierarchy trees rooted by a given node (unless orphan is specified -- See below)

        This method also retrieves the Experimenters linked to the objects in the tree. Similarly, all Images will be linked to their Pixel objects if included.

        Note that objects are never duplicated. For example, if an Experimenter owns all the objects in the retrieved tree, then those objects will be linked to the same instance of Experimenter. Or if an Image is contained in more than one Dataset in the retrieved tree, then all enclosing Dataset objects will point to the same Image object. And so on.

        Specified by:
        begin_loadContainerHierarchy in interface IContainerPrx
        Parameters:
        rootType - The type of the root node. Can be Project, Dataset, Screen or Plate. Cannot be null.
        rootIds - The ids of the root nodes. Can be null if an Experimenter is specified in options, otherwise an Exception is thrown to prevent all images in the entire database from being downloaded.
        options - Parameters as above. annotator, leaves, orphan, acquisition data used. acquisition data is only relevant for images and taken into account if the images are loaded. If rootNodeIds==null, experimenter|group must be set and filtering will be applied at the Class-level; e.g. to retrieve a user's Projects, or user's Datasets. If rootNodeIds!=null, the result will be filtered by the experimenter|group at the Image and intermediate levels if available. Due to the amount of data potentially linked a Screen/Plate, the leaves option is not taken into account when the root node is a Screen. orphan implies that objects which are not contained in an object of rootNodeType should also be returned.
        __responseCb - The lambda response callback.
        __userExceptionCb - The lambda user exception callback.
        __exceptionCb - The lambda exception callback.
        __sentCb - The lambda sent callback.
        Returns:
        The asynchronous result object.

      • begin_loadContainerHierarchy

        public Ice.AsyncResult begin_loadContainerHierarchy​(java.lang.String rootType,
                                                    java.util.List<java.lang.Long> rootIds,
                                                    Parameters options,
                                                    java.util.Map<java.lang.String,​java.lang.String> __ctx,
                                                    IceInternal.Functional_GenericCallback1<java.util.List<IObject>> __responseCb,
                                                    IceInternal.Functional_GenericCallback1<Ice.UserException> __userExceptionCb,
                                                    IceInternal.Functional_GenericCallback1<Ice.Exception> __exceptionCb)
        Description copied from interface: IContainerPrx
        Retrieves hierarchy trees rooted by a given node (unless orphan is specified -- See below)

        This method also retrieves the Experimenters linked to the objects in the tree. Similarly, all Images will be linked to their Pixel objects if included.

        Note that objects are never duplicated. For example, if an Experimenter owns all the objects in the retrieved tree, then those objects will be linked to the same instance of Experimenter. Or if an Image is contained in more than one Dataset in the retrieved tree, then all enclosing Dataset objects will point to the same Image object. And so on.

        Specified by:
        begin_loadContainerHierarchy in interface IContainerPrx
        Parameters:
        rootType - The type of the root node. Can be Project, Dataset, Screen or Plate. Cannot be null.
        rootIds - The ids of the root nodes. Can be null if an Experimenter is specified in options, otherwise an Exception is thrown to prevent all images in the entire database from being downloaded.
        options - Parameters as above. annotator, leaves, orphan, acquisition data used. acquisition data is only relevant for images and taken into account if the images are loaded. If rootNodeIds==null, experimenter|group must be set and filtering will be applied at the Class-level; e.g. to retrieve a user's Projects, or user's Datasets. If rootNodeIds!=null, the result will be filtered by the experimenter|group at the Image and intermediate levels if available. Due to the amount of data potentially linked a Screen/Plate, the leaves option is not taken into account when the root node is a Screen. orphan implies that objects which are not contained in an object of rootNodeType should also be returned.
        __ctx - The Context map to send with the invocation.
        __responseCb - The lambda response callback.
        __userExceptionCb - The lambda user exception callback.
        __exceptionCb - The lambda exception callback.
        Returns:
        The asynchronous result object.

      • begin_loadContainerHierarchy

        public Ice.AsyncResult begin_loadContainerHierarchy​(java.lang.String rootType,
                                                    java.util.List<java.lang.Long> rootIds,
                                                    Parameters options,
                                                    java.util.Map<java.lang.String,​java.lang.String> __ctx,
                                                    IceInternal.Functional_GenericCallback1<java.util.List<IObject>> __responseCb,
                                                    IceInternal.Functional_GenericCallback1<Ice.UserException> __userExceptionCb,
                                                    IceInternal.Functional_GenericCallback1<Ice.Exception> __exceptionCb,
                                                    IceInternal.Functional_BoolCallback __sentCb)
        Description copied from interface: IContainerPrx
        Retrieves hierarchy trees rooted by a given node (unless orphan is specified -- See below)

        This method also retrieves the Experimenters linked to the objects in the tree. Similarly, all Images will be linked to their Pixel objects if included.

        Note that objects are never duplicated. For example, if an Experimenter owns all the objects in the retrieved tree, then those objects will be linked to the same instance of Experimenter. Or if an Image is contained in more than one Dataset in the retrieved tree, then all enclosing Dataset objects will point to the same Image object. And so on.

        Specified by:
        begin_loadContainerHierarchy in interface IContainerPrx
        Parameters:
        rootType - The type of the root node. Can be Project, Dataset, Screen or Plate. Cannot be null.
        rootIds - The ids of the root nodes. Can be null if an Experimenter is specified in options, otherwise an Exception is thrown to prevent all images in the entire database from being downloaded.
        options - Parameters as above. annotator, leaves, orphan, acquisition data used. acquisition data is only relevant for images and taken into account if the images are loaded. If rootNodeIds==null, experimenter|group must be set and filtering will be applied at the Class-level; e.g. to retrieve a user's Projects, or user's Datasets. If rootNodeIds!=null, the result will be filtered by the experimenter|group at the Image and intermediate levels if available. Due to the amount of data potentially linked a Screen/Plate, the leaves option is not taken into account when the root node is a Screen. orphan implies that objects which are not contained in an object of rootNodeType should also be returned.
        __ctx - The Context map to send with the invocation.
        __responseCb - The lambda response callback.
        __userExceptionCb - The lambda user exception callback.
        __exceptionCb - The lambda exception callback.
        __sentCb - The lambda sent callback.
        Returns:
        The asynchronous result object.

      • end_loadContainerHierarchy

        public java.util.List<IObject> end_loadContainerHierarchy​(Ice.AsyncResult __iresult)
                                                   throws ServerError
        Description copied from interface: IContainerPrx
        Retrieves hierarchy trees rooted by a given node (unless orphan is specified -- See below)

        This method also retrieves the Experimenters linked to the objects in the tree. Similarly, all Images will be linked to their Pixel objects if included.

        Note that objects are never duplicated. For example, if an Experimenter owns all the objects in the retrieved tree, then those objects will be linked to the same instance of Experimenter. Or if an Image is contained in more than one Dataset in the retrieved tree, then all enclosing Dataset objects will point to the same Image object. And so on.

        Specified by:
        end_loadContainerHierarchy in interface IContainerPrx
        Parameters:
        __iresult - The asynchronous result object.
        Returns:
        a set of hierarchy trees. The requested node as root and all of its descendants. The type of the returned value will be rootNodeType, unless orphan is specified in which case objects of type rootNodeType and below may be returned.
        Throws:
        ServerError

      • retrieveCollection

        public java.util.List<IObject> retrieveCollection​(IObject obj,
                                                  java.lang.String collectionName,
                                                  Parameters options)
                                           throws ServerError
        Description copied from interface: IContainerPrx
        Retrieves a collection with all members initialized (loaded). This is useful when a collection has been nulled in a previous query.
        Specified by:
        retrieveCollection in interface IContainerPrx
        Parameters:
        obj - Can be unloaded.
        collectionName - public static final String from the IObject.class
        options - Parameters. Unused.
        Returns:
        An initialized collection.
        Throws:
        ServerError

      • retrieveCollection

        public java.util.List<IObject> retrieveCollection​(IObject obj,
                                                  java.lang.String collectionName,
                                                  Parameters options,
                                                  java.util.Map<java.lang.String,​java.lang.String> __ctx)
                                           throws ServerError
        Description copied from interface: IContainerPrx
        Retrieves a collection with all members initialized (loaded). This is useful when a collection has been nulled in a previous query.
        Specified by:
        retrieveCollection in interface IContainerPrx
        Parameters:
        obj - Can be unloaded.
        collectionName - public static final String from the IObject.class
        options - Parameters. Unused.
        __ctx - The Context map to send with the invocation.
        Returns:
        An initialized collection.
        Throws:
        ServerError

      • begin_retrieveCollection

        public Ice.AsyncResult begin_retrieveCollection​(IObject obj,
                                                java.lang.String collectionName,
                                                Parameters options)
        Description copied from interface: IContainerPrx
        Retrieves a collection with all members initialized (loaded). This is useful when a collection has been nulled in a previous query.
        Specified by:
        begin_retrieveCollection in interface IContainerPrx
        Parameters:
        obj - Can be unloaded.
        options - Parameters. Unused.
        Returns:
        The asynchronous result object.

      • begin_retrieveCollection

        public Ice.AsyncResult begin_retrieveCollection​(IObject obj,
                                                java.lang.String collectionName,
                                                Parameters options,
                                                java.util.Map<java.lang.String,​java.lang.String> __ctx)
        Description copied from interface: IContainerPrx
        Retrieves a collection with all members initialized (loaded). This is useful when a collection has been nulled in a previous query.
        Specified by:
        begin_retrieveCollection in interface IContainerPrx
        Parameters:
        obj - Can be unloaded.
        options - Parameters. Unused.
        __ctx - The Context map to send with the invocation.
        Returns:
        The asynchronous result object.

      • begin_retrieveCollection

        public Ice.AsyncResult begin_retrieveCollection​(IObject obj,
                                                java.lang.String collectionName,
                                                Parameters options,
                                                Ice.Callback __cb)
        Description copied from interface: IContainerPrx
        Retrieves a collection with all members initialized (loaded). This is useful when a collection has been nulled in a previous query.
        Specified by:
        begin_retrieveCollection in interface IContainerPrx
        Parameters:
        obj - Can be unloaded.
        options - Parameters. Unused.
        __cb - The asynchronous callback object.
        Returns:
        The asynchronous result object.

      • begin_retrieveCollection

        public Ice.AsyncResult begin_retrieveCollection​(IObject obj,
                                                java.lang.String collectionName,
                                                Parameters options,
                                                java.util.Map<java.lang.String,​java.lang.String> __ctx,
                                                Ice.Callback __cb)
        Description copied from interface: IContainerPrx
        Retrieves a collection with all members initialized (loaded). This is useful when a collection has been nulled in a previous query.
        Specified by:
        begin_retrieveCollection in interface IContainerPrx
        Parameters:
        obj - Can be unloaded.
        options - Parameters. Unused.
        __ctx - The Context map to send with the invocation.
        __cb - The asynchronous callback object.
        Returns:
        The asynchronous result object.

      • begin_retrieveCollection

        public Ice.AsyncResult begin_retrieveCollection​(IObject obj,
                                                java.lang.String collectionName,
                                                Parameters options,
                                                java.util.Map<java.lang.String,​java.lang.String> __ctx,
                                                Callback_IContainer_retrieveCollection __cb)
        Description copied from interface: IContainerPrx
        Retrieves a collection with all members initialized (loaded). This is useful when a collection has been nulled in a previous query.
        Specified by:
        begin_retrieveCollection in interface IContainerPrx
        Parameters:
        obj - Can be unloaded.
        options - Parameters. Unused.
        __ctx - The Context map to send with the invocation.
        __cb - The asynchronous callback object.
        Returns:
        The asynchronous result object.

      • end_retrieveCollection

        public java.util.List<IObject> end_retrieveCollection​(Ice.AsyncResult __iresult)
                                               throws ServerError
        Description copied from interface: IContainerPrx
        Retrieves a collection with all members initialized (loaded). This is useful when a collection has been nulled in a previous query.
        Specified by:
        end_retrieveCollection in interface IContainerPrx
        Parameters:
        __iresult - The asynchronous result object.
        Returns:
        An initialized collection.
        Throws:
        ServerError

      • unlink

        public void unlink​(java.util.List<IObject> links,
                   Parameters options)
            throws ServerError
        Description copied from interface: IContainerPrx
        Removes links between OmeroDataObjects e.g Project-Dataset, Dataset-Image Note that the objects themselves aren't deleted, only the Link objects.
        Specified by:
        unlink in interface IContainerPrx
        Parameters:
        links - Not null.
        options - Parameters as above.
        Throws:
        ServerError

      • unlink

        public void unlink​(java.util.List<IObject> links,
                   Parameters options,
                   java.util.Map<java.lang.String,​java.lang.String> __ctx)
            throws ServerError
        Description copied from interface: IContainerPrx
        Removes links between OmeroDataObjects e.g Project-Dataset, Dataset-Image Note that the objects themselves aren't deleted, only the Link objects.
        Specified by:
        unlink in interface IContainerPrx
        Parameters:
        links - Not null.
        options - Parameters as above.
        __ctx - The Context map to send with the invocation.
        Throws:
        ServerError

      • begin_unlink

        public Ice.AsyncResult begin_unlink​(java.util.List<IObject> links,
                                    Parameters options)
        Description copied from interface: IContainerPrx
        Removes links between OmeroDataObjects e.g Project-Dataset, Dataset-Image Note that the objects themselves aren't deleted, only the Link objects.
        Specified by:
        begin_unlink in interface IContainerPrx
        Parameters:
        links - Not null.
        Returns:
        The asynchronous result object.

      • begin_unlink

        public Ice.AsyncResult begin_unlink​(java.util.List<IObject> links,
                                    Parameters options,
                                    java.util.Map<java.lang.String,​java.lang.String> __ctx)
        Description copied from interface: IContainerPrx
        Removes links between OmeroDataObjects e.g Project-Dataset, Dataset-Image Note that the objects themselves aren't deleted, only the Link objects.
        Specified by:
        begin_unlink in interface IContainerPrx
        Parameters:
        links - Not null.
        __ctx - The Context map to send with the invocation.
        Returns:
        The asynchronous result object.

      • begin_unlink

        public Ice.AsyncResult begin_unlink​(java.util.List<IObject> links,
                                    Parameters options,
                                    Ice.Callback __cb)
        Description copied from interface: IContainerPrx
        Removes links between OmeroDataObjects e.g Project-Dataset, Dataset-Image Note that the objects themselves aren't deleted, only the Link objects.
        Specified by:
        begin_unlink in interface IContainerPrx
        Parameters:
        links - Not null.
        __cb - The asynchronous callback object.
        Returns:
        The asynchronous result object.

      • begin_unlink

        public Ice.AsyncResult begin_unlink​(java.util.List<IObject> links,
                                    Parameters options,
                                    java.util.Map<java.lang.String,​java.lang.String> __ctx,
                                    Ice.Callback __cb)
        Description copied from interface: IContainerPrx
        Removes links between OmeroDataObjects e.g Project-Dataset, Dataset-Image Note that the objects themselves aren't deleted, only the Link objects.
        Specified by:
        begin_unlink in interface IContainerPrx
        Parameters:
        links - Not null.
        __ctx - The Context map to send with the invocation.
        __cb - The asynchronous callback object.
        Returns:
        The asynchronous result object.

      • begin_unlink

        public Ice.AsyncResult begin_unlink​(java.util.List<IObject> links,
                                    Parameters options,
                                    Callback_IContainer_unlink __cb)
        Description copied from interface: IContainerPrx
        Removes links between OmeroDataObjects e.g Project-Dataset, Dataset-Image Note that the objects themselves aren't deleted, only the Link objects.
        Specified by:
        begin_unlink in interface IContainerPrx
        Parameters:
        links - Not null.
        __cb - The asynchronous callback object.
        Returns:
        The asynchronous result object.

      • begin_unlink

        public Ice.AsyncResult begin_unlink​(java.util.List<IObject> links,
                                    Parameters options,
                                    java.util.Map<java.lang.String,​java.lang.String> __ctx,
                                    Callback_IContainer_unlink __cb)
        Description copied from interface: IContainerPrx
        Removes links between OmeroDataObjects e.g Project-Dataset, Dataset-Image Note that the objects themselves aren't deleted, only the Link objects.
        Specified by:
        begin_unlink in interface IContainerPrx
        Parameters:
        links - Not null.
        __ctx - The Context map to send with the invocation.
        __cb - The asynchronous callback object.
        Returns:
        The asynchronous result object.

      • end_unlink

        public void end_unlink​(Ice.AsyncResult __iresult)
                throws ServerError
        Description copied from interface: IContainerPrx
        Removes links between OmeroDataObjects e.g Project-Dataset, Dataset-Image Note that the objects themselves aren't deleted, only the Link objects.
        Specified by:
        end_unlink in interface IContainerPrx
        Parameters:
        __iresult - The asynchronous result object.
        Throws:
        ServerError

      • updateDataObject

        public IObject updateDataObject​(IObject obj,
                                Parameters options)
                         throws ServerError
        Description copied from interface: IContainerPrx
        Updates a data object.

        To link or unlink objects to the specified object, we should call the methods link or unlink. TODO Or do we use for example dataset.setProjects(set of projects) to add. Link has to be set as follows dataset→project and project→dataset. Alternatively, you can make sure that the collection is exactly how it should be in the database. If you can't guarantee this, it's best to send all your collections back as null

        Specified by:
        updateDataObject in interface IContainerPrx
        Parameters:
        obj - Pojos-based IObject. Supported: Project, Dataset, Annotation, Group, Experimenter.
        options - Parameters as above.
        Returns:
        created data object
        Throws:
        ServerError

      • updateDataObject

        public IObject updateDataObject​(IObject obj,
                                Parameters options,
                                java.util.Map<java.lang.String,​java.lang.String> __ctx)
                         throws ServerError
        Description copied from interface: IContainerPrx
        Updates a data object.

        To link or unlink objects to the specified object, we should call the methods link or unlink. TODO Or do we use for example dataset.setProjects(set of projects) to add. Link has to be set as follows dataset→project and project→dataset. Alternatively, you can make sure that the collection is exactly how it should be in the database. If you can't guarantee this, it's best to send all your collections back as null

        Specified by:
        updateDataObject in interface IContainerPrx
        Parameters:
        obj - Pojos-based IObject. Supported: Project, Dataset, Annotation, Group, Experimenter.
        options - Parameters as above.
        __ctx - The Context map to send with the invocation.
        Returns:
        created data object
        Throws:
        ServerError

      • begin_updateDataObject

        public Ice.AsyncResult begin_updateDataObject​(IObject obj,
                                              Parameters options)
        Description copied from interface: IContainerPrx
        Updates a data object.

        To link or unlink objects to the specified object, we should call the methods link or unlink. TODO Or do we use for example dataset.setProjects(set of projects) to add. Link has to be set as follows dataset→project and project→dataset. Alternatively, you can make sure that the collection is exactly how it should be in the database. If you can't guarantee this, it's best to send all your collections back as null

        Specified by:
        begin_updateDataObject in interface IContainerPrx
        Parameters:
        obj - Pojos-based IObject. Supported: Project, Dataset, Annotation, Group, Experimenter.
        options - Parameters as above.
        Returns:
        The asynchronous result object.

      • begin_updateDataObject

        public Ice.AsyncResult begin_updateDataObject​(IObject obj,
                                              Parameters options,
                                              java.util.Map<java.lang.String,​java.lang.String> __ctx)
        Description copied from interface: IContainerPrx
        Updates a data object.

        To link or unlink objects to the specified object, we should call the methods link or unlink. TODO Or do we use for example dataset.setProjects(set of projects) to add. Link has to be set as follows dataset→project and project→dataset. Alternatively, you can make sure that the collection is exactly how it should be in the database. If you can't guarantee this, it's best to send all your collections back as null

        Specified by:
        begin_updateDataObject in interface IContainerPrx
        Parameters:
        obj - Pojos-based IObject. Supported: Project, Dataset, Annotation, Group, Experimenter.
        options - Parameters as above.
        __ctx - The Context map to send with the invocation.
        Returns:
        The asynchronous result object.

      • begin_updateDataObject

        public Ice.AsyncResult begin_updateDataObject​(IObject obj,
                                              Parameters options,
                                              Ice.Callback __cb)
        Description copied from interface: IContainerPrx
        Updates a data object.

        To link or unlink objects to the specified object, we should call the methods link or unlink. TODO Or do we use for example dataset.setProjects(set of projects) to add. Link has to be set as follows dataset→project and project→dataset. Alternatively, you can make sure that the collection is exactly how it should be in the database. If you can't guarantee this, it's best to send all your collections back as null

        Specified by:
        begin_updateDataObject in interface IContainerPrx
        Parameters:
        obj - Pojos-based IObject. Supported: Project, Dataset, Annotation, Group, Experimenter.
        options - Parameters as above.
        __cb - The asynchronous callback object.
        Returns:
        The asynchronous result object.

      • begin_updateDataObject

        public Ice.AsyncResult begin_updateDataObject​(IObject obj,
                                              Parameters options,
                                              java.util.Map<java.lang.String,​java.lang.String> __ctx,
                                              Ice.Callback __cb)
        Description copied from interface: IContainerPrx
        Updates a data object.

        To link or unlink objects to the specified object, we should call the methods link or unlink. TODO Or do we use for example dataset.setProjects(set of projects) to add. Link has to be set as follows dataset→project and project→dataset. Alternatively, you can make sure that the collection is exactly how it should be in the database. If you can't guarantee this, it's best to send all your collections back as null

        Specified by:
        begin_updateDataObject in interface IContainerPrx
        Parameters:
        obj - Pojos-based IObject. Supported: Project, Dataset, Annotation, Group, Experimenter.
        options - Parameters as above.
        __ctx - The Context map to send with the invocation.
        __cb - The asynchronous callback object.
        Returns:
        The asynchronous result object.

      • begin_updateDataObject

        public Ice.AsyncResult begin_updateDataObject​(IObject obj,
                                              Parameters options,
                                              Callback_IContainer_updateDataObject __cb)
        Description copied from interface: IContainerPrx
        Updates a data object.

        To link or unlink objects to the specified object, we should call the methods link or unlink. TODO Or do we use for example dataset.setProjects(set of projects) to add. Link has to be set as follows dataset→project and project→dataset. Alternatively, you can make sure that the collection is exactly how it should be in the database. If you can't guarantee this, it's best to send all your collections back as null

        Specified by:
        begin_updateDataObject in interface IContainerPrx
        Parameters:
        obj - Pojos-based IObject. Supported: Project, Dataset, Annotation, Group, Experimenter.
        options - Parameters as above.
        __cb - The asynchronous callback object.
        Returns:
        The asynchronous result object.

      • begin_updateDataObject

        public Ice.AsyncResult begin_updateDataObject​(IObject obj,
                                              Parameters options,
                                              java.util.Map<java.lang.String,​java.lang.String> __ctx,
                                              Callback_IContainer_updateDataObject __cb)
        Description copied from interface: IContainerPrx
        Updates a data object.

        To link or unlink objects to the specified object, we should call the methods link or unlink. TODO Or do we use for example dataset.setProjects(set of projects) to add. Link has to be set as follows dataset→project and project→dataset. Alternatively, you can make sure that the collection is exactly how it should be in the database. If you can't guarantee this, it's best to send all your collections back as null

        Specified by:
        begin_updateDataObject in interface IContainerPrx
        Parameters:
        obj - Pojos-based IObject. Supported: Project, Dataset, Annotation, Group, Experimenter.
        options - Parameters as above.
        __ctx - The Context map to send with the invocation.
        __cb - The asynchronous callback object.
        Returns:
        The asynchronous result object.

      • begin_updateDataObject

        public Ice.AsyncResult begin_updateDataObject​(IObject obj,
                                              Parameters options,
                                              IceInternal.Functional_GenericCallback1<IObject> __responseCb,
                                              IceInternal.Functional_GenericCallback1<Ice.UserException> __userExceptionCb,
                                              IceInternal.Functional_GenericCallback1<Ice.Exception> __exceptionCb)
        Description copied from interface: IContainerPrx
        Updates a data object.

        To link or unlink objects to the specified object, we should call the methods link or unlink. TODO Or do we use for example dataset.setProjects(set of projects) to add. Link has to be set as follows dataset→project and project→dataset. Alternatively, you can make sure that the collection is exactly how it should be in the database. If you can't guarantee this, it's best to send all your collections back as null

        Specified by:
        begin_updateDataObject in interface IContainerPrx
        Parameters:
        obj - Pojos-based IObject. Supported: Project, Dataset, Annotation, Group, Experimenter.
        options - Parameters as above.
        __responseCb - The lambda response callback.
        __userExceptionCb - The lambda user exception callback.
        __exceptionCb - The lambda exception callback.
        Returns:
        The asynchronous result object.

      • begin_updateDataObject

        public Ice.AsyncResult begin_updateDataObject​(IObject obj,
                                              Parameters options,
                                              java.util.Map<java.lang.String,​java.lang.String> __ctx,
                                              IceInternal.Functional_GenericCallback1<IObject> __responseCb,
                                              IceInternal.Functional_GenericCallback1<Ice.UserException> __userExceptionCb,
                                              IceInternal.Functional_GenericCallback1<Ice.Exception> __exceptionCb)
        Description copied from interface: IContainerPrx
        Updates a data object.

        To link or unlink objects to the specified object, we should call the methods link or unlink. TODO Or do we use for example dataset.setProjects(set of projects) to add. Link has to be set as follows dataset→project and project→dataset. Alternatively, you can make sure that the collection is exactly how it should be in the database. If you can't guarantee this, it's best to send all your collections back as null

        Specified by:
        begin_updateDataObject in interface IContainerPrx
        Parameters:
        obj - Pojos-based IObject. Supported: Project, Dataset, Annotation, Group, Experimenter.
        options - Parameters as above.
        __ctx - The Context map to send with the invocation.
        __responseCb - The lambda response callback.
        __userExceptionCb - The lambda user exception callback.
        __exceptionCb - The lambda exception callback.
        Returns:
        The asynchronous result object.

      • begin_updateDataObject

        public Ice.AsyncResult begin_updateDataObject​(IObject obj,
                                              Parameters options,
                                              java.util.Map<java.lang.String,​java.lang.String> __ctx,
                                              IceInternal.Functional_GenericCallback1<IObject> __responseCb,
                                              IceInternal.Functional_GenericCallback1<Ice.UserException> __userExceptionCb,
                                              IceInternal.Functional_GenericCallback1<Ice.Exception> __exceptionCb,
                                              IceInternal.Functional_BoolCallback __sentCb)
        Description copied from interface: IContainerPrx
        Updates a data object.

        To link or unlink objects to the specified object, we should call the methods link or unlink. TODO Or do we use for example dataset.setProjects(set of projects) to add. Link has to be set as follows dataset→project and project→dataset. Alternatively, you can make sure that the collection is exactly how it should be in the database. If you can't guarantee this, it's best to send all your collections back as null

        Specified by:
        begin_updateDataObject in interface IContainerPrx
        Parameters:
        obj - Pojos-based IObject. Supported: Project, Dataset, Annotation, Group, Experimenter.
        options - Parameters as above.
        __ctx - The Context map to send with the invocation.
        __responseCb - The lambda response callback.
        __userExceptionCb - The lambda user exception callback.
        __exceptionCb - The lambda exception callback.
        __sentCb - The lambda sent callback.
        Returns:
        The asynchronous result object.

      • end_updateDataObject

        public IObject end_updateDataObject​(Ice.AsyncResult __iresult)
                             throws ServerError
        Description copied from interface: IContainerPrx
        Updates a data object.

        To link or unlink objects to the specified object, we should call the methods link or unlink. TODO Or do we use for example dataset.setProjects(set of projects) to add. Link has to be set as follows dataset→project and project→dataset. Alternatively, you can make sure that the collection is exactly how it should be in the database. If you can't guarantee this, it's best to send all your collections back as null

        Specified by:
        end_updateDataObject in interface IContainerPrx
        Parameters:
        __iresult - The asynchronous result object.
        Returns:
        created data object
        Throws:
        ServerError

      • begin_updateDataObjects

        public Ice.AsyncResult begin_updateDataObjects​(java.util.List<IObject> objs,
                                               Parameters options,
                                               java.util.Map<java.lang.String,​java.lang.String> __ctx)
        Description copied from interface: IContainerPrx
        Convenience method to save network calls. Loops over the array of IObjects calling updateDataObject.
        Specified by:
        begin_updateDataObjects in interface IContainerPrx
        __ctx - The Context map to send with the invocation.
        Returns:
        The asynchronous result object.

      • begin_updateDataObjects

        public Ice.AsyncResult begin_updateDataObjects​(java.util.List<IObject> objs,
                                               Parameters options,
                                               java.util.Map<java.lang.String,​java.lang.String> __ctx,
                                               Ice.Callback __cb)
        Description copied from interface: IContainerPrx
        Convenience method to save network calls. Loops over the array of IObjects calling updateDataObject.
        Specified by:
        begin_updateDataObjects in interface IContainerPrx
        __ctx - The Context map to send with the invocation.
        __cb - The asynchronous callback object.
        Returns:
        The asynchronous result object.

      • checkedCast

        public static IContainerPrx checkedCast​(Ice.ObjectPrx __obj)
        Contacts the remote server to verify that the object implements this type. Raises a local exception if a communication error occurs.
        Parameters:
        __obj - The untyped proxy.
        Returns:
        A proxy for this type, or null if the object does not support this type.

      • checkedCast

        public static IContainerPrx checkedCast​(Ice.ObjectPrx __obj,
                                        java.util.Map<java.lang.String,​java.lang.String> __ctx)
        Contacts the remote server to verify that the object implements this type. Raises a local exception if a communication error occurs.
        Parameters:
        __obj - The untyped proxy.
        __ctx - The Context map to send with the invocation.
        Returns:
        A proxy for this type, or null if the object does not support this type.

      • checkedCast

        public static IContainerPrx checkedCast​(Ice.ObjectPrx __obj,
                                        java.lang.String __facet)
        Contacts the remote server to verify that a facet of the object implements this type. Raises a local exception if a communication error occurs.
        Parameters:
        __obj - The untyped proxy.
        __facet - The name of the desired facet.
        Returns:
        A proxy for this type, or null if the object does not support this type.

      • checkedCast

        public static IContainerPrx checkedCast​(Ice.ObjectPrx __obj,
                                        java.lang.String __facet,
                                        java.util.Map<java.lang.String,​java.lang.String> __ctx)
        Contacts the remote server to verify that a facet of the object implements this type. Raises a local exception if a communication error occurs.
        Parameters:
        __obj - The untyped proxy.
        __facet - The name of the desired facet.
        __ctx - The Context map to send with the invocation.
        Returns:
        A proxy for this type, or null if the object does not support this type.

      • uncheckedCast

        public static IContainerPrx uncheckedCast​(Ice.ObjectPrx __obj)
        Downcasts the given proxy to this type without contacting the remote server.
        Parameters:
        __obj - The untyped proxy.
        Returns:
        A proxy for this type.

      • uncheckedCast

        public static IContainerPrx uncheckedCast​(Ice.ObjectPrx __obj,
                                          java.lang.String __facet)
        Downcasts the given proxy to this type without contacting the remote server.
        Parameters:
        __obj - The untyped proxy.
        __facet - The name of the desired facet.
        Returns:
        A proxy for this type.

      • ice_staticId

        public static java.lang.String ice_staticId()
        Provides the Slice type ID of this type.
        Returns:
        The Slice type ID.