Add 'target' to the list of targets in this project
        that should be build only by explicit request.
183285
def mark_targets_as_explicit (self, target_names):
        """"""

        # Record the name of the target, not instance, since this
        # rule is called before main target instaces are created.
        assert is_iterable_typed(target_names, basestring)
        self.explicit_targets_.update(target_names)
249608
def add_instruction(self, target, data):
        
        self._add_instruction(self.impl_node, target, data)
60942
def add_targets_to_INSTALLED_FILES(target, source, env):
    
    global _INSTALLED_FILES, _UNIQUE_INSTALLED_FILES
    _INSTALLED_FILES.extend(target)

    _UNIQUE_INSTALLED_FILES = None
    return (target, source)
340633
def construct (self, properties = [], targets = []):
        
        if not targets:
            for name, project in self.projects ().projects ():
                targets.append (project.target ())

        property_groups = build_request.expand_no_defaults (properties)

        virtual_targets = []
        build_prop_sets = []
        for p in property_groups:
            build_prop_sets.append (property_set.create (feature.split (p)))

        if not build_prop_sets:
            build_prop_sets = [property_set.empty ()]

        for build_properties in build_prop_sets:
            for target in targets:
                result = target.generate (build_properties)
                virtual_targets.extend (result.targets ())

        actual_targets = []
        for virtual_target in virtual_targets:
            actual_targets.extend (virtual_target.actualize ())
290025
@Override
    public T add(final Asset asset, final String target, final String name) throws IllegalArgumentException {
        Validate.notNull(target, "target must be specified");
        final ArchivePath path = ArchivePaths.create(target);
        return this.add(asset, path, name);
    }
571931
public void addTargets(final List<? extends AjaxTarget> targets) {
		if (targets != null) {
			for (AjaxTarget target : targets) {
				this.addTarget(target);
			}
		}
	}
1043095
def add_alternative (self, target):
        
        assert isinstance(target, BasicTarget)
        d = target.default_build ()

        if self.alternatives_ and self.default_build_ != d:
            get_manager().errors()("default build must be identical in all alternatives\n"
              "main target is '%s'\n"
              "with '%s'\n"
              "differing from previous default build: '%s'" % (self.full_name (), d.raw (), self.default_build_.raw ()))

        else:
            self.default_build_ = d

        self.alternatives_.append (target)
993475
public void addTargetRequests(List<String> requests) {
        for (String s : requests) {
            if (StringUtils.isBlank(s) || s.equals("#") || s.startsWith("javascript:")) {
                continue;
            }
            s = UrlUtils.canonicalizeUrl(s, url.toString());
            targetRequests.add(new Request(s));
        }
    }
5151
public void execute(final CCTask task, final List<File> sources, final Map<String, TargetInfo> targets,
      final TargetInfo linkTarget) {
    try {
      this.projectWriter.writeProject(this.outFile, task, this, sources, targets, linkTarget);
    } catch (final BuildException ex) {
      if (this.failOnError) {
        throw ex;
      } else {
        task.log(ex.toString());
      }
    } catch (final Exception ex) {
      if (this.failOnError) {
        throw new BuildException(ex);
      } else {
        task.log(ex.toString());
      }
    }
  }
748911
def add(self, cmd):
        '''
        
        '''
        self.wait_ready()
        self._vehicle._handler.fix_targets(cmd)
        self._vehicle._wploader.add(cmd, comment='Added by DroneKit')
        self._vehicle._wpts_dirty = True
1245821
def add_for_targets(self, targets, classpath_elements):
    """"""
    for target in targets:
      self.add_for_target(target, classpath_elements)
1231379
private function setupTargets()
    {
        // has targets
        $args = $this->request->getAsArray('args');
        foreach ($args as $arg) {
            $this->runner->addTarget(realpath($arg));
        }
    }
764580
def setTargets(self, targets):
        
        if not self.verifyArguments(targets) and not self.patterned:
            raise NetworkError('setTargets() requires [[...],[...],...] or [{"layerName": [...]}, ...].', targets)
        self.targets = targets
343792
@Override
    public List<String> setTargetHostsFromCmsQueryUrl(String cmsQueryUrl)
            throws TargetHostsLoadException {
        List<String> targetHosts = new ArrayList<String>();
        try {

            logger.info("will use default project label");
            targetHosts = setTargetHostsFromCmsQueryUrl(cmsQueryUrl, "label");
        } catch (Exception e) {
            throw new TargetHostsLoadException("error when reading  "
                    + cmsQueryUrl, e);
        }

        return targetHosts;

    }
947970
public void add(Project project2) {
        analysisTargets = appendWithoutDuplicates(analysisTargets, project2.analysisTargets);
        srcDirList = appendWithoutDuplicates(srcDirList, project2.srcDirList);
        auxClasspathEntryList = appendWithoutDuplicates(auxClasspathEntryList, project2.auxClasspathEntryList);
    }
427957
def newBuild(self, requests):
        
        b = self.buildClass(requests)
        b.useProgress = self.useProgress
        b.workdir = self.workdir
        b.setStepFactories(self.steps)
        return b
1108494
@Override
    public T addAsManifestResource(URL resource, ArchivePath target) throws IllegalArgumentException {
        Validate.notNull(resource, "Resource should be specified");
        Validate.notNull(target, "Target should be specified");

        File file = new File(resource.getFile());
        if (file.exists()) {
            return addAsManifestResource(file, target);
        }

        return addAsManifestResource(new UrlAsset(resource), target);
    }