Gets the user-defined accumulators values.
@return the serialized map
556972
public Map<String, Accumulator<?, ?>> deserializeUserAccumulators(ClassLoader classLoader) throws IOException, ClassNotFoundException {
		return userAccumulators.deserializeValue(classLoader);
	}
360441
public Map<String, String> getSortedMap()
    {
        ImmutableSortedMap.Builder<String, String> builder = ImmutableSortedMap.naturalOrder();
        for ( FieldValue fv : fieldValues )
        {
            builder.put(fv.getField(), fv.getValue());
        }

        return builder.build();
    }
1352933
public DataBuffer getIncludedValues() {
        List<Double> val = new ArrayList<>();

        for (int i = 0; i < values.length(); i++) {
            boolean isIn = true;
            int idxNotFixed = 0;
            int[] idx = getUnderlyingIndicesOf(i).asInt();
            for (int dim = 0; dim < idx.length; dim++) {
                if (flags()[dim] == 1) {
                    if (sparseOffsets()[dim] != idx[dim]) {
                        isIn = false;
                        break;
                    }
                } else {
                    int lowerBound = sparseOffsets()[dim];
                    long upperBound = sparseOffsets()[dim] + shape()[idxNotFixed];
                    if (!(idx[dim] >= lowerBound && idx[dim] < upperBound)) {
                        isIn = false;
                        break;
                    }
                    idxNotFixed++;
                }
            }
            if (isIn) {
                val.add(values.getDouble(i));
            }
        }
        return Nd4j.createBuffer(Doubles.toArray(val));
    }
170751
public Collection<V> values() {
       Set<Map.Entry<K, V>> s = entrySet();
       ArrayList l = new ArrayList(s.size());
       for (Map.Entry e : s) 
           l.add(e.getValue());
       return l;
    }


    /**
     * Return a filtered set of keys.
     * @see Map.keySet
     */
    public Set<K> keySet() {
       Set<Map.Entry<K, V>> s = entrySet();
       HashSet keys = new HashSet(s.size());
       for (Map.Entry e : mBackingMap.entrySet())
           keys.add(e.getKey());
       return keys;
    }


    /**
     * Delegates to backing map.
     * @see java.util.Map.clear()
     */
    public void clear() { 
        mBackingMap.clear(); 
    }


    /**
     * Delegates to backing map.
     * @see java.util.Map.containsKey
     */
    public boolean containsKey(Object key) { 
        return mBackingMap.containsKey(key); 
    }


    /**
     * Delegates to backing map.
     * @see java.util.Map.containsValue
     */
    public boolean containsValue(Object value) {
       return mBackingMap.containsValue(value);
    }

    
    /**
     * Delegates to backing map.
     * @see Object.equals.
     */
    public boolean equals(Object o) {
       return mBackingMap.equals(o);
    }


    /**
     * Delegates to backing map.
     * @see Object.hashCode
     */
    public int hashCode() {
       return mBackingMap.hashCode();
    }


    /**
     * Delegates to backing map.
     * @see java.util.Map.get
     */
    public V get(Object key) {
       return mBackingMap.get(key);
    }

    
    /**
     * Delegates to backing map.
     * @see java.util.Map.isEmpty
     */
    public boolean isEmpty() {
       return mBackingMap.isEmpty();
    }


    /**
     * Delegates to backing map.
     * @see java.util.Map.put
     */
    public V put(K key, V value) {
        return mBackingMap.put(key, value);
    }


    /**
     * Delegates to backing map.
     * @see java.util.Map.putAll
     */
    public void putAll(Map<? extends K,? extends V> m) {
        mBackingMap.putAll(m);
    }
    

    /**
     * Delegates to backing map.
     * @see java.util.Map.remove
     */
    public V remove(Object key) {
        return mBackingMap.remove(key);
    }


    /**
     * Delegates to backing map.
     * @see java.util.Map.size
     */
    public int size() {
        return mBackingMap.size();
    }


    /**
     * Filter interface.
     */
    public interface Filter {
        /**
         * Returns true if the given entry should be included.
         */
        public boolean accept(Map.Entry e);
    }


}
968312
public Map<String, String> getFieldMap() {
		if (headerMap == null) {
			throw new IllegalStateException("No header available");
		}

		final Map<String, String> fieldMap = new LinkedHashMap<>(headerMap.size());
		String key;
		Integer col;
		String val;
		for (final Map.Entry<String, Integer> header : headerMap.entrySet()) {
			key = header.getKey();
			col = headerMap.get(key);
			val = null == col ? null : get(col);
			fieldMap.put(key, val);
		}

		return fieldMap;
	}
889869
public Map getElementValues()
    {
        if ( _elementValues == null )
        {
            Set< Map.Entry< com.sun.mirror.declaration.AnnotationTypeElementDeclaration, com.sun.mirror.declaration.AnnotationValue > >
                    entries = getDelegate().getElementValues().entrySet();
            Map< AnnotationTypeElementDeclaration, AnnotationValue > elementValues =
                    new HashMap< AnnotationTypeElementDeclaration, AnnotationValue >();
            for ( Map.Entry< com.sun.mirror.declaration.AnnotationTypeElementDeclaration, com.sun.mirror.declaration.AnnotationValue > i : entries )
            {
                elementValues.put(
                        WrapperFactory.get().getAnnotationTypeElementDeclaration( i.getKey() ),
                        WrapperFactory.get().getAnnotationValue( i.getValue(), this ) );
            }
            _elementValues = elementValues;
        }

        return _elementValues;
    }
12563
public Map<ComponentJob, AnalyzerResult> getUnsafeResultElements() {
        if (_unsafeResultElements == null) {
            _unsafeResultElements = new LinkedHashMap<>();
            final Map<ComponentJob, AnalyzerResult> resultMap = _analysisResult.getResultMap();
            for (final Entry<ComponentJob, AnalyzerResult> entry : resultMap.entrySet()) {
                final AnalyzerResult analyzerResult = entry.getValue();
                try {
                    SerializationUtils.serialize(analyzerResult, new NullOutputStream());
                } catch (final SerializationException e) {
                    _unsafeResultElements.put(entry.getKey(), analyzerResult);
                }
            }
        }
        return _unsafeResultElements;
    }
98850
@Override
    public Map<String, List<Object>> getAttributes() {
        final Map<String, List<Object>> attributeMap = new LinkedHashMap<String, List<Object>>();

        for (final LocalAccountPersonAttributeImpl attribute : attributes) {
            final List<Object> objValues = this.getObjectValues(attribute);
            attributeMap.put(attribute.getName(), objValues);
        }

        return Collections.unmodifiableMap(attributeMap);
    }
362824
public Collection<B> values() {
	return new AbstractCollection<B>() {
	    public int size() { return map.size(); }
	    public Iterator<B> iterator() {
		return 
		    DSUtil.<Map.Entry<A,B>,B>mapIterator
		    (BijMap.this.entrySet().iterator(),
		     new Function<Map.Entry<A,B>,B>() {
			public B f(Map.Entry<A,B> entry) {
			    return entry.getValue();
			}
		    });
	    }
	    public boolean remove(Object b) {
		return BijMap.this.rev().remove(b) != null;
	    }
	    public void clear() {
		BijMap.this.clear();
	    }
	};
    }
382831
public ByteBuffer getSerializedValue(ByteBuffer serializedMap, ByteBuffer serializedKey, AbstractType keyType)
    {
        try
        {
            ByteBuffer input = serializedMap.duplicate();
            int n = readCollectionSize(input, Server.VERSION_3);
            for (int i = 0; i < n; i++)
            {
                ByteBuffer kbb = readValue(input, Server.VERSION_3);
                ByteBuffer vbb = readValue(input, Server.VERSION_3);
                int comparison = keyType.compare(kbb, serializedKey);
                if (comparison == 0)
                    return vbb;
                else if (comparison > 0)
                    // since the map is in sorted order, we know we've gone too far and the element doesn't exist
                    return null;
            }
            return null;
        }
        catch (BufferUnderflowException e)
        {
            throw new MarshalException("Not enough bytes to read a map");
        }
    }
381223
public List<V> values() {
        List<V> values = new ArrayList<>(size());
        for (List<V> list : map.values()) {
            values.addAll(list);
        }
        return values;
    }
323564
public double[] foldNonZeroInColumns(VectorAccumulator accumulator) {
        double[] result = new double[columns];

        for (int j = 0; j < columns; j++) {
            result[j] = foldNonZeroInColumn(j, accumulator);
        }

        return result;
    }
974810
private Map<MethodSymbol, Attribute> getAllValues() {
        Map<MethodSymbol, Attribute> res =
            new LinkedHashMap<MethodSymbol, Attribute>();

        // First find the default values.
        ClassSymbol sym = (ClassSymbol) anno.type.tsym;
        for (Scope.Entry e = sym.members().elems; e != null; e = e.sibling) {
            if (e.sym.kind == Kinds.MTH) {
                MethodSymbol m = (MethodSymbol) e.sym;
                Attribute def = m.getDefaultValue();
                if (def != null)
                    res.put(m, def);
            }
        }
        // Next find the explicit values, possibly overriding defaults.
        for (Pair<MethodSymbol, Attribute> p : anno.values)
            res.put(p.fst, p.snd);
        return res;
    }
743816
public Collection values() {
        if (values == null) {
            values = new AbstractCollectionView() {
                public long size() throws ObjectManagerException {
                    return AbstractTreeMap.this.size();
                }

                public Iterator iterator() throws ObjectManagerException {
                    return makeTreeMapIterator(new AbstractMapEntry.Type() {
                        public Object get(AbstractMapEntry entry) {
                            return entry.getValue();
                        }
                    });
                }
            };
        }
        return values;
    }
1014572
@GET
	public ReplyObject getAccumulators(){
		try{
			return ReplyObject.success("accumulators", getAccumulatorAPI().getAccumulatorDefinitions() );
		}catch(APIException e){
			return ReplyObject.error(e);
		}
	}
970172
public Map<String, String> getFieldValues() {
		Map<String, String> values = new HashMap<>(requiredFields.length + optionalFields.length);
		for (Entry<String, ZapTextField> f : textFields.entrySet())
			values.put(f.getKey(), f.getValue().getText());
		return values;
	}

	/**
	 * Bind a mapping of field names/values to the fields in this panel. All the fields whose names
	 * have a value provided in the map get set to that value, the others get cleared.
	 * 
	 * @param fieldValues the field values
	 */
	public void bindFieldValues(Map<String, String> fieldValues) {
		for (Entry<String, ZapTextField> f : textFields.entrySet()) {
			ZapTextField field = f.getValue();
			field.setText(fieldValues.get(f.getKey()));
			field.discardAllEdits();
		}
	}
788517
public TreeMap<Bits, Long> computeSums() {
    final TreeMap<Bits, Long> sums = new TreeMap<Bits, Long>();
    long total = 0;
    for (final Entry<Bits, AtomicInteger> e : this.map.entrySet()) {
      sums.put(e.getKey(), total += e.getValue().get());
    }
    return sums;
  }