Set Maven Project from String notation

@param notation String
961756
public void setProjectNotation(String notation) {
        Map<String, String> notationMap = Notation.parse(notation);
        this.setGroupId(notationMap.get("groupId"));
        this.setArtifactId(notationMap.get("artifactId"));
        this.setType(notationMap.get("type"));
        this.setVersion(notationMap.get("version"));
    }
834424
private void around(final CtMethod m, final String before, final String after, final List<VarDeclarationData> declarations) throws CannotCompileException, NotFoundException {
		String signature = Modifier.toString(m.getModifiers()) + " " + m.getReturnType().getName() + " " + m.getLongName();
		LOG.info("--- Instrumenting " + signature);
		for (VarDeclarationData declaration : declarations) {
			m.addLocalVariable(declaration.getName(), pool.get(declaration.getType()));
		}
		m.insertBefore(before);
		m.insertAfter(after);
	}
941703
private ActionPatternHolder convertStringToPattern(String line) {
        ActionPatternHolder holder = new ActionPatternHolder();
        String[] strs = org.apache.commons.lang.StringUtils.split(line, "|");
        if (strs.length != 2) {
            throw new IllegalArgumentException("illegal expression: " + line);
        }
        Pattern compiledPattern;
        Perl5Compiler compiler = new Perl5Compiler();
        try {
            holder.setActionName(strs[0]);
            compiledPattern = compiler.compile(strs[0], Perl5Compiler.READ_ONLY_MASK);
            holder.setActionPattern(compiledPattern);
        } catch (MalformedPatternException mpe) {
            throw new IllegalArgumentException("Malformed regular expression: " + strs[0]);
        }

        try {
            holder.setMethodName(strs[1]);
            compiledPattern = compiler.compile(strs[1], Perl5Compiler.READ_ONLY_MASK);
            holder.setMethodPattern(compiledPattern);
        } catch (MalformedPatternException mpe) {
            throw new IllegalArgumentException("Malformed regular expression: " + strs[1]);
        }

        return holder;
    }
260329
public function setNotation(\Innova\CollecticielBundle\Entity\Notation $notation)
    {
        $this->notation = $notation;

        return $this;
    }
468007
@Override
	public void setPrefix(final String prefixString) {
		lock.writeLock().lock();
		try {
			if (prefixString == null || StringUtils.isBlank(prefixString)) {
				localPrefix.remove();
			} else {
				if (prefixes != null) {
					if (!prefixes.contains(prefixString)) {
						throw new IllegalArgumentException("The given prefix is not part of the prefixes.");
					}
				}
				localPrefix.set(prefixString);
			}
		} finally {
			lock.writeLock().unlock();
		}
	}
649508
private void installProject(final MavenProject mavenProject) throws MojoExecutionException {
        Artifact artifact = mavenProject.getArtifact();
        String packaging = mavenProject.getPackaging();

        boolean isPomArtifact = "pom".equals(packaging);

        try {
            // skip copying pom to Ceylon repository
            if (!isPomArtifact) {
                File file = artifact.getFile();

                if (file != null && file.isFile()) {
                    install(file, artifact, localRepository);
                    
                    File artifactFile = new File(localRepository.getBasedir(), localRepository.pathOf(artifact));
                    installAdditional(artifactFile, ".sha1", CeylonUtil.calculateChecksum(artifactFile), false);
                    String deps = calculateDependencies(mavenProject);
                    if (!"".equals(deps)) {
                        installAdditional(artifactFile, "module.properties", deps, false);
                        installAdditional(artifactFile, ".module", deps, true);
                    }
                } else {
                    throw new MojoExecutionException(
                        "The packaging for this project did not assign a file to the build artifact");
                }
            }

        } catch (Exception e) {
            throw new MojoExecutionException(e.getMessage(), e);
        }
    }
1202357
public void install(String notation, String pomPath, String filePath ) throws InstallException {
        log.debug("installing artifact: {} ", notation);
        
        RepositoryClient repoClient = new RepositoryClient(this.getLocalRepoPath());
        InstallRequest installRequest = new InstallRequest();
        
        if ( filePath != null ) {
            DefaultArtifact jarArtifact = new DefaultArtifact( notation );
            jarArtifact = (DefaultArtifact)jarArtifact.setFile( new File( filePath ) );
            
            installRequest.addArtifact( jarArtifact );
                
            if ( pomPath != null ) {
                SubArtifact pomArtifact = new SubArtifact( jarArtifact, "", Const.POM );
                pomArtifact = (SubArtifact)pomArtifact.setFile( new File( pomPath ) );
                installRequest.addArtifact( pomArtifact );
            }
            
        // If Pom only, without a jar, ensure the notation type is set to pom
        } else  if ( pomPath != null ) {
            Map<String,String> notationMap = Notation.parse( notation );
            notationMap.put( "type", Const.POM );
            
            org.sonatype.aether.spi.connector.ArtifactDownload at;
            
            DefaultArtifact pomArtifact = new DefaultArtifact( Notation.generate(notationMap) );
            pomArtifact = (DefaultArtifact)pomArtifact.setFile( new File(pomPath ) );
            installRequest.addArtifact( pomArtifact );    
        }
                
        try {
            repoClient.install(installRequest);
        } catch (InstallationException e) {
            log.error("Failed to install artifact", e);
            throw new InstallException(e);
        }
    }
791526
@PublicEvolving
	public void setString(ConfigOption<String> key, String value) {
		setValueInternal(key.key(), value);
	}
1305846
public void setString(@NotNull final String key, @NotNull final String value) {
        props.setProperty(key, value);
        LOGGER.debug("Setting: {}='{}'", key, value);
    }
1151791
public void setProjects(java.util.Collection<ProjectSummary> projects) {
        if (projects == null) {
            this.projects = null;
            return;
        }

        this.projects = new java.util.ArrayList<ProjectSummary>(projects);
    }
452994
@Override
    public void setProducerBind(String bind) throws JMSException {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "setProducerBind", bind);

        // Make sure null and empty are treated equally.
        if ((bind == null) || ("".equals(bind.trim())))
            bind = null;

        if ((bind == null) ||
            (ApiJmsConstants.PRODUCER_BIND_OFF.equals(bind) ||
            (ApiJmsConstants.PRODUCER_BIND_ON.equals(bind)))) {

            updateProperty(PRODUCER_BIND, bind);
        }
        else {
            // bad value, throw exception
            String key = "INVALID_VALUE_CWSIA0281";
            Object[] inserts = new Object[] { PRODUCER_BIND, bind };
            throw (JMSException) JmsErrorUtils.newThrowable(JMSException.class, key, inserts, tc);
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(this, tc, "setProducerBind");
    }
1101868
public void setName(String name) {

        String oufqn = getOufqn();
        if (oufqn != null) {
            if (!oufqn.endsWith("/")) {
                oufqn += "/";
            }
        } else {
            oufqn = "/";
        }
        m_project.setName(oufqn + name);

    }
540791
public static ImmutableSet<Symbol> setFrom(final Iterable<String> strings) {
    checkNotNull(strings);

    return FluentIterable.from(strings)
        .transform(Symbolize)
        .toSet();
  }
138139
public void setPrefix(String prefix)
  {
    _prefix = prefix;
    
    if (prefix != null)
      _pathPrefix = prefix.replace('.', '/');
  }
849282
@Override
	protected void setBody(JvmExecutable executable, XExpression expression) {
		final GenerationContext context = getContext(
				EcoreUtil2.getContainerOfType(executable, JvmType.class));
		this.typeBuilder.removeExistingBody(executable);
		this.associator.associateLogicalContainer(expression, executable);
		if (expression != null) {
			if (context.getParentContext() == null) {
				context.getPostFinalizationElements().add(() -> {
					initializeLocalTypes(context, executable, expression);
				});
			} else {
				initializeLocalTypes(context, executable, expression);
			}
		} else {
			initializeLocalTypes(context, executable, expression);
		}
	}
1154590
@Override
  @Deprecated
  public final org.jdom2.Element setName(String value) {
    return super.setName(value);
  }
148805
@Override
    public void setCustomSetString(String setting, Boolean recursive) {
        if (tc.isEntryEnabled())
            Tr.entry(tc, "setCustomSetString (String, Boolean): " + setting);

        setInstrumentationLevel(_createSLSFromString(setting), recursive);

        if (tc.isEntryEnabled())
            Tr.exit(tc, "setCustomSetString");
    }