Adds the current listeners to the {@link android.animation.AnimatorSet}
before animation starts

@param set The set to add listeners to
@return The set with listeners added
507284
protected AnimatorSet addListenersToSet(AnimatorSet set) {
        if (set != null) {
            set.addListener(this);
            if (mListeners != null) {
                for (Animator.AnimatorListener listener : mListeners) {
                    set.addListener(listener);
                }
            }
        }
        return set;
    }
488951
public static <T> Set<T> nullToEmpty(final Set<T> set) {
        return set == null ? N.<T> emptySet() : set;
    }
370
public SortedSet<T> firstSubset(SortedSet<T> set) {
        if (this.rootNodes.isEmpty() || set == null || set.isEmpty()) {
            return null;
        }
        return firstSubset(set, this.rootNodes);
    }
1346929
public static <T> Set<T> newSet(T...contents)
	{
		Set<T> set;

		if(contents == null || contents.length==0)
			return newSet();
		set = newSet(contents.length);
		Collections.addAll(set, contents);
		return set;
	}
46951
private void startAnimation() {
        initAnimation();
        sAnimations.get().add(this);
        if (mStartDelay > 0 && mListeners != null) {
            // Listeners were already notified in start() if startDelay is 0; this is
            // just for delayed animations
            ArrayList<AnimatorListener> tmpListeners =
                    (ArrayList<AnimatorListener>) mListeners.clone();
            int numListeners = tmpListeners.size();
            for (int i = 0; i < numListeners; ++i) {
                tmpListeners.get(i).onAnimationStart(this);
            }
        }
    }
384305
public Set entrySet()
    {
        if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
            trace.entry(this, cclass,
                        "entrySet");

        EntrySet entrySet = new EntrySet();

        if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
            trace.exit(this, cclass,
                       "entrySet",
                       new Object[] { entrySet });
        return entrySet;
    }
918026
public static int fromModifierSet(Set<Modifier> set) {
    int modifiers = 0;
    if (set.contains(Modifier.PUBLIC)) {
      modifiers |= java.lang.reflect.Modifier.PUBLIC;
    }
    if (set.contains(Modifier.PRIVATE)) {
      modifiers |= java.lang.reflect.Modifier.PRIVATE;
    }
    if (set.contains(Modifier.PROTECTED)) {
      modifiers |= java.lang.reflect.Modifier.PROTECTED;
    }
    if (set.contains(Modifier.STATIC)) {
      modifiers |= java.lang.reflect.Modifier.STATIC;
    }
    if (set.contains(Modifier.FINAL)) {
      modifiers |= java.lang.reflect.Modifier.FINAL;
    }
    if (set.contains(Modifier.SYNCHRONIZED)) {
      modifiers |= java.lang.reflect.Modifier.SYNCHRONIZED;
    }
    if (set.contains(Modifier.VOLATILE)) {
      modifiers |= java.lang.reflect.Modifier.VOLATILE;
    }
    if (set.contains(Modifier.TRANSIENT)) {
      modifiers |= java.lang.reflect.Modifier.TRANSIENT;
    }
    if (set.contains(Modifier.NATIVE)) {
      modifiers |= java.lang.reflect.Modifier.NATIVE;
    }
    if (set.contains(Modifier.ABSTRACT)) {
      modifiers |= java.lang.reflect.Modifier.ABSTRACT;
    }
    if (set.contains(Modifier.STRICTFP)) {
      modifiers |= java.lang.reflect.Modifier.STRICT;
    }
    return modifiers;
  }
1020470
public static <T extends MethodDescription> ElementMatcher.Junction<T> isSetter() {
        return nameStartsWith("set").and(takesArguments(1)).and(returns(TypeDescription.VOID));
    }
539928
public void setOfferingSet(java.util.Collection<HostOffering> offeringSet) {
        if (offeringSet == null) {
            this.offeringSet = null;
            return;
        }

        this.offeringSet = new com.amazonaws.internal.SdkInternalList<HostOffering>(offeringSet);
    }
496563
public static <L, K> void addListener (Map<K, ListenerList<L>> map, K key, L listener)
    {
        ListenerList<L> list = map.get(key);
        if (list == null) {
            map.put(key, list = new ListenerList<L>());
        }
        list.add(listener);
    }
461684
public ExpiringSet<T> buildSet() {
		Set<T> target = (Set<T>) (handleExistEls ? Sets.<T>newHashSet() :
				(elements instanceof Set ? elements : Sets.newHashSet(elements)));
		
		ExpiringSet<T> expiringSet = new ExpirationSet<T>(target, ticker.or(systemTicker()),
				defaultExpireTime.orNull(), defaultExpireUnit.orNull());
		
		if (handleExistEls) {
			expiringSet.addAll(elements);
		}
		
		return expiringSet;
	}
404252
@NonNull
    public IconicsAnimationProcessor addListener(@NonNull IconicsAnimationListener listener) {
        if (mListeners == null) {
            mListeners = new ArrayList<>();
            mAnimator.addListener(mProxyListener);
        }
        mListeners.add(listener);
        return this;
    }
175095
public void setListenerArns(java.util.Collection<String> listenerArns) {
        if (listenerArns == null) {
            this.listenerArns = null;
            return;
        }

        this.listenerArns = new java.util.ArrayList<String>(listenerArns);
    }
1006763
public void setAttachmentSet(java.util.Collection<AttachmentDetails> attachmentSet) {
        if (attachmentSet == null) {
            this.attachmentSet = null;
            return;
        }

        this.attachmentSet = new com.amazonaws.internal.SdkInternalList<AttachmentDetails>(attachmentSet);
    }
1328810
public void setListeners(final List listeners) {
        // early type check, and avoid aliassing
        this.preListeners = new ArrayList<IReloadablePropertiesListener>();
        for (Object o : listeners) {
            preListeners.add((IReloadablePropertiesListener) o);
        }
    }
1043847
public static <E, S extends SortedSet<E>> SynchronizedSortedSet<E> of(S set)
    {
        return new SynchronizedSortedSet<E>(SortedSetAdapter.adapt(set));
    }
1040012
public Set<String> keySet(){
		HashSet<String> set=new HashSet<String>();
		Iterator<String> keys=keys();
		while(keys.hasNext()){
			set.add(keys.next());
		}
		return set;
	}