import org.pentaho.di.core.injection.Injection; //导入依赖的package包/类
protected void addInjectionProperty( Injection metaInj, BeanLevelInfo leaf ) {
  if ( StringUtils.isBlank( metaInj.name() ) ) {
    throw new RuntimeException( "Property name shouldn't be blank in the " + clazz );
  }

  String propertyName = calcPropertyName( metaInj, leaf );
  if ( properties.containsKey( propertyName ) ) {
    throw new RuntimeException( "Property '" + propertyName + "' already defined for " + clazz );
  }

  // probably hided
  if ( hideProperties.contains( propertyName ) ) {
    return;
  }

  Property prop = new Property( propertyName, metaInj.group(), leaf.createCallStack() );
  properties.put( prop.name, prop );
  Group gr = groupsMap.get( metaInj.group() );
  if ( gr == null ) {
    throw new RuntimeException( "Group '" + metaInj.group() + "' for property '" + metaInj.name()
        + "' is not defined " + clazz );
  }
  gr.groupProperties.add( prop );
}
 

import org.pentaho.di.core.injection.Injection; //导入依赖的package包/类
@Injection( name = "CONDITION" )
public void setConditionXML( String conditionXML ) {
  try  {
    this.condition = new Condition( conditionXML );
  } catch ( KettleXMLException e ) {
    log.logError( e.getMessage() );
  }
}
 

import org.pentaho.di.core.injection.Injection; //导入依赖的package包/类
@Injection( name = "PARAMETER_NAME", group = "PARAMETERS" )
public void setParameter( String value ) {
  parameter = value;
  if ( parameter != null && field != null ) {
    setup();
  }
}
 

import org.pentaho.di.core.injection.Injection; //导入依赖的package包/类
@Injection( name = "FIELDNAME", group = "PARAMETERS" )
public void setField( String value ) {
  field = value;
  if ( parameter != null && field != null ) {
    setup();
  }
}
 

import org.pentaho.di.core.injection.Injection; //导入依赖的package包/类
private String calcPropertyName( Injection metaInj, BeanLevelInfo leaf ) {
  String name = metaInj.name();
  while ( leaf != null ) {
    if ( StringUtils.isNotBlank( leaf.prefix ) ) {
      name = leaf.prefix + '.' + name;
    }
    leaf = leaf.parent;
  }
  if ( !name.equals( metaInj.name() ) && !metaInj.group().isEmpty() ) {
    // group exist with prefix
    throw new RuntimeException( "Group shouldn't be declared with prefix in " + clazz );
  }
  return name;
}
 

import org.pentaho.di.core.injection.Injection; //导入依赖的package包/类
@Injection( name = "CONNECTIONNAME" )
public void setConnection( String connectionName ) {
  databaseMeta = DatabaseMeta.findDatabase( databases, connectionName );
}
 

import org.pentaho.di.core.injection.Injection; //导入依赖的package包/类
@Injection( name = "FIELD_INDEXED", group = "FIELDS" )
public void setIndexedVals( String vals ) {
  m_indexedVals = MongoDbInputData.indexedValsList( vals );
}
 

import org.pentaho.di.core.injection.Injection; //导入依赖的package包/类
@Injection( name = "CONNECTION_NAME" )
public void setConnection( String connectionName ) {
  databaseMeta = DatabaseMeta.findDatabase( databases, connectionName );
}
 

import org.pentaho.di.core.injection.Injection; //导入依赖的package包/类
@Injection( name = "META_TYPE", group = "METAS" )
public void setType( String value ) {
  type = ValueMetaFactory.getIdForValueMeta( value );
}
 

import org.pentaho.di.core.injection.Injection; //导入依赖的package包/类
@Injection( name = "META_STORAGE_TYPE", group = "METAS" )
public void setStorageType( String storageType ) {
  this.storageType = ValueMetaBase.getStorageType( storageType );
}
 

import org.pentaho.di.core.injection.Injection; //导入依赖的package包/类
@Injection( name = "SEND_TRUE_STEP" )
public void setTrueStepname( String trueStepname ) {
  getStepIOMeta().getTargetStreams().get( 0 ).setSubject( trueStepname );
}
 

import org.pentaho.di.core.injection.Injection; //导入依赖的package包/类
@Injection( name = "SEND_FALSE_STEP" )
public void setFalseStepname( String falseStepname ) {
  getStepIOMeta().getTargetStreams().get( 1 ).setSubject( falseStepname );
}
 

import org.pentaho.di.core.injection.Injection; //导入依赖的package包/类
/**
 * @param fileFormat
 *          The fileFormat to set.
 */
@Injection( name = "FORMAT" )
public void setFileFormat( String fileFormat ) {
  this.fileFormat = fileFormat;
  this.newline = getNewLine( fileFormat );
}
 

import org.pentaho.di.core.injection.Injection; //导入依赖的package包/类
@Injection( name = "OUTPUT_TYPE", group = "OUTPUT_FIELDS" )
public void setType( String typeDesc ) {
  this.type = ValueMetaFactory.getIdForValueMeta( typeDesc );
}
 

import org.pentaho.di.core.injection.Injection; //导入依赖的package包/类
@Injection( name = "OUTPUT_TRIM", group = "OUTPUT_FIELDS" )
public void setTrimTypeByDesc( String value ) {
  this.trimType = ValueMetaString.getTrimTypeByDesc( value );
}
 

import org.pentaho.di.core.injection.Injection; //导入依赖的package包/类
@Injection( name = "CONDITION" )
public void setCondition( String conditionXML ) throws Exception {
  condition = new Condition( conditionXML );
}
 

import org.pentaho.di.core.injection.Injection; //导入依赖的package包/类
@Injection( name = "CONNECTIONNAME" )
public void setConnection( String connectionName ) {
  database = DatabaseMeta.findDatabase( databases, connectionName );
}
 

import org.pentaho.di.core.injection.Injection; //导入依赖的package包/类
@Injection( name = "FIELD_TYPE", group = "FIELDS" )
public void setType( String value ) {
  this.type = ValueMetaFactory.getIdForValueMeta( value );
}
 

import org.pentaho.di.core.injection.Injection; //导入依赖的package包/类
@Injection( name = "FIELD_TRIM_TYPE", group = "FIELDS" )
public void setTrimType( String value ) {
  this.trimtype = ValueMetaString.getTrimTypeByCode( value );
}
 

import org.pentaho.di.core.injection.Injection; //导入依赖的package包/类
@Injection( name = "TYPE", group = "FIELDS" )
public void setType( String typeDesc ) {
  this.type = ValueMetaFactory.getIdForValueMeta( typeDesc );
}