Checks if it is new group.

@param currentOptGroup
the current opt group
@return true, if is new group
969547
private boolean isNewGroup(final OptGroup currentOptGroup)
	{
		return (last == null) || !currentOptGroup.getLabel().equals(last.getLabel());
	}
998271
protected boolean hasPlusMinusOneValues(StatementGroup statementGroup) {
		if (statementGroup == null) {
			return false;
		}
		for (Statement s : statementGroup) {
			QuantityValue qv = (QuantityValue) s.getValue();
			if (qv != null && isPlusMinusOneValue(qv)) {
				return true;
			}
		}
		return false;
	}
227991
public function inAllowedGroup()
    {
        if ($this->isCurrentUser() || (! $this->isStaff())) {
            // Always allow editing of non-staff user
            // for the time being
            return true;
        }

        $group  = $this->getGroupId();
        $groups = $this->util->getDbLookup()->getActiveStaffGroups();
        if (! isset($groups[$group])) {
            // Allow editing when the group does not exist or is no longer active.
            return true;
        }

        $allowedGroups = $this->userLoader->getCurrentUser()->getAllowedStaffGroups();
        if ($allowedGroups) {
            return (boolean) isset($allowedGroups[$group]);
        } else {
            return false;
        }
    }
758070
public static void compareGroup(ProviderGroup oldGroup, ProviderGroup newGroup,
                                    List<ProviderInfo> add, List<ProviderInfo> remove) {
        compareProviders(oldGroup.getProviderInfos(), newGroup.getProviderInfos(), add, remove);
    }
880328
public boolean isGroupGuests(String groupName) {

        if (CmsStringUtil.isEmptyOrWhitespaceOnly(groupName)) {
            return false;
        }
        return m_groupGuests.equals(groupName) || groupName.endsWith(CmsOrganizationalUnit.SEPARATOR + m_groupGuests);
    }
1232692
protected void setGroups(List<CmsPublishGroup> groups, boolean newData) {

        m_model = new CmsPublishDataModel(groups, this);
        m_model.setSelectionChangeAction(new Runnable() {

            public void run() {

                onChangePublishSelection();
            }
        });
        m_currentGroupIndex = 0;
        m_currentGroupPanel = null;
        m_problemsPanel.clear();
        if (newData) {
            m_showProblemsOnly = false;
            m_checkboxProblems.setChecked(false);
            m_checkboxProblems.setVisible(false);
            m_problemsPanel.setVisible(false);
        }
        m_groupPanels.clear();
        m_groupPanelContainer.clear();
        m_scrollPanel.onResizeDescendant();
        enableActions(false);

        int numGroups = groups.size();
        setResourcesVisible(numGroups > 0);

        if (numGroups == 0) {
            return;
        }
        enableActions(true);
        addMoreListItems();
        showProblemCount(m_model.countProblems());
    }
497858
@Override
	public boolean isPrevGoupNotEq(String actualGroup) {
		if (LOGGER.isTraceEnabled()) LOGGER.trace(String.format("check group prev: %s, act: %s", this.prevGroup, actualGroup));
		return StringUtils.isEmpty(this.prevGroup) || !actualGroup.equals(this.prevGroup);
	}
577583
public ElementWithOptions addOptionGroup(OptionGroup optionGroup) {
        if (optionGroup == null) {
            throw new IllegalArgumentException("Group cannot be null");
        }

        String groupId = optionGroup.getId();
        if (optionGroups.containsKey(groupId)) {
            throw new IllegalArgumentException("The group id '" + groupId + "' already present in this element");
        }

        Set<String> groupValues = optionGroup.getOptionValues();
        for (String groupValue : groupValues) {
            if (this.hasValue(groupValue)) {
                throw new IllegalArgumentException("The value '" + groupValue + "' is already present in this element");
            }
        }

        optionGroups.put(groupId, optionGroup);
        return this;
    }
505168
function Group(config) {
  if (!(this instanceof Group)) {
    return new Group(config);
  }

  Base.call(this, config);
  this.is('Group');
  this.use(utils.option());
  this.use(utils.plugin());
  this.init();
}
909466
def is_in_groups? *groups
      groups = groups.flat_uniq
      groups.all? {|group| is_in_group? group}
    end
64069
public boolean hasGroupsInOtherOus() {

        if (m_hasGroupsInOtherOus == null) {
            // lazzy initialization
            m_hasGroupsInOtherOus = Boolean.FALSE;
            try {
                List<CmsGroup> groups = getGroups(true);
                Iterator<CmsGroup> itGroups = groups.iterator();
                while (itGroups.hasNext()) {
                    CmsGroup group = itGroups.next();
                    if (!group.getOuFqn().equals(getParamOufqn())) {
                        m_hasGroupsInOtherOus = Boolean.TRUE;
                        break;
                    }
                }
            } catch (Exception e) {
                // ignore
            }
        }
        return m_hasGroupsInOtherOus.booleanValue();
    }
1156407
public void setOptionGroupsList(java.util.Collection<OptionGroup> optionGroupsList) {
        if (optionGroupsList == null) {
            this.optionGroupsList = null;
            return;
        }

        this.optionGroupsList = new com.amazonaws.internal.SdkInternalList<OptionGroup>(optionGroupsList);
    }
541745
public void setCurrentGroup(int groupId){
        if(mCurrentGroup != groupId){
            int oldGroupId = mCurrentGroup;
            mCurrentGroup = groupId;
            mGroupChanged = true;
            dispatchOnToolbarGroupChanged(oldGroupId, mCurrentGroup);
            animateOut();
        }
    }
911171
public boolean isGroupEnd()
    {
        if (getValue() == null || isCommand() || getValue().length() != 1)
            return false;
        return getValue().charAt(0) == ')' || getValue().charAt(0) == ']';
    }
1273210
private void checkGroup(Entry<Point, Set<Collidable>> current)
    {
        final Set<Collidable> elements = current.getValue();
        for (final Collidable objectA : elements)
        {
            checkOthers(objectA, current);
        }
    }
889194
public GroupsType<ConstraintType<T>> getOrCreateGroups()
   {
      Node node = childNode.getOrCreate("groups");
      GroupsType<ConstraintType<T>> groups = new GroupsTypeImpl<ConstraintType<T>>(this, "groups", childNode, node);
      return groups;
   }
116077
function(bottomGroup) {
		var selectedGroups = [];
		this.selectedGroups = selectedGroups;
	
		var display = this.display;
		display.groupSelect.innerHTML = "";
		var selectedGroup = this.selectedGroup;
	
		WireIt.GroupUtils.getOuterGroup(bottomGroup, function(current) {
			var option = WireIt.cn("option", {value: "N" + selectedGroups.length}, {}, "N" + selectedGroups.length);
			selectedGroups.push(current);
		
			display.groupSelect.appendChild(option);
		
			if (selectedGroup == current)
		    	option.selected = true;
	    	}
	    );
   }