private <MODEL> CompositeObject createModelAndParentAdapterPair(final MODEL model, final IJsonAdapter<?> parentAdapter) { return new CompositeObject(model, parentAdapter); } }
sortMap.put(new CompositeObject(classNameScore, userPreferenceContextScore, index), p); if (ObjectUtility.equals(bestMatchingKey.getComponent(0), nextKey.getComponent(0)) && ObjectUtility.equals(bestMatchingKey.getComponent(1), nextKey.getComponent(1))) { LOG.warn("More than one pages found for page class [{}] and bookmark Identifier [{}]", className, bookmarkIdentifier);
@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); } }
if (childPk != null) { for (int r = 0; r < table.getRowCount(); r++) { CompositeObject testPkLegacy = new CompositeObject(makeSerializableKeys(table.getRowKeys(r), true)); CompositeObject testPk = new CompositeObject(makeSerializableKeys(table.getRowKeys(r), false)); if (testPk.equals(childPk) || testPkLegacy.equals(childPk)) { if (r < tablePage.getChildNodeCount()) { childPage = tablePage.getChildPage(r); List<ITableRow> rowList = new ArrayList<>(); for (ITableRow row : table.getRows()) { CompositeObject testPkLegacy = new CompositeObject(makeSerializableKeys(row.getKeyValues(), true)); CompositeObject testPk = new CompositeObject(makeSerializableKeys(row.getKeyValues(), false)); if ((selectionSet.contains(testPk) || selectionSet.contains(testPkLegacy)) && row.isFilterAccepted()) {
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; } } }
CompositeObject key = new CompositeObject(sectionOrder, sectionName); Collection<ServiceInspector> list = servicesMap.computeIfAbsent(key, k -> new ArrayList<>()); list.add(inspector); String sectionName = (String) e.getKey().getComponent(1); Collection<ServiceInspector> list = e.getValue(); renderServiceTable(p, sectionName, list);
@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 accept(IFormField field) { int fieldIdRank = getFieldIdRank(field); if (fieldIdRank > 0) { int enclosingFieldPathRank = getEnclosingFieldPathRank(field); CompositeObject key; if (field instanceof IValueField) { key = new CompositeObject(fieldIdRank, enclosingFieldPathRank, 2); } else if (!(field instanceof ICompositeField)) { key = new CompositeObject(fieldIdRank, enclosingFieldPathRank, 1); } else { key = new CompositeObject(fieldIdRank, enclosingFieldPathRank, 0); } if (m_prioMap.containsKey(key)) { m_ambiguousFieldKeys.add(key); } else { m_prioMap.put(key, field); } } }
@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()); } }
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 VirtualRow[] getSortedRows() { SortedMap<CompositeObject, VirtualRow> sortMap = new TreeMap<>(); int rowIndex = 0; for (VirtualRow row : m_rows) { sortMap.put(new CompositeObject(row.getCellAt(m_sortInfo.getColumnIndex()), rowIndex), row); rowIndex++; } VirtualRow[] result = new VirtualRow[m_rows.size()]; if (m_sortInfo.getColumnIndex() >= 0 && !m_sortInfo.isAscending()) { // reverse int i = m_rows.size() - 1; for (VirtualRow row : sortMap.values()) { result[i] = row; i--; } } else { // forward int i = 0; for (VirtualRow row : sortMap.values()) { result[i] = row; i++; } } return result; }