For internal use only.
328310
public function _log($level, $fmt, $allArgs) {
        // The $allArgs variable contains the $fmt string
        array_shift($allArgs);
        $text = vsprintf($fmt, $allArgs);

        $this->_rawLogRecord(array(
            'level' => $level,
            'message' => $text,
        ), $allArgs);

        $this->flushIfNeeded();
        return $text;
    }
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");
    }
480312
@MustBeLocked (ELockType.WRITE)
  protected final void internalMarkItemUndeleted (@Nonnull final IMPLTYPE aItem)
  {
    internalMarkItemUndeleted (aItem, true);
  }
873746
public final Object put(Object key, Object value) {
        return internalData.put(key, value);
    }
103349
void internalAddChange(String valuePath, String attributeName, int valueIndex, ChangeType changeType) {

        m_changeTimer = null;
        //TODO: keep the IDs, otherwise redo will not work
        CmsEntity currentData = m_entity.cloneEntity();
        if (!currentData.equals(m_current.getEntityData())) {
            m_undo.push(m_current);
            m_current = new Change(currentData, valuePath, attributeName, valueIndex, changeType);
            m_redo.clear();
            fireStateChange();
        }
    }
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);
        }
    }
720634
function internal(obj) {
  if (!privateMap.has(obj)) {
    privateMap.set(obj, {});
  }

  return privateMap.get(obj);
}
743565
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        comparator = (Comparator) in.readObject();
        elements = (Activation[]) in.readObject();
        size = in.readInt();
    }
633512
@Override
  public void writeExternal(ObjectOutput out) throws IOException {
    super.writeExternal(out);
    out.writeObject(approximation);
  }
320413
def _convert_to_internal(self, data):
        """'"""
        for _dict in data:
            keys = list(_dict.keys())[:]
            for key in keys:
                if key not in self._disp_cols:
                    raise Exception(key + ' not a column in current List.')
                _dict[self._disp_cols[key]['name']] = self._sp_type(key, _dict.pop(key))
1050867
public void free()
    {
        super.free();
        try
        {
            if (this.getHandle(DBConstants.DATA_SOURCE_HANDLE) != null)
                ((BaseBuffer)this.getHandle(DBConstants.DATA_SOURCE_HANDLE)).free();
        } catch (DBException ex)    {
            // Never
        }
        if (m_pTable != null)
            m_pTable.removePTableOwner(this, true);      // Free or decrement the use count of the physical table
        m_pTable = null;
    }
500488
def to_internal_value(self, data):
        
        course_id = data
        course_video = image = ''
        if data:
            if isinstance(data, dict):
                (course_id, image), = list(data.items())

            course_video = CourseVideo(course_id=course_id)
            course_video.full_clean(exclude=['video'])

        return course_video, image
418686
public void writeExternal(java.io.ObjectOutput out)
        throws java.io.IOException
    {
        HashMap map = new HashMap(this);
        out.writeObject(map);
    }
1083810
def internal2external(xi, bounds):
    

    xe = np.empty_like(xi)

    for i, (v, bound) in enumerate(zip(xi, bounds)):

        a = bound[0]  # minimum
        b = bound[1]  # maximum

        if a == None and b == None:  # No constraints
            xe[i] = v

        elif b == None:  # only min
            xe[i] = a - 1. + np.sqrt(v ** 2. + 1.)

        elif a == None:  # only max
            xe[i] = b + 1. - np.sqrt(v ** 2. + 1.)

        else:  # both min and max
            xe[i] = a + ((b - a) / 2.) * (np.sin(v) + 1.)

    return xe
429654
def _convert_internal(cls, record):
        
        if isinstance(record, list):
            return [cls._convert(r) for r in record]
        else:
            return cls._convert(record)
531495
private void internalRelease()
    {
        _facesContext = null;
        _componentInstance = null;
        _created = false;

        _childrenAdded = null;
        _facetsAdded = null;
    }
790282
function internalResolveDictionary(source, noFetch) {
    var dictionary;

    if (typeof source == 'string')
    {
      var location = source;
      var extname = basis.path.extname(location);

      if (extname != '.l10n')
        location = location.replace(new RegExp(extname + '([#?]|$)'), '.l10n$1');

      source = basis.resource(location);
    }

    if (basis.resource.isResource(source))
      dictionary = dictionaryByUrl[source.url];

    return dictionary || new Dictionary(source, noFetch);
  }