The "start" method as required by Javadoc.

@param root
the root of the documentation tree.
@see com.sun.javadoc.RootDoc
@return true if the doclet ran without encountering any errors.
963918
public static boolean start(RootDoc root) {
		try {
			HtmlDoclet doclet = new HtmlDoclet();
			return doclet.start(doclet, root);
		} finally {
			ConfigurationImpl.reset();
		}
	}
993352
function setAsRootDocument(doc) {
  rootDoc = doc;
  var window = rootDoc.defaultView;
  window.setTimeout = function(code, delay, arguments) {};
  window.setInterval = function(code, delay, arguments) {};
  anychartify(rootDoc);

  return rootDoc
}
745682
protected Map<String,String> buildRoot(HttpServletRequest request,
      XMLOutputter doc) {
    final String path = request.getPathInfo() != null
      ? request.getPathInfo() : "/";
    final String exclude = request.getParameter("exclude") != null
      ? request.getParameter("exclude") : "\\..*\\.crc";
    final String filter = request.getParameter("filter") != null
      ? request.getParameter("filter") : ".*";
    final boolean recur = request.getParameter("recursive") != null
      && "yes".equals(request.getParameter("recursive"));

    Map<String, String> root = new HashMap<String, String>();
    root.put("path", path);
    root.put("recursive", recur ? "yes" : "no");
    root.put("filter", filter);
    root.put("exclude", exclude);
    root.put("time", df.get().format(new Date()));
    root.put("version", VersionInfo.getVersion());
    return root;
  }
1238332
public static boolean start(RootDoc root) {
        // In typical use, options will have been set up by calling validOptions,
        // which will create an HtmlDoclet for use here.
        HtmlDoclet doclet;
        if (docletToStart != null) {
            doclet = docletToStart;
            docletToStart = null;
        } else {
            doclet = new HtmlDoclet();
        }
        return doclet.startDoclet(root);
    }
1023651
public static boolean start(RootDoc root) {
    List<Object> objs = new ArrayList<>();
    for (ClassDoc doc : root.specifiedClasses()) {
      // TODO: Class.forName() expects a binary name but doc.qualifiedName()
      // returns a fully qualified name.  I do not know a good way to convert
      // between these two name formats.  For now, we simply ignore inner
      // classes.  This limitation can be removed when we figure out a better
      // way to go from ClassDoc to Class<?>.
      if (doc.containingClass() != null) {
        continue;
      }

      Class<?> clazz;
      try {
        @SuppressWarnings("signature") // Javadoc source code is not yet annotated
        @BinaryName String className = doc.qualifiedName();
        clazz = Class.forName(className, true, Thread.currentThread().getContextClassLoader());
      } catch (ClassNotFoundException e) {
        e.printStackTrace();
        Options.printClassPath();
        return false;
      }

      if (needsInstantiation(clazz)) {
        try {
          Constructor<?> c = clazz.getDeclaredConstructor();
          c.setAccessible(true);
          objs.add(c.newInstance(new Object[0]));
        } catch (Exception e) {
          e.printStackTrace();
          return false;
        }
      } else {
        objs.add(clazz);
      }
    }

    if (objs.isEmpty()) {
      System.out.println("Error: no classes found");
      return false;
    }

    Object[] objarray = objs.toArray();
    Options options = new Options(objarray);
    if (options.getOptions().size() < 1) {
      System.out.println("Error: no @Option-annotated fields found");
      return false;
    }

    OptionsDoclet o = new OptionsDoclet(root, options);
    o.setOptions(root.options());
    o.processJavadoc();
    try {
      o.write();
    } catch (Exception e) {
      e.printStackTrace();
      return false;
    }

    return true;
  }
65206
public boolean start() {
        if (!this.isTailing.compareAndSet(false, true)) {
            return false;
        }
        final boolean willReadFromEnd = this.willReadFromEnd();
        LogWatchTailingManager.LOGGER.debug("Tailer {} ignore existing file contents.", willReadFromEnd ? "will"
                : "won't");
        this.tailer = new SplitlogTailer(this.watch.getWatchedFile(), new LogWatchTailerListener(this),
                this.delayBetweenReads, this.willReadFromEnd(), this.reopenBetweenReads, this.bufferSize);
        LogWatchTailingManager.EXECUTOR.submit(this.tailer);
        final long start = System.nanoTime();
        this.tailer.waitUntilStarted();
        final long duration = System.nanoTime() - start;
        LogWatchTailingManager.LOGGER.debug("It took {} ms for the tailing to actually start.",
                TimeUnit.NANOSECONDS.toMillis(duration));
        final long iterationNum = this.numberOfTimesThatTailerWasStarted.incrementAndGet();
        LogWatchTailingManager.LOGGER.info("Tailing #{} started for {}.", iterationNum, this.watch);
        return true;
    }
386654
public void setRoot(int root)
  {
    // %OPT% Get this directly from the lpi.
    XPathContext xctxt = wi().getXPathContext();
    m_dtm = xctxt.getDTM(root);
    m_traverser = m_dtm.getAxisTraverser(m_axis);
    m_isFresh = true;
    m_foundLast = false;
    m_root = root;
    m_currentNode = root;

    if (DTM.NULL == root)
    {
      throw new RuntimeException(
        XSLMessages.createXPATHMessage(XPATHErrorResources.ER_SETTING_WALKER_ROOT_TO_NULL, null)); //"\n !!!! Error! Setting the root of a walker to null!!!");
    }

    resetProximityPositions();
  }
443678
public static PropertyDoc[] create(RootDoc root,
                                       MethodDoc[] docs) {

        if (docs == null) {
            return null;
        }

        // Vector of the PropertyDocs to be returned by this method
        Vector propertyDocVector = new Vector();

        // HashMap that maps propertyName to PropertyDoc object.  This is
        // used to ensure that a single PropertyDoc instance contains
        // both the "get" and the "set" MethodDoc (if both exist).
        HashMap propertyMap = new HashMap();

        for (int i = 0; i < docs.length; i++) {

            MethodDoc method = docs[i];

            if (!method.isPublic() ||
                method.isStatic() || method.isExcluded()) {
                continue;
            }

            String methodName = method.getName();
            Parameter[] params = method.getParameters();
            Type returnType = method.getReturnType();
            String typeName = returnType.getQualifiedTypeName();
            if (typeName != null) {
                String dimension = returnType.getDimension();
                if (dimension != null && dimension.length() > 0) {
                    typeName += dimension;
                }
            }

            //
            // Look for JavaBeans naming patterns
            //

            String propertyName = null;
            boolean isReadMethod = true;

            if (params == null || (params.length == 0)) {
                // Accepts no params, might be a "get" method

                if (methodName.startsWith("get") && methodName.length() > 3) {

                    propertyName =
                        Introspector.decapitalize(methodName.substring(3));
                }
                else if (methodName.startsWith("is") &&
                         methodName.length() > 2) {

                    if ("boolean".equalsIgnoreCase(typeName)) {
                        propertyName =
                            Introspector.decapitalize(methodName.substring(2));
                    }
                }
            }
            else if (params != null && (params.length == 1)) {
                // Accepts a single param, might be a "set" method

                if (methodName.startsWith("set") && methodName.length() > 3) {

                    propertyName =
                        Introspector.decapitalize(methodName.substring(3));
                    isReadMethod = false;
                }
            }

            if (propertyName == null) {
                // Was neither a "get" nor a "set"
                continue;
            }

            PropertyDoc pd = (PropertyDoc) propertyMap.get(propertyName);
            if (pd != null) {
                MethodDoc readMethod = pd.getReadMethod();
                if (readMethod == null) {
                    pd.setReadMethod(method);
                }
                else {
                    MethodDoc writeMethod = pd.getWriteMethod();
                    if (writeMethod == null) {
                        pd.setWriteMethod(method);
                    }
                }
            }
            else {
                pd = new PropertyDoc(root, method, isReadMethod);
                pd.setName(propertyName);
                propertyMap.put(propertyName, pd);
                propertyDocVector.addElement(pd);
            }

        }

        PropertyDoc[] propertyDocs = new PropertyDoc[propertyDocVector.size()];
        propertyDocVector.copyInto(propertyDocs);

        return propertyDocs;
    }
173484
public static void addListener(Document doc, Element root) {
    Element listener = doc.createElement("listener");
    Element listenerClass = doc.createElement("listener-class");
    listener.appendChild(listenerClass);
    listenerClass.appendChild(doc
        .createTextNode("org.apache.shiro.web.env.EnvironmentLoaderListener"));

    addRelativeTo(root, listener, "listener", true);
  }
125509
public boolean nextStartElement() throws XMLException, IOException {
		try {
			do {
				next();
			} while (!Type.START_ELEMENT.equals(event.type));
			return true;
		} catch (EOFException e) {
			return false;
		}
	}
213872
public static boolean start(final String configurationFilename) {
        try {
            if (getPm() == null) {
                instance = new PresentationManager(configurationFilename);
            }
            return isActive();
        } catch (Exception ex) {
            instance = null;
            Logger.getRootLogger().fatal("Unable to initialize jPM", ex);
            return false;
        }
    }
394955
public void startElement(String tag, HashMap h)
    {
        if ( !foundRoot ) {
            if (!tag.equals("xfdf")) {
                throw new RuntimeException("Root element is not Bookmark.");
            }
            else { 
            	foundRoot = true;
            }
        }

        if ( tag.equals("xfdf") ){
    		
    	} else if ( tag.equals("f") ) {
    		fileSpec = (String)h.get( "href" );
    	} else if ( tag.equals("fields") ) {
            fields = new HashMap();		// init it!
            listFields = new HashMap();
    	} else if ( tag.equals("field") ) {
    		String	fName = (String) h.get( "name" );
    		fieldNames.push( fName );
    	} else if ( tag.equals("value") ) {
    		fieldValues.push( "" );
    	}
    }
479149
public boolean begin(Class<?> docletClass,
            Iterable<String> options,
            Iterable<? extends JavaFileObject> fileObjects) {
        this.docletClass = docletClass;
        List<String> opts = new ArrayList<>();
        for (String opt: options)
            opts.add(opt);

        return begin(opts, fileObjects).isOK();
    }
1163163
public static void save(CommandLine commandLine, Root root) {
		if (commandLine.hasOption("dryrun")) {
			return;
		}

		FileOutputStream fileOutputStream = null;
		BufferedOutputStream bufferedOutputStream = null;
		try {
			JAXBContext contextObj = JAXBContext.newInstance(Root.class);

			Marshaller marshaller = contextObj.createMarshaller();
			marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
			if (commandLine.hasOption("docencoding")) {
				marshaller.setProperty(Marshaller.JAXB_ENCODING, commandLine.getOptionValue("docencoding"));
			}

			String filename = "javadoc.xml";
			if (commandLine.hasOption("filename")) {
				filename = commandLine.getOptionValue("filename");
			}
			if (commandLine.hasOption("d")) {
				filename = commandLine.getOptionValue("d") + File.separator + filename;
			}

			fileOutputStream = new FileOutputStream(filename);
			bufferedOutputStream = new BufferedOutputStream(fileOutputStream, 1024 * 1024);

			marshaller.marshal(root, bufferedOutputStream);
			bufferedOutputStream.flush();
			fileOutputStream.flush();

		} catch (JAXBException e) {
			log.error(e.getMessage(), e);
		} catch (FileNotFoundException e) {
			log.error(e.getMessage(), e);
		} catch (IOException e) {
			log.error(e.getMessage(), e);
		} finally {
			try {
				if (bufferedOutputStream != null) {
					bufferedOutputStream.close();
				}
				if (fileOutputStream != null) {
					fileOutputStream.close();
				}
			} catch (IOException e) {
				log.error(e.getMessage(), e);
			}
		}
	}
1365315
public boolean start(RootDoc root) {
        Object retVal;
        String methodName = "start";
        Class<?>[] paramTypes = { RootDoc.class };
        Object[] params = { root };
        try {
            retVal = invoke(methodName, null, paramTypes, params);
        } catch (DocletInvokeException exc) {
            return false;
        }
        if (retVal instanceof Boolean) {
            return ((Boolean)retVal);
        } else {
            messager.error(Messager.NOPOS, "main.must_return_boolean",
                           docletClassName, methodName);
            return false;
        }
    }
893703
public boolean validateDocumentRoot(DocumentRoot documentRoot, DiagnosticChain diagnostics, Map<Object, Object> context) {
		return validate_EveryDefaultConstraint(documentRoot, diagnostics, context);
	}
555736
private boolean goToNextStartPosition() throws IOException {
    int basicStartPosition;
    int basicEndPosition;
    if (docId == -1 || docId == NO_MORE_DOCS) {
      throw new IOException("no document");
    } else {
      while ((basicStartPosition = subSpans
          .nextStartPosition()) != NO_MORE_POSITIONS) {
        basicEndPosition = subSpans.endPosition();
        startPosition = Math.max(minPosition,
            (basicStartPosition - query.maximumLeft));
        endPosition = Math.min(maxPosition + 1,
            (basicEndPosition + query.maximumRight));
        if (startPosition <= (basicStartPosition - query.minimumLeft)
            && endPosition >= (basicEndPosition + query.minimumRight)) {
          return true;
        }
      }
      return false;
    }
  }