private <MODEL> CompositeObject createModelAndParentAdapterPair(final MODEL model, final IJsonAdapter<?> parentAdapter) { return new CompositeObject(model, parentAdapter); } }
protected CompositeObject newSessionCacheKey(final String sessionId, final Subject subject) { if (sessionId != null) { return new CompositeObject(sessionId); } else if (subject != null) { return new CompositeObject(BEANS.get(IAccessControlService.class).getUserId(subject)); } else { return null; } } }
@Override public ITableRow getRowByKey(List<?> keys) { if (!CollectionUtility.hasElements(keys)) { return null; } return m_rowsByKey.get(new CompositeObject(keys)); }
public PropertyDescriptor[] getProperties() { SortedMap<CompositeObject, PropertyDescriptor> sortMap = new TreeMap<>(); int index = 0; for (PropertyDescriptor p : m_properties) { if ("class".equals(p.getName())) { // ignore } else { if (p.getName().startsWith("configured")) { sortMap.put(new CompositeObject(1, p.getName(), index), p); } else { sortMap.put(new CompositeObject(2, p.getName(), index), p); } } index++; } return sortMap.values().toArray(new PropertyDescriptor[0]); }
public Method[] getOperations() { SortedMap<CompositeObject, Method> sortMap = new TreeMap<>(); int index = 0; for (Method m : m_operations) { if ("getInventory".equals(m.getName())) { // ignore } else { if (m.getName().startsWith("exec")) { sortMap.put(new CompositeObject(1, m.getName(), index), m); } else { sortMap.put(new CompositeObject(2, m.getName(), index), m); } } index++; } return sortMap.values().toArray(new Method[0]); }
private void restoreSelection(List<CompositeObject> selectedKeys) { List<ITableRow> selectedRows = new ArrayList<>(); if (!selectedKeys.isEmpty()) { for (ITableRow r : m_rows) { if (selectedKeys.remove(new CompositeObject(getRowKeys(r)))) { selectedRows.add(r); if (selectedKeys.isEmpty()) { break; } } } } selectRows(selectedRows, false); }
private List<CompositeObject> getSelectedKeys() { List<CompositeObject> selectedKeys = new ArrayList<>(); for (ITableRow r : getSelectedRows()) { selectedKeys.add(new CompositeObject(getRowKeys(r))); } return selectedKeys; }
@Override public void discardDeletedRows(Collection<? extends ITableRow> deletedRows) { if (deletedRows != null) { for (ITableRow row : deletedRows) { m_deletedRows.remove(new CompositeObject(getRowKeys(row))); ((InternalTableRow) row).setTableInternal(null); } } }
protected CompositeObject newSessionCacheKey(final String sessionId, final Subject subject) { // Test specific: Make session class part of the cache key. // That is because JUnit tests can be configured to run with another session via {@link RunWithClientSession}. if (sessionId != null) { return new CompositeObject(BEANS.get(IClientSession.class).getClass(), sessionId); } else if (subject != null) { return new CompositeObject(BEANS.get(IClientSession.class).getClass(), BEANS.get(IAccessControlService.class).getUserId(subject)); } else { return null; } }
private void calculateDisplayableIndexes() { int viewIndex = 0; Map<CompositeObject, Integer> displayableMap = new TreeMap<>(); for (int modelIndex = 0; modelIndex < getColumnCount(); modelIndex++) { IColumn col = getColumn(modelIndex); if (col.isDisplayable()) { displayableMap.put(new CompositeObject(modelIndex), modelIndex); } } m_displayableIndexes = new int[displayableMap.size()]; viewIndex = 0; for (int modelIndex : displayableMap.values()) { m_displayableIndexes[viewIndex++] = modelIndex; } }
@Override protected CompositeObject calculateIndexFor(final RegistryEntry runMonitorEntry) { return new CompositeObject(runMonitorEntry.getSessionId(), runMonitorEntry.getRequestId()); } }
@Override protected CompositeObject newSessionCacheKey(final String sessionId, final Subject subject) { final Object[] superComponents = super.newSessionCacheKey(sessionId, subject).getComponents(); if (superComponents == null) { return null; } // Make the session part of the cache key. final Object[] components = new Object[superComponents.length + 1]; System.arraycopy(superComponents, 0, components, 1, superComponents.length); components[0] = BEANS.get(IServerSession.class).getClass(); return new CompositeObject(components); } }
protected List<RunMonitor> getAllBySessionIdAndRequestId(final String sessionId, final long requestId) { return getRunMonitors(m_sessionIdRequestIdIndex.get(new CompositeObject(sessionId, requestId))); }
protected SessionInspector[] getSortedSessions() { SessionInspector[] sessionInspectors = ProcessInspector.instance().getSessionInspectors(); TreeMap<CompositeObject, SessionInspector> userAndTimeToSessions = new TreeMap<>(); for (int i = 0; i < sessionInspectors.length; i++) { String user = sessionInspectors[i].getInfo().getUserId(); long lastAccess = NumberUtility.nvl(sessionInspectors[i].getInfo().getLastAccessedTime(), 0L); userAndTimeToSessions.put(new CompositeObject(lastAccess, user, i), sessionInspectors[i]); } return userAndTimeToSessions.values().toArray(new SessionInspector[userAndTimeToSessions.size()]); }
public List<IColumn<?>> getAllColumnsInUserOrder() { List<IColumn<?>> visibleCols = getVisibleColumns(); int counter = 0; SortedMap<CompositeObject, IColumn<?>> sortMap = new TreeMap<>(); for (IColumn col : visibleCols) { counter++; sortMap.put(new CompositeObject(col.getVisibleColumnIndexHint(), counter), col); } for (IColumn<?> column : getColumns()) { if (column.isDisplayable() && column.isVisible()) { //already in map } else { counter++; sortMap.put(new CompositeObject(column.getVisibleColumnIndexHint(), counter), column); } } return CollectionUtility.arrayList(sortMap.values()); }
private ITableRow addInternalRow(InternalTableRow newIRow) { synchronized (m_cachedRowsLock) { m_cachedRows = null; int newIndex = m_rows.size(); newIRow.setRowIndex(newIndex); newIRow.setTableInternal(this); m_rows.add(newIRow); m_rowsByKey.put(new CompositeObject(newIRow.getKeyValues()), newIRow); } rebuildTreeStructure(); Set<Integer> indexes = new HashSet<>(); for (int idx : getColumnSet().getAllColumnIndexes()) { indexes.add(idx); } enqueueValueChangeTasks(newIRow, indexes); enqueueDecorationTasks(newIRow); return newIRow; }
/** * Cancels all registered monitors associated with the given 'sessionId' and 'requestId'. * * @return <code>true</code> if all monitors matching the given 'sessionId' and 'requestId' could be cancelled, or * <code>false</code> if no monitor is registered, or if at least one monitor was already cancelled or failed * to be cancelled. */ public boolean cancelAllBySessionIdAndRequestId(final String sessionId, final long requestId) { final List<RegistryEntry> entries; synchronized (m_registryLock) { entries = m_sessionIdRequestIdIndex.get(new CompositeObject(sessionId, requestId)); m_registry.remove(entries); } return cancelRunMonitors(getRunMonitors(entries)); }
private void deleteRowImpl(ITableRow row) { if (!(row instanceof InternalTableRow)) { return; } InternalTableRow internalRow = (InternalTableRow) row; if (isAutoDiscardOnDelete()) { internalRow.setTableInternal(null); // don't manage deleted rows any further } else if (internalRow.getStatus() == ITableRow.STATUS_INSERTED) { internalRow.setTableInternal(null); // it was new and now it is gone, no further action required } else { internalRow.setStatus(ITableRow.STATUS_DELETED); m_deletedRows.put(new CompositeObject(getRowKeys(internalRow)), internalRow); } }
protected void handleOwnerValueChanged() { IImageField container = getContainer(); if (container != null) { final Object ownerValue = new CompositeObject(container.getImageId(), container.getImageUrl(), container.getImage()); setCurrentMenuTypes(getMenuTypesForValues()); visit(new MenuOwnerChangedVisitor(ownerValue, getCurrentMenuTypes()), IMenu.class); } calculateLocalVisibility(); }
protected void handleOwnerValueChanged() { IPlanner<?, ?> container = getContainer(); if (container != null) { final CompositeObject ownerValue = new CompositeObject(container.getSelectedResources(), container.getSelectedActivity(), container.getSelectionRange()); setCurrentMenuTypes(getMenuTypesForSelection(container.getSelectedResources(), container.getSelectedActivity(), container.getSelectionRange())); visit(new MenuOwnerChangedVisitor(ownerValue, getCurrentMenuTypes()), IMenu.class); calculateLocalVisibility(); } }