Bind annotated fields in the specified {@code target} from the {@link android.content.Intent}.

@param target Target object to bind the extras.
@param intent Intent containing the extras.
3336
public static <T> void bindExtras(T target, Intent intent) {
        @SuppressWarnings("unchecked")
        IntentBinding<T> binding = (IntentBinding<T>) getIntentBinding(target.getClass().getClassLoader(), target.getClass());
        if (binding != null) {
            binding.bindExtras(target, intent);
        }
    }
915519
@Override
    public IBinder onBind(Intent intent) {
        LogManager.i(TAG, "binding");
        return mMessenger.getBinder();
    }
1317799
@Override
	public void associateTargetWith( String targetId, AbstractApplication app, String instancePathOrComponentName )
	throws IOException, UnauthorizedActionException {

		boolean valid = false;
		if( instancePathOrComponentName == null ) {
			valid = true;

		} else if( instancePathOrComponentName.startsWith( "@" )) {
			Component comp = ComponentHelpers.findComponent( app, instancePathOrComponentName.substring( 1 ));
			valid = comp != null;

		} else {
			Instance instance = InstanceHelpers.findInstanceByPath( app, instancePathOrComponentName );
			valid = instance != null;
			if( instance != null ) {
				if( instance.getStatus() != InstanceStatus.NOT_DEPLOYED )
					throw new UnauthorizedActionException( "Operation not allowed: " + app + " :: " + instancePathOrComponentName + " should be not deployed." );

				if( ! InstanceHelpers.isTarget( instance ))
					throw new IllegalArgumentException( "Only scoped instances can be associated with targets. Path in error: " + instancePathOrComponentName );
			}
		}

		if( valid )
			saveAssociation( app, targetId, instancePathOrComponentName, true );
	}
1142339
public ConditionalMultibind<T> addBinding(Class<? extends T> target)
  {
    multibinder.addBinding().to(target);
    return this;
  }
545576
public void addMappingTarget(String mapping, RequestProcessor target) throws Exception
	{
		context.addMappingTarget(mapping, target);
	}
1031964
public static <T> void bindArguments(T target, Bundle bundle) {
        @SuppressWarnings("unchecked")
        BundleBinding<T> binding = (BundleBinding<T>) getBundleBinding(target.getClass().getClassLoader(), target.getClass());
        if (binding != null) {
            binding.bindArguments(target, bundle);
        }
    }
1101079
public static void unbindActionListeners(IActionTarget target, List<ActionListener> actionListeners) {
        if (actionListeners != null) {
            for (ActionListener listener : actionListeners) {
                listener.unbind(target);
            }
        }
    }
91325
public void setIntent(Intent intent) {
        synchronized (mInstanceLock) {
            if (mIntent == intent) {
                return;
            }
            mIntent = intent;
            mReloadActivities = true;
            ensureConsistentState();
        }
    }
79133
public static void mapping(String mappedFieldName, String mappedClassName, String targetFieldName, String targetClassName){
		throw new MappingErrorException(MSG.INSTANCE.message(mappingErrorException4,mappedFieldName,mappedClassName, targetFieldName,targetClassName));
	}
1942
public static <T> T getFieldValue(final Object target, final String name) {
		Field field = FieldUtils.getDeclaredField(target.getClass(), name, true);

		if (field == null) {
			throw new IllegalArgumentException("Could not find field [" + name + "] on target [" + target + ']');
		}

		T result = null;
		try {
			result = (T) field.get(target);
		} catch (IllegalAccessException e) {
			throw new ImpossibleException(e);
		}
		return result;
	}
1155270
public void setTarget(String v) {
    if (Link_Type.featOkTst && ((Link_Type)jcasType).casFeat_target == null)
      jcasType.jcas.throwFeatMissing("target", "de.julielab.jules.types.wikipedia.Link");
    jcasType.ll_cas.ll_setStringValue(addr, ((Link_Type)jcasType).casFeatCode_target, v);}
1076982
public void addTargetHandler( TargetHandler targetItf ) {

		if( targetItf != null ) {
			this.logger.info( "Target handler '" + targetItf.getTargetId() + "' is now available in Roboconf's DM." );

			synchronized( this.targetHandlers ) {
				this.targetHandlers.add( targetItf );
			}

			listTargets( this.targetHandlers, this.logger );
		}
	}
1319613
public void setTargets(java.util.Collection<String> targets) {
        if (targets == null) {
            this.targets = null;
            return;
        }

        this.targets = new java.util.ArrayList<String>(targets);
    }
545038
public static String setOrAppend(final String target, final String value, final boolean withSpace) {
        if (target == null) {
            return value;
        }if(value == null) {
            return target;
        } else {
            if (withSpace && !target.endsWith(STRING_BLANK)) {
                return target + STRING_BLANK + value;
            } else {
                return target + value;
            }
        }
    }
1140994
public void setContentAction(Action.OnActionListener listener, ComponentName activity, Bundle extra) {
        setContentAction(listener, activity, null, null, extra);
    }
498751
public void setEditorTarget (PropertyEditorTarget target)
    {
        if (target instanceof DBMetaCatalogNode)
        {
            super.setEditorTarget(target);
            this.tfCatalogName.setText((String)target.getAttribute(DBMetaCatalogNode.ATT_CATALOG_NAME));
        }
        else
        {
            throw new UnsupportedOperationException("This editor can only edit DBMetaCatalogNode objects");
        }
    }
341559
private void launchIntent(Intent intent) {
        if (intent == null) {
            return;
        }
        try {
            // If the intent was created from a suggestion, it will always have an explicit
            // component here.
            getContext().startActivity(intent);
        } catch (RuntimeException ex) {
            Log.e(LOG_TAG, "Failed launch activity: " + intent, ex);
        }
    }