TODO Update method comments with appropriate information.
962489
private IAtomContainer readCoordinates(IAtomContainer molecule, boolean coordinatesUnits) throws IOException {

        /*
         * Coordinates must all be given in angstr???ms.
         */
        double unitScaling = GamessReader.scalesCoordinatesUnits(coordinatesUnits);

        String retrievedLineFromFile;

        while (this.input.ready() == true) {
            retrievedLineFromFile = this.input.readLine();
            /*
             * A coordinate set is followed by an empty line, so when this line
             * is reached, there are no more coordinates to add to the current
             * set.
             */
            if ((retrievedLineFromFile == null) || (retrievedLineFromFile.trim().length() == 0)) {
                break;
            }

            int atomicNumber;
            String atomicSymbol;

            //StringReader sr = new StringReader(retrievedLineFromFile);
            StreamTokenizer token = new StreamTokenizer(new StringReader(retrievedLineFromFile));

            /*
             * The first token is ignored. It contains the atomic symbol and may
             * be concatenated with a number.
             */
            token.nextToken();

            if (token.nextToken() == StreamTokenizer.TT_NUMBER) {
                atomicNumber = (int) token.nval;
                atomicSymbol = this.identifyAtomicSymbol(atomicNumber);
                /*
                 * Dummy atoms are assumed to be given with an atomic number set
                 * to zero. We will do not add them to the molecule.
                 */
                if (atomicNumber == 0) {
                    continue;
                }
            } else {
                throw new IOException("Error reading coordinates");
            }

            /*
             * Atom's coordinates are stored in an array.
             */
            double[] coordinates = new double[3];
            for (int i = 0; i < coordinates.length; i++) {
                if (token.nextToken() == StreamTokenizer.TT_NUMBER) {
                    coordinates[i] = token.nval * unitScaling;
                } else {
                    throw new IOException("Error reading coordinates");
                }
            }
            IAtom atom = molecule.getBuilder().newInstance(IAtom.class, atomicSymbol,
                    new Point3d(coordinates[0], coordinates[1], coordinates[2]));
            molecule.addAtom(atom);
        }
        return molecule;
    }
601740
def update(self, callback=int):
        """"""
        # print(self._pending_modifications)
        add_var = self._pending_modifications.add_var
        if len(add_var) > 0:
            self._add_variables(add_var)
            self._pending_modifications.add_var = []
        callback()

        add_constr = self._pending_modifications.add_constr
        if len(add_constr) > 0:
            self._add_constraints(add_constr)
            self._pending_modifications.add_constr = []

        add_constr_sloppy = self._pending_modifications.add_constr_sloppy
        if len(add_constr_sloppy) > 0:
            self._add_constraints(add_constr_sloppy, sloppy=True)
            self._pending_modifications.add_constr_sloppy = []

        var_lb = self._pending_modifications.var_lb
        var_ub = self._pending_modifications.var_ub
        if len(var_lb) > 0 or len(var_ub) > 0:
            self._set_variable_bounds_on_problem(var_lb, var_ub)
            self._pending_modifications.var_lb = []
            self._pending_modifications.var_ub = []

        rm_var = self._pending_modifications.rm_var
        if len(rm_var) > 0:
            self._remove_variables(rm_var)
            self._pending_modifications.rm_var = []
        callback()

        rm_constr = self._pending_modifications.rm_constr
        if len(rm_constr) > 0:
            self._remove_constraints(rm_constr)
            self._pending_modifications.rm_constr = []
267774
def _update_submission(self, submission):
        """"""
        submission._comments_by_id[self.name] = self  # pylint: disable=W0212
        self._submission = submission
        if self._replies:
            for reply in self._replies:
                reply._update_submission(submission)
1224112
Comment comment() {
        if (comment == null) {
            String d = documentation();
            if (env.javaScriptScanner != null) {
                env.javaScriptScanner.parse(d, new JavaScriptScanner.Reporter() {
                    @Override
                    public void report() {
                        env.error(DocImpl.this, "javadoc.JavaScript_in_comment");
                        throw new FatalError();
                    }
                });
            }
            if (env.doclint != null
                    && treePath != null
                    && env.shouldCheck(treePath.getCompilationUnit())
                    && d.equals(getCommentText(treePath))) {
                env.doclint.scan(treePath);
            }
            comment = new Comment(this, d);
        }
        return comment;
    }
1274676
def updated(self, user, options):
        
        for comment in self.comments:
            created = dateutil.parser.parse(comment["created"]).date()
            try:
                if (comment["author"]["emailAddress"] == user.email and
                        created >= options.since.date and
                        created < options.until.date):
                    return True
            except KeyError:
                pass
        return False
322140
def annotate_tree_properties(comments):
    
    if not comments:
        return

    it = iter(comments)

    # get the first item, this will fail if no items !
    old = next(it)

    # first item starts a new thread
    old.open = True
    last = set()
    for c in it:
        # if this comment has a parent, store its last child for future reference
        if old.last_child_id:
            last.add(old.last_child_id)

        # this is the last child, mark it
        if c.pk in last:
            c.last = True

        # increase the depth
        if c.depth > old.depth:
            c.open = True

        else:  # c.depth <= old.depth
            # close some depths
            old.close = list(range(old.depth - c.depth))

            # new thread
            if old.root_id != c.root_id:
                # close even the top depth
                old.close.append(len(old.close))
                # and start a new thread
                c.open = True
                # empty the last set
                last = set()
        # iterate
        yield old
        old = c

    old.close = range(old.depth)
    yield old
1047447
private void associateJavadoc(List<Comment> comments, List<Node> nodes) {
		final TreeMap<Integer, Node> startPosMap = Maps.newTreeMap();
		for (Node node : nodes) node.accept(new ForwardingAstVisitor() {
			@Override public boolean visitNode(Node node) {
				if (node.isGenerated()) return false;
				int startPos = node.getPosition().getStart();
				Node current = startPosMap.get(startPos);
				if (current == null || !(current instanceof JavadocContainer)) {
					startPosMap.put(startPos, node);
				}
				
				return false;
			}
		});
		
		for (Comment comment : comments) {
			if (!comment.isJavadoc()) continue;
			Map<Integer, Node> tailMap = startPosMap.tailMap(comment.getPosition().getEnd());
			if (tailMap.isEmpty()) continue;
			Node assoc = tailMap.values().iterator().next();
			if (!(assoc instanceof JavadocContainer)) continue;
			JavadocContainer jc = (JavadocContainer) assoc;
			if (jc.rawJavadoc() != null) {
				if (jc.rawJavadoc().getPosition().getEnd() >= comment.getPosition().getEnd()) continue;
			}
			jc.rawJavadoc(comment);
		}
	}
550599
public void update() {
        embeddedAn = (Embedded) getAnnotation(Embedded.class);
        entityAn = (Entity) getFirstAnnotation(Entity.class);
        // polymorphicAn = (Polymorphic) getAnnotation(Polymorphic.class);
        final List<MappedField> fields = getFieldsAnnotatedWith(Id.class);
        if (fields != null && !fields.isEmpty()) {
            idField = fields.get(0).getField();
        }
    }
407950
def update_views(self):
        """"""
        # Call the father's method
        super(Plugin, self).update_views()

        # Add specifics informations
        # Alert and log
        self.views['used']['decoration'] = self.get_alert_log(self.stats['used'], maximum=self.stats['total'])
        # Optional
        for key in ['active', 'inactive', 'buffers', 'cached']:
            if key in self.stats:
                self.views[key]['optional'] = True
286062
def comment_update(self, comment_id, body):
        
        params = {'comment[body]': body}
        return self._get('comments/{0}.json'.format(comment_id), params, 'PUT',
                         auth=True)
512418
function Comment() {
    this.type = 'func'; //func or attr

    this.descs = [];
    this.attr = {
        name: null
    };
    this.func = {
        name: null,
        params: null
    };

    this.clazz = null; //class
    this.zuper = null; //super
    this.tags = {
        /*
        name:[val1,val2]
    */
    };
}
1175791
def update_settings(self):
        """"""
        self.display()
        self.display_markers()
        if self.parent.notes.annot is not None:
            self.parent.notes.display_notes()
886145
function update(annotationObject, changeSet) {
  const updatedAnnotation = Object.assign({}, annotationObject, changeSet);

  let changeDetected = false;
  Object.keys(updatedAnnotation).forEach((key) => {
    if (updatedAnnotation[key] !== annotationObject[key]) {
      changeDetected = true;
    }
  });

  if (changeDetected) {
    generation += 1;
    updatedAnnotation.generation = generation;
  }

  return updatedAnnotation;
}
814339
def update(self, **kwargs):
        
        for kw in kwargs:
            setattr(self, kw, kwargs[kw])
964761
def update(self, **kwargs):
    """"""
    for key, value in kwargs.items():
      setattr(self, key, value)
755546
public void addComment(Comment comment) {
        if (comments == null || comments.size() == 0) {
            comments = new ArrayList<Comment>();
        }

        comments.add((CommentImpl) comment);
    }
1215888
def update(self, **kwargs):
        """"""
        assert not self.called
        self.kw.update(kwargs)
        return self