Member components if this component is composite.
193892
def members(self):
        ''''''
        with self._mutex:
            if not self._members:
                self._members = {}
                for o in self.organisations:
                    # TODO: Search for these in the tree
                    self._members[o.org_id] = o.obj.get_members()
        return self._members
1012882
protected boolean isContained(T instance) {
		for(T ref : registry) {
			if(areEqual(instance, ref)) {
				return true;
			}
		}
		return false;
	}
1325826
public void setComposite(Composite comp) {
        
		if (comp instanceof AlphaComposite) {

			AlphaComposite composite = (AlphaComposite) comp;

			if (composite.getRule() == 3) {

				alpha = composite.getAlpha();
				this.composite = composite;

				if (realPaint != null && (realPaint instanceof Color)) {

					Color c = (Color) realPaint;
					paint = new Color(c.getRed(), c.getGreen(), c.getBlue(),
							(int) (c.getAlpha() * alpha));
				}
				return;
			}
		}

		this.composite = comp;
		alpha = 1.0F;

    }
248090
private void addComponent(final WComponent component) {
		collapsibleList.add(component);
		MemoryUtil.checkSize(collapsibleList.size(), this.getClass().getSimpleName());
	}
655782
public static boolean isAtLeastOneChildComponentVisible(Container component) {
        for (Component comp : component.getComponents()) {
            if (comp.isVisible()) {
                return true;
            }
        }
        return false;
    }
1307044
private void consolidateIfNeeded() {
        // Consolidate if the number of components will exceed the allowed maximum by the current
        // operation.
        int size = componentCount;
        if (size > maxNumComponents) {
            final int capacity = components[size - 1].endOffset;

            ByteBuf consolidated = allocBuffer(capacity);
            lastAccessed = null;

            // We're not using foreach to avoid creating an iterator.
            for (int i = 0; i < size; i ++) {
                components[i].transferTo(consolidated);
            }

            components[0] = new Component(consolidated, 0, 0, capacity, consolidated);
            removeCompRange(1, size);
        }
    }
62555
public <T> List<T> getComponentInstancesOfType(Class<T> componentType)
   {
      return container.getComponentInstancesOfType(componentType);
   }
246090
function(component, components) {
        var deps, depsName, depsConfig;
        if (Type.assert(Type.STRING, component.name)) {
            deps = this.getDependency(component.name);
            if (Type.isArray(deps)) {
                while (true) {
                    depsName = deps.shift();
                    if (!depsName) {
                        break;
                    }
                    if (!this.has(depsName)) {
                        if (!!components) {
                            depsConfig = this.find(depsName, components);
                            if (depsConfig) {
                                this.set(depsName, depsConfig);
                                break;
                            }
                        }
                        this.set(depsName, {});
                    }
                }
            }
        }
    }
1292079
public static boolean isModal(Component component) {
	synchronized (modals) {
	  Iterator<Entry<RootPaneContainer, Modal>> it =
		  modals.entrySet().iterator();
	  while (it.hasNext()) {
		Entry<RootPaneContainer, Modal> entry = it.next();
		if (entry.getValue().components.contains(component)) {
		  return true;
		}
	  }
	  return false;
	}
  }
798916
private static boolean lenientIsInstance(Class<?> expectedClass, Object value) {
    if (expectedClass.isArray()) {
      Class<?> componentType = expectedClass.getComponentType();
      if (!(value instanceof Object[])) {
        return false;
      }
      for (Object element : (Object[]) value) {
        if (!lenientIsInstance(componentType, element)) return false;
      }
      return true;
    } else if (expectedClass == Class.class) {
      return value instanceof TypeMirror;
    } else {
      return expectedClass == value.getClass();
    }
  }
830789
private static boolean checkCollectionMembers(Collection<?> c, Class<?> type) {
        for (Object element : c) {
            if (element != null && !type.isInstance(element)) {
                return false;
            }
        }
        return true;
    }
82194
function isComponentWillChange(oldValue, newValue) {
    const oldType = getObjectType(oldValue);
    const newType = getObjectType(newValue);
    return ((oldType === 'Function' || newType === 'Function') && newType !== oldType);
}
873635
private static boolean hasBrackets(Sgroup sgroup) {
        switch (sgroup.getType()) {
            case CtabStructureRepeatUnit:
            case CtabAnyPolymer:
            case CtabCrossLink:
            case CtabComponent:
            case CtabMixture:
            case CtabFormulation:
            case CtabGraft:
            case CtabModified:
            case CtabMonomer:
            case CtabCopolymer:
            case CtabMultipleGroup:
                return true;
            case CtabGeneric:
                List<SgroupBracket> brackets = sgroup.getValue(SgroupKey.CtabBracket);
                return brackets != null && !brackets.isEmpty();
            default:
                return false;
        }
    }
1017982
protected final void buildAny(Component component, BuilderT builder, Context context)
    {
        if (component instanceof ResolvedMacro)
        {
            buildResolved((ResolvedMacro)component, builder, context);
        }
        else if (component instanceof UnresolvableMacro)
        {
            buildUnresolvable((UnresolvableMacro)component, builder, context);
        }
        else if (component instanceof TextComponent)
        {
            buildText((TextComponent)component, builder, context);
        }
        else if (component instanceof ComponentGroup)
        {
            buildGroup((ComponentGroup)component, builder, context);
        }
        else
        {
            buildOther(component, builder, context);
        }
    }
989809
protected Member getMember(PageContext pc, Collection.Key key, boolean dataMember, boolean superAccess) {
	// check super
	if (dataMember && key.equalsIgnoreCase(KeyConstants._super) && isPrivate(pc)) {
	    Component ac = ComponentUtil.getActiveComponent(pc, this);
	    return SuperComponent.superMember((ComponentImpl) ac.getBaseComponent());
	}
	if (superAccess) return _udfs.get(key);

	// check data
	Member member = _data.get(key);
	if (isAccessible(pc, member)) return member;
	return null;
    }
1297156
private boolean hasNonComplexMember(Complex cx) {
		for (PhysicalEntity mem : cx.getComponent()) {
			if (!(mem instanceof Complex) || hasNonComplexMember((Complex) mem)) {
				return true;
			}
		}
		return false;
	}
233705
@GwtIncompatible("incompatible method")
    private static boolean arrayMemberEquals(final Class<?> componentType, final Object o1, final Object o2) {
        if (componentType.isAnnotation()) {
            return annotationArrayMemberEquals((Annotation[]) o1, (Annotation[]) o2);
        }
        if (componentType.equals(Byte.TYPE)) {
            return Arrays.equals((byte[]) o1, (byte[]) o2);
        }
        if (componentType.equals(Short.TYPE)) {
            return Arrays.equals((short[]) o1, (short[]) o2);
        }
        if (componentType.equals(Integer.TYPE)) {
            return Arrays.equals((int[]) o1, (int[]) o2);
        }
        if (componentType.equals(Character.TYPE)) {
            return Arrays.equals((char[]) o1, (char[]) o2);
        }
        if (componentType.equals(Long.TYPE)) {
            return Arrays.equals((long[]) o1, (long[]) o2);
        }
        if (componentType.equals(Float.TYPE)) {
            return Arrays.equals((float[]) o1, (float[]) o2);
        }
        if (componentType.equals(Double.TYPE)) {
            return Arrays.equals((double[]) o1, (double[]) o2);
        }
        if (componentType.equals(Boolean.TYPE)) {
            return Arrays.equals((boolean[]) o1, (boolean[]) o2);
        }
        return Arrays.equals((Object[]) o1, (Object[]) o2);
    }