--- INTERNAL ---
488215
private static void writeConfig(String prefix, Config config, Properties properties) {
        for (String key : new TreeSet<>(config.keySet())) {
            Object value = config.get(key);

            String entryKey = makeKey(prefix, key);
            if (value instanceof Collection) {
                writeCollection(entryKey, (Collection) value, properties);
            } else {
                properties.setProperty(entryKey, asString(value));
            }
        }
    }
1327904
protected void internalStartValidation() {

        assert m_isNew : "A validation controller can only be used once!";
        m_isNew = false;

        m_validationOk = true;
        for (I_CmsFormField field : m_fields) {
            I_CmsFormField.ValidationStatus status = field.getValidationStatus();
            if (status == I_CmsFormField.ValidationStatus.unknown) {
                I_CmsValidator validator = field.getValidator();
                validator.validate(field, this);
                m_validatedFields.add(field.getId());
            } else if (status == I_CmsFormField.ValidationStatus.invalid) {
                m_validationOk = false;
            }
        }
        if (m_validationQueries.isEmpty()) {
            m_handler.onValidationFinished(m_validationOk);
            CmsValidationScheduler.get().executeNext();
        } else {
            if (m_formValidatorClass == null) {
                startAsyncValidation();
            } else {
                startAsyncValidation(m_formValidatorClass, m_formValidatorConfig);
            }
        }
    }
296742
public static InternalLogId allocate(String typeName, @Nullable String details) {
    return new InternalLogId(typeName, details, getNextId());
  }
899969
private ObjectNode internalCreateRequest(String methodName, Object arguments, String id) {
		final ObjectNode request = mapper.createObjectNode();
		addId(id, request);
		addProtocolAndMethod(methodName, request);
		addParameters(arguments, request);
		addAdditionalHeaders(request);
		notifyBeforeRequestListener(request);
		return request;
	}
498207
protected CmsAlias internalReadAlias(ResultSet resultset) throws SQLException {

        String siteRoot = resultset.getString(1);
        String path = resultset.getString(2);
        int mode = resultset.getInt(3);
        String structId = resultset.getString(4);
        return new CmsAlias(new CmsUUID(structId), siteRoot, path, CmsAliasMode.fromInt(mode));
    }
181073
public function set($key, $value)
    {
        Util::checkArgString($key);
        Util::checkArgSerializable($value);

        try {
            return $this->getAdapter()->set($key, $value);
        } catch (\Exception $e) {
            throw new InternalException($e->getMessage(), $e->getCode(), $e);
        }
    }
165131
private void internalBytes(Object source, Class sourceClass, byte[] data, int start, int count)
    {
        StringBuffer stringBuffer = new StringBuffer();

        stringBuffer.append(sourceClass.getName());
        stringBuffer.append(" [");

        if (source != null)
        {
            stringBuffer.append(source);
        }
        else
        {
            stringBuffer.append("Static");
        }

        stringBuffer.append("]");
        stringBuffer.append(ls);

        if (data != null)
        {
            if (count > 0)
            {
                stringBuffer.append(formatBytes(data, start, count, true));
            }
            else
            {
                stringBuffer.append(formatBytes(data, start, data.length, true));
            }
        }
        else
        {
            stringBuffer.append("data is null");
        }

        Tr.debug(traceComponent, stringBuffer.toString());

        if (usePrintWriterForTrace)
        {
            if (printWriter != null)
            {
                printWriter.print(new java.util.Date()+" B ");
                printWriter.println(stringBuffer.toString());
                printWriter.flush();
            }
        }
    }
235616
private void internalSet(VarTensor newFactor) {
        this.vars = newFactor.vars;
        this.dims = newFactor.dims;
        this.strides = newFactor.strides;
        this.values = newFactor.values;
    }
1373002
function internalError(response, message, body) {
  var content = errorContent(ErrorType.server, message, body);
  send(response, content, StatusCode.internalServerError);
}
8479
private void internalAdd(Cell cell)
    {
        if (cells.length == size)
            cells = Arrays.copyOf(cells, Math.max(MINIMAL_CAPACITY, size * 3 / 2 + 1));
        cells[size++] = cell;
    }
1208060
static function internalCharset()
    {
        $realCharset =& $GLOBALS['eZTextCodecInternalCharsetReal'];
        if ( !isset( $realCharset ) )
        {
            if ( !isset( $GLOBALS['eZTextCodecInternalCharset'] ) )
            {
                $i18n = eZINI::instance( 'i18n.ini', '', false );
                $charsetCode = $i18n->variable( 'CharacterSettings', 'Charset' );
            }
            else
                $charsetCode = $GLOBALS['eZTextCodecInternalCharset'];
            $realCharset = eZCharsetInfo::realCharsetCode( $charsetCode );
        }
        return $realCharset;
    }
1093973
private void internalSetParent(CommandRegistry parentRegistry) {
        
        if (!ObjectUtils.nullSafeEquals(this.parent, parentRegistry)) {
            
            if (this.parent != null) {
                this.parent.removeCommandRegistryListener(this);
            }
            
            this.parent = parentRegistry;
            
            if (this.parent != null) {
                this.parent.addCommandRegistryListener(this);
            }
            
        }
        
    }
260845
def data_parent(self) -> Optional["InternalNode"]:
        """"""
        parent = self.parent
        while parent:
            if isinstance(parent, DataNode):
                return parent
            parent = parent.parent
1170031
private static function isInternalPhpType(string $type): bool
    {
        return in_array(strtolower($type), self::$internalPhpTypes, true);
    }
523364
@Override
    protected XMLEvent internalNextEvent() throws XMLStreamException {
        // If there is an iterator to read from reset was called, use the iterator
        // until it runs out of events.
        if (this.bufferReader != null) {
            final XMLEvent event = this.bufferReader.next();

            // If nothing left in the iterator, remove the reference and fall through to direct
            // reading
            if (!this.bufferReader.hasNext()) {
                this.bufferReader = null;
            }

            return event;
        }

        // Get the next event from the underlying reader
        final XMLEvent event = this.getParent().nextEvent();

        // if buffering add the event
        if (this.eventLimit != 0) {
            this.eventBuffer.offer(event);

            // If limited buffer size and buffer is too big trim the buffer.
            if (this.eventLimit > 0 && this.eventBuffer.size() > this.eventLimit) {
                this.eventBuffer.poll();
            }
        }

        return event;
    }
687000
public void internalProcess( double[] input, DMatrix leftPoint, DMatrix rightView) {
		int numRows = getNumOfOutputsM();
		// number of parameters on left. All points
		int numPointParam = structure.points.length*lengthPoint + numRigidUnknown*lengthSE3;
		// Number of paramters on right. views + camera
		int numViewParam = numParameters-numPointParam; // view + camera

		((ReshapeMatrix)leftPoint).reshape(numRows,numPointParam);
		((ReshapeMatrix)rightView).reshape(numRows,numViewParam);
		leftPoint.zero();
		rightView.zero();

		// parse parameters for rigid bodies. the translation + rotation is the same for all views
		for (int rigidIndex = 0; rigidIndex < structure.rigids.length; rigidIndex++) {
			if( !structure.rigids[rigidIndex].known ) {
				jacRigidS03[rigidIndex].setParameters(input,indexFirstRigid+rigidParameterIndexes[rigidIndex]);
			}
		}

		int observationIndex = 0;
		// first decode the transformation
		for( int viewIndex = 0; viewIndex < structure.views.length; viewIndex++ ) {
			SceneStructureMetric.View view = structure.views[viewIndex];
			SceneStructureMetric.Camera camera = structure.cameras[view.camera];

			if( !view.known ) {
				int paramIndex = viewParameterIndexes[viewIndex]+indexFirstView;
				jacSO3.setParameters(input,paramIndex);
				paramIndex += jacSO3.getParameterLength();

				worldToView.T.x = input[paramIndex];
				worldToView.T.y = input[paramIndex+1];
				worldToView.T.z = input[paramIndex+2];

				worldToView.getR().set(jacSO3.getRotationMatrix());
			} else {
				worldToView.set(view.worldToView);
			}
			int cameraParamStartIndex = cameraParameterIndexes[view.camera];
			if( !camera.known ) {
				camera.model.setIntrinsic(input,indexLastView+cameraParamStartIndex);
			}

			observationIndex = computeGeneralPoints(leftPoint,rightView, input, observationIndex, viewIndex, view, camera, cameraParamStartIndex);
			if( observations.viewsRigid != null )
				observationIndex = computeRigidPoints(leftPoint,rightView,observationIndex, viewIndex, view, camera, cameraParamStartIndex);
		}
	}
480312
@MustBeLocked (ELockType.WRITE)
  protected final void internalMarkItemUndeleted (@Nonnull final IMPLTYPE aItem)
  {
    internalMarkItemUndeleted (aItem, true);
  }