Get required elements that were not found.

@return required elements that were not found.
176644
String getRequiredElem()
  {
		if (m_requiredFound == null)
			return null;
		Enumeration elems = m_requiredFound.elements();
		String s = "";
		boolean first = true;
		while (elems.hasMoreElements())
		{
			if (first)
				first = false;
			else
			 s = s + ", ";
			s = s + (String)elems.nextElement();
		}
    return s;
  }
77809
@Requires("element != null")
  @Ensures("result != null")
  @SuppressWarnings("unchecked")
  protected Set<String> getImportNames(Element element) {
    if (JavaUtils.classExists("com.sun.source.util.Trees")) {
      try {
        return (Set<String>) Class
            .forName("com.google.java.contract.core.apt.JavacUtils")
            .getMethod("getImportNames", ProcessingEnvironment.class,
                       Element.class)
            .invoke(null, utils.processingEnv, element);
      } catch (Exception e) {
        return Collections.emptySet();
      }
    } else {
      return Collections.emptySet();
    }
  }
834286
public function listMissingMethod()
    {
        if (!is_null($this->listMissingMethod)) return $this->listMissingMethod;

        $required = $this->listRequiredMethod();
        $missing = array();

        foreach ($required as $methodName => $data) {
            if (!$this->reflection->hasMethod($methodName)) {
                $missing[$methodName] = $data;
            }
        }

        $this->listMissingMethod = $missing;

        return $missing;
    }
1369824
public @Nullable
    List<ComapiValidationFailure> getValidationFailures() {
        if (errorBody != null && !errorBody.isEmpty()) {
            ComapiValidationFailures failures = null;
            try {
                failures = new Parser().parse(errorBody, ComapiValidationFailures.class);
            } catch (Exception e) {
                return null;
            }
            return failures.validationFailures;
        }

        return null;
    }
340402
public List<IfClassNotAvailable<Exclude<T>>> getAllIfClassNotAvailable()
   {
      List<IfClassNotAvailable<Exclude<T>>> list = new ArrayList<IfClassNotAvailable<Exclude<T>>>();
      List<Node> nodeList = childNode.get("if-class-not-available");
      for(Node node: nodeList)
      {
         IfClassNotAvailable<Exclude<T>>  type = new IfClassNotAvailableImpl<Exclude<T>>(this, "if-class-not-available", childNode, node);
         list.add(type);
      }
      return list;
   }
159231
public List<CmsContainerElementBean> getElements() {

        if (m_elements == null) {
            m_elements = new ArrayList<CmsContainerElementBean>();
            for (CmsContainerBean container : m_containers.values()) {
                m_elements.addAll(container.getElements());
            }
        }
        return m_elements;
    }
1081953
def get_missing_required_annotations(self) -> List[str]:
        """"""
        return [
            required_annotation
            for required_annotation in self.required_annotations
            if required_annotation not in self.annotations
        ]
812617
public ArrayList<Integer> getUnvisited() {
    if (0 == this.unvisitedCount) {
      return new ArrayList<Integer>();
    }
    ArrayList<Integer> res = new ArrayList<Integer>(this.unvisitedCount);
    for (int i = 0; i < this.registry.length; i++) {
      if (ZERO == this.registry[i]) {
        res.add(i);
      }
    }
    return res;
  }
562652
public static XMLStreamException missingRequired(final XMLStreamReader reader, final Set<?> required) {
        final StringBuilder b = new StringBuilder();
        Iterator<?> iterator = required.iterator();
        while (iterator.hasNext()) {
            final Object o = iterator.next();
            b.append(o.toString());
            if (iterator.hasNext()) {
                b.append(", ");
            }
        }
        return new XMLStreamException("Missing required attribute(s): " + b, reader.getLocation());
    }
551025
function() {
      return elementArrayFinder.getWebElements().then(function(webElements) {
        if (webElements.length === 0) {
          throw new webdriver.error.Error(
              webdriver.error.ErrorCode.NO_SUCH_ELEMENT,
              'No element found using locator: ' +
                  elementArrayFinder.locator_.toString());
        } else {
          if (webElements.length > 1) {
            console.log('warning: more than one element found for locator ' +
                elementArrayFinder.locator_.toString() +
                ' - you may need to be more specific');
          }
          return [webElements[0]];
        }
      });
    }
898068
public Set<ElementDescriptor<?>> getProperties()
	{
		return mProp == null ? null : Collections.unmodifiableSet(mProp.keySet());
	}
440374
public List<?> getNotSelected() {
		List options = getOptions();
		if (options == null || options.isEmpty()) {
			return Collections.EMPTY_LIST;
		}

		List notSelected = new ArrayList(options);
		notSelected.removeAll(getSelected());
		return Collections.unmodifiableList(notSelected);
	}
1127989
public function findMissingDependencies()
    {
        $missing = [];

        foreach ($this->plugins as $id => $plugin) {
            if (!$required = $this->getDependencies($plugin)) {
                continue;
            }

            foreach ($required as $require) {
                if ($this->hasPlugin($require)) {
                    continue;
                }

                if (!in_array($require, $missing)) {
                    $missing[] = $require;
                }
            }
        }

        return $missing;
    }
910511
@Override
	public List<String> getExcludes() throws BadRequestException {
		final String sourceMethod = "getExcludes"; //$NON-NLS-1$
		if (isTraceLogging) {
			log.entering(RequestedModuleNames.class.getName(), sourceMethod);
		}
		List<String> result = excludes;
		List<String> encodedExcludes = getExcludesEncoded();
		if (!encodedExcludes.isEmpty()) {
			result = encodedExcludes;
		if (isTraceLogging);
			log.exiting(RequestedModuleNames.class.getName(), sourceMethod, result);
		}
		return result;
	}
1306831
protected Set<?> getPrevRenderedRows() {
		Set<?> keys = getComponentModel().prevRenderedRows;
		if (keys == null) {
			return Collections.emptySet();
		} else {
			return Collections.unmodifiableSet(keys);
		}
	}
423521
def get_requires(self, ignored=tuple()):
        

        if self._requires is None:
            self._requires = set(self._get_requires())

        requires = self._requires
        return [req for req in requires if not fnmatches(req, *ignored)]
705550
public static XMLStreamException missingRequired(final XMLExtendedStreamReader reader, final String... required) {
        final StringBuilder b = new StringBuilder();
        for (int i = 0; i < required.length; i++) {
            final String o = required[i];
            b.append(o);
            if (required.length > i + 1) {
                b.append(", ");
            }
        }

        return wrapMissingRequiredAttribute(ControllerLogger.ROOT_LOGGER.missingRequiredAttributes(b, reader.getLocation()),
                                            reader, new HashSet<>(Arrays.asList(required)));
    }