Processes the individual package entry.

<package><class></package>

@param {Object} packageObject is the package object from the report.
@param {Object} computation is the result of the computation.
326513
function processPackage(packageObject, computation) {
  if (packageObject.classes.class instanceof Array) {
    // Process each individual class
    packageObject.classes.class.forEach(function(clazz) {
      processClass(clazz, computation);
    });

  } else {
    // Single class to be processed
    processClass(packageObject.classes.class, computation);
  }
}
1111424
private Process getPackageHandler(ProcessInstance masterInstance, Integer eventType) {
        Process process = getProcessDefinition(masterInstance);
        Process handler = getPackageHandler(process.getPackageName(), eventType);
        if (handler != null && handler.getName().equals(process.getName())) {
            logger.warn("Package handler recursion is not allowed. "
                    + "Define an embedded handler in package handler: " + handler.getLabel());
        }
        return handler;
    }
1072015
void process(EventEnvelope envelope) {
        Object event = getEvent(envelope);
        String serviceName = envelope.getServiceName();
        EventPublishingService<Object, Object> service = eventService.nodeEngine.getService(serviceName);
        Registration registration = getRegistration(envelope, serviceName);
        if (registration == null) {
            return;
        }
        service.dispatchEvent(event, registration.getListener());
    }
203129
public void registerFunctionPackage(String packageName, Object o)
	{
		checkFunctionName(packageName);
		registerFunctionPackage(packageName, o.getClass(), o);

	}
1004627
function(object, properties) {
        if (!object.__isInterfaceImplemented('properties')) {
            object.__implementInterface('properties', this.interface);
        }

        object.__initProperties();

        var processor = this.get();

        _.each(properties, function(data, property) {
             processor.process(object, data, property);
        });
    }
545350
function Package(name)
    {
        var dotBowerJson = Package._readBowerJson(name) || {};
        var overrides = globalOverrides[name] || {};

        this.name         = name;
        this.installed    = !! dotBowerJson.name;
        this.main         = overrides.main || dotBowerJson.main || [];
        this.dependencies = overrides.dependencies || dotBowerJson.dependencies || [];
    }
991536
@Override
   public void writeImport(Definition def, Writer out) throws IOException
   {
      out.write("package " + def.getRaPackage() + ";\n\n");
   }
544935
def process_package(self, package_name):
        

        metadata = super(ArtifactRegistry, self).process_package(package_name)
        if metadata:
            self.update_artifact_metadata(package_name, metadata)
404492
protected void _computeTypes(SarlAssertExpression object, ITypeComputationState state) {
		state.withExpectation(getTypeForName(Boolean.class, state)).computeTypes(object.getCondition());
	}
692334
function process(services) {
            if (services == null || (typeof services === "undefined" ? "undefined" : _typeof(services)) !== "object") {
                throw new Error("Service definitions should be an object, a function returning an object (or a !!promise resolving to an object!!)");
            }
            var index = 0;
            var next = Object.keys(services)[index];
            return this.processKey(index, next, services).then(function () {
                return this;
            }.bind(this));
        }
655797
@SuppressWarnings("unchecked")
  @Override
  public Object finalizeComputation(Object object)
  {
    return af.finalizeComputation((T) object);
  }
294171
def apply_computation(cls,
                          state: BaseState,
                          message: Message,
                          transaction_context: BaseTransactionContext) -> 'BaseComputation':
        
        with cls(state, message, transaction_context) as computation:
            # Early exit on pre-compiles
            if message.code_address in computation.precompiles:
                computation.precompiles[message.code_address](computation)
                return computation

            show_debug2 = computation.logger.show_debug2

            for opcode in computation.code:
                opcode_fn = computation.get_opcode_fn(opcode)

                if show_debug2:
                    computation.logger.debug2(
                        "OPCODE: 0x%x (%s) | pc: %s",
                        opcode,
                        opcode_fn.mnemonic,
                        max(0, computation.code.pc - 1),
                    )

                try:
                    opcode_fn(computation=computation)
                except Halt:
                    break
        return computation
798238
public Object process(BinaryEntry entry) {
        Object result = processEntry(entry);
        return result == NO_RESULT ? null : result;
    }
544938
function renderObjectImmediate( object, program ) {

		object.render( function ( object ) {

			_this.renderBufferImmediate( object, program );

		} );

	}
1201742
private void processOperations(
            final Consumer<WorkflowSystem.OperationResult<DAT, RES, OP>> resultConsumer
    )
    {
        int origPendingCount = pending.size();

        //operations which match runnable conditions
        List<OP> shouldrun = pending.stream()
                                    .filter(input -> input.shouldRun(workflowEngine.getState()))
                                    .collect(Collectors.toList());

        //runnable that should be skipped
        List<OP> shouldskip = shouldrun.stream()
                                       .filter(input -> input.shouldSkip(workflowEngine.getState()))
                                       .collect(Collectors.toList());

        //shared data
        DAT inputData = null != sharedData ? sharedData.produceNext() : null;


        processRunnableOperations(resultConsumer, shouldrun, shouldskip, inputData);

        processSkippedOperations(shouldskip);

        pending.removeAll(shouldskip);
        skipped.addAll(shouldskip);

        workflowEngine.eventLoopProgress(origPendingCount, shouldskip.size(), shouldrun.size(), pending.size());
    }
876783
def packageProject(self, dir=os.getcwd(), configuration='Shipping', extraArgs=[]):
		
		
		# Verify that the specified build configuration is valid
		if configuration not in self.validBuildConfigurations():
			raise UnrealManagerException('invalid build configuration "' + configuration + '"')
		
		# Strip out the `-NoCompileEditor` flag if the user has specified it, since the Development version
		# of the Editor modules for the project are needed in order to run the commandlet that cooks content
		extraArgs = Utility.stripArgs(extraArgs, ['-nocompileeditor'])
		
		# Prevent the user from specifying multiple `-platform=` or `-targetplatform=` arguments,
		# and use the current host platform if no platform argument was explicitly specified
		platformArgs = Utility.findArgs(extraArgs, ['-platform=', '-targetplatform='])
		platform = Utility.getArgValue(platformArgs[0]) if len(platformArgs) > 0 else self.getPlatformIdentifier()
		extraArgs = Utility.stripArgs(extraArgs, platformArgs) + ['-platform={}'.format(platform)]
		
		# If we are packaging a Shipping build, do not include debug symbols
		if configuration == 'Shipping':
			extraArgs.append('-nodebuginfo')
		
		# Do not create a .pak file when packaging for HTML5
		pakArg = '-package' if platform.upper() == 'HTML5' else '-pak'
		
		# Invoke UAT to package the build
		distDir = os.path.join(os.path.abspath(dir), 'dist')
		self.runUAT([
			'BuildCookRun',
			'-utf8output',
			'-clientconfig=' + configuration,
			'-serverconfig=' + configuration,
			'-project=' + self.getProjectDescriptor(dir),
			'-noP4',
			'-cook',
			'-allmaps',
			'-build',
			'-stage',
			'-prereqs',
			pakArg,
			'-archive',
			'-archivedirectory=' + distDir
		] + extraArgs)
1271653
function writePackageVersion(newVersion) {
  var packageJson = path.join(process.cwd(), 'package.json'),
    raw = require(packageJson);

  raw.version = newVersion;

  fs.writeFileSync(packageJson, JSON.stringify(raw, null, 2));
}