Returns a set view of the entries from this
<code>BijMap</code>.  The view is fully functional (i.e.,
allows mutation) and connected to this bijective map (i.e.,
changes in one of them are reflected in the other one).
499043
public Set<Map.Entry<A,B>> entrySet() {
	return new AbstractSet<Map.Entry<A,B>>() {
	    public int size() {
		return map.size();
	    }
	    public Iterator<Map.Entry<A,B>> iterator() {
		return new Iterator<Map.Entry<A,B>>() {
		    private final Iterator<Map.Entry<A,B>> it = map.entrySet().iterator();
		    private Map.Entry<A,B> last = null;
		    public boolean hasNext() {
			return it.hasNext(); 
		    }
		    public Map.Entry<A,B> next() { 
		        last = it.next();
			return last;
		    }
		    public void remove() {
			it.remove();
			revMap.remove(last.getValue());
		    }
		};
	    }
	    public boolean remove(Object o) {
		if(!(o instanceof Map.Entry/*<A,B>*/)) return false;
		@SuppressWarnings("unchecked")
		Map.Entry<A,B> entry = (Map.Entry<A,B>) o;
		B currValue = BijMap.this.get(entry.getKey());
		if((currValue == null) || !currValue.equals(entry.getValue())) return false;
		BijMap.this.remove(entry.getKey());
		return true;
	    }
	    public void clear() {
		BijMap.this.clear();
	    }
	};
    }
1197153
public static synchronized View getSingleton() {
        if (view == null) {
            if (daemon) {
                Exception e = new Exception("Attempting to initialise View in daemon mode");
                logger.error(e.getMessage(), e);
                return null;
            }
            
            logger.info("Initialising View");
            view = new View();
            view.init();
        }
        
        return view;
    }
655117
private MapCollections<K, V> getCollection() {
        @WeakOuter
        class InteropMapCollections extends MapCollections<K, V> {
            @Override
            protected int colGetSize() {
                return mSize;
            }

            @Override
            protected Object colGetEntry(int index, int offset) {
                return mArray[(index<<1) + offset];
            }

            @Override
            protected int colIndexOfKey(Object key) {
                return key == null ? indexOfNull() : indexOf(key, key.hashCode());
            }

            @Override
            protected int colIndexOfValue(Object value) {
                return indexOfValue(value);
            }

            @Override
            protected Map<K, V> colGetMap() {
                return ArrayMap.this;
            }

            @Override
            protected void colPut(K key, V value) {
                put(key, value);
            }

            @Override
            protected V colSetValue(int index, V value) {
                return setValueAt(index, value);
            }

            @Override
            protected void colRemoveAt(int index) {
                removeAt(index);
            }

            @Override
            protected void colClear() {
                clear();
            }
        }
        if (mCollections == null) {
            mCollections = new InteropMapCollections();
        }
        return mCollections;
    }
139112
public final Collection<V> values() {
	return new AbstractCollection<V>() {
	    public Iterator<V> iterator() {
		final Iterator<Map.Entry<K,V>> ite = entryIterator();
		return new Iterator<V>() {
		    public boolean hasNext() { return ite.hasNext(); }
		    public void    remove()  { ite.remove(); }
		    public V       next()    { return ite.next().getValue(); }
		};
	    }
	    public int size() {
		return size;
	    }
	};
    }
604358
public static <K, V> Map<K, V> toMap(final Iterable<Map.Entry<K, V>> iterable) {
        final Map<K, V> result = newLinkedHashMap();
        for (Map.Entry<K, V> entry : iterable) {
            result.put(entry.getKey(), entry.getValue());
        }
        return result;
    }
922337
public BiMap<V, K> inversed() {
        return (inverse == null) ? inverse = new BiMap<>(valueMap, keyMap) : inverse;
    }
1157173
function View(template) {
  this.context = null;
  if (!template) template = this;
  this.template = template;
  if (!this.template.bindings) this.template.bindings = [];
  this.bindings = this.template.bindings.map(mapBinding.bind(this), this);

  this.firstViewNode = this.firstChild;
  this.lastViewNode = this.lastChild;
  if (this.firstViewNode) {
    this.firstViewNode.view = this;
    this.lastViewNode.view = this;
  }
}
505204
protected void view(Map values){
        for(Object key:values.keySet() ){
            assign(key.toString(), values.get(key));
        }
    }
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;
    }
809703
@SuppressWarnings("ConstantConditions")
  private ImmutableBiMap<K,V> toImmutableBiMap() {
    final ImmutableBiMap.Builder<K,V> ret = ImmutableBiMap.builder();

    for (final MapEntry<K, V> entry : entries) {
      ret.put(entry.key, entry.value);
    }

    return ret.build();
  }
630930
@Override
    public Set<java.util.Map.Entry<K, V>> entrySet() {
        final Set<Entry<K, V>> localSet = this.localMap.entrySet();

        if (isReadyOnly())
            return Collections.unmodifiableSet(localSet);

        return localSet;
    }
991003
@Override
	public <NK, NV> FMap<NK, NV> map(BiFunction<? super K, ? super V, Product2<? extends NK, ? extends NV>> f) {
		HashFMap<NK, NV> ret = new HashFMap<>(new HashMap<>(this.size()));
		for (java.util.Map.Entry<K, V> entry : entrySet()) {
			Product2<? extends NK,? extends NV> t = f.apply(entry.getKey(), entry.getValue());
			ret.put(t.get1(), t.get2());
		}
		return ret;
	}
530319
@Exported
    public Collection<View> getViews() {
        List<View> orig = views();
        List<View> copy = new ArrayList<>(orig.size());
        for (View v : orig) {
            if (v.hasPermission(View.READ))
                copy.add(v);
        }
        copy.sort(View.SORTER);
        return copy;
    }
587
protected void view(Map<String, Object> values){
        for(String key:values.keySet() ){
            view(key, values.get(key));
        }
    }
1250273
public Set<Map.Entry<K,V>> entrySet()
  {
    if (TraceComponent.isAnyTracingEnabled() && _tc.isEntryEnabled()) SibTr.entry(this, _tc, "entrySet");
    
    UnsupportedOperationException uoe = new UnsupportedOperationException();
    
    if (TraceComponent.isAnyTracingEnabled() && _tc.isEntryEnabled()) SibTr.exit(this, _tc, "entrySet", uoe);
    throw uoe;
  }
472651
@Override
    public Set<java.util.Map.Entry<K, V>> entrySet() {
        try {
            lockAllSegments();
            Set<java.util.Map.Entry<K, V>> set = new HashSet<>();
            for (LinkedHashMapSegment<K, V> seg : segments) {
                set.addAll(seg.entrySet());
            }
            return set;
        } finally {
            unlockAllSegments();
        }
    }
448219
@Override
    public Set<Entry<String, V>> entrySet() {
        HashMap<String, V> entries = new HashMap<>();
        entriesR(root.getLeft(), -1, entries);
        return entries.entrySet();
    }