Dummy convert

@param decision
@return
3349
private String getStatusCode(DecisionType decision) {
        if (fXACMLParsingError) {
            return STATUS_CODE_SYNTAX_ERROR;
        } else if (fProcessingError) {
            return STATUS_CODE_PROCESSING_ERROR;
        } else if (decision == DecisionType.Deny ||
                decision == DecisionType.Permit) {
            return STATUS_CODE_OK;
        } else if (decision == DecisionType.Indeterminate ||
                decision == DecisionType.Indeterminate_D ||
                decision == DecisionType.Indeterminate_P ||
                decision == DecisionType.Indeterminate_DP) {
            return STATUS_CODE_MISSING_ATTRIBUTE;
        } else {
            logger.debug("Unknown status code decision");
            return STATUS_CODE_PROCESSING_ERROR;
        }
    }
673546
def decision_function(self, X):
        ""
        self._X = Model.convert_features(X)
        self._eval()
        return self._ind[0].hy
736606
public Assignment outcomeToAssignment(Object[] outcome) {
    Preconditions.checkArgument(outcome.length == nums.length,
        "outcome %s cannot be assigned to %s (wrong number of values)", outcome, this);
    return Assignment.fromSortedArrays(nums, outcome);
  }
752754
@Override
    public void copyFrom(Frame<IsNullValue> other) {
        super.copyFrom(other);
        decision = ((IsNullValueFrame) other).decision;
        if (trackValueNumbers) {
            knownValueMap = Util.makeSmallHashMap(((IsNullValueFrame) other).knownValueMap);
        }
    }
690088
public <T> T convert(Type type, Object value) throws ConvertException {
		return convert(type, value, null);
	}
805305
@Override
	public String convert(SIFInteraction inter)
	{
		String s = inter.toString();

		for (OutputColumn column : columns)
		{
			s += "\t" + column.getColumnValue(inter);
		}

		return s;
	}
859407
public DecisionDefinitionEntity getPreviousDefinition() {
    DecisionDefinitionEntity previousDecisionDefinition = null;

    String previousDecisionDefinitionId = getPreviousDecisionDefinitionId();
    if (previousDecisionDefinitionId != null) {

      previousDecisionDefinition = loadDecisionDefinition(previousDecisionDefinitionId);

      if (previousDecisionDefinition == null) {
        resetPreviousDecisionDefinitionId();
        previousDecisionDefinitionId = getPreviousDecisionDefinitionId();

        if (previousDecisionDefinitionId != null) {
          previousDecisionDefinition = loadDecisionDefinition(previousDecisionDefinitionId);
        }
      }
    }

    return previousDecisionDefinition;
  }
62754
public void setFidelity(String key, boolean decision)
			throws UnsupportedOption {
		if (key.equals(FEATURE_STRICT)) {
			if (decision) {
				// no other features allowed
				// (LEXICAL_VALUE is an exception)
				boolean prevContainedLexVal = options
						.contains(FEATURE_LEXICAL_VALUE);

				options.clear();
				isComment = false;
				isPI = false;
				isDTD = false;
				isPrefix = false;
				isLexicalValue = false;
				isSC = false;

				if (prevContainedLexVal) {
					options.add(FEATURE_LEXICAL_VALUE);
					isLexicalValue = true;
				}
				options.add(FEATURE_STRICT);

				isStrict = true;
			} else {
				// remove strict (if present)
				options.remove(key);
				isStrict = false;
			}
		} else if (key.equals(FEATURE_LEXICAL_VALUE)) {
			// LEXICAL_VALUE is special --> does affect grammars
			if (decision) {
				options.add(key);
				isLexicalValue = true;
			} else {
				// remove option (if present)
				options.remove(key);
				isLexicalValue = false;
			}
		} else if (key.equals(FEATURE_COMMENT) || key.equals(FEATURE_PI)
				|| key.equals(FEATURE_DTD) || key.equals(FEATURE_PREFIX)
				|| key.equals(FEATURE_SC)) {
			if (decision) {
				if (isStrict()) {
					options.remove(FEATURE_STRICT);
					this.isStrict = false;
					// TODO inform user that STRICT mode is de-activated
					// throw new UnsupportedOption(
					// "StrictMode is exclusive and does not allow any other option.");
				}
				options.add(key);
				if (key.equals(FEATURE_COMMENT)) {
					isComment = true;
				}
				if (key.equals(FEATURE_PI)) {
					isPI = true;
				}
				if (key.equals(FEATURE_DTD)) {
					isDTD = true;
				}
				if (key.equals(FEATURE_PREFIX)) {
					isPrefix = true;
				}
				if (key.equals(FEATURE_SC)) {
					isSC = true;
				}
			} else {
				// remove option (if present)
				options.remove(key);
				if (key.equals(FEATURE_COMMENT)) {
					isComment = false;
				}
				if (key.equals(FEATURE_PI)) {
					isPI = false;
				}
				if (key.equals(FEATURE_DTD)) {
					isDTD = false;
				}
				if (key.equals(FEATURE_PREFIX)) {
					isPrefix = false;
				}
				if (key.equals(FEATURE_SC)) {
					isSC = false;
				}
			}
		} else {
			throw new UnsupportedOption("FidelityOption '" + key
					+ "' is unknown!");
		}
	}
1158277
public static <A, B> Choice2<A, B> a(A a) {
        return new _A<>(a);
    }
1349609
protected
  Object convertArg(String val, Class type) {
    if(val == null)
      return null;

    String v = val.trim();
    if (String.class.isAssignableFrom(type)) {
      return val;
    } else if (Integer.TYPE.isAssignableFrom(type)) {
      return new Integer(v);
    } else if (Long.TYPE.isAssignableFrom(type)) {
      return new Long(v);
    } else if (Boolean.TYPE.isAssignableFrom(type)) {
      if ("true".equalsIgnoreCase(v)) {
        return Boolean.TRUE;
      } else if ("false".equalsIgnoreCase(v)) {
        return Boolean.FALSE;
      }
    } else if (Priority.class.isAssignableFrom(type)) {
      return OptionConverter.toLevel(v, (Level) Level.DEBUG);
    } else if (ErrorHandler.class.isAssignableFrom(type)) {
      return OptionConverter.instantiateByClassName(v,
	  ErrorHandler.class, null);
    }
    return null;
  }
416850
public static int compare(String left, double right) {
	if (Decision.isNumber(left)) {
	    if (left.length() > 9) {
		try {
		    return new BigDecimal(left).compareTo(new BigDecimal(Caster.toString(right)));
		}
		catch (Exception e) {}
	    }
	    return compare(Caster.toDoubleValue(left, Double.NaN), right);
	}
	if (Decision.isBoolean(left)) return compare(Caster.toBooleanValue(left, false), right);

	if (left.length() == 0) return -1;
	char leftFirst = left.charAt(0);
	if (leftFirst >= '0' && leftFirst <= '9') return left.compareToIgnoreCase(Caster.toString(right));
	return leftFirst - '0';
    }
1113028
private BigInteger toBigInteger(Object value) {
		if (value instanceof Long) {
			return BigInteger.valueOf((Long) value);
		} else if(value instanceof Boolean) {
			return BigInteger.valueOf((boolean)value ? 1 : 0);
		}
		final String valueStr = convertToStr(value);
		if (StrUtil.isBlank(valueStr)) {
			return null;
		}
		return new BigInteger(valueStr);
	}
211973
def _convert_choices(self, choices):
        """"""

        final_choices = []
        for choice in choices:

            if isinstance(choice, ChoiceEntry):
                final_choices.append(choice)
                continue

            original_choice = choice
            if isinstance(choice, six.string_types):
                if choice == _NO_SUBSET_NAME_:
                    continue
                choice = [choice, ]
            else:
                choice = list(choice)

            length = len(choice)

            assert 1 <= length <= 4, 'Invalid number of entries in %s' % (original_choice,)

            final_choice = []

            # do we have attributes?
            if length > 1 and isinstance(choice[-1], Mapping):
                final_choice.append(choice.pop())
            elif length == 4:
                attributes = choice.pop()
                assert attributes is None or isinstance(attributes, Mapping), 'Last argument must be a dict-like object in %s' % (original_choice,)
                if attributes:
                    final_choice.append(attributes)

            # the constant
            final_choice.insert(0, choice.pop(0))

            if len(choice):
                # we were given a db value
                final_choice.insert(1, choice.pop(0))
                if len(choice):
                    # we were given a display value
                    final_choice.insert(2, choice.pop(0))
            else:
                # set None to compute it later
                final_choice.insert(1, None)

            if final_choice[1] is None:
                # no db value, we compute it from the constant
                final_choice[1] = self.value_transform(final_choice[0])

            final_choices.append(final_choice)

        return super(AutoChoices, self)._convert_choices(final_choices)
482595
public static Object convertValue(final Object value, final Class<?> convertType) {
        if (null == value) {
            return convertNullValue(convertType);
        } 
        if (value.getClass() == convertType) {
            return value;
        }
        if (value instanceof Number) {
            return convertNumberValue(value, convertType);
        }
        if (value instanceof Date) {
            return convertDateValue(value, convertType);
        }
        if (String.class.equals(convertType)) {
            return value.toString();
        } else {
            return value;
        }
    }
670787
BigInteger toBigInteger(int sign) {
        if (intLen == 0 || sign == 0)
            return BigInteger.ZERO;
        return new BigInteger(getMagnitudeArray(), sign);
    }
1319433
@Override
    public Collection<StatementOrBundle> convert(String pgmfile, 
                                                 String activity, 
                                                 String giffile, String giflabel,
                                                 String workflow, String agent)  {
        
        Collection<StatementOrBundle> ll=new LinkedList<StatementOrBundle>();

        Activity a13 = pFactory.newActivity(pc(activity));
        pFactory.addType(a13, pFactory.newQualifiedName(PRIM_NS, CONVERT,    PRIM_PREFIX), name.PROV_QUALIFIED_NAME);
        
        Entity e25 = pFactory.newEntity(pc(pgmfile));

        Entity e28 = newFile(pFactory, giffile, giflabel);
        
        ll.add(newUsed(a13, ROLE_IN, e25));
        
        WasGeneratedBy wg18 = newWasGeneratedBy(e28, ROLE_OUT, a13);
        //wg18.setTime(pFactory.newTimeNow());
        
        ll.add(newWasDerivedFrom(e28, e25));
        
        ll.add(pFactory.newAgent(pc(agent)));
        ll.add(pFactory.newActivity(pc(workflow)));
        ll.add(pFactory.newWasAssociatedWith(null,pc(workflow), pc(agent)));
        ll.add(pFactory.newWasStartedBy(null, pc(activity), null, pc(workflow)));
        
        ll.addAll(Arrays.asList(a13,e25,e28,wg18));
        return ll;
        
    }
791329
public Collection<T> filterAsCollection(Predicate<T> decision) {
		return Collections2.filter(elements.get(), decision);
	}