Maps a Compound Input field to a internal simple input field.

@param in Compound input field.
@param to   internal Component
@param to_in  Input field of the internal component
353190
public void in2in(String in, Object to, String to_in) {
        controller.mapIn(in, to, to_in);
    }
935947
private int mapIndexToAction(int index) {
    if (index < buttonCount) {
      int count = -1;
      for (int x = 0; x < MAX_BUTTON_COUNT; x++) {
        if (fields[x]) {
          count++;
        }
        if (count == index) {
          return x;
        }
      }
    }
    return -1;
  }
1368737
public static void encodeSingle(final byte[] input, final int inoff,
                                    final byte[] output, final int outoff) {

        if (input == null) {
            throw new NullPointerException("input");
        }

        if (inoff < 0) {
            throw new IllegalArgumentException("inoff(" + inoff + ") < 0");
        }

        if (inoff >= input.length) {
            throw new IllegalArgumentException(
                "inoff(" + inoff + ") >= input.length(" + input.length + ")");
        }

        encodeSingle(input[inoff], output, outoff);
    }
297168
public void field2inout(Object o, String field, Object comp, String inout) {
        controller.mapInField(o, field, comp, inout);
        controller.mapOutField(comp, inout, o, field);
    }
1237415
@Deprecated
	public void setInput(Operator<IN>... input) {
		this.input = Operator.createUnionCascade(null, input);
	}
1056142
public void apply(Insert objectToInsert) {
    if (hasContentGenerationMatch()) {
      objectToInsert.setIfGenerationMatch(getContentGenerationMatch());
    }

    if (hasMetaGenerationMatch()) {
      objectToInsert.setIfMetagenerationMatch(getMetaGenerationMatch());
    }
  }
24100
public void incr(ResourceType resourceType) {
    Integer current = typeToCountMap.get(resourceType);
    if (current == null) {
      typeToCountMap.put(resourceType, new Integer(1));
    } else {
      typeToCountMap.put(resourceType, current + 1);
    }
  }
546192
protected void putMembersInIndexMap(TypeElement te) {
        adjustIndexMap(utils.getAnnotationFields(te));
        adjustIndexMap(utils.getFields(te));
        adjustIndexMap(utils.getMethods(te));
        adjustIndexMap(utils.getConstructors(te));
        adjustIndexMap(utils.getEnumConstants(te));
    }
876598
@Nonnull
    public static <T extends AbstractPattern> List<T> toList(@Nonnull Iterable<? extends T> in) {
        List<T> out = new ArrayList<T>();
        for (T i : in)
            out.add(i);
        return out;
    }
555298
public void setInRGB(IntRange inRGB) {
        this.inRed = inRGB;
        this.inGreen = inRGB;
        this.inBlue = inRGB;

        CalculateMap(inRGB, outRed, mapRed);
        CalculateMap(inRGB, outGreen, mapGreen);
        CalculateMap(inRGB, outBlue, mapBlue);
    }
92184
def type_in(type_s, el, args = {})
      extra_keys = args[:extra_keys] || [:enter]
      el = find_by_id("#{el}") if el.is_a? String
      el.native.clear()
      type_s.each_char do |key|
        el.native.send_keys(key)
      end
      el.send_keys(extra_keys)
    end
347199
public void setInput(int inputNum, INDArray input) {
        if (inputs == null) {
            //May be null after clear()
            inputs = new INDArray[numInputArrays];
        }
        inputs[inputNum] = input;
    }
266082
public final void mTO() throws RecognitionException {
        try {
            int _type = TO;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/dyuproject/protostuff/parser/ProtoLexer.g:83:5: ( 'to' )
            // com/dyuproject/protostuff/parser/ProtoLexer.g:83:9: 'to'
            {
            match("to"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
881981
public void out2in(Object from, String from_out, Object... tos) {
        for (Object co : tos) {
            out2in(from, from_out, co, from_out);
        }
    }
790826
protected Map<Character, List<Pair<FeaturePattern, FeatureReplacement>>> initMapping() {
		final Map<Character, List<Pair<FeaturePattern, FeatureReplacement>>> map = new TreeMap<>();
		if (!this.ruleReader.initializeConversions(map, this.context) && this.initializer != null) {
			this.initializer.initializeConversions((simpleName, source, target) -> {
				final char c = getKey(simpleName);
				if (c == FeaturePattern.ALL_PATTERN_CHAR) {
					for (int i = 'a'; i <= 'z'; ++i) {
						createMappingEntry(map, (char) i, source, target);
					}
				} else {
					createMappingEntry(map, c, source, target);
				}
			});
		}
		return map;
	}
473381
public void out2out(String out, Object to, String to_out) {
        controller.mapOut(out, to, to_out);
    }
837658
protected final NUMERICTYPE convertToOutputType(final double in) {
        if (performCalculationsAsDoublePrimitive) {
            NUMERICTYPE returnThis = null;
            try {
                returnThis = this.constructorOfNumericType.newInstance(in);
            } catch (IllegalArgumentException e) {
                e.printStackTrace();
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }
            return returnThis;
        } else {
            return convertToOutputType(Double.toString(in));
        }
    }