internal /////////
424782
function _arrayOp(arrayFn, opArgs) {
		var res
		var key = opArgs[1]
		var rest = slice(opArgs, 2)
		this.update(key, [], function(arrVal) {
			res = Array.prototype[arrayFn].apply(arrVal, rest)
		})
		return res
	}
747808
public function init(): void
    {
        parent::init();

        if ($this->default !== '' && $this->default !== null && !is_array($this->default)) {
            try {
                $default = Json::decode($this->default);

                if (is_array($default)) {
                    $this->default = $default;
                }
            } catch (InvalidArgumentException $exception) {}
        }
    }
302841
@Override
	public void internalWrite(Server server, Query query, ImmutableList<Result> results) throws Exception {
		graphiteWriter.write(logwriter, server, query, results);
	}
257868
public function process()
    {
        parent::process();

        if ($this->value === null) {
            $this->path = array();
        } else {
            $this->path = $this->value;
            $this->value = end($this->path);
        }
    }
944882
public void readExternal(ObjectInput in) throws IOException {
        type = in.readByte();
        object = readInternal(type, in);
    }
303842
function internalAction(scope, page) {

        // Block clicks we try to load the active page
        if (scope.page == page) {
            return;
        }

        // Block if we are forcing disabled 
        if(scope.isDisabled)
        {
            return;
        }

        // Update the page in scope
        scope.page = page;

        // Pass our parameters to the paging action
        scope.pagingAction({
            page: scope.page,
            pageSize: scope.pageSize,
            total: scope.total
        });

        // If allowed scroll up to the top of the page
        if (scope.scrollTop) {
            scrollTo(0, 0);
        }
    }
74222
private final void internalInfo(Object source, Class sourceClass, String methodName, String messageIdentifier, Object object)
    {
        if (usePrintWriterForTrace)
        {
            if (printWriter != null)
            {
                StringBuffer stringBuffer = new StringBuffer(new java.util.Date().toString());

                stringBuffer.append(" I ");
                stringBuffer.append(sourceClass.getName());
                stringBuffer.append(".");
                stringBuffer.append(methodName);


                printWriter.println(stringBuffer.toString());
                printWriter.println("\t\t"+NLS.format(messageIdentifier, object));
                printWriter.flush();
            }
        }

        if (object != null)
        {
            Tr.info(traceComponent, messageIdentifier, object);
        }
        else
        {
            Tr.info(traceComponent, messageIdentifier);
        }
    }
586128
protected InternalHttpResponse sendInternalRequest(HttpRequest request) {
    InternalHttpResponder responder = new InternalHttpResponder();
    httpResourceHandler.handle(request, responder);
    return responder.getResponse();
  }
924734
final private com.ibm.websphere.cache.CacheEntry internal_putAndGet(
                                                                        Object key,
                                                                        Object value,
                                                                        Object userMetaData,
                                                                        int priority,
                                                                        int timeToLive,
                                                                        int inactivityTime,
                                                                        int sharingPolicy,
                                                                        Object dependencyIds[],
                                                                        Object aliasIds[],
                                                                        boolean incrementRefCount,
                                                                        boolean skipMemoryAndWriteToDisk) throws DynamicCacheException {

        final String methodName = "putAndGet(..)";
        ValidateUtility.objectNotNull(key, "key", value, "value");
        if (skipMemoryAndWriteToDisk && !cache.getSwapToDisk()) {
            throw new DiskOffloadNotEnabledException("DiskOffloadNotEnabledException occurred. The disk offload feature for cache instance \"" + cache.getCacheName()
                                                     + "\" is not enabled.");
        }
        if (skipMemoryAndWriteToDisk == true && sharingPolicy != EntryInfo.NOT_SHARED) {
            //DYNA1072W=DYNA1072W: The cache id \"{0}\" will not be replicated to other servers because \"skipMemoryWriteToDisk\" is set to true. The sharing policy will be set to \"not-shared\".
            Tr.warning(tc, "DYNA1072W", new Object[] { key });
            sharingPolicy = EntryInfo.NOT_SHARED;
        }
        ValidateUtility.sharingPolicy(sharingPolicy);
        if (sharingPolicy == EntryInfo.SHARED_PUSH_PULL ||
            sharingPolicy == EntryInfo.SHARED_PULL) {
            invalidate(key, true);
        }
        EntryInfo ei = entryInfoPool.allocate(key, dependencyIds, aliasIds);
        ei.setUserMetaData(userMetaData);
        ei.setPriority(priority);
        ei.setTimeLimit(timeToLive);
        ei.setSharingPolicy(sharingPolicy);
        ei.setInactivity(inactivityTime);
        CacheEntry ce = cacheEntryPool.allocate();
        ce.copyMetaData(ei);
        ce.setValue(value);
        ce.setSkipMemoryAndWriteToDisk(skipMemoryAndWriteToDisk);
        if (value instanceof DistributedNioMapObject) {
            ce.useByteBuffer = true;
        }
        // only put and no get for when skipMemoryAndWriteToDisk is true ==> refcount will not increment
        com.ibm.websphere.cache.CacheEntry newEntry = cache.setEntry(ce, CachePerf.LOCAL, false, Cache.COORDINATE, incrementRefCount);
        ei.returnToPool();

        try {

            if (cache.getCacheConfig().isDefaultCacheProvider()) {

                if (tc.isDebugEnabled()) {
                    if (newEntry != null) {
                        Tr.debug(tc, methodName + " " + cache.getCacheName() + " id=" + newEntry.getIdObject() + " incRefCount=" + incrementRefCount +
                                     " skipMemoryWriteToDisk=" + skipMemoryAndWriteToDisk);
                    }
                }

                if (ce.skipMemoryAndWriteToDisk) {
                    int errorCode = ce.skipMemoryAndWriteToDiskErrorCode;
                    StringBuffer message = new StringBuffer();
                    Exception ex = null;
                    switch (errorCode) {
                        case HTODDynacache.NO_EXCEPTION:
                            break;
                        case HTODDynacache.DISK_EXCEPTION:
                            message.append("The disk IO exception has occurred when writing cache ID: ");
                            message.append(ce.id);
                            message.append(" to the disk cache. ");
                            ex = cache.getDiskCacheException();
                            if (ex != null) {
                                message.append(ex.getMessage());
                            }
                            throw new DiskIOException(message.toString());
                        case HTODDynacache.DISK_SIZE_OVER_LIMIT_EXCEPTION:
                            message.append("Exception has occurred either (1) there is no disk space available, or (2) the disk cache size in GB s over the (diskCacheSizeInGB) limit when writing cache ID: ");
                            message.append(ce.id);
                            message.append(" to the disk cache. ");
                            ex = cache.getDiskCacheException();
                            if (ex != null) {
                                message.append(ex.getMessage());
                            }
                            throw new DiskSizeOverLimitException(message.toString());
                        case HTODDynacache.OTHER_EXCEPTION:
                            message.append("The runtime exception other than a Disk IOException has occurred when writing cache ID: ");
                            message.append(ce.id);
                            message.append(" to the disk cache. ");
                            ex = cache.getDiskCacheException();
                            if (ex != null) {
                                message.append(ex.getMessage());
                            }
                            throw new MiscellaneousException(message.toString());
                        case HTODDynacache.SERIALIZATION_EXCEPTION:
                            message.append("The serialization exception has occurred when writing cache ID: ");
                            message.append(ce.id);
                            message.append(" to the disk cache. ");
                            throw new SerializationException(message.toString());
                        case HTODDynacache.DISK_SIZE_IN_ENTRIES_OVER_LIMIT_EXCEPTION:
                            message.append("The disk cache size in entries is over the (diskCacheSize) limit when writing cache ID: ");
                            message.append(ce.id);
                            message.append(" to the disk cache. ");
                            throw new DiskSizeInEntriesOverLimitException(message.toString());
                        case HTODDynacache.DISK_CACHE_ENTRY_SIZE_OVER_LIMIT_EXCEPTION:
                            message.append("The cache entry size is over the configured disk cache entry size (diskCacheEntrySizeInMB) limit when writing cache ID: ");
                            message.append(ce.id);
                            message.append(" to the disk cache. ");
                            throw new DiskCacheEntrySizeOverLimitException(message.toString());
                    }
                }
            }
        } finally {
            ce.value = ce.serializedValue = null; //prevent ce.reset from Nio object release
            ce.returnToPool();
        }
        return newEntry;
    }
1074912
protected void internalBeginToCompile(ICompilationUnit[] sourceUnits, int maxUnits) {
        if (!this.useSingleThread && maxUnits >= ReadManager.THRESHOLD)
            this.parser.readManager = new ReadManager(sourceUnits, maxUnits);

        // Switch the current policy and compilation result for this unit to the requested one.
        for (int i = 0; i < maxUnits; i++) {
            CompilationResult unitResult = null;
            try {
                if (this.options.verbose) {
                    this.out.println(
                        Messages.bind(Messages.compilation_request,
                        new String[] {
                            String.valueOf(i + 1),
                            String.valueOf(maxUnits),
                            new String(sourceUnits[i].getFileName())
                        }));
                }
                // diet parsing for large collection of units
                CompilationUnitDeclaration parsedUnit;
                unitResult = new CompilationResult(sourceUnits[i], i, maxUnits, this.options.maxProblemsPerUnit);
                long parseStart = System.currentTimeMillis();
                if (this.totalUnits < this.parseThreshold) {
                    parsedUnit = this.parser.parse(sourceUnits[i], unitResult);
                } else {
                    parsedUnit = this.parser.dietParse(sourceUnits[i], unitResult);
                }
                long resolveStart = System.currentTimeMillis();
                this.stats.parseTime += resolveStart - parseStart;
                // initial type binding creation
                this.lookupEnvironment.buildTypeBindings(parsedUnit, null /*no access restriction*/);
                this.stats.resolveTime += System.currentTimeMillis() - resolveStart;
                addCompilationUnit(sourceUnits[i], parsedUnit);
                ImportReference currentPackage = parsedUnit.currentPackage;
                if (currentPackage != null) {
                    unitResult.recordPackageName(currentPackage.tokens);
                }
                //} catch (AbortCompilationUnit e) {
                //	requestor.acceptResult(unitResult.tagAsAccepted());
            } catch (AbortCompilation a) {
                // best effort to find a way for reporting this problem:
                if (a.compilationResult == null)
                    a.compilationResult = unitResult;
                throw a;
            } finally {
                sourceUnits[i] = null; // no longer hold onto the unit
            }
        }
        if (this.parser.readManager != null) {
            this.parser.readManager.shutdown();
            this.parser.readManager = null;
        }
        // binding resolution
        this.lookupEnvironment.completeTypeBindings();
    }
927399
public static void internAll(String[] strings) {
        for (int i = 0; i < strings.length; i++) {
            strings[i] = strings[i].intern();
        }
    }
665435
public void setInternal(boolean internal) {

        m_internal = internal;
        m_textbox.setReadOnly(internal);
        m_editButton.setEnabled(internal);
        m_editButton.getElement().getStyle().setVisibility(internal ? Visibility.VISIBLE : Visibility.HIDDEN);
        //m_editButton.setVisible(internal);
        m_externalCheckbox.setChecked(!internal);
    }
107049
def _finalized_internal(self,
                          context,
                          pipeline_key,
                          root_pipeline_key,
                          caller_output,
                          aborted):
    """"""
    result_status = _PipelineRecord.RUN
    if aborted:
      result_status = _PipelineRecord.ABORTED

    self._set_values_internal(
        context, pipeline_key, root_pipeline_key, caller_output, result_status)
    logging.debug('Finalizing %s(*%r, **%r)#%s',
                  self._class_path, _short_repr(self.args),
                  _short_repr(self.kwargs), self._pipeline_key.name())
    try:
      self.finalized()
    except NotImplementedError:
      pass
661535
public function process()
    {
        $this->initializeStorageNode($this->storageNodeNodePath, $this->storageNodeTitle);
        $this->initializeNodeTemplates();

        $nodeTemplate = new NodeTemplate();
        $this->processBatch($nodeTemplate);
    }
150888
@Override
  public void writeExternal(ObjectOutput out) throws IOException {
    out.writeInt(id);
    mbr.writeExternal(out);
  }
531495
private void internalRelease()
    {
        _facesContext = null;
        _componentInstance = null;
        _created = false;

        _childrenAdded = null;
        _facetsAdded = null;
    }
404988
private void keypointInternal() throws InternalLogException
    {
        if (tc.isEntryEnabled())
            Tr.entry(tc, "keypointInternal");

        try
        {
            //  _activeFile is in KEYPOINTING state, other file is in ACTIVE state

            force();

            // _activeFile is in KEYPOINTING state, other file is in ACTIVE state

            _activeFile.keypointComplete();

            // _activeFile is in ACTIVE(time2) state, other file is in ACTIVE(time1) (time2 later than time1)

            if (_activeFile == _file1)
            {
                _file2.becomeInactive();
            }
            else
            {
                _file1.becomeInactive();
            }
        } catch (InternalLogException exc)
        {
            FFDCFilter.processException(exc, "com.ibm.ws.recoverylog.spi.LogHandle.keypointInternal", "952", this);
            if (tc.isEntryEnabled())
                Tr.exit(tc, "keypointInternal", exc);
            throw exc;
        } catch (Throwable exc)
        {
            FFDCFilter.processException(exc, "com.ibm.ws.recoverylog.spi.LogHandle.keypointInternal", "958", this);
            if (tc.isEntryEnabled())
                Tr.exit(tc, "keypointInternal", "InternalLogException");
            throw new InternalLogException(exc);
        }

        // _activeFile is in ACTIVE state, other file is in INACTIVE state

        if (tc.isEntryEnabled())
            Tr.exit(tc, "keypointInternal");
    }