Returns true if the given layout matches this one. Layout ID,
generation, and creation info is not considered in the comparison.
175111
public boolean equalLayouts(Layout layout) throws FetchException {
        if (this == layout) {
            return true;
        }
        return getStorableTypeName().equals(layout.getStorableTypeName())
            && getAllProperties().equals(layout.getAllProperties())
            && Arrays.equals(mStoredLayout.getExtraData(), layout.mStoredLayout.getExtraData());
    }
733028
public boolean matches(long minWidth, long minHeight, long maxWidth, long maxHeight, double ratio) {
    if (minWidth > 0 && getWidth() < minWidth) {
      return false;
    }
    if (minHeight > 0 && getHeight() < minHeight) {
      return false;
    }
    if (maxWidth > 0 && getWidth() > maxWidth) {
      return false;
    }
    if (maxHeight > 0 && getHeight() > maxHeight) {
      return false;
    }
    if (ratio > 0) {
      double renditionRatio = (double)getWidth() / (double)getHeight();
      if (!Ratio.matches(renditionRatio, ratio)) {
        return false;
      }
    }
    return true;
  }
1232715
public boolean isMatched(String value)
    {
        if (value == null)
            return false;
        if ((_match != null)) {
            for (int i = 0; i < _match.length; i++) {
                if (value.equals(_match[i]))
                    return true;
            }
        }
        else {
            if (_defaultSelections != null) {
                return (_defaultSelections.contains(value));
            }
        }

        return false;

    }
20769
def contains?(child)
      children.any? { |c|
        (c.kind_of?(Layout) && c.contains?(child)) || c == child
      }
    end
1313282
private boolean isSimilarSignature(Method possiblyMatchingMethod, String desiredMethodName, Class<?>[] desiredParamTypes) {
        return possiblyMatchingMethod.getName().equals(desiredMethodName) && match(possiblyMatchingMethod.getParameterTypes(), desiredParamTypes);
    }
1253812
public boolean matches(LinkedList<Node> nodePath) {
        if(simplePattern) {
            // simple pattern
            return items.get(0).matches(nodePath.getLast());
        }
        // match the full pattern
        if(items.size() != nodePath.size()) {
            // different size
            return false;
        }
        for(int i=0; i<items.size(); i++) {
            if (! items.get(i).matches(nodePath.get(i))) {
                // failed a comparison
                return false;
            }
        }
        // pass all comparisons
        return true;
    }
372902
def should_build(self, fpath, meta):
        
        if meta.get('layout', self.default_template) in self.inc_layout:
            if self.prev_mtime.get(fpath, 0) == os.path.getmtime(fpath):
                return False
            else:
                return True
        return True
581965
public boolean matchesSystemAndCode(BaseCodingDt theCoding) {
		if (theCoding == null) {
			return false;
		}
		return getCodeElement().equals(theCoding.getCodeElement()) && getSystemElement().equals(theCoding.getSystemElement());
	}
505234
private boolean isViewLeftAligned(ViewGroup.MarginLayoutParams layoutParams) {
		final int left =  getView().getLeft();
		boolean viewLeftAligned = left == 0 || left == layoutParams.leftMargin;
		LOGGER.trace("View is {} aligned", viewLeftAligned ? "LEFT" : "RIGHT");
		return viewLeftAligned;
	}
764612
private boolean matchView(String actualView, String declaredView) {

        if (CmsStringUtil.isEmptyOrWhitespaceOnly(declaredView) || CmsStringUtil.isEmptyOrWhitespaceOnly(actualView)) {
            return true;
        }
        return CmsStringUtil.splitAsList(declaredView, "|").contains(actualView);

    }
1089858
private boolean matchesField(Format.Field attribute, int field) {
        if (this.attribute != null) {
            return this.attribute.equals(attribute);
        }
        return (field == this.field);
    }
760119
public Layout getGeneration(int generation) throws FetchNoneException, FetchException {
        try {
            Storage<StoredLayoutEquivalence> equivStorage =
                mLayoutFactory.mRepository.storageFor(StoredLayoutEquivalence.class);
            StoredLayoutEquivalence equiv = equivStorage.prepare();
            equiv.setStorableTypeName(getStorableTypeName());
            equiv.setGeneration(generation);
            if (equiv.tryLoad()) {
                generation = equiv.getMatchedGeneration();
            }
        } catch (RepositoryException e) {
            throw e.toFetchException();
        }

        return new Layout(mLayoutFactory, getStoredLayoutByGeneration(generation));
    }
195777
private boolean checkMatch() {
        if (matchList == null) {
            return true;
        }
        final int matchSize = matchList.size();
        final int ancestorSize = topicIdList.size();
        final List<String> tail = topicIdList.subList(ancestorSize - matchSize, ancestorSize);
        return matchList.equals(tail);
    }
798523
public boolean match( VersionID vid )
    {
        if ( _isCompound )
        {
            if ( !_rest.match( vid ) )
            {
                return false;
            }
        }
        return ( _usePrefixMatch )
                ? this.isPrefixMatch( vid )
                : ( _useGreaterThan ) ? vid.isGreaterThanOrEqual( this ) : matchTuple( vid );
    }
23255
def unregister_layout(self, name):
        

        if not name in self:
            raise umbra.exceptions.LayoutRegistrationError("{0} | '{1}' layout is not registered!".format(
                self.__class__.__name__, name))

        del (self.__layouts[name])
        return True
106908
@Override
    public void cloneLayout(LayoutIdentifier layout, LayoutIdentifier layout2) {
        String text = getLayoutContent(layout);
        saveLayout(layout2, text);
    }
816046
private boolean equalsSimpleTypeNames(MethodIdentifier identifier, MethodResult methodResult) {
        MethodIdentifier originalIdentifier = methodResult.getOriginalMethodSignature();

        return originalIdentifier.getMethodName().equals(identifier.getMethodName()) &&
                matchesTypeBestEffort(originalIdentifier.getReturnType(), identifier.getReturnType()) &&
                parameterMatch(originalIdentifier.getParameters(), identifier.getParameters());
    }