True iif input target is intercepted.

    :param target: target to check such as an intercepted target.

    :return: True iif input target is intercepted.
    :rtype: bool
344668
def is_intercepted(target):
    

    result = False

    # get interception function from input target
    function = _get_function(target)

    result = hasattr(function, _INTERCEPTED)

    return result
316744
public boolean matches(String target, Match match) {
		return this.matches(target, 0, target.length(), match);
	}
525012
def get_inputs_helper(step, ignore, target):
    
    outputs = set()
    if not ignore and step.target == target:
        outputs.add(step)

    if ignore or not step.target:
        for i in step.inputs:
            outputs.update(get_inputs_helper(i, ignore=False, target=target))

    return outputs
401527
def _is_target_a_directory(link, rel_target):
	
	target = os.path.join(os.path.dirname(link), rel_target)
	return os.path.isdir(target)
792002
def target(self, value):
        
        if value == self._defaults['target'] and 'target' in self._values:
            del self._values['target']
        else:
            self._values['target'] = value
277209
protected boolean isTypeableTarget (Component target)
    {
        return target.isShowing() &&
            (((target instanceof JTextComponent) && ((JTextComponent) target).isEditable()) ||
             (target instanceof JComboBox) ||
             (target instanceof JTable) ||
             (target instanceof JRootPane));
    }
214009
def is_type_target(self):
        
        if self._is_type_target is None:
            #All we need to do is search through the custom types in the parent
            #module and see if any of their executables points to this method.
            self._is_type_target = False
            for tkey in self.module.types:
                custype = self.module.types[tkey]
                for execkey, execinst in custype.executables.items():
                    if execinst.target is self:
                        self._is_type_target = custype
                        break
                if self._is_type_target:
                    break

        return self._is_type_target
216763
def calculateKey( cls, target ):
        
        return (id(getattr(target,im_self)),id(getattr(target,im_func)))
94674
private boolean hasChangedPosition(I_CmsDropTarget target) {

        if ((m_currentTarget != target) || (m_currentIndex != target.getPlaceholderIndex())) {
            m_currentTarget = target;
            m_currentIndex = target.getPlaceholderIndex();
            return true;
        }
        return false;
    }
1254349
def set_target(self, target):
        '''
        
        '''
        self.target = target
        if target:
            self.target.set_fuzzer(self)
        return self
860733
protected function hasTargetedBinding(string $interface, string $target = null) : bool
    {
        return isset($this->bindings[$target][$interface]);
    }
51479
def unmonitor(self, target):
        
        if 'monitor-notify' in self._capabilities and self.is_monitoring(target):
            yield from self.rawmsg('MONITOR', '-', target)
            self._monitoring.remove(target)
            return True
        else:
            return False
1242350
private IStatus validateTarget(Object target, TransferData transferType,
			int dropOperation) {
		
		

		if (target instanceof IVdmContainer) {
			target = ((IVdmContainer) target).getContainer();
		} 
		
		if (!(target instanceof IResource)) {
			return WorkbenchNavigatorPlugin
					.createInfoStatus(WorkbenchNavigatorMessages.DropAdapter_targetMustBeResource);
		}						
		IResource resource = (IResource) target;
		if (!resource.isAccessible()) {
			return WorkbenchNavigatorPlugin
					.createErrorStatus(WorkbenchNavigatorMessages.DropAdapter_canNotDropIntoClosedProject);
		}
		IContainer destination = getActualTarget(resource);
		if (destination.getType() == IResource.ROOT) {
			return WorkbenchNavigatorPlugin
					.createErrorStatus(WorkbenchNavigatorMessages.DropAdapter_resourcesCanNotBeSiblings);
		}
		String message = null;
		// drag within Eclipse?
		if (LocalSelectionTransfer.getTransfer().isSupportedType(transferType)) {
			IResource[] selectedResources = getSelectedResources();

			if (selectedResources.length == 0) {
				message = WorkbenchNavigatorMessages.DropAdapter_dropOperationErrorOther;
			} else {
				CopyFilesAndFoldersOperation operation;
				if (dropOperation == DND.DROP_COPY) {
					operation = new CopyFilesAndFoldersOperation(getShell());
				} else {
					operation = new MoveFilesAndFoldersOperation(getShell());
				}
				message = operation.validateDestination(destination,
						selectedResources);
			}
		} // file import?
		else if (FileTransfer.getInstance().isSupportedType(transferType)) {
			String[] sourceNames = (String[]) FileTransfer.getInstance()
					.nativeToJava(transferType);
			if (sourceNames == null) {
				// source names will be null on Linux. Use empty names to do
				// destination validation.
				// Fixes bug 29778
				sourceNames = new String[0];
			}
			CopyFilesAndFoldersOperation copyOperation = new CopyFilesAndFoldersOperation(
					getShell());
			message = copyOperation.validateImportDestination(destination,
					sourceNames);
		}
		if (message != null) {
			return WorkbenchNavigatorPlugin.createErrorStatus(message);
		}
		return Status.OK_STATUS;
	}
438548
private static boolean isAssignableFrom(Class<?> src, Class<?> target) {
        // src will always be an object
        // Short-cut. null is always assignable to an object and in EL null
        // can always be coerced to a valid value for a primitive
        if (src == null) {
            return true;
        }

        Class<?> targetClass;
        if (target.isPrimitive()) {
            if (target == Boolean.TYPE) {
                targetClass = Boolean.class;
            } else if (target == Character.TYPE) {
                targetClass = Character.class;
            } else if (target == Byte.TYPE) {
                targetClass = Byte.class;
            } else if (target == Short.TYPE) {
                targetClass = Short.class;
            } else if (target == Integer.TYPE) {
                targetClass = Integer.class;
            } else if (target == Long.TYPE) {
                targetClass = Long.class;
            } else if (target == Float.TYPE) {
                targetClass = Float.class;
            } else {
                targetClass = Double.class;
            }
        } else {
            targetClass = target;
        }
        return targetClass.isAssignableFrom(src);
    }
966857
def _copy_source_to_target(self):
        
        if self.source and self.target:
            for k, v in self.source.items('config'):
                # always have source override target.
                self.target.set_input(k, v)
241730
def set_target(self, new_target):
        
        try:
            self.device.target = new_target
            return 'T={}'.format(new_target)
        except RuntimeError:
            return 'err: not idle'
        except ValueError:
            return 'err: not 0<=T<=250'
780965
def _bind_target(self, target, ctx=None, *args, **kwargs):
        """"""

        result = super(Interceptor, self)._bind_target(
            target=target, ctx=ctx, *args, **kwargs
        )

        pointcut = getattr(self, Interceptor.POINTCUT)

        weave(result, pointcut=pointcut, advices=self.intercepts, ctx=ctx)

        return result