/**
* This function is used to re-run the analyser, and re-create the rows corresponding the its
* results.
*/
private void refreshReviewTable() {
reviewPanel.removeAll();
rows.clear();
GridBagLayout gbl = new GridBagLayout();
reviewPanel.setLayout(gbl);
GridBagConstraints gbc = new GridBagConstraints();
gbc.fill = GridBagConstraints.HORIZONTAL;
gbc.gridy = 0;
try {
Map<String, Long> sums =
analyser.processLogFile(config.getLogFilename(), fromDate.getDate(), toDate.getDate());
for (Entry<String, Long> entry : sums.entrySet()) {
String project = entry.getKey();
double hours = 1.0 * entry.getValue() / (1000 * 3600);
addRow(gbl, gbc, project, hours);
}
for (String project : main.getProjectsTree().getTopLevelProjects())
if (!rows.containsKey(project)) addRow(gbl, gbc, project, 0);
gbc.insets = new Insets(10, 0, 0, 0);
addLeftLabel(gbl, gbc, "TOTAL");
gbc.gridx = 1;
gbc.weightx = 1;
totalLabel.setBorder(BorderFactory.createEmptyBorder(0, 0, 0, 3));
gbl.setConstraints(totalLabel, gbc);
reviewPanel.add(totalLabel);
gbc.weightx = 0;
addRightLabel(gbl, gbc);
} catch (IOException e) {
e.printStackTrace();
}
recomputeTotal();
pack();
}
/**
* Generates a JavaScript command to update the JavaScript agent's parameter names. Follows this
* format: <code>agent.updateParameterNames({serial: 'XXXX', parameter: 'YYYY'});</code>
*
* @return A JavaScript Command.
*/
public String generateCommand(String type, Map<String, ?> props) {
StringBuilder buff = new StringBuilder(agentName);
buff.append(".update").append(type).append("({");
for (Entry<String, ?> entry : props.entrySet()) {
if (entry.getValue() instanceof String) {
buff.append(entry.getKey()).append(": '").append(entry.getValue()).append("',");
} else {
buff.append(entry.getKey()).append(": ").append(entry.getValue()).append(",");
}
}
buff.deleteCharAt(buff.length() - 1);
buff.append("});");
return buff.toString();
}
/**
* Returns the value to which this map maps the specified key. Returns <tt>null</tt> if the map
* contains no mapping for this key. A return value of <tt>null</tt> does not <i>necessarily</i>
* indicate that the map contains no mapping for the key; it's also possible that the map
* explicitly maps the key to <tt>null</tt>. The containsKey operation may be used to distinguish
* these two cases.
*
* <p>This implementation iterates over <tt>entrySet()</tt> searching for an entry with the
* specified key. If such an entry is found, the entry's value is returned. If the iteration
* terminates without finding such an entry, <tt>null</tt> is returned. Note that this
* implementation requires linear time in the size of the map; many implementations will override
* this method.
*
* @param key key whose associated value is to be returned.
* @return the value to which this map maps the specified key.
* @throws NullPointerException if the key is <tt>null</tt> and this map does not not permit
* <tt>null</tt> keys.
* @see #containsKey(Object)
*/
public Object get(Object key) {
Iterator i = entrySet().iterator();
if (key == null) {
while (i.hasNext()) {
Entry e = (Entry) i.next();
if (e.getKey() == null) return e.getValue();
}
} else {
while (i.hasNext()) {
Entry e = (Entry) i.next();
if (key.equals(e.getKey())) return e.getValue();
}
}
return null;
}
/**
* Returns <tt>true</tt> if this map contains a mapping for the specified key.
*
* <p>This implementation iterates over <tt>entrySet()</tt> searching for an entry with the
* specified key. If such an entry is found, <tt>true</tt> is returned. If the iteration
* terminates without finding such an entry, <tt>false</tt> is returned. Note that this
* implementation requires linear time in the size of the map; many implementations will override
* this method.
*
* @param key key whose presence in this map is to be tested.
* @return <tt>true</tt> if this map contains a mapping for the specified key.
* @throws NullPointerException key is <tt>null</tt> and this map does not not permit
* <tt>null</tt> keys.
*/
public boolean containsKey(Object key) {
Iterator i = entrySet().iterator();
if (key == null) {
while (i.hasNext()) {
Entry e = (Entry) i.next();
if (e.getKey() == null) return true;
}
} else {
while (i.hasNext()) {
Entry e = (Entry) i.next();
if (key.equals(e.getKey())) return true;
}
}
return false;
}
@Override
public Map<String, Set<String>> unmarshal(List<StringSetMapAdapter.Entry> entryList)
throws Exception {
Map<String, Set<String>> map = new HashMap<String, Set<String>>();
for (Entry entry : entryList) {
if (map.containsKey(entry.getKey())) {
map.get(entry.getKey()).add(entry.getValue());
} else {
Set<String> valueSet = new HashSet<String>();
valueSet.add(entry.getValue());
map.put(entry.getKey(), valueSet);
}
}
return map;
}
/**
* Compares the specified object with this map for equality. Returns <tt>true</tt> if the given
* object is also a map and the two maps represent the same mappings. More formally, two maps
* <tt>t1</tt> and <tt>t2</tt> represent the same mappings if
* <tt>t1.keySet().equals(t2.keySet())</tt> and for every key <tt>k</tt> in <tt>t1.keySet()</tt>,
* <tt> (t1.get(k)==null ? t2.get(k)==null : t1.get(k).equals(t2.get(k))) </tt>. This ensures that
* the <tt>equals</tt> method works properly across different implementations of the map
* interface.
*
* <p>This implementation first checks if the specified object is this map; if so it returns
* <tt>true</tt>. Then, it checks if the specified object is a map whose size is identical to the
* size of this set; if not, it it returns <tt>false</tt>. If so, it iterates over this map's
* <tt>entrySet</tt> collection, and checks that the specified map contains each mapping that this
* map contains. If the specified map fails to contain such a mapping, <tt>false</tt> is returned.
* If the iteration completes, <tt>true</tt> is returned.
*
* @param o object to be compared for equality with this map.
* @return <tt>true</tt> if the specified object is equal to this map.
*/
public boolean equals(Object o) {
if (o == this) return true;
if (!(o instanceof Map)) return false;
Map t = (Map) o;
if (t.size() != size()) return false;
try {
Iterator i = entrySet().iterator();
while (i.hasNext()) {
Entry e = (Entry) i.next();
Object key = e.getKey();
Object value = e.getValue();
if (value == null) {
if (!(t.get(key) == null && t.containsKey(key))) return false;
} else {
if (!value.equals(t.get(key))) return false;
}
}
} catch (ClassCastException unused) {
return false;
} catch (NullPointerException unused) {
return false;
}
return true;
}
/**
* Copies all of the mappings from the specified map to this map (optional operation). These
* mappings will replace any mappings that this map had for any of the keys currently in the
* specified map.
*
* <p>This implementation iterates over the specified map's <tt>entrySet()</tt> collection, and
* calls this map's <tt>put</tt> operation once for each entry returned by the iteration.
*
* <p>Note that this implementation throws an <tt>UnsupportedOperationException</tt> if this map
* does not support the <tt>put</tt> operation and the specified map is nonempty.
*
* @param t mappings to be stored in this map.
* @throws UnsupportedOperationException if the <tt>putAll</tt> operation is not supported by this
* map.
* @throws ClassCastException if the class of a key or value in the specified map prevents it from
* being stored in this map.
* @throws IllegalArgumentException if some aspect of a key or value in the specified map prevents
* it from being stored in this map.
* @throws NullPointerException the specified map is <tt>null</tt>, or if this map does not permit
* <tt>null</tt> keys or values, and the specified map contains <tt>null</tt> keys or values.
*/
public void putAll(Map t) {
Iterator i = t.entrySet().iterator();
while (i.hasNext()) {
Entry e = (Entry) i.next();
put(e.getKey(), e.getValue());
}
}
/**
* Copies the key/value mappings in <tt>map</tt> into this map. Note that this will be a
* <b>deep</b> copy, as storage is by primitive value.
*
* @param map a <code>Map</code> value
*/
public void putAll(Map<? extends Character, ? extends Double> map) {
Iterator<? extends Entry<? extends Character, ? extends Double>> it = map.entrySet().iterator();
for (int i = map.size(); i-- > 0; ) {
Entry<? extends Character, ? extends Double> e = it.next();
this.put(e.getKey(), e.getValue());
}
}
@Nullable
public InstanceFactory findInstanceFactory(@Nonnull Type mockedType) {
InstanceFactory instanceFactory = mockedTypesAndInstances.get(mockedType);
if (instanceFactory != null) {
return instanceFactory;
}
Class<?> mockedClass = getClassType(mockedType);
//noinspection ReuseOfLocalVariable
instanceFactory = mockedTypesAndInstances.get(mockedClass);
if (instanceFactory != null) {
return instanceFactory;
}
boolean abstractType = mockedClass.isInterface() || isAbstract(mockedClass.getModifiers());
for (Entry<Type, InstanceFactory> entry : mockedTypesAndInstances.entrySet()) {
Type registeredMockedType = entry.getKey();
Class<?> registeredMockedClass = getClassType(registeredMockedType);
if (abstractType) {
registeredMockedClass = getMockedClassOrInterfaceType(registeredMockedClass);
}
if (mockedClass.isAssignableFrom(registeredMockedClass)) {
instanceFactory = entry.getValue();
break;
}
}
return instanceFactory;
}
/**
* Parses connection options.
*
* @param options options
* @return connection properties
*/
private static Properties connProps(final HashMap<String, String> options) {
final Properties props = new Properties();
for (final Entry<String, String> entry : options.entrySet()) {
props.setProperty(entry.getKey(), entry.getValue());
}
return props;
}
/** Code completion. */
private void complete() {
if (selected()) return;
// find first character
final int caret = editor.pos(), startPos = editor.completionStart();
final String prefix = string(substring(editor.text(), startPos, caret));
if (prefix.isEmpty()) return;
// find insertion candidates
final TreeMap<String, String> tmp = new TreeMap<>();
for (final Entry<String, String> entry : REPLACE.entrySet()) {
final String key = entry.getKey();
if (key.startsWith(prefix)) tmp.put(key, entry.getValue());
}
if (tmp.size() == 1) {
// insert single candidate
complete(tmp.values().iterator().next(), startPos);
} else if (!tmp.isEmpty()) {
// show popup menu
final JPopupMenu pm = new JPopupMenu();
final ActionListener al =
new ActionListener() {
@Override
public void actionPerformed(final ActionEvent ae) {
complete(ae.getActionCommand().replaceAll("^.*?\\] ", ""), startPos);
}
};
for (final Entry<String, String> entry : tmp.entrySet()) {
final JMenuItem mi = new JMenuItem("[" + entry.getKey() + "] " + entry.getValue());
pm.add(mi);
mi.addActionListener(al);
}
pm.addSeparator();
final JMenuItem mi = new JMenuItem(Text.INPUT + Text.COLS + prefix);
mi.setEnabled(false);
pm.add(mi);
final int[] cursor = rend.cursor();
pm.show(this, cursor[0], cursor[1]);
// highlight first entry
final MenuElement[] me = {pm, (JMenuItem) pm.getComponent(0)};
MenuSelectionManager.defaultManager().setSelectedPath(me);
}
}
/** Format: mapType, num, (key, value) pairs */
private void writeObject(ObjectOutputStream out) throws IOException {
out.writeObject(mapType);
out.writeInt(num);
for (Entry e : this) {
out.writeObject(e.getKey());
out.writeDouble(e.getValue());
}
}
/**
* Copies all of the mappings from the specified map to this one.
*
* <p>These mappings replace any mappings that this map had for any of the keys currently in the
* specified Map.
*
* @param t Mappings to be stored in this map.
*/
public void putAll(Map<? extends K, ? extends V> t) {
for (Iterator<? extends Map.Entry<? extends K, ? extends V>> it =
(Iterator<? extends Map.Entry<? extends K, ? extends V>>) t.entrySet().iterator();
it.hasNext(); ) {
Entry<? extends K, ? extends V> e = it.next();
put(e.getKey(), e.getValue());
}
}
/** ** Adds an entry ({@link Entry}) to <code>RTKey</code> */
public static void addRuntimeEntry(Entry dftEntry) {
if (dftEntry != null) {
String rtKey = dftEntry.getKey();
if (rtKey != null) {
RTKey.getRuntimeEntryMap().put(rtKey, dftEntry);
defaultProperties = null;
}
}
}
/**
* Generates a string representation of the configuration options.
*
* @return A string
* @see java.lang.Object#toString()
*/
public String toString() {
StringBuilder buff = new StringBuilder("AjaxMetricsFilterConfiguration:");
buff.append("\n\tParameter Names:");
for (Entry<String, String> entry : parameterNames.entrySet()) {
buff.append("\n\t\t").append(entry.getKey()).append(":").append(entry.getValue());
}
buff.append("\n\tRun Options:");
for (Entry<String, Boolean> entry : runOptions.entrySet()) {
buff.append("\n\t\t").append(entry.getKey()).append(":").append(entry.getValue());
}
buff.append("\n\tBatch Options:");
for (Entry<String, Integer> entry : batchOptions.entrySet()) {
buff.append("\n\t\t").append(entry.getKey()).append(":").append(entry.getValue());
}
buff.append("\n\tListener Class Name:").append(listenerClassName);
buff.append("\n\tAgent Logging Level:").append(agentLogLevel);
buff.append("\n\tAgent Name:").append(agentName);
return buff.toString();
}
/**
* Get the vertex with the maximal label.
*
* @param vertexLabels Map that gives a label for each vertex.
* @return Vertex with the maximal label.
*/
private V getMaxLabelVertex(Map<V, Integer> vertexLabels) {
Iterator<Entry<V, Integer>> iterator = vertexLabels.entrySet().iterator();
Entry<V, Integer> max = iterator.next();
while (iterator.hasNext()) {
Entry<V, Integer> e = iterator.next();
if (e.getValue() > max.getValue()) {
max = e;
}
}
return max.getKey();
}
public Set entrySet() {
Set<Entry<Data, Data>> entries = entrySetInternal();
Set<Entry<K, V>> resultSet = new HashSet<Entry<K, V>>();
for (Entry<Data, Data> entry : entries) {
resultSet.add(
new AbstractMap.SimpleImmutableEntry(
(K) getService().toObject(entry.getKey()),
(V) getService().toObject(entry.getValue())));
}
return resultSet;
}
/**
* Removes the mapping for this key from this map if present (optional operation).
*
* <p>This implementation iterates over <tt>entrySet()</tt> searching for an entry with the
* specified key. If such an entry is found, its value is obtained with its <tt>getValue</tt>
* operation, the entry is is removed from the Collection (and the backing map) with the
* iterator's <tt>remove</tt> operation, and the saved value is returned. If the iteration
* terminates without finding such an entry, <tt>null</tt> is returned. Note that this
* implementation requires linear time in the size of the map; many implementations will override
* this method.
*
* <p>Note that this implementation throws an <tt>UnsupportedOperationException</tt> if the
* <tt>entrySet</tt> iterator does not support the <tt>remove</tt> method and this map contains a
* mapping for the specified key.
*
* @param key key whose mapping is to be removed from the map.
* @return previous value associated with specified key, or <tt>null</tt> if there was no entry
* for key. (A <tt>null</tt> return can also indicate that the map previously associated
* <tt>null</tt> with the specified key, if the implementation supports <tt>null</tt> values.)
* @throws UnsupportedOperationException if the <tt>remove</tt> operation is not supported by this
* map.
*/
public Object remove(Object key) {
Iterator i = entrySet().iterator();
Entry correctEntry = null;
if (key == null) {
while (correctEntry == null && i.hasNext()) {
Entry e = (Entry) i.next();
if (e.getKey() == null) correctEntry = e;
}
} else {
while (correctEntry == null && i.hasNext()) {
Entry e = (Entry) i.next();
if (key.equals(e.getKey())) correctEntry = e;
}
}
Object oldValue = null;
if (correctEntry != null) {
oldValue = correctEntry.getValue();
i.remove();
}
return oldValue;
}
@Override
public boolean contains(Object o) {
if (o == null) return false;
if (!(o instanceof Entry)) return false;
Entry e = (Entry) o;
// Values are primitive and cannot be null.
if (e.getKey() == null || e.getKey() == null) return false;
if (!(e.getKey() instanceof String) || !(e.getValue() instanceof Boolean)) return false;
String key = (String) e.getKey();
Boolean value = (Boolean) e.getValue();
int hash = d_keys.number(key);
// Does not contain the key.
if (hash == -1) return false;
return d_values[hash - 1] == value.booleanValue();
}
public XContentBuilder toXContentBuilder() throws IOException {
if (this == null) {
return null;
}
XContentBuilder builder = JsonXContent.contentBuilder();
builder.startObject();
Iterator<Entry<String, Object>> it = this.entrySet().iterator();
while (it.hasNext()) {
Entry<String, Object> entry = it.next();
builder.field(entry.getKey()).value(entry.getValue());
}
builder.endObject();
return builder;
}
private String generateOverviewText() throws InsufficientDataException {
StringBuilder sb = new StringBuilder();
final String team = config.getTeam();
double total = checkTotal();
final String nl = System.getProperty("line.separator");
for (Entry<String, Row> entry : rows.entrySet()) {
double hours = Double.parseDouble(entry.getValue().hoursTF.getText());
double fraction = hours / total;
if (fraction < 0.004) continue;
String line = team + ", " + decimalFormat.format(fraction) + ", " + entry.getKey();
sb.append(line + nl);
}
return sb.toString();
}
@SuppressWarnings("unchecked")
public void putAll(Map<? extends K, ? extends V> map) {
for (Entry<? extends K, ? extends V> entry : map.entrySet()) {
V value = entry.getValue();
// If the map is another DefaultCache instance than the
// entry values will be CacheObject instances that need
// to be converted to the normal object form.
if (value instanceof CacheObject) {
//noinspection unchecked
value = ((CacheObject<V>) value).object;
}
put(entry.getKey(), value);
}
}
private Entry<K, V> nextSegmentEntry() {
while (segmentIndex >= 0) {
Segment<K, V> segment = segments[segmentIndex];
Entry<K, V> entry = segment.getNextEntry(lastSegmentKey);
if (entry == null) {
segmentIndex--;
lastSegmentKey = null;
} else {
lastSegmentKey = entry.getKey();
return entry;
}
}
return null;
}
/**
* ** Gets all the ddefault properties in <code>RTKey</code> represented ** as an {@link
* RTProperties} instance ** @return The <code>RTProperties</code> instance
*/
public static RTProperties getDefaultProperties() {
if (defaultProperties == null) {
RTProperties rtp = new RTProperties();
for (Iterator<Entry> v = RTKey.getRuntimeEntryMap().values().iterator(); v.hasNext(); ) {
Entry rtk = v.next();
if (!rtk.isHelp()) {
String key = rtk.getKey();
Object val = rtk.getDefault();
rtp.setProperty(key, val);
}
}
defaultProperties = rtp;
}
return defaultProperties;
}
/**
* ** Prints all the default values from <code>RTKey</code> and {@link RTConfig} ** to the
* specified <code>PrintStream</code>. Used for debugging/testing ** @param out The <code>
* PrintStream</code>
*/
public static void printDefaults(PrintStream out) {
/* print standard runtime entries */
Set<String> keyList = new OrderedSet<String>();
String keyGrp = null;
for (Iterator<Entry> v = RTKey.getRuntimeEntryMap().values().iterator(); v.hasNext(); ) {
Entry rtk = v.next();
if (rtk.isHelp()) {
out.println("");
out.println("# ===== " + rtk.getHelp());
} else {
Object dft = rtk.getDefault();
out.println("# --- " + rtk.getHelp());
out.println("# " + rtk.toString(dft));
String key = rtk.getKey();
keyList.add(key);
if (!key.equals(CONFIG_FILE) && RTConfig.hasProperty(key)) {
String val = RTConfig.getString(key, null);
// if ((val != null) && ((dft == null) || !val.equals(dft.toString()))) {
out.println(rtk.toString(val));
// }
}
}
}
/* orphaned entries */
RTProperties cmdLineProps = RTConfig.getConfigFileProperties();
if (cmdLineProps != null) {
boolean orphanHeader = false;
for (Iterator i = cmdLineProps.keyIterator(); i.hasNext(); ) {
Object k = i.next();
if (!k.equals(COMMAND_LINE_CONF) && !keyList.contains(k)) {
if (!orphanHeader) {
out.println("");
out.println("# ===== Other entries");
orphanHeader = true;
}
Object v = cmdLineProps.getProperty(k, null);
out.println(k + "=" + ((v != null) ? v : NULL_VALUE));
}
}
}
/* final blank line */
out.println("");
}
/**
* Returns a string representation of this map. The string representation consists of a list of
* key-value mappings in the order returned by the map's <tt>entrySet</tt> view's iterator,
* enclosed in braces (<tt>"{}"</tt>). Adjacent mappings are separated by the characters <tt>",
* "</tt> (comma and space). Each key-value mapping is rendered as the key followed by an equals
* sign (<tt>"="</tt>) followed by the associated value. Keys and values are converted to strings
* as by <tt>String.valueOf(Object)</tt>.
*
* <p>This implementation creates an empty string buffer, appends a left brace, and iterates over
* the map's <tt>entrySet</tt> view, appending the string representation of each
* <tt>map.entry</tt> in turn. After appending each entry except the last, the string <tt>",
* "</tt> is appended. Finally a right brace is appended. A string is obtained from the
* stringbuffer, and returned.
*
* @return a String representation of this map.
*/
public String toString() {
StringBuffer buf = new StringBuffer();
buf.append("{");
Iterator i = entrySet().iterator();
boolean hasNext = i.hasNext();
while (hasNext) {
Entry e = (Entry) (i.next());
Object key = e.getKey();
Object value = e.getValue();
buf.append((key == this ? "(this Map)" : key) + "=" + (value == this ? "(this Map)" : value));
hasNext = i.hasNext();
if (hasNext) buf.append(", ");
}
buf.append("}");
return buf.toString();
}
@Override
public boolean remove(Object o) {
processQueue();
if (!(o instanceof Entry)) return false;
Entry<K, V> e = (Entry<K, V>) o;
V ev = e.getValue();
// optimization: do not recreate the key
myHardKeyInstance.set(e.getKey());
Key<K> key = myHardKeyInstance;
V hv = myMap.get(key);
boolean toRemove = hv == null ? ev == null && myMap.containsKey(key) : hv.equals(ev);
if (toRemove) {
myMap.remove(key);
}
myHardKeyInstance.clear();
return toRemove;
}
public String toString()
{
StringBuilder stringbuilder = new StringBuilder();
stringbuilder.append("PATH: ");
stringbuilder.append(uF);
if (uD != null)
{
stringbuilder.append(" PARAMS: ");
for (Iterator iterator = uD.entrySet().iterator(); iterator.hasNext(); stringbuilder.append(", "))
{
java.util.Entry entry = (java.util.Entry)iterator.next();
stringbuilder.append((String)entry.getKey());
stringbuilder.append("=");
stringbuilder.append((String)entry.getValue());
}
}
return stringbuilder.toString();
}
private Date lazyEvaluateDateParam(Object key) {
// parse date structs automatically
Map dateParams = new HashMap();
for (Object o : entrySet()) {
Entry entry = (Entry) o;
final Object entryKey = entry.getKey();
if (entryKey instanceof String) {
String paramName = (String) entryKey;
final String prefix = key + "_";
if (paramName.startsWith(prefix)) {
dateParams.put(
paramName.substring(prefix.length(), paramName.length()), entry.getValue());
}
}
}
DateFormat dateFormat =
new SimpleDateFormat(GrailsDataBinder.DEFAULT_DATE_FORMAT, LocaleContextHolder.getLocale());
StructuredPropertyEditor editor = new StructuredDateEditor(dateFormat, true);
Date d = (Date) editor.assemble(Date.class, dateParams);
put(key, d);
return d;
}
// 将Json集合转换为大Json
public static XContentBuilder parse(List<Json> list, String arrayName) throws IOException {
XContentBuilder builder = XContentFactory.jsonBuilder();
builder.startObject();
if (list == null || list.size() == 0) {
builder.field("total", 0);
builder.startArray(arrayName);
} else {
builder.field("total", list.size());
builder.startArray(arrayName);
for (Json json : list) {
builder.startObject();
Iterator<Entry<String, Object>> it = json.entrySet().iterator();
while (it.hasNext()) {
Entry<String, Object> entry = it.next();
builder.field(entry.getKey()).value(entry.getValue());
}
builder.endObject();
}
}
builder.endArray();
builder.endObject();
return builder;
}
