Package de.aristaflow.ilm.model.worklistmodel

Class Transformation

java.lang.Object

de.aristaflow.ilm.model.worklistmodel.Transformation

public class Transformation
extends Object

Constructor Summary

Constructors

Constructor	Description
Transformation()

Method Summary

Modifier and Type	Method	Description
static void	addArFilter(FilterFactory ff, AttributeFactory af, String attrName, ActivityReferenceFilter arf, Collection<Filter> filters)
static void	addFilter(FilterFactory ff, AttributeFactory af, String attrName, CollectionDelFilter cdf, Collection<Filter> filters)
static void	addFilter(FilterFactory ff, AttributeFactory af, String attrName, DelegationFilter df, Collection<Filter> filters)
static void	addFilter(FilterFactory ff, Attribute attr, ActivityReferenceTypeFilter artf, Collection<Filter> filters)
protected static <T extends ActivityReference,I extends ActivityReference> I	fillActivityReference(T actRef, I ret)
protected static <T extends ADEPT2EBPReference,I extends AfEbpReference> I	fillAfEbpReference(T actRef, I ret)
protected static <T extends WorklistItem,W extends Worklist<I>,I extends WorklistItem> W	fillWorklist(Worklist<T> worklist, W ret, Function<T,I> transformation)
protected static <T extends WorklistItem,I extends WorklistItem> I	fillWorklistItem(T worklistItem, I ret)
protected static <T extends ActivityReference> Filter	fromArIlm(FilterFactory ff, AttributeFactory af, String attrName, AtomicAttributeFilter<T> filter)
protected static Filter	fromIlm(FilterFactory ff, AttributeFactory af, DelegationFilter.DelegationSelection ds)
protected static <T extends WorklistItem> Filter	fromIlm(FilterFactory ff, AttributeFactory af, String attrName, ActivityReferenceFilter.ActivityReferenceSelection ars)
protected static Filter	fromIlm(FilterFactory ff, AttributeFactory af, String attrName, CollectionDelFilter cdf)
protected static Filter	fromIlm(FilterFactory ff, AttributeFactory af, String attrName, DelegationFilter df)
protected static Filter	fromIlm(FilterFactory ff, Attribute attr, ActivityReferenceTypeFilter artf)
protected static Filter	fromIlm(FilterFactory ff, AdministrativeWorklistItemFilter.PredefinedAdministrativeWorklistItemSelection filter)
protected static Filter	fromIlm(FilterFactory ff, ClientWorklistItemFilter.PredefinedClientWorklistItemSelection filter)
protected static <T extends WorklistItem> Filter	fromIlm(FilterFactory ff, WorklistItemFilter.AbstractWorklistItemSelection<T> wis)
protected static Filter	fromIlm(FilterFactory ff, WorklistItemFilter.PredefinedWorklistItemSelection filter)
static ClientWorklistItem	fromIlm(WorklistModelFactory wmf, ExecutionFactory ef, ClientWorklistItem item)
static WorklistUpdate	fromIlm(WorklistModelFactory wmf, ExecutionFactory ef, WorklistUpdateNotification notification)
static WorklistUpdateConfiguration	fromIlm(WorklistModelFactory wmf, FilterFactory ff, WorklistUpdateConfiguration conf)
static WorklistItem.Delegation	fromIlm(WorklistModelFactory wmf, Delegation delegation)
static WorklistRevision	fromIlm(WorklistModelFactory wmf, WorklistRevision revision)
static ActivityReference	fromIlm(ActivityReference ar)
static <T extends WorklistItem> Filter	fromWifIlm(FilterFactory ff, AtomicAttributeFilter<T> filter)
static AbsenceInformation	toIlm(WorklistUpdateManager.AbsenceInformation absence)
static ClientWorklistItemFilter	toIlm(FilterFactory ff, Filter filter, ClientWorklistItemFilter worklistFilter)
static ClientWorklist	toIlm(FilterFactory ff, ClientWorklist cw, ClientWorklistItemFilter worklistFilter)
static InitialIncClientWorklistData	toIlm(FilterFactory ff, ClientWorklist cw, InitialIncWorklistData<ClientWorklistItem> iwd, ClientWorklistItemFilter worklistFilter)
static WorklistUpdateConfiguration	toIlm(FilterFactory ff, WorklistUpdateConfiguration conf, ClientWorklistItemFilter worklistFilter)
static GroupReference	toIlm(ActivityGroupReference agr)
static ActivityReference	toIlm(ActivityReference ar)
static AfActivityReference	toIlm(ADEPT2ActivityReference aar)
static AfEbpReference	toIlm(ADEPT2EBPReference aer)
static AdministrativeWorklistItem	toIlm(AdministrativeWorklistItem item, Logger logger)
static ClientWorklistItem	toIlm(ClientWorklistItem item)
static AfInstanceReference	toIlm(TLPInstanceReference tir)
static Worklist<AdministrativeWorklistItem>	toIlm(Worklist<? extends AdministrativeWorklistItem> worklist, Logger logger)
static PlainWorklist	toIlm(Worklist<? extends WorklistItem> worklist)
static WorklistItem	toIlm(WorklistItem item)
static Delegation	toIlm(WorklistItem.Delegation delegation)
static ClientWorklistItemUpdate	toIlm(WorklistItemUpdate<ClientWorklistItem> itemUpdate)
static WorklistRevision	toIlm(WorklistRevision revision)
static WorklistUpdate	toIlm(WorklistUpdate update)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

Transformation

public Transformation()

Method Detail

fromIlm

public static ActivityReference fromIlm(ActivityReference ar)

fromIlm

public static ClientWorklistItem fromIlm(WorklistModelFactory wmf,
                                         ExecutionFactory ef,
                                         ClientWorklistItem item)

fromIlm

public static WorklistUpdate fromIlm(WorklistModelFactory wmf,
                                     ExecutionFactory ef,
                                     WorklistUpdateNotification notification)

fromIlm

public static WorklistRevision fromIlm(WorklistModelFactory wmf,
                                       WorklistRevision revision)

fromIlm

public static WorklistUpdateConfiguration fromIlm(WorklistModelFactory wmf,
                                                  FilterFactory ff,
                                                  WorklistUpdateConfiguration conf)

fromIlm

public static WorklistItem.Delegation fromIlm(WorklistModelFactory wmf,
                                              Delegation delegation)

addFilter

public static void addFilter(FilterFactory ff,
                             AttributeFactory af,
                             String attrName,
                             DelegationFilter df,
                             Collection<Filter> filters)

fromIlm

protected static Filter fromIlm(FilterFactory ff,
                                AttributeFactory af,
                                String attrName,
                                DelegationFilter df)

fromIlm

protected static Filter fromIlm(FilterFactory ff,
                                AttributeFactory af,
                                DelegationFilter.DelegationSelection ds)

addFilter

public static void addFilter(FilterFactory ff,
                             AttributeFactory af,
                             String attrName,
                             CollectionDelFilter cdf,
                             Collection<Filter> filters)

fromIlm

protected static Filter fromIlm(FilterFactory ff,
                                AttributeFactory af,
                                String attrName,
                                CollectionDelFilter cdf)

addFilter

public static void addFilter(FilterFactory ff,
                             Attribute attr,
                             ActivityReferenceTypeFilter artf,
                             Collection<Filter> filters)

fromIlm

protected static Filter fromIlm(FilterFactory ff,
                                Attribute attr,
                                ActivityReferenceTypeFilter artf)

addArFilter

public static void addArFilter(FilterFactory ff,
                               AttributeFactory af,
                               String attrName,
                               ActivityReferenceFilter arf,
                               Collection<Filter> filters)

fromArIlm

protected static <T extends ActivityReference> Filter fromArIlm(FilterFactory ff,
                                                                AttributeFactory af,
                                                                String attrName,
                                                                AtomicAttributeFilter<T> filter)

fromIlm

protected static <T extends WorklistItem> Filter fromIlm(FilterFactory ff,
                                                         AttributeFactory af,
                                                         String attrName,
                                                         ActivityReferenceFilter.ActivityReferenceSelection ars)

fromWifIlm

public static <T extends WorklistItem> Filter fromWifIlm(FilterFactory ff,
                                                         AtomicAttributeFilter<T> filter)

fromIlm

protected static <T extends WorklistItem> Filter fromIlm(FilterFactory ff,
                                                         WorklistItemFilter.AbstractWorklistItemSelection<T> wis)

fromIlm

protected static Filter fromIlm(FilterFactory ff,
                                WorklistItemFilter.PredefinedWorklistItemSelection filter)

fromIlm

protected static Filter fromIlm(FilterFactory ff,
                                ClientWorklistItemFilter.PredefinedClientWorklistItemSelection filter)

fromIlm

protected static Filter fromIlm(FilterFactory ff,
                                AdministrativeWorklistItemFilter.PredefinedAdministrativeWorklistItemSelection filter)

toIlm

public static ActivityReference toIlm(ActivityReference ar)

toIlm

public static AfActivityReference toIlm(ADEPT2ActivityReference aar)

toIlm

public static AfEbpReference toIlm(ADEPT2EBPReference aer)

fillAfEbpReference

protected static <T extends ADEPT2EBPReference,I extends AfEbpReference> I fillAfEbpReference(T actRef,
                                                                                                    I ret)

toIlm

public static AfInstanceReference toIlm(TLPInstanceReference tir)

toIlm

public static GroupReference toIlm(ActivityGroupReference agr)

fillActivityReference

protected static <T extends ActivityReference,I extends ActivityReference> I fillActivityReference(T actRef,
                                                                                                         I ret)

toIlm

public static ClientWorklistItem toIlm(ClientWorklistItem item)

toIlm

public static AdministrativeWorklistItem toIlm(AdministrativeWorklistItem item,
                                               Logger logger)

toIlm

public static WorklistItem toIlm(WorklistItem item)

fillWorklistItem

protected static <T extends WorklistItem,I extends WorklistItem> I fillWorklistItem(T worklistItem,
                                                                                          I ret)

toIlm

public static ClientWorklist toIlm(FilterFactory ff,
                                   ClientWorklist cw,
                                   ClientWorklistItemFilter worklistFilter)

toIlm

public static InitialIncClientWorklistData toIlm(FilterFactory ff,
                                                 ClientWorklist cw,
                                                 InitialIncWorklistData<ClientWorklistItem> iwd,
                                                 ClientWorklistItemFilter worklistFilter)

toIlm

public static WorklistUpdate toIlm(WorklistUpdate update)

toIlm

public static ClientWorklistItemUpdate toIlm(WorklistItemUpdate<ClientWorklistItem> itemUpdate)

toIlm

public static Worklist<AdministrativeWorklistItem> toIlm(Worklist<? extends AdministrativeWorklistItem> worklist,
                                                         Logger logger)

toIlm

public static PlainWorklist toIlm(Worklist<? extends WorklistItem> worklist)

fillWorklist

protected static <T extends WorklistItem,W extends Worklist<I>,I extends WorklistItem> W fillWorklist(Worklist<T> worklist,
                                                                                                                  W ret,
                                                                                                                  Function<T,I> transformation)

toIlm

public static WorklistRevision toIlm(WorklistRevision revision)

toIlm

public static WorklistUpdateConfiguration toIlm(FilterFactory ff,
                                                WorklistUpdateConfiguration conf,
                                                ClientWorklistItemFilter worklistFilter)

toIlm

public static Delegation toIlm(WorklistItem.Delegation delegation)

toIlm

public static AbsenceInformation toIlm(WorklistUpdateManager.AbsenceInformation absence)

toIlm

public static ClientWorklistItemFilter toIlm(FilterFactory ff,
                                             Filter filter,
                                             ClientWorklistItemFilter worklistFilter)