Checks if a divider drawable has been defined in the current theme. If it has, will apply
an item decoration with the divider. If no divider has been specified, then does nothing.
344553
protected void configureItemDecoration(@NonNull LayoutInflater inflater,
                                           @NonNull RecyclerView recyclerView) {
        final TypedArray attributes =
                getActivity().obtainStyledAttributes(new int[]{R.attr.nnf_list_item_divider});
        Drawable divider = attributes.getDrawable(0);
        attributes.recycle();

        if (divider != null) {
            recyclerView.addItemDecoration(new DividerItemDecoration(divider));
        }
    }
1091974
public void applyTo(Context ctx, GradientDrawable drawable) {
        if (mColorInt != 0) {
            drawable.setColor(mColorInt);
        } else if (mColorRes != -1) {
            drawable.setColor(ContextCompat.getColor(ctx, mColorRes));
        }
    }
1071889
public void setFooterDivider(Drawable drawable) {
        mFooterDivider = drawable;
        if (drawable != null) {
            mFooterDividerHeight = drawable.getIntrinsicHeight();
        } else {
            mFooterDividerHeight = 0;
        }
        mContentView.setWillNotDraw(drawable == null);
        mContentView.invalidate();
    }
390080
def match(self, item):
        
        if not self._unused_matchers:
            raise RuntimeError('Matcher exhausted, no more matchers to use')

        for matcher in self._unused_matchers:
            if matcher(item):
                self._used_matchers.append(matcher)
                break

        if not self._unused_matchers:
            # All patterns have been matched
            return True

        return False
663205
public static Divider getDivider(@ColorInt int color) {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
            return new Api21ItemDivider(color);
        }
        return new Api20ItemDivider(color);
    }
219548
@NonNull
    private Divider addDivider() {
        Divider divider = new Divider(getContext());
        divider.setVisibility(View.INVISIBLE);
        divider.setBackgroundColor(dividerColor);
        LayoutParams layoutParams =
                new LayoutParams(LayoutParams.MATCH_PARENT, dpToPixels(getContext(), 1));
        layoutParams.leftMargin = dividerMargin;
        layoutParams.rightMargin = dividerMargin;
        addView(divider, layoutParams);
        return divider;
    }
542147
private void defineSeparators(UIDefaults d) {
        String c = PAINTER_PREFIX + "SeparatorPainter";
        d.put("Separator.contentMargins", new InsetsUIResource(0, 0, 0, 0));
        d.put("Separator[Enabled].backgroundPainter", new LazyPainter(c, SeparatorPainter.Which.BACKGROUND_ENABLED));
    }
1114185
public boolean hasNext() {

        if (items != null) {
            if (items.hasNext()) {
                return (true);
            } else {
                items = null;
            }
        }
        Object next = findNextValidChild();
        while (next != null) {
            initializeItems(next);
            if (items != null) {
                return true;
            } else {
                next = findNextValidChild();
            }
        }
        return false;

    }
543594
public void select(final boolean considerSelectableFlag) {
        mFastAdapter.recursive(new AdapterPredicate<Item>() {
            @Override
            public boolean apply(@NonNull IAdapter<Item> lastParentAdapter, int lastParentPosition, Item item, int position) {
                select(lastParentAdapter, item, -1, false, considerSelectableFlag);
                return false;
            }
        }, false);
        mFastAdapter.notifyDataSetChanged();
    }
1170694
function( splitter ) {
		var items = this._getItemsForSplitter( splitter ),
			minSize = this.layoutManager.config.dimensions[ this._isColumn ? 'minItemHeight' : 'minItemWidth' ];

		var beforeMinDim = this._getMinimumDimensions( items.before.config.content );
		var beforeMinSize = this._isColumn ? beforeMinDim.vertical : beforeMinDim.horizontal;

		var afterMinDim = this._getMinimumDimensions( items.after.config.content );
		var afterMinSize = this._isColumn ? afterMinDim.vertical : afterMinDim.horizontal;

		this._splitterPosition = 0;
		this._splitterMinPosition = -1 * ( items.before.element[ this._dimension ]() - (beforeMinSize || minSize) );
		this._splitterMaxPosition = items.after.element[ this._dimension ]() - (afterMinSize || minSize);
	}
823014
public boolean verifyDrawable(Drawable who) {
    for (int i = 0; i < mHolders.size(); ++i) {
      if (who == get(i).getTopLevelDrawable()) {
        return true;
      }
    }
    return false;
  }
495284
public void setIndicatorStyleResource(int selected, int unselected){
        mUserSetSelectedIndicatorResId = selected;
        mUserSetUnSelectedIndicatorResId = unselected;
        if(selected == 0){
            mSelectedDrawable = mSelectedLayerDrawable;
        }else{
            mSelectedDrawable = mContext.getResources().getDrawable(mUserSetSelectedIndicatorResId);
        }
        if(unselected == 0){
            mUnselectedDrawable = mUnSelectedLayerDrawable;
        }else{
            mUnselectedDrawable = mContext.getResources().getDrawable(mUserSetUnSelectedIndicatorResId);
        }

        resetDrawable();
    }
310890
private void checkLayout()
    {
        Dimension dim = getLayoutDimension();
        if (currentDimension == null || !currentDimension.equals(dim)) //the dimension has changed
        {
            createLayout(dim);
            //containing box for the new viewport
            viewport.setContainingBlockBox(owner);
            if (owner instanceof BlockBox)
                viewport.clipByBlock((BlockBox) owner);
            
            owner.removeAllSubBoxes();
            owner.addSubBox(viewport);
            currentDimension = new Dimension(dim);
        }
    }
10849
public final boolean isParentItem(int adapterPosition) {
        int itemCount = 0;

        int parentCount = parentItemCount();
        for (int i = 0; i < parentCount; i++) {
            if (itemCount == adapterPosition) {
                return true;
            }

            itemCount += 1;

            if (isExpanded(i)) {
                itemCount += childItemCount(i);
            } else {
                // itemCount += 1;
            }
        }

        return false;
    }
445378
public boolean isDeleted() {
        boolean deleted = true;
        for (PolylineMarkers polyline : polylineMarkers) {
            deleted = polyline.isDeleted();
            if (!deleted) {
                break;
            }
        }
        return deleted;
    }
1130234
private boolean shouldDividerTitleBeShown() {
        SharedPreferences sharedPreferences =
                PreferenceManager.getDefaultSharedPreferences(getActivity());
        String key = getString(R.string.show_divider_title_preference_key);
        boolean defaultValue =
                getResources().getBoolean(R.bool.show_divider_title_preference_default_value);
        return sharedPreferences.getBoolean(key, defaultValue);
    }
1204567
public final void setDividerColor(@ColorInt final int color) {
        this.seekBarColor = color;

        try {
            Field divider = getClass().getSuperclass().getDeclaredField("mSelectionDivider");
            divider.setAccessible(true);
            divider.set(this, new ColorDrawable(color));
        } catch (NoSuchFieldException | IllegalArgumentException | IllegalAccessException e) {
            Log.w(TAG, "Failed to set divider color", e);
        }
    }