Does the checking of all necessary values of the TransformationDescription which are needed to process the
description
971597
private void checkNeededValues(TransformationDescription description) {
        String message = "The TransformationDescription doesn't contain a %s. Description loading aborted";
        if (description.getSourceModel().getModelClassName() == null) {
            throw new IllegalArgumentException(String.format(message, "source class"));
        }
        if (description.getTargetModel().getModelClassName() == null) {
            throw new IllegalArgumentException(String.format(message, "target class"));
        }
        String message2 = "The version string of the %s is not a correct version string. Description loading aborted";
        try {
            Version.parseVersion(description.getSourceModel().getVersionString());
        } catch (IllegalArgumentException e) {
            throw new IllegalArgumentException(String.format(message2, "source class"), e);            
        }
        try {
            Version.parseVersion(description.getTargetModel().getVersionString());
        } catch (IllegalArgumentException e) {
            throw new IllegalArgumentException(String.format(message2, "target class"), e);            
        }
    }
1357238
function checkMetaDocsDescription (context, exportsNode) {
  if (exportsNode.type !== 'ObjectExpression') {
    // if the exported node is not the correct format, "internal-no-invalid-meta" will already report this.
    return
  }

  const metaProperty = getPropertyFromObject('meta', exportsNode)
  const metaDocs = metaProperty && getPropertyFromObject('docs', metaProperty.value)
  const metaDocsDescription = metaDocs && getPropertyFromObject('description', metaDocs.value)

  if (!metaDocsDescription) {
    // if there is no `meta.docs.description` property, "internal-no-invalid-meta" will already report this.
    return
  }

  const description = metaDocsDescription.value.value

  if (typeof description !== 'string') {
    context.report({
      node: metaDocsDescription.value,
      message: '`meta.docs.description` should be a string.'
    })
    return
  }

  if (description === '') {
    context.report({
      node: metaDocsDescription.value,
      message: '`meta.docs.description` should not be empty.'
    })
    return
  }

  if (description.indexOf(' ') === 0) {
    context.report({
      node: metaDocsDescription.value,
      message: '`meta.docs.description` should not start with whitespace.'
    })
    return
  }

  const firstWord = description.split(' ')[0]

  if (ALLOWED_FIRST_WORDS.indexOf(firstWord) === -1) {
    context.report({
      node: metaDocsDescription.value,
      message: '`meta.docs.description` should start with one of the following words: {{ allowedWords }}. Started with "{{ firstWord }}" instead.',
      data: {
        allowedWords: ALLOWED_FIRST_WORDS.join(', '),
        firstWord
      }
    })
  }

  if (description.endsWith('.')) {
    context.report({
      node: metaDocsDescription.value,
      message: '`meta.docs.description` should not end with `.`.',
      fix (fixer) {
        const pos = metaDocsDescription.range[1] - 2
        return fixer.removeRange([pos, pos + 1])
      }
    })
  }
}
1144642
private Set<String> checkModel(final ModelNode model, TransformationContext context) throws OperationFailedException {
        final Set<String> attributes = new HashSet<String>();
        AttributeTransformationRequirementChecker checker;
        for (final String attribute : attributeNames) {
            if (model.hasDefined(attribute)) {
                if (attributeCheckers != null && (checker = attributeCheckers.get(attribute)) != null) {
                    if (checker.isAttributeTransformationRequired(attribute, model.get(attribute), context)) {
                        attributes.add(attribute);
                    }
                } else if (SIMPLE_EXPRESSIONS.isAttributeTransformationRequired(attribute, model.get(attribute), context)) {
                    attributes.add(attribute);
                }
            }
        }
        return attributes;
    }
726549
function recordTransformer(table){
	
	/**
	*	Process record transformation
	*/
	this.process = function( record ){
		if ( !table.name ){
			return;
		}
		var tableName = table.name.toLowerCase();
		if ( transformConfiguration.hasOwnProperty( tableName )){
			var requiredFields = transformConfiguration[tableName].requiredFields;
			if ( requiredFields ){
				_.forEach( requiredFields, function( fieldName ){
					if ( !record.hasOwnProperty(fieldName) || record[fieldName] == null ){
						record[fieldName] = "";
					}
				})
			}
		}
	}
}
328659
def itransform_define(transform):
        
        if transform == 'tanh':
            return np.arctanh
        elif transform == 'exp':
            return np.log
        elif transform == 'logit':
            return Family.logit
        elif transform is None:
            return np.array
        else:
            return None
910041
private void writeAffineTransform (final AffineTransform transform) throws IOException
  {
    final double [] values = new double [6];
    transform.getMatrix (values);
    for (final double v : values)
    {
      writeOperand ((float) v);
    }
  }
803063
private void writeTextHandleTransformAs(String transformName, ExtensionMetadata metadata, Object source, String transformType)
    throws ResourceNotFoundException, ResourceNotResendableException, ForbiddenUserException, FailedRequestException {
    if (source == null) {
      throw new IllegalArgumentException("no source to write");
    }

    Class<?> as = source.getClass();

    TextWriteHandle sourceHandle = null;
    if (TextWriteHandle.class.isAssignableFrom(as)) {
      sourceHandle = (TextWriteHandle) source;
    } else {
      ContentHandle<?> handle = getHandleRegistry().makeHandle(as);
      if (!TextWriteHandle.class.isAssignableFrom(handle.getClass())) {
        throw new IllegalArgumentException(
          "Handle "+handle.getClass().getName()+
            " cannot be used to write transform source as "+as.getName()
        );
      }
      Utilities.setHandleContent(handle, source);
      sourceHandle = (TextWriteHandle) handle;
    }

    if (transformType.equals("javascript")) {
      writeJavascriptTransform(transformName, sourceHandle, metadata);
    }
    else if (transformType.equals("xquery")) {
      writeXQueryTransform(transformName, sourceHandle, metadata);
    }
  }
641539
@Override
    public boolean contains(Object value) {
        final Iterator<Comparable> iter = new StepIterator(this, 1);
        if (value == null) {
            return false;
        }
        while (iter.hasNext()) {
            if (DefaultTypeTransformation.compareEqual(value, iter.next())) return true;
        }
        return false;
    }
1227438
boolean hasTransformation() {

        String transformationPath = getTransformationPath();
        boolean result = (transformationPath != null) && new File(transformationPath).exists();
        if (result) {
            CmsLog.INIT.info(Messages.get().getBundle().key(Messages.INIT_XSLT_CONFIG_ENABLED_1, transformationPath));
        } else {
            CmsLog.INIT.info(Messages.get().getBundle().key(Messages.INIT_XSLT_CONFIG_DISABLED_0));
        }
        return result;
    }
1019302
private void performTransformation(MutableRenderingContext renderingContext, Transformation transformation,
        TransformationContext context, Block block) throws MacroExecutionException
    {
        try {
            renderingContext.transformInContext(transformation, context, block);
        } catch (Exception e) {
            throw new MacroExecutionException("Failed to perform transformation", e);
        }
    }
1058486
private boolean shouldVerifyCompletenessForDataset(Dataset dataset, List<Pattern> blacklist,
    List<Pattern> whitelist) {
    boolean renamingRequired = this.state.getPropAsBoolean(COMPACTION_RENAME_SOURCE_DIR_ENABLED, DEFAULT_COMPACTION_RENAME_SOURCE_DIR_ENABLED);

    LOG.info ("Should verify completeness with renaming source dir : " + renamingRequired);

    return !datasetAlreadyCompacted(this.fs, dataset, renamingRequired)
        && DatasetFilterUtils.survived(dataset.getName(), blacklist, whitelist);
  }
957006
private boolean checkArrivedY(double extrp, double sy, double dy)
    {
        final double y = transformable.getY();
        if (sy < 0 && y <= dy || sy >= 0 && y >= dy)
        {
            transformable.moveLocation(extrp, 0, dy - y);
            return true;
        }
        return false;
    }
893186
def set_transform_interface_params(spec, input_features, output_features, are_optional = False):
    
    input_features = _fm.process_or_validate_features(input_features)
    output_features = _fm.process_or_validate_features(output_features)

    # Add input and output features
    for (fname, ftype) in input_features:
        input_ = spec.description.input.add()
        input_.name = fname
        datatypes._set_datatype(input_.type, ftype)
        if are_optional:
            input_.type.isOptional = are_optional

    for (fname, ftype) in output_features:
        output_ = spec.description.output.add()
        output_.name = fname
        datatypes._set_datatype(output_.type, ftype)

    return spec
1335072
function transformData( &$data, /* bool */ $toLocal )
    {
        // Check if it is already in correct format
        if ( isset( $data['_info']['format'] ) )
        {
            if ( $data['_info']['format'] == ( $toLocal ? 'local' : 'generic' ) )
                return true;
        }

        // Set the new format it will get
        $data['_info']['format'] = $toLocal ? 'local' : 'generic';

        // load the schema transformation rules
        $schemaType = $this->schemaType();
        $schemaTransformationRules = eZDBSchemaInterface::loadSchemaTransformationRules( $schemaType );
        if ( $schemaTransformationRules === false )
            return false;

        // transform column names
        foreach ( $schemaTransformationRules['column-name'] as $key => $val )
        {
            list( $tableName, $genericColName ) = explode( '.', $key );
            $localColName = $val;

            if ( $toLocal )
            {
                $searchColName = $genericColName;
                $replacementColName = $localColName;
            }
            else
            {
                $searchColName = $localColName;
                $replacementColName = $genericColName;
            }

            if ( !isset( $data[$tableName] ) )
                continue;

            // transform column names in tables
            $fieldsData = $data[$tableName]['fields'];
            foreach ( $fieldsData as $key => $fieldName )
            {
                if ( $searchColName == $fieldName )
                {
                    $data[$tableName]['fields'][$key] = $replacementColName;
                    eZDebugSetting::writeDebug( 'lib-dbschema-data-transformation', '',
                                                "transformed table column name $tableName.$searchColName to $replacementColName" );
                }
            }
        }

        return true;
    }
815289
private Statement transformExtendedTryWithResourcesStatement(TryCatchStatement tryCatchStatement) {
        /*
         *  try ResourceSpecification
         *      Block
         */
        TryCatchStatement newTryWithResourcesStatement =
                new TryCatchStatement(
                        tryCatchStatement.getTryStatement(),
                        EmptyStatement.INSTANCE);
        tryCatchStatement.getResourceStatements().forEach(newTryWithResourcesStatement::addResource);


        /*
         *   try {
         *       << the following try-with-resources has been transformed >>
         *       try ResourceSpecification
         *           Block
         *   }
         *   Catchesopt
         *   Finallyopt
         */
        TryCatchStatement newTryCatchStatement =
                new TryCatchStatement(
                        astBuilder.createBlockStatement(this.transform(newTryWithResourcesStatement)),
                        tryCatchStatement.getFinallyStatement());

        tryCatchStatement.getCatchStatements().forEach(newTryCatchStatement::addCatch);

        return newTryCatchStatement;
    }
559068
function processCompositionExpressions( composition, item, itemPointer, containingPageRef ) {

      const { name, definition } = composition;

      // Feature definitions in compositions may contain generated topics for default resource names or action
      // topics. As such these are generated before instantiating the composition's features.
      const ref = item.composition;
      const validate = validators.features.pages[ name ];

      if( validate && !validate( item, `${itemPointer}` ) ) {
         throw validators.error(
            `Validation of page ${containingPageRef} failed for ${ref} features`,
            validate.errors
         );
      }

      if( typeof definition.mergedFeatures === 'object' ) {
         const mergedFeatures = interpolator.interpolate( item, definition.mergedFeatures );
         Object.keys( mergedFeatures ).forEach( featurePath => {
            const currentValue = path( item.features, featurePath, [] );
            const values = mergedFeatures[ featurePath ];
            setPath( item.features, featurePath, values.concat( currentValue ) );
         } );
      }

      definition.areas = interpolator.interpolate( item, definition.areas );

      return composition;

   }
726579
private static boolean requiredByOtherFeature(ContentBasedLocalBundleRepository br, Map<String, ProvisioningFeatureDefinition> features, File b) {
        for (ProvisioningFeatureDefinition fd : features.values()) {
            if (requiredByJar(br, fd, b))
                return true;
        }
        return false;
    }