Process a chat group summary.
@param {object} groupSummary
@param {boolean} [preProcessed=false]
@returns {object}
324362
function processChatGroupSummary(groupSummary, preProcessed) {
	if (!preProcessed) {
		groupSummary = preProcessObject(groupSummary);
	}

	if (groupSummary.top_members) {
		groupSummary.top_members = groupSummary.top_members.map(accountid => SteamID.fromIndividualAccountID(accountid));
	}

	return groupSummary;
}
299247
private void processGroupData() throws IOException
   {
      DirectoryEntry dir = (DirectoryEntry) m_viewDir.getEntry("CGrouping");
      FixedMeta fixedMeta = new FixedMeta(new DocumentInputStream(((DocumentEntry) dir.getEntry("FixedMeta"))), 10);
      FixedData fixedData = new FixedData(fixedMeta, m_inputStreamFactory.getInstance(dir, "FixedData"));
      VarMeta varMeta = new VarMeta12(new DocumentInputStream(((DocumentEntry) dir.getEntry("VarMeta"))));
      Var2Data varData = new Var2Data(varMeta, new DocumentInputStream(((DocumentEntry) dir.getEntry("Var2Data"))));

      //System.out.println(fixedMeta);
      //System.out.println(fixedData);
      //System.out.println(varMeta);
      //System.out.println(varData);

      GroupReader14 reader = new GroupReader14();
      reader.process(m_file, fixedData, varData, m_fontBases);
   }
1301623
function ChunkedStreamManager_groupChunks(chunks) {
      var groupedChunks = [];
      var beginChunk = -1;
      var prevChunk = -1;
      for (var i = 0; i < chunks.length; ++i) {
        var chunk = chunks[i];

        if (beginChunk < 0) {
          beginChunk = chunk;
        }

        if (prevChunk >= 0 && prevChunk + 1 !== chunk) {
          groupedChunks.push({ beginChunk: beginChunk,
                               endChunk: prevChunk + 1 });
          beginChunk = chunk;
        }
        if (i + 1 === chunks.length) {
          groupedChunks.push({ beginChunk: beginChunk,
                               endChunk: chunk + 1 });
        }

        prevChunk = chunk;
      }
      return groupedChunks;
    }
693974
function(things, level) {
						// stop if there is nothing to process or if the maximum processing depth has been reached
						if(((! things) && (level > 1)) || ((amaStats.max_depth_to_inspect) && (level > amaStats.max_depth_to_inspect))){
							return;
						}

						// update statistics	
						if(amaStats.max_processed_level < level) {
							amaStats.max_processed_level = level;	
						}

						if(! amaStats.level_stats['level_' + level]) {
							amaStats.level_stats['level_' + level] = {
																		processed : 0,
																		warnings : 0,
																		missing	: 0
																	};
						}
						
						// process records 
						if(things.hasOwnProperty('kind') && (things.kind === 'Listing')) {
								if((things.hasOwnProperty('data')) && (things.data.hasOwnProperty('children'))) {
									_.forEach(things.data.children, function (thing) {
											// for a definition of thing refer to the Reddit API doc
											if(thing.hasOwnProperty('data')) {
												if((thing.data.hasOwnProperty('selftext')) || (thing.data.hasOwnProperty('body'))) {
													// the record includes text that can be analyzed; submit comment for Tone Analyzer processing
													q.push( thing.data );	
													amaStats.processed_record_count++;
													amaStats.level_stats['level_' + level].processed++;
												}
												else {
													// the record does not include text that can be analyzed; skip

													if(thing.kind === 'more'){
														// type "more" indicates that there are things (e.g. comments) in this subtree that were not loaded but could be 
														// retrieved using https://www.reddit.com/dev/api#GET_api_morechildren
												    	// TODO additional processing is required
												    	// calculate total (across all levels)
												    	if(thing.data.count) {
															amaStats.missing_record_count = amaStats.missing_record_count + thing.data.count; 
												    		// calculate total for current level
												    		amaStats.level_stats['level_' + level].missing = amaStats.level_stats['level_' + level].missing + thing.data.count;														 
												    	}
													}
													else {
														  // unknown record type 	
														  amaStats.parser_warnings++;
														  amaStats.level_stats['level_' + level].warnings++;
														  logger.warn('Potential parser error detected for record type ' + thing.kind + ' at level ' + level + ': ' + util.inspect(thing.data,3));
													}	
												}

												// process sub-tree things (which are typically comments/replies)
												// before processung other things at the current level
												processSubtree(thing.data.replies, level + 1);
											}	
									});
								} // ! data.children
								else {
									// potential parser logic error
									amaStats.parser_warnings++;
									amaStats.level_stats['level_' + level].warnings++;
									logger.warn('Potential parser error detected at level ' + level + ': ' + util.inspect(things,3));
								}
						}
						else {
								// potential parser logic error
								amaStats.parser_warnings++;
								amaStats.level_stats['level_' + level].warnings++;
								logger.warn('Potential parser error detected at level ' + level + ': ' + util.inspect(things,3));
						}
				}
478280
function parseGroup(tokenizer) {
  // Group this functon will return.
  var mrow = {tag: 'mrow', children: []};
  // Last child of mrow.
  var lastItem;
  // Current token.
  var tkn;
  // Current tag.
  var tag;
  // Macro. This is a function with this prototype: (tokenizer, mrow).
  var macro;

  for(;;) {
    tkn = tokenizer.next();
    // End of stream.
    if (!tkn) break;
    // End of block.
    if (tkn.typ == '}') break;
    // Deal with msup.
    if (tkn.typ == '^') {
      if (mrow.children.length == 0) {
        mrow.children.push({tag: 'mrow', children: []});
      }
      lastItem = mrow.children[mrow.children.length - 1];
      if (lastItem.msup) {
        tokenizer.fatal("Double superscript.", tkn.idx);
      }
      lastItem.msup = parseItemOrGroup(tokenizer);
    }
    else if (tkn.typ == '_') {
      if (mrow.children.length == 0) {
        mrow.children.push({tag: 'mrow', children: []});
      }
      lastItem = mrow.children[mrow.children.length - 1];
      if (lastItem.msub) {
        tokenizer.fatal("Double subscript.", tkn.idx);
      }
      lastItem.msub = parseItemOrGroup(tokenizer);
    }
    // Prime, double, triple or quadruple prime.
    else if (tkn.typ == 'prime') {
      lastItem = mrow.children[mrow.children.length - 1];
      if (lastItem.msup) {
        tokenizer.fatal("Double superscript because of a prime.", tkn.idx);
      }
      lastItem.msup = {tag: 'mo', children: tkn.txt};
    }
    // Beginning of a new group.
    else if (tkn.typ == '{') {
      mrow.children.push( parseGroup(tokenizer) );
    }
    // Add this leaf in the tree.
    else {
      tag = tokenToTag(tkn);
      if (typeof tag === 'function') {
        // This is a macro.
        macro = tag;
        tag = macro(tokenizer, mrow, tkn.idx);
        if (tag) {
          mrow.children.push(tag);
        }
      } else {
        mrow.children.push(tag);
      }
    }
  }
  return mrow;
}
535628
function grouped(array, groups, order) {
  if (!groups) { groups = [returnFalse]; }
  var sorted = [];
  var ordered = [];
  var remaining = array.slice();
  var unmatchedPosition = groups.indexOf('unmatched');
  groups.forEach(function(criteria, index) {
    if (index === unmatchedPosition) { return; }
    var tieBreakers = [];
    if (index !== groups.length - 1) {
      tieBreakers = groups.slice(index + 1);
      if (index < unmatchedPosition) {
        tieBreakers.splice(unmatchedPosition - index - 1, 1);
      }
    }
    var spliced = splice(remaining, criteria, tieBreakers);
    var matched = spliced.matched;
    var unmatched = spliced.unmatched;
    sorted[index] = matched;
    remaining = unmatched;
  });
  if (unmatchedPosition === -1) { unmatchedPosition = sorted.length; }
  sorted[unmatchedPosition] = remaining;
  if (Array.isArray(order)) {
    order.forEach(function(position, index) {
      ordered[index] = sorted[position];
    });
  } else {
    ordered = sorted;
  }
  return ordered.reduce(function(flat, group) {
    return flat.concat(group);
  }, []);
}
113327
function process(node) {
          var children, i, l, lastContentEditable, hasContentEditableState;

          // Node has a contentEditable value
          if (node.nodeType === 1 && getContentEditable(node)) {
            lastContentEditable = contentEditable;
            contentEditable = getContentEditable(node) === "true";
            hasContentEditableState = true; // We don't want to wrap the container only it's children
          }

          // Grab the children first since the nodelist might be changed
          children = grep(node.childNodes);

          // Process current node
          if (contentEditable && !hasContentEditableState) {
            for (i = 0, l = formatList.length; i < l; i++) {
              if (removeFormat(formatList[i], vars, node, node)) {
                break;
              }
            }
          }

          // Process the children
          if (format.deep) {
            if (children.length) {
              for (i = 0, l = children.length; i < l; i++) {
                process(children[i]);
              }

              if (hasContentEditableState) {
                contentEditable = lastContentEditable; // Restore last contentEditable state from stack
              }
            }
          }
        }
515201
function processPartitionKeys(keys){
    var result = "(",
        j,
        len,
        keyGroup;

    if(typeof keys === 'string'){
        return result += keys + ")";
    }

    len = keys.length;
    for(j = 0; j< keys.length; j++){
        keyGroup = keys[j];
        if(keyGroup instanceof Array){
            result += "(";
            result += keyGroup.join(", ");
            result += ")";
        }else{
            result += keyGroup;
        }
        result += (j < len-1) ? ", " : "";
    }
    result += ")";

    return result;
}
658881
def process_normalization(cls, parse_group):
        
        if ('norm_options' not in parse_group): return None
        opts = parse_group['norm_options'][0].asList()
        if opts == []: return None

        options = ['+framewise', '-framewise', '+axiswise', '-axiswise']

        for normopt in options:
            if opts.count(normopt) > 1:
                raise SyntaxError("Normalization specification must not"
                                  " contain repeated %r" % normopt)

        if not all(opt in options for opt in opts):
            raise SyntaxError("Normalization option not one of %s"
                              % ", ".join(options))
        excluded = [('+framewise', '-framewise'), ('+axiswise', '-axiswise')]
        for pair in excluded:
            if all(exclude in opts for exclude in pair):
                raise SyntaxError("Normalization specification cannot"
                                  " contain both %s and %s" % (pair[0], pair[1]))

        # If unspecified, default is -axiswise and -framewise
        if len(opts) == 1 and opts[0].endswith('framewise'):
            axiswise = False
            framewise = True if '+framewise' in opts else False
        elif len(opts) == 1 and opts[0].endswith('axiswise'):
            framewise = False
            axiswise = True if '+axiswise' in opts else False
        else:
            axiswise = True if '+axiswise' in opts else False
            framewise = True if '+framewise' in opts else False

        return dict(axiswise=axiswise,
                    framewise=framewise)
1177440
def preview_processed_html(self, group_id, html=None):
        
        path = {}
        data = {}
        params = {}

        # REQUIRED - PATH - group_id
        """ID"""
        path["group_id"] = group_id

        # OPTIONAL - html
        """The html content to process"""
        if html is not None:
            data["html"] = html

        self.logger.debug("POST /api/v1/groups/{group_id}/preview_html with query params: {params} and form data: {data}".format(params=params, data=data, **path))
        return self.generic_request("POST", "/api/v1/groups/{group_id}/preview_html".format(**path), data=data, params=params, no_data=True)
727212
def _get_grprobj(self, goids, sections):
        """"""
        grprdflt = GrouperDflts(self.gosubdag, "goslim_generic.obo")
        hdrobj = HdrgosSections(self.gosubdag, grprdflt.hdrgos_dflt, sections)
        return Grouper("sections", goids, hdrobj, self.gosubdag)
854145
@Override
    public void processMessage() {
        // since our computations are symmetric - we aggregate dot everywhere
        if (chunks == null) {
            chunks = new TreeMap<>();
            chunksCounter = new AtomicInteger(1);
            addToChunks(payload);
        }

        clipboard.pin(this);

        //log.info("sI_{} dot aggregation received", transport.getShardIndex());

        if (clipboard.isReady(this.getOriginatorId(), this.getTaskId())) {
            trainer.aggregationFinished(clipboard.unpin(this.getOriginatorId(), this.taskId));
        }
    }
611353
def process(self):
        
        # Short cut
        if self._all_expressions_evaluated():
            if self.drop:
                # Drop extra columns. They do not correspond to
                # any expressions.
                columns = [expr.column for expr in self.expressions]
                self.data = self.data.loc[:, columns]
            return self.data

        # group_by
        # evaluate expressions
        # combine columns
        # concat evalutated group data and clean up index and group
        gdfs = self._get_group_dataframes()
        egdfs = self._evaluate_expressions(gdfs)
        edata = self._concat(egdfs)
        return edata
457229
public function getGroup(Communicator $communicator): ProcessedGroup
    {
            $groupJSON = $communicator->get('api/groups/'.$this->groupID);
            $group = RecipientFactory::createProcessedGroupFromJSON($groupJSON);
            return $group;
    }
131084
function processMeta (markdownContent) {
  let meta = {};
  let metaArr;
  let metaString;
  let metas;

  let yamlObject;

  switch (true) {
    case _metaRegex.test(markdownContent):
      metaArr = markdownContent.match(_metaRegex);
      metaString = metaArr ? metaArr[1].trim() : '';

      if (metaString) {
        metas = metaString.match(/(.*): (.*)/ig);
        metas.forEach(item => {
          const parts = item.split(': ');
          if (parts[0] && parts[1]) {
            meta[cleanString(parts[0], true)] = parts[1].trim();
          }
        });
      }
      break;

    case _metaRegexYaml.test(markdownContent):
      metaArr = markdownContent.match(_metaRegexYaml);
      metaString = metaArr ? metaArr[1].trim() : '';
      yamlObject = yaml.safeLoad(metaString);
      meta = cleanObjectStrings(yamlObject);
      break;

    default:
    // No meta information
  }

  return meta;
}
84249
function process_token(token, index, tokens) {
	var last = (index === (tokens.length - 1));
	if (token[0] === "+") return process_single(token, last);
	else if (token[0] === "#") return process_multi(token, last);
	else return process_raw(token, last);
}
1267513
func NewGroupSummary(GroupName string, GroupId string, GroupManagementType *GroupManagementType) *GroupSummary {
	s := new(GroupSummary)
	s.GroupName = GroupName
	s.GroupId = GroupId
	s.GroupManagementType = GroupManagementType
	return s
}