code stringlengths 73 34.1k | label stringclasses 1 value |
|---|---|
public String generateNaturalAnalogSequenceRNA(String notation)
throws org.helm.notation2.parser.exceptionparser.NotationException, HELM2HandledException,
ValidationException, MonomerLoadingException, ChemistryException {
String result = SequenceConverter.getNucleotideNaturalAnalogSequenceFromNotation(validate(notation));
setMonomerFactoryToDefault(notation);
return result;
} | java |
public String convertMolFileSMILESWithAtomMapping(String molfile, List<Attachment> attachments) throws CTKException, ChemistryException{
return SMILES.convertMolToSMILESWithAtomMapping(molfile, attachments);
} | java |
public static List<MonomerNotation> getListOfMonomerNotation(List<PolymerNotation> polymers) {
List<MonomerNotation> items = new ArrayList<MonomerNotation>();
for (PolymerNotation polymer : polymers) {
items.addAll(polymer.getListMonomers());
}
return items;
} | java |
public static List<Monomer> getListOfMonomer(List<MonomerNotation> monomerNotations) throws MonomerException,
HELM2HandledException, CTKException, NotationException, ChemistryException, MonomerLoadingException {
List<Monomer> items = new ArrayList<Monomer>();
for (int i = 0; i < monomerNotations.size(); i++) {
items.addAll(Validation.getAllMonomers(monomerNotations.get(i), i));
}
return items;
} | java |
public static Monomer getMonomer(String type, String id, String info) throws MonomerException, NotationException, ChemistryException{
try {
if (id.startsWith("[") && id.endsWith("]")) {
id = id.substring(1, id.length() - 1);
}
MonomerFactory monomerFactory = MonomerFactory.getInstance();
MonomerStore monomerStore = monomerFactory.getMonomerStore();
Monomer monomer;
/* Monomer was saved to the database */
monomer = monomerStore.getMonomer(type, id);
if (monomer == null) {
/*
* smiles check! Maybe the smiles is already included in the data base
*/
if (monomerFactory.getSmilesMonomerDB().get(id) != null) {
monomer = monomerFactory.getSmilesMonomerDB().get(id);
return monomer;
} else {
/* This has to be done */
monomer = monomerFactory.getSmilesMonomerDB().get(id);
if (monomer == null) {
/* Rgroups information are not given -> only smiles information */
AbstractChemistryManipulator manipulator = Chemistry.getInstance().getManipulator();
if (manipulator.validateSMILES(id)) {
if (type.equals(Monomer.CHEMICAL_POLYMER_TYPE)) {
monomer = generateTemporaryMonomer(id, type, "X");
} else if (type.equals(Monomer.PEPTIDE_POLYMER_TYPE)) {
monomer = generateTemporaryMonomer(id, type, "X");
} else if (type.equals(Monomer.NUCLIEC_ACID_POLYMER_TYPE)) {
monomer = generateTemporaryMonomer(id, type, info);
}
} else {
if(!id.equals("?") && !id.equals("X") && !id.equals("N")){
throw new MonomerException("Defined Monomer is not in the database and also not valid SMILES " + id);
}
else{
return new Monomer(type,"Undefined",id, id);
}
}
/* Add new monomer to the database */
MonomerFactory.getInstance().getMonomerStore().addNewMonomer(monomer);
MonomerFactory.getInstance().getSmilesMonomerDB().put(monomer.getCanSMILES(), monomer);
// save monomer db to local file after successful update //
MonomerFactory.getInstance().saveMonomerCache();
LOG.info("Monomer was added to the database");
}
}
}
try{
List<Attachment> idList = monomer.getAttachmentList();
for (Attachment att : idList) {
if (att.getCapGroupSMILES() == null) {
MonomerParser.fillAttachmentInfo(att);
}
}
} catch(CTKException |JDOMException ex){
throw new MonomerException("Attachments could not be filled with default attachments");
}
return monomer;
} catch (IOException e) {
e.printStackTrace();
/*
* monomer is not in the database and also not a valid SMILES -> throw
* exception
*/
throw new MonomerException("Defined Monomer is not in the database and also not a valid SMILES " + id);
}
} | java |
public static JKLocale valueOf(final String localeString) {
return localeString.equals(ARABIC.shortName) ? ARABIC : ENGLISH;
} | java |
public String getAuditText() {
final StringBuffer b = new StringBuffer();
b.append(getOldValue().replaceAll(",", "\n"));
b.append("-----------------------------------------\n");
b.append(getNewValue().replaceAll(",", "\n"));
b.append("-----------------------------------------\n");
return b.toString();
} | java |
public float calculate(HELM2Notation helm2notation, int unitType) throws ExtinctionCoefficientException, ChemistryException {
LOG.debug("ExtinctionCalculation is starting with the unitType: " + unitType);
float result = 0.0f;
List<PolymerNotation> polymerNodes = helm2notation.getListOfPolymers();
for (PolymerNotation polymerNode : polymerNodes) {
String polymerType = polymerNode.getPolymerID().getType();
float ext = 0.0f;
ArrayList<PolymerNotation> not = new ArrayList<PolymerNotation>();
not.add(polymerNode);
if (polymerType.equals(Monomer.NUCLIEC_ACID_POLYMER_TYPE)) {
try {
ext = calculateExtinctionFromRNA(MethodsMonomerUtils.getListOfHandledMonomersOnlyBase(polymerNode.getPolymerElements().getListOfElements()));
} catch (CalculationException | IOException | HELM2HandledException | NotationException e) {
throw new ExtinctionCoefficientException(e.getMessage());
}
if (unitType == PEPTIDE_UNIT_TYPE) {
ext = ext * UNIT;
}
} else if (polymerType.equals(Monomer.PEPTIDE_POLYMER_TYPE)) {
try {
ext = calculateExtinctionFromPeptide(MethodsMonomerUtils.getListOfHandledMonomers(polymerNode.getPolymerElements().getListOfElements()));
} catch (IOException | HELM2HandledException e) {
throw new ExtinctionCoefficientException(e.getMessage());
}
if (unitType == RNA_UNIT_TYPE) {
ext = ext / UNIT;
}
}
result = result + ext;
}
return result;
} | java |
private static float calculateExtinctionFromRNA(List<Monomer> monomers) throws CalculationException, IOException {
LOG.debug("ExtinctionCalculation of RNA");
float resultSingle = 0.0f;
float resultDi = 0.0f;
String previous = "";
if (monomers.size() == 0) {
throw new CalculationException("Input sequence cannot be null");
} else {
if (monomers.size() == 1) {
if (monoNucleotideMap.containsKey(monomers.get(0).getNaturalAnalog())) {
return monoNucleotideMap.get(monomers.get(0).getNaturalAnalog()).floatValue();
} else {
throw new CalculationException("Unknown nucleotide found");
}
}
for (int i = 0; i < monomers.size(); i++) {
if (i > 0 && i < monomers.size() - 1) {
if (monoNucleotideMap.containsKey(monomers.get(i).getNaturalAnalog())) {
Float value = monoNucleotideMap.get(monomers.get(i).getNaturalAnalog()).floatValue();
resultSingle += (value.floatValue() * 1.0);
}
}
if (previous != "") {
if (diNucleotideMap.containsKey(previous + monomers.get(i).getNaturalAnalog())) {
Float value = diNucleotideMap.get(previous + monomers.get(i).getNaturalAnalog()).floatValue();
resultDi += (value.floatValue() * 1.0);
}
}
previous = monomers.get(i).getNaturalAnalog();
}
}
resultSingle = BigDecimal.valueOf(resultSingle).floatValue();
resultDi = BigDecimal.valueOf(resultDi).floatValue();
return 2 * resultDi - resultSingle;
} | java |
private static float calculateExtinctionFromPeptide(List<Monomer> monomers) throws IOException, HELM2HandledException {
if (null == monomers || monomers.isEmpty()) {
return 0.0f;
}
Map<String, Integer> countMap = new HashMap<String, Integer>();
for (Monomer monomer : monomers) {
if (aminoAcidMap.containsKey(monomer.getAlternateId())) {
int count = 1;
if (countMap.containsKey(monomer.getAlternateId())) {
count = count + countMap.get(monomer.getAlternateId());
}
countMap.put(monomer.getAlternateId(), count);
}
}
float result = 0.0f;
Set<String> keys = countMap.keySet();
for (Iterator<String> it = keys.iterator(); it.hasNext();) {
String key = it.next();
int count = countMap.get(key);
float factor = aminoAcidMap.get(key);
result = result + factor * count;
}
return BigDecimal.valueOf(result).floatValue();
} | java |
public static boolean isAuthenticed(String host, int port, String userName, String password) throws NamingException {
log.info("isAuthenticed");
// Set up the environment for creating the initial context
Hashtable<String, String> env = new Hashtable<String, String>();
env.put(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.ldap.LdapCtxFactory");
env.put(Context.PROVIDER_URL, "ldap://" + host + ":" + port);
env.put(Context.SECURITY_AUTHENTICATION, "simple");
env.put(Context.SECURITY_PRINCIPAL, userName + "@" + host);
log.info(env.toString());
env.put(Context.SECURITY_CREDENTIALS, password);
// Create the initial context
DirContext ctx = new InitialDirContext(env);
log.info("DirContext Init Succ");
boolean result = ctx != null;
if (ctx != null) {
log.info("Closing DirContext");
ctx.close();
}
return result;
} | java |
protected static String fixKey(final String key) {
if (key.startsWith(getKeyPrefix())) {
return key;
}
return getKeyPrefix() + "-" + key;
} | java |
public static float getFloat(final String key, final float def) {
try {
return systemRoot.getFloat(fixKey(key), def);
} catch (final Exception e) {
// just eat the exception to avoid any system
// crash on system issues
return def;
}
} | java |
public static Hashtable<String, String> getHashtable(final String name) {
final Hashtable<String, String> hash = new Hashtable<String, String>();
try {
final String configStr = UserPreferences.get(fixKey(name), "");
if (!configStr.equals("")) {
final String[] rows = configStr.split(";");
for (final String row : rows) {
final String[] split = row.split(":");
if (split.length == 2) {
final String key = split[0];
final String value = split[1];
hash.put(key, value);
}
}
}
} catch (final Exception e) {
// just eat the exception to avoid any system crash on system issues
}
return hash;
} | java |
public static int getInt(final String key, final int def) {
try {
return systemRoot.getInt(fixKey(key), def);
} catch (final Exception e) {
// just eat the exception to avoid any system crash on system issues
return def;
}
} | java |
public static void putHashTable(final String name, final Hashtable hash) {
final Enumeration<String> keys = hash.keys();
final StringBuffer buf = new StringBuffer("");
while (keys.hasMoreElements()) {
if (!buf.toString().equals("")) {
// end the previous record
buf.append(";");
}
final String key = keys.nextElement();
final String value = hash.get(key).toString();
buf.append(key + ":" + value);
}
put(fixKey(name), buf.toString());
} | java |
public static void setKeyPrefix(final String keyPrefix) {
UserPreferences.keyPrefix = keyPrefix;
try {
systemRoot.sync();
} catch (final Exception e) {
JKExceptionUtil.handle(e);
}
} | java |
private static void initializeNucleotideTemplates() throws NucleotideLoadingException {
InputStream in = null;
File localFile = new File(LOCAL_NUCLEOTIDE_TEMPLATE_FILE_PATH);
Map<String, Map<String, String>> templates = null;
if (localFile.exists()) {
try {
in = new FileInputStream(localFile);
templates = buildNucleotideTemplates(in);
validate(templates);
logger.log(Level.INFO, LOCAL_NUCLEOTIDE_TEMPLATE_FILE_PATH
+ " is used for nucleotide templates initialization");
} catch (Exception e) {
logger.log(Level.INFO, "Unable to use local nucleotide templates for initialization");
localFile.delete();
logger.log(Level.INFO, "Deleted local nucleotide templates file");
}
}
if (null == templates) {
in = NucleotideFactory.class.getResourceAsStream(NUCLEOTIDE_TEMPLATE_XML_RESOURCE);
try {
templates = buildNucleotideTemplates(in);
validate(templates);
} catch (IOException | JDOMException | NotationException e) {
throw new NucleotideLoadingException(
"Initializing NucleotideStore failed because of "
+ e.getClass().getSimpleName(), e);
}
logger.log(Level.INFO, NUCLEOTIDE_TEMPLATE_XML_RESOURCE
+ " is used for nucleotide templates initialization");
}
nucleotideTemplates = templates;
reverseNucleotideMap = getReverseNucleotideTemplateMap(NotationConstant.NOTATION_SOURCE);
} | java |
public void saveNucleotideTemplates() throws IOException {
File f = new File(NOTATION_DIRECTORY);
if (!f.exists()) {
f.mkdir();
}
String nucleotideTemplatesXML = NucleotideParser.getNucleotideTemplatesXML(getNucleotideTemplates());
FileOutputStream fos = new FileOutputStream(
LOCAL_NUCLEOTIDE_TEMPLATE_FILE_PATH);
fos.write(nucleotideTemplatesXML.getBytes());
} | java |
@SuppressWarnings("rawtypes")
public Class[] getParamtersTypes() {
final Class[] types = new Class[this.paramters.length];
for (int i = 0; i < types.length; i++) {
types[i] = this.paramters[i].getClass();
}
return types;
} | java |
private void readConfigFile() {
File configFile = new File(CONFIG_FILE_PATH);
/* config file is not there -> create config file with default */
if (!configFile.exists()) {
resetConfigToDefault();
}
try {
PropertiesConfiguration conf = new PropertiesConfiguration(CONFIG_FILE_PATH);
chemistry = conf.getString(CHEMISTRY_PLUGIN);
} catch (ConfigurationException e) {
resetConfigToDefault();
e.printStackTrace();
}
} | java |
public static boolean compileJavaClass(String sourceCode) {
try {
String fileName = getClassName(sourceCode).concat(".java");
logger.info("Compiling Java Class ({})", fileName);
File rootDir = JKIOUtil.createTempDirectory();
String packageDir = getPackageDir(sourceCode);
File sourceFile ;
if(packageDir!=null) {
File file=new File(rootDir,packageDir);
file.mkdirs();
sourceFile=new File(file, fileName);
}else {
sourceFile=new File(rootDir, fileName);
}
JKIOUtil.writeDataToFile(sourceCode, sourceFile);
// Compile source file.
JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
StandardJavaFileManager standardJavaFileManager = compiler.getStandardFileManager(null, null, null);
standardJavaFileManager.setLocation(StandardLocation.CLASS_PATH, getClassPath());
standardJavaFileManager.setLocation(StandardLocation.SOURCE_PATH, Arrays.asList(rootDir));
List<String> options = new ArrayList<String>();
options.add("-Xlint:unchecked");
CompilationTask compilationTask = compiler.getTask(null, standardJavaFileManager, null, options, null,
standardJavaFileManager.getJavaFileObjectsFromFiles(JK.toList(sourceFile)));
return compilationTask.call();
} catch (IOException e) {
JK.throww(e);
return false;
}
// if (compiler.run(System.in, System.out, System.err, sourceFile.getPath()) != 0) {
// JK.error("Compilation failed, check stack trace");
// }
} | java |
@Override
public void showAndChoose(IConsumer<File> consumer) {
this.consumer = consumer;
initSrvNodeFile();
Intent activityTreeIntent = new Intent(activity, ActivityTreeChooser.class);
activityTreeIntent.putExtra(FragmentNodes.ARG_ID_NODE_SRVNODES, new String[]{idFolderStart, idSrvGetNodeFile, idCommand, title});
activity.startActivityForResult(activityTreeIntent, REQUEST_NODE_FILE);
} | java |
public static String getHELMNotationString(Element rootElement) {
Element helmNotationElement = rootElement.getChild("HelmNotation");
return helmNotationElement.getText();
} | java |
public static String getComplexNotationString(Element rootElement) {
Element helmNotationElement = rootElement.getChild("HelmNotation");
return helmNotationElement.getText();
} | java |
public static MonomerStore getMonomerStore(Element rootElement)
throws MonomerException, IOException {
MonomerStore monomerStore = new MonomerStore();
Element monomerListElement = rootElement.getChild("Monomers");
if (monomerListElement != null) {
@SuppressWarnings("unchecked")
List<Element> elementList = monomerListElement.getChildren("Monomer");
for (Element monomerElement : elementList) {
Monomer m = MonomerParser.getMonomer(monomerElement);
monomerStore.addMonomer(m);
}
}
return monomerStore;
} | java |
public boolean isNumeric() {
final Class c = getColumnClass();
return c.equals(Integer.class) || c.equals(Float.class) || c.equals(Long.class) || c.equals(BigDecimal.class);
} | java |
public void setColumnClassName(final String columnClassName) throws ClassNotFoundException {
if (columnClassName.equals("byte[]")) {
setColumnClass(Object.class);
} else {
setColumnClass(Class.forName(columnClassName));
}
this.columnClassName = columnClassName;
} | java |
public static String generateMDL(final HELM2Notation helm2notation) throws BuilderMoleculeException, CTKException, NotationException, ChemistryException {
LOG.debug("Generate smiles representation for the whole HELM molecule");
String smiles = SMILES.getSMILESForAll(helm2notation);
LOG.debug("Convert smiles to mol");
return Chemistry.getInstance().getManipulator().convert(smiles, AbstractChemistryManipulator.StType.SMILES);
} | java |
public void callMethod(final MethodCallInfo info) {
this.logger.info("calling remote method ".concat(info.toString()));
try (Socket socket = new Socket(this.host, this.port)) {
final ObjectOutputStream out = new ObjectOutputStream(socket.getOutputStream());
out.writeObject(info);
final ObjectInputStream in = new ObjectInputStream(socket.getInputStream());
final MethodCallInfo serverCopy = (MethodCallInfo) in.readObject();
info.set(serverCopy);
} catch (final Exception e) {
throw new RemoteReflectionException(e);
}
} | java |
protected static Vector convertToVector(final Object[] anArray) {
if (anArray == null) {
return null;
}
final Vector v = new Vector(anArray.length);
for (final Object element : anArray) {
v.addElement(element);
}
return v;
} | java |
private static Vector newVector(final int size) {
final Vector v = new Vector(size);
v.setSize(size);
return v;
} | java |
@Override
public String getColumnName(final int column) {
Object id = null;
// This test is to cover the case when
// getColumnCount has been subclassed by mistake ...
if (column < this.columnIdentifiers.size() && column >= 0) {
id = this.columnIdentifiers.elementAt(column);
}
return id == null ? super.getColumnName(column) : id.toString();
} | java |
private void justifyRows(final int from, final int to) {
// Sometimes the DefaultTableModel is subclassed
// instead of the AbstractTableModel by mistake.
// Set the number of rows for the case when getRowCount
// is overridden.
this.dataVector.setSize(getRowCount());
for (int i = from; i < to; i++) {
if (this.dataVector.elementAt(i) == null) {
this.dataVector.setElementAt(new Vector(), i);
}
// ((Vector)dataVector.elementAt(i)).setSize(getColumnCount());
}
} | java |
public static String findPathJar(final Class clas) throws IllegalStateException {
URL url;
String extURL;
try {
url = clas.getProtectionDomain().getCodeSource().getLocation();
} catch (final SecurityException ex) {
url = clas.getResource(clas.getSimpleName() + ".class");
}
extURL = url.toExternalForm();
try {
url = new URL(extURL);
} catch (final MalformedURLException mux) {
// leave url unchanged; probably does not happen
}
try {
return new File(url.toURI()).toString();
} catch (final Exception ex) {
return new File(url.getPath()).toString();
}
} | java |
public static byte[] readStream(final InputStream inStream) {
try {
return IOUtils.toByteArray(inStream);
} catch (IOException e) {
throw new JKException(e);
}
//
// try {
// DataInputStream in = null;
// try {
// in = new DataInputStream(inStream);
// int ch;
//
// List<Byte> bytes=new ArrayList<>();
// while((ch=in.read())!=-1){
// bytes.add(ch);
// }
// return arr;
// } finally {
// if (in != null) {
// in.close();
// }
// }
// } catch (final IOException e) {
// throw new RuntimeException(e);
// }
} | java |
public static String convertToString(InputStream input) throws IOException {
try {
if (input == null) {
throw new IOException("Input Stream Cannot be NULL");
}
StringBuilder sb1 = new StringBuilder();
String line;
try {
BufferedReader r1 = new BufferedReader(new InputStreamReader(input, "UTF-8"));
while ((line = r1.readLine()) != null) {
sb1.append(line);
}
} finally {
input.close();
}
return sb1.toString();
} catch (IOException e) {
throw new JKException(e);
}
} | java |
public static Reader getReader(String name) {
InputStream inputStream = getInputStream(name);
if (inputStream != null) {
BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
return reader;
}
return null;
} | java |
public static String getExtension(final String fileName, final boolean withPoint) {
final int lastIndexOf = fileName.lastIndexOf(".");
if (!withPoint) {
return fileName.substring(lastIndexOf + 1);
}
return fileName.substring(lastIndexOf);
} | java |
public static String removeExtension(String fileName) {
final String separator = FILE_SEPARATOR;
String filename;
// Remove the path upto the filename.
final int lastSeparatorIndex = fileName.lastIndexOf(separator);
if (lastSeparatorIndex == -1) {
filename = fileName;
} else {
filename = fileName.substring(lastSeparatorIndex + 1);
}
// Remove the extension.
final int extensionIndex = filename.lastIndexOf(".");
if (extensionIndex == -1) {
return filename;
}
fileName = fileName.substring(0, lastSeparatorIndex);
return fileName + File.separator + filename.substring(0, extensionIndex);
} | java |
public static File writeDataToFile(final byte[] data, final File file, final boolean append) {
try (FileOutputStream out = new FileOutputStream(file, append)) {
out.write(data);
out.flush();
out.close();
return file;
} catch (Exception e) {
JKExceptionUtil.handle(e);
return null;
}
} | java |
public static Properties readPropertiesStream(InputStream inputStream) {
try {
final Properties prop = new Properties();
// try to read in utf 8
prop.load(new InputStreamReader(inputStream, Charset.forName("utf-8")));
JKCollectionUtil.fixPropertiesKeys(prop);
return prop;
} catch (IOException e) {
JKExceptionUtil.handle(e);
return null;
} finally {
close(inputStream);
}
} | java |
public static File writeFileToTempDirectory(final byte[] data, final String fileName) {
try {
File file = createTempDirectory();
File out = new File(file, fileName);
out.deleteOnExit();
file.deleteOnExit();
return writeDataToFile(data, out);
} catch (IOException e) {
JKExceptionUtil.handle(e);
return null;
}
} | java |
public static File createTempFile(final String ext) {
try {
File file;
file = File.createTempFile("jk-", "." + ext);
return file;
} catch (IOException e) {
JK.throww(e);
return null;
}
} | java |
public static Process executeFile(final String fileName) {
try {
final String command = "cmd /c \"" + fileName + "\"";
logger.info(command);
return Runtime.getRuntime().exec(command);
} catch (IOException e) {
throw new RuntimeException(e);
}
} | java |
public static String getSqlFile(String fileName) {
String file = "/jk/sql/".concat(fileName);
logger.debug("Loading sql file: ", file);
return readFile(file);
} | java |
public static void clearTempFiles() {
String userFolderPath = getUserFolderPath(false);
File file = new File(userFolderPath);
deleteDir(file);
} | java |
public static void startFakeThread(ServerSocket server) {
Thread thread = new Thread(new FakeRunnable(server));
thread.start();
} | java |
public static String getReportsOutPath(boolean appendFileSeprator) {
String userLocalPath = getUserFolderPath(true);
String reportPath = userLocalPath + REPORTS_OUT_PATH;
checkFolderPath(reportPath, true);// to create the folder if not exist
if (appendFileSeprator) {
reportPath += FILE_SEPARATOR;
}
return reportPath;
} | java |
public static List<String> getFilesInFolder(String folder, String ext) {
// tryto find using normal file system lookup
List<String> files = new Vector<>();
File dir = new File(folder);
if (dir.exists() && dir.isDirectory()) {
String[] list = dir.list();
for (String file : list) {
if (file.endsWith(ext)) {
files.add(file);
}
}
}
return files;
} | java |
public static void copResourcesFromJarToDir(String sourceClassPath, File dest) {
try {
List<File> resourcesInnPackage = getResourcesInnPackage(sourceClassPath);
for (File file : resourcesInnPackage) {
JK.printBlock("Copying file: " + file.getName() + " to folder " + dest.getAbsolutePath());
FileUtils.copyFileToDirectory(file, dest);
}
} catch (IOException e) {
JK.throww(e);
}
} | java |
public static List<File> getResourcesInnPackage(String root) {
try {
logger.debug("getResourcesInnPackage for package: " + root);
ClassLoader loader = Thread.currentThread().getContextClassLoader();
URL url = loader.getResource(root);
if (url != null) {
logger.debug(" URL :" + url.toURI());
InputStream in = loader.getResourceAsStream(root);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String resource;
List<File> fileNames = new ArrayList<>();
while ((resource = br.readLine()) != null) {
if (!root.endsWith("/")) {
root += "/";
}
String resourcePath = root + resource;
logger.debug("Processing resource path:" + resourcePath);
File file = new File(loader.getResource(resourcePath).toURI());
if (file.isDirectory()) {
fileNames.addAll(getResourcesInnPackage(resourcePath + "/"));
} else {
logger.debug("Adding file :" + file.getName());
fileNames.add(file);
}
}
return fileNames;
} else {
logger.debug("Package not found, return empty list");
return Collections.emptyList();
}
} catch (Exception e) {
JK.throww(e);
return null;
}
} | java |
public static JKConfig readConfigFile(String configFileName) {
URL url = getURL(configFileName);
logger.debug(configFileName + " Url is ", url.toString());
JKConfig config = new JKConfig(url);
return config;
} | java |
private static String convertLessThanOneThousand(int number) {
String soFar;
if (number % 100 < 20) {
soFar = numNames[number % 100];
number /= 100;
} else {
soFar = numNames[number % 10];
number /= 10;
soFar = tensNames[number % 10] + soFar;
number /= 10;
}
if (number == 0) {
return soFar;
}
return numNames[number] + " Hundred" + soFar;
} | java |
public static double addAmounts(final double num1, final double num2) {
final BigDecimal b1 = new BigDecimal(num1);
final BigDecimal b2 = new BigDecimal(num2);
BigDecimal b3 = b1.add(b2);
b3 = b3.setScale(3, BigDecimal.ROUND_HALF_UP);
final double result = b3.doubleValue();
return result;
} | java |
public static double fixAmount(final double value) {
final BigDecimal b1 = new BigDecimal(value);
final BigDecimal b2 = b1.setScale(3, BigDecimal.ROUND_HALF_UP);
return b2.doubleValue();
} | java |
public static double subAmounts(final double n1, final double n2) {
final BigDecimal b1 = new BigDecimal(n1);
final BigDecimal b2 = new BigDecimal(n2);
BigDecimal b3 = b1.subtract(b2);
b3 = b3.setScale(3, BigDecimal.ROUND_HALF_UP);
final double result = b3.doubleValue();
return result;
} | java |
public void fillEmail(final MultiPartEmail email) throws EmailException, IOException {
email.setHostName(getHost());
email.setSmtpPort(getSmtpPort());
email.addTo(getTo());
email.setFrom(getFrom());
email.setSubject(getSubject());
email.setMsg(getMsg());
email.setSSLOnConnect(isSecured());
if(this.bcc!=null) {
String[] bccList = this.bcc.split(",");
for (String bcc : bccList) {
email.addBcc(bcc);
}
}
if(this.cc!=null) {
String[] ccList = this.cc.split(",");
for (String cc : ccList) {
email.addCc(cc);
}
}
if (isRequiresAuthentication()) {
email.setAuthentication(getUsername(), getPassword());
}
for (int i = 0; i < this.attachements.size(); i++) {
final Attachment attachment = this.attachements.get(i);
final ByteArrayDataSource ds = new ByteArrayDataSource(attachment.getData(), attachment.getMimeType());
email.attach(ds, attachment.getName(), attachment.getDescription());
}
} | java |
public static Date toDate(final Object value) {
if (value instanceof Date) {
return (Date) value;
}
if (value == null || value.equals("null")) {
return null;
}
if (value instanceof String) {
throw new IllegalStateException("fix me");
}
return null;
} | java |
public static float toFloat(final Object value) {
if (value instanceof Float) {
return (float) value;
}
if (value == null) {
return 0;
}
return new Float(value.toString());
} | java |
public static java.sql.Time toTime(final Object value) {
if (value == null) {
return null;
}
if (value instanceof java.sql.Time) {
return (java.sql.Time) value;
}
if (value instanceof java.util.Date) {
final Date date = (java.util.Date) value;
return new java.sql.Time(date.getTime());
}
return null;
} | java |
public static boolean toBoolean(Object value, boolean defaultValue) {
boolean result;// = defaultValue;
if (value != null) {
if (value instanceof Boolean) {
return ((Boolean) value).booleanValue();
}
if (value.toString().trim().equals("1") || value.toString().trim().toLowerCase().equals("true")) {
result = true;
} else {
result = false;
}
} else {
result = defaultValue;
}
return result;
} | java |
public static double toDouble(Object value, double defaultValue) {
if (value == null || value.toString().trim().equals("")) {
return defaultValue;
}
if (value instanceof Double) {
return (double) value;
}
if (value instanceof Date) {
final Date date = (Date) value;
return date.getTime();
}
return Double.parseDouble(value.toString());
} | java |
public static int toInteger(Object value, int defaultValue) {
if (value == null || value.toString().trim().equals("")) {
return defaultValue;
}
if (value instanceof Integer) {
return (Integer) value;
}
return (int) JKConversionUtil.toDouble(value);
} | java |
public static void validateNotationObjects(HELM2Notation helm2notation) throws PolymerIDsException,
MonomerException, GroupingNotationException, ConnectionNotationException, NotationException,
ChemistryException, MonomerLoadingException, org.helm.notation2.parser.exceptionparser.NotationException {
LOG.info("Validation process is starting");
/* all polymer ids have to be unique */
if (!validateUniquePolymerIDs(helm2notation)) {
LOG.info("Polymer IDS have to be unique");
throw new PolymerIDsException("Polymer IDs have to be unique");
}
/* Validation of Monomers */
if (!validateMonomers(MethodsMonomerUtils.getListOfMonomerNotation(helm2notation.getListOfPolymers()))) {
LOG.info("Monomers have to be valid");
throw new MonomerException("Monomers have to be valid");
}
/* validate the grouping section */
if (!validateGrouping(helm2notation)) {
LOG.info("Group information is not valid");
throw new GroupingNotationException("Group notation is not valid");
}
/* validate the connection */
if (!validateConnections(helm2notation)) {
LOG.info("Connection information is not valid");
throw new ConnectionNotationException("Connection notation is not valid");
}
} | java |
protected static boolean validateMonomers(List<MonomerNotation> mon) throws ChemistryException,
MonomerLoadingException, org.helm.notation2.parser.exceptionparser.NotationException {
for (MonomerNotation monomerNotation : mon) {
if (!(isMonomerValid(monomerNotation.getUnit(), monomerNotation.getType()))) {
return false;
}
}
return true;
} | java |
private static boolean isConnectionSpecific(ConnectionNotation connectionNotation) {
String connection = connectionNotation.getSourceUnit() + ":" + connectionNotation.getrGroupSource() + "-"
+ connectionNotation.getTargetUnit() + ":" + connectionNotation.getrGroupTarget();
/* check for specific interaction */
if (connection.matches("\\d+:R\\d-\\d+:R\\d|\\d+:pair-\\d+:pair")) {
return true;
}
return false;
} | java |
private static List<Integer> getOccurencesOfMonomerNotation(String sourceUnit, HELMEntity e,
HELM2Notation helm2notation)
throws org.helm.notation2.parser.exceptionparser.NotationException, AttachmentException {
List<Integer> occurences = new ArrayList<Integer>();
/* The monomer's position in the polymer is specified */
try {
occurences.add(Integer.parseInt(sourceUnit));
return occurences;
} catch (NumberFormatException ex) {
MonomerNotation mon = ValidationMethod.decideWhichMonomerNotation(sourceUnit, e.getType());
/* it is only one monomer e.g. C */
if (mon instanceof MonomerNotationUnit) {
PolymerNotation polymerNotation = helm2notation.getPolymerNotation(e.getId());
/* monomer can also be unknown */
if (sourceUnit.equals("?")) {
return occurences;
}
occurences.addAll(findElementInPolymer(sourceUnit, polymerNotation));
/* the specified monomer does not exist in the polymer */
if (occurences.isEmpty()) {
throw new AttachmentException("Monomer is not there");
}
} /* second: group (mixture or or) or list */ else if (mon instanceof MonomerNotationGroup
|| mon instanceof MonomerNotationList) {
PolymerNotation polymerNotation = helm2notation.getPolymerNotation(e.getId());
Map<String, String> elements = new HashMap<String, String>();
for (MonomerNotationGroupElement groupElement : ((MonomerNotationGroup) mon).getListOfElements()) {
elements.put(groupElement.getMonomerNotation().getUnit(), "");
}
for (String e1 : elements.keySet()) {
try {
int i = Integer.parseInt(e1);
elements.put(e1, "1");
occurences.add(i);
} catch (NumberFormatException ex1) {
// have to be found in polymer
List<Integer> foundMonomers = findElementInPolymer(e1, polymerNotation);
if (foundMonomers.size() > 0) {
elements.put(e1, "1");
occurences.addAll(foundMonomers);
}
}
}
if (occurences.size() < elements.size() || elements.containsValue("")) {
throw new AttachmentException("Not all Monomers are there");
}
}
return occurences;
}
} | java |
public static boolean validateGrouping(HELM2Notation helm2notation) {
List<GroupingNotation> listGroupings = helm2notation.getListOfGroupings();
List<String> listPolymerIDs = helm2notation.getPolymerAndGroupingIDs();
/* validate each group */
for (GroupingNotation grouping : listGroupings) {
/* check for each group element if the polymer id is there */
for (GroupingElement groupingElement : grouping.getAmbiguity().getListOfElements()) {
if (!(listPolymerIDs.contains(groupingElement.getID().getId()))) {
LOG.info("Element of Group: " + groupingElement.getID().getId() + " does not exist");
return false;
}
}
}
return true;
} | java |
public static boolean validateUniquePolymerIDs(HELM2Notation helm2notation) {
List<String> listPolymerIDs = helm2notation.getPolymerAndGroupingIDs();
Map<String, String> uniqueId = new HashMap<String, String>();
for (String polymerID : listPolymerIDs) {
uniqueId.put(polymerID, "");
}
if (listPolymerIDs.size() > uniqueId.size()) {
LOG.info("Polymer node IDs are not unique");
return false;
}
return true;
} | java |
private static void checkExistenceOfPolymerID(String str, List<String> listPolymerIDs) throws PolymerIDsException {
if (!(listPolymerIDs.contains(str))) {
LOG.info("Polymer Id does not exist");
throw new PolymerIDsException("Polymer ID does not exist");
}
} | java |
private static boolean isMonomerValid(String str, String type) throws ChemistryException, MonomerLoadingException,
org.helm.notation2.parser.exceptionparser.NotationException {
LOG.info("Is Monomer valid: " + str);
MonomerFactory monomerFactory = null;
monomerFactory = MonomerFactory.getInstance();
/* Search in Database */
MonomerStore monomerStore = monomerFactory.getMonomerStore();
if (monomerStore.hasMonomer(type, str)) {
LOG.info("Monomer is located in the database: " + str);
return true;
} else if (str.charAt(0) == '[' && str.charAt(str.length() - 1) == ']'
&& monomerStore.hasMonomer(type, str.substring(1, str.length() - 1))) {
LOG.info("Monomer is located in the database: " + str);
return true;
} /* polymer type is Blob: accept all */ else if (type.equals("BLOB")) {
LOG.info("Blob's Monomer Type: " + str);
return true;
} /* new unknown monomer for peptide */ else if (type.equals("PEPTIDE") && str.equals("X")) {
LOG.info("Unknown monomer type for peptide: " + str);
return true;
} /* new unknown monomer for peptide */ else if (type.equals("RNA") && str.equals("N")) {
LOG.info("Unknown monomer type for rna: " + str);
return true;
} /* new unknown types */ else if (str.equals("?") || str.equals("_")) {
LOG.info("Unknown types: " + str);
return true;
} /* nucleotide */ else if (type.equals("RNA")) {
List<String> elements = NucleotideParser.getMonomerIDListFromNucleotide(str);
for (String element : elements) {
if (!(monomerStore.hasMonomer(type, element))) {
/* SMILES Check */
if (element.startsWith("[") && element.endsWith("]")) {
element = element.substring(1, element.length() - 1);
}
if (!Chemistry.getInstance().getManipulator().validateSMILES(element)) {
return false;
}
}
}
LOG.info("Nucleotide type for RNA: " + str);
return true;
}
LOG.info("SMILES Check");
/* SMILES Check */
if (str.charAt(0) == '[' && str.charAt(str.length() - 1) == ']') {
str = str.substring(1, str.length() - 1);
}
return Chemistry.getInstance().getManipulator().validateSMILES(str);
} | java |
private static void checkPolymerIDSConnection(ConnectionNotation not, List<String> listPolymerIDs)
throws PolymerIDsException {
/* the polymer ids have to be there */
checkExistenceOfPolymerID(not.getSourceId().getId(), listPolymerIDs);
checkExistenceOfPolymerID(not.getTargetId().getId(), listPolymerIDs);
} | java |
public static List<Monomer> getAllMonomers(MonomerNotation not, int position) throws HELM2HandledException,
MonomerException, NotationException, ChemistryException, CTKException, MonomerLoadingException {
List<Monomer> monomers = new ArrayList<Monomer>();
MonomerFactory monomerFactory = MonomerFactory.getInstance();
MonomerStore monomerStore = monomerFactory.getMonomerStore();
if (not instanceof MonomerNotationUnitRNA) {
monomers.addAll(getMonomersRNA((MonomerNotationUnitRNA) not, monomerStore, position));
} else if (not instanceof MonomerNotationUnit) {
String id = not.getUnit();
// if (id.startsWith("[") && id.endsWith("]")) {
// id = id.substring(1, id.length() - 1);
// }
monomers.add(MethodsMonomerUtils.getMonomer(not.getType(), id, ""));
} else if (not instanceof MonomerNotationGroup) {
for (MonomerNotationGroupElement groupElement : ((MonomerNotationGroup) not).getListOfElements()) {
String id = groupElement.getMonomerNotation().getUnit();
/*
* if (id.startsWith("[") && id.endsWith("]")) { id =
* id.substring(1, id.length() - 1); }
*/
monomers.add(MethodsMonomerUtils.getMonomer(not.getType(), id, ""));
}
} else if (not instanceof MonomerNotationList) {
for (MonomerNotation listElement : ((MonomerNotationList) not).getListofMonomerUnits()) {
if (listElement instanceof MonomerNotationUnitRNA) {
monomers.addAll(getMonomersRNA(((MonomerNotationUnitRNA) listElement), monomerStore, position));
} else {
String id = listElement.getUnit();
/*
* if (id.startsWith("[") && id.endsWith("]")) { id =
* id.substring(1, id.length() - 1); }
*/
monomers.add(MethodsMonomerUtils.getMonomer(not.getType(), id, ""));
}
}
}
return monomers;
} | java |
public static List<Monomer> getAllMonomersOnlyBase(MonomerNotation not) throws HELM2HandledException,
MonomerException, NotationException, ChemistryException, CTKException, MonomerLoadingException {
LOG.debug("Get base for " + not);
List<Monomer> monomers = new ArrayList<Monomer>();
MonomerFactory monomerFactory = MonomerFactory.getInstance();
MonomerStore monomerStore = monomerFactory.getMonomerStore();
LOG.debug("Which MonomerNotationType " + not.getClass());
if (not instanceof MonomerNotationUnitRNA) {
LOG.debug("MonomerNotationUnitRNA");
monomers.addAll(getMonomersRNAOnlyBase((MonomerNotationUnitRNA) not, monomerStore));
} else if (not instanceof MonomerNotationUnit) {
String id = not.getUnit();
if (id.startsWith("[") && id.endsWith("]")) {
id = id.substring(1, id.length() - 1);
}
monomers.add(MethodsMonomerUtils.getMonomer(not.getType(), id, ""));
} else if (not instanceof MonomerNotationGroup) {
LOG.debug("MonomerNotationGroup");
for (MonomerNotationGroupElement groupElement : ((MonomerNotationGroup) not).getListOfElements()) {
String id = groupElement.getMonomerNotation().getUnit();
if (id.startsWith("[") && id.endsWith("]")) {
id = id.substring(1, id.length() - 1);
}
monomers.add(MethodsMonomerUtils.getMonomer(not.getType(), id, ""));
}
} else if (not instanceof MonomerNotationList) {
LOG.debug("MonomerNotationList");
for (MonomerNotation listElement : ((MonomerNotationList) not).getListofMonomerUnits()) {
if (listElement instanceof MonomerNotationUnitRNA) {
monomers.addAll(getMonomersRNAOnlyBase(((MonomerNotationUnitRNA) listElement), monomerStore));
} else {
String id = listElement.getUnit();
if (id.startsWith("[") && id.endsWith("]")) {
id = id.substring(1, id.length() - 1);
}
monomers.add(MethodsMonomerUtils.getMonomer(not.getType(), id, ""));
}
}
}
return monomers;
} | java |
private static void checkAttachmentPoint(Monomer mon, String str) throws AttachmentException {
if (!(mon.getAttachmentListString().contains(str))) {
if (!(str.equals("?") || str.equals("pair")) && !mon.getAlternateId().equals("?")) {
LOG.info("Attachment point for source is not there");
throw new AttachmentException("Attachment point for source is not there: " + str);
}
}
} | java |
private static boolean checkSingleAttachment(List<Monomer> monomers, String rGroup, HELM2Notation helm2notation,
ConnectionNotation not, InterConnections interconnection, String id) throws AttachmentException {
for (Monomer monomer : monomers) {
/* Are the attachment points there */
checkAttachmentPoint(monomer, rGroup);
/* is the attachment point already occupied by another monomer? */
String detail = not.getSourceUnit() + "$" + not.getrGroupSource();
/* Is the attachment point already occupied by another monomer */
/* Intra connections */
if (helm2notation.getSimplePolymer(id).getMapIntraConnection().containsKey(detail)) {
throw new AttachmentException("Attachment point is already occupied");
}
/* Inter connections */
detail = id + "$" + detail;
/* check */
if (interconnection.hasKey(detail)) {
throw new AttachmentException("Attachment point is already occupied");
}
}
return true;
} | java |
private static List<Monomer> getMonomersRNA(MonomerNotationUnitRNA rna, MonomerStore monomerStore, int position)
throws HELM2HandledException {
try {
List<Monomer> monomers = new ArrayList<Monomer>();
for (int index = 0; index < rna.getContents().size(); index++) {
String id = rna.getContents().get(index).getUnit();
if (rna.getContents().get(index).getUnit().startsWith("[")
&& rna.getContents().get(index).getUnit().endsWith("]")) {
id = id.substring(1, id.length() - 1);
}
/* Special case */
if (rna.getContents().size() == 1 && position == 0) {
monomers.add(MethodsMonomerUtils.getMonomer(rna.getType(), id, "P"));
} else {
monomers.add(MethodsMonomerUtils.getMonomer(rna.getType(), id, rna.getInformation().get(index)));
}
}
return monomers;
} catch (Exception e) {
e.printStackTrace();
throw new HELM2HandledException(e.getMessage());
}
} | java |
private static List<Monomer> getMonomersRNAOnlyBase(MonomerNotationUnitRNA rna, MonomerStore monomerStore)
throws HELM2HandledException {
try {
List<Monomer> monomers = new ArrayList<Monomer>();
for (MonomerNotationUnit unit : rna.getContents()) {
String id = unit.getUnit().replace("[", "");
id = id.replace("]", "");
Monomer mon = MethodsMonomerUtils.getMonomer(rna.getType(), id, "");
if (mon.getMonomerType().equals(Monomer.BRANCH_MOMONER_TYPE)) {
monomers.add(mon);
}
}
return monomers;
} catch (Exception e) {
e.printStackTrace();
throw new HELM2HandledException(e.getMessage());
}
} | java |
private static void initComplementMap() {
complementMap = new HashMap<String, String>();
complementMap.put("A", "U");
complementMap.put("G", "C");
complementMap.put("C", "G");
complementMap.put("U", "A");
complementMap.put("T", "A");
complementMap.put("X", "X");
} | java |
public static boolean areAntiparallel(PolymerNotation polymerOne, PolymerNotation polymerTwo)
throws RNAUtilsException, HELM2HandledException, ChemistryException, NucleotideLoadingException {
checkRNA(polymerOne);
checkRNA(polymerTwo);
PolymerNotation antiparallel = getAntiparallel(polymerOne);
String sequenceOne = FastaFormat
.generateFastaFromRNA(MethodsMonomerUtils.getListOfHandledMonomers(antiparallel.getListMonomers()));
String sequenceTwo = FastaFormat
.generateFastaFromRNA(MethodsMonomerUtils.getListOfHandledMonomers(polymerTwo.getListMonomers()));
return sequenceOne.equals(sequenceTwo);
} | java |
public static String getMaxMatchFragment(String seq1, String seq2) throws NotationException {
return getMaxMatchFragment(seq1, seq2, MINUMUM_MATCH_FRAGMENT_LENGTH);
} | java |
public static String getMaxMatchFragment(String seq1, String seq2, int minLength) throws NotationException {
if (null == seq1 || null == seq2) {
throw new NotationException("Both sequences must not be null ");
}
if (!seq1.equals(seq1.toUpperCase()) || !seq2.equals(seq2.toUpperCase())) {
throw new NotationException("Both sequences must be natural nucleotide sequence in upper case ");
}
String longSeq, shortSeq;
if (seq1.length() > seq2.length()) {
longSeq = seq1;
shortSeq = seq2;
} else {
longSeq = seq2;
shortSeq = seq1;
}
// replace T with U
longSeq = longSeq.replaceAll("T", "U");
shortSeq = shortSeq.replaceAll("T", "U");
int min = MINUMUM_MATCH_FRAGMENT_LENGTH;
if (minLength > min) {
min = minLength;
}
for (int len = shortSeq.length(); len > min; len--) {
for (int i = 0; i <= shortSeq.length() - len; i++) {
String tmp = shortSeq.substring(i, i + len);
if (longSeq.contains(tmp)) {
return tmp;
}
}
}
return "";
} | java |
public static void removeLastP(PolymerNotation polymer)
throws RNAUtilsException, NotationException, HELM2HandledException {
checkRNA(polymer);
/* Get last monomerNotation */
MonomerNotation lastObject = polymer.getPolymerElements().getListOfElements()
.get(polymer.getPolymerElements().getListOfElements().size() - 1);
/* What happens to HELM2 features */
if (lastObject instanceof MonomerNotationGroup || lastObject instanceof MonomerNotationList) {
throw new HELM2HandledException("HELM2 features are involved");
}
if (hasPhosphat((MonomerNotationUnitRNA) lastObject)) {
MonomerNotation lastObjectwithoutPhosphat = new MonomerNotationUnitRNA(
lastObject.getUnit().substring(0, lastObject.getUnit().length() - 1), "RNA");
ChangeObjects.changeMonomerNotation(polymer.getPolymerElements().getListOfElements().size() - 1, polymer,
lastObjectwithoutPhosphat);
LOG.info("Last phosphate was removed from the last nucleotide");
}
} | java |
public static void addLastP(PolymerNotation polymer)
throws RNAUtilsException, NotationException, HELM2HandledException {
checkRNA(polymer);
/* Get last monomerNotation */
MonomerNotation lastObject = polymer.getPolymerElements().getListOfElements()
.get(polymer.getPolymerElements().getListOfElements().size() - 1);
/* What happens to HELM2 features */
if (lastObject instanceof MonomerNotationGroup || lastObject instanceof MonomerNotationList) {
throw new HELM2HandledException("HELM2 features are involved");
}
if (!(hasPhosphat((MonomerNotationUnitRNA) lastObject))) {
MonomerNotation lastObjectwithPhosphat = new MonomerNotationUnitRNA(lastObject.getUnit() + "P", "RNA");
ChangeObjects.changeMonomerNotation(polymer.getPolymerElements().getListOfElements().size() - 1, polymer,
lastObjectwithPhosphat);
LOG.info("Phosphate was added to the last nucleotide");
}
} | java |
public static PolymerNotation getInverse(PolymerNotation polymer) throws RNAUtilsException, org.helm.notation2.exception.NotationException, ChemistryException, NucleotideLoadingException {
checkRNA(polymer);
PolymerNotation inverse;
try {
inverse = SequenceConverter.readRNA(generateInverse(polymer).toString()).getListOfPolymers().get(0);
inverse = new PolymerNotation(inverse.getPolymerID(), inverse.getPolymerElements(),
"Inverse to " + polymer.getPolymerID().getId());
return inverse;
} catch (NotationException | FastaFormatException | HELM2HandledException e) {
e.printStackTrace();
throw new RNAUtilsException("The inverse strand can not be built");
}
} | java |
public static PolymerNotation getReverseComplement(PolymerNotation polymer) throws RNAUtilsException, org.helm.notation2.exception.NotationException, ChemistryException, NucleotideLoadingException {
checkRNA(polymer);
PolymerNotation complementReversePolymer;
try {
complementReversePolymer = SequenceConverter.readRNA(generateReverseComplement(polymer).toString())
.getListOfPolymers().get(0);
complementReversePolymer = new PolymerNotation(complementReversePolymer.getPolymerID(),
complementReversePolymer.getPolymerElements(),
"ReverseComplement to " + polymer.getPolymerID().getId());
return complementReversePolymer;
} catch (NotationException | FastaFormatException | HELM2HandledException e) {
e.printStackTrace();
throw new RNAUtilsException("Complement polymer can not be built");
}
} | java |
private static StringBuilder generateInverse(PolymerNotation polymer) throws HELM2HandledException,
RNAUtilsException, org.helm.notation2.exception.NotationException, ChemistryException {
initComplementMap();
String sequence = getNaturalAnalogSequence(polymer);
StringBuilder sb = new StringBuilder(sequence);
return sb.reverse();
} | java |
public static boolean hasNucleotideModification(PolymerNotation polymer) throws NotationException {
for (MonomerNotation current : polymer.getPolymerElements().getListOfElements()) {
if (hasModification(current)) {
return true;
}
}
return false;
} | java |
private static boolean hasModification(MonomerNotation monomerNotation) throws NotationException {
if (monomerNotation instanceof MonomerNotationUnitRNA) {
if (hasModification((MonomerNotationUnitRNA) monomerNotation)) {
return true;
}
} else if (monomerNotation instanceof MonomerNotationGroup) {
for (MonomerNotationGroupElement element : ((MonomerNotationGroup) monomerNotation).getListOfElements()) {
if (hasModification(element.getMonomerNotation())) {
return true;
}
}
} else if (monomerNotation instanceof MonomerNotationList) {
for (MonomerNotation element : ((MonomerNotationList) monomerNotation).getListofMonomerUnits()) {
if (hasModification(element)) {
return true;
}
}
} else {
throw new NotationException("Unknown MonomerNotation Type " + monomerNotation.getClass());
}
return false;
} | java |
private static boolean hasModification(MonomerNotationUnitRNA monomerNotation) {
if (monomerNotation.getUnit().contains("[") || monomerNotation.getUnit().contains("(X)")
|| monomerNotation.getUnit().endsWith(")")) {
return true;
}
return false;
} | java |
public static List<ConnectionNotation> hybridizeAntiparallel(PolymerNotation one, PolymerNotation two)
throws RNAUtilsException, NotationException, HELM2HandledException,
ChemistryException, NucleotideLoadingException {
checkRNA(one);
checkRNA(two);
List<ConnectionNotation> connections = new ArrayList<ConnectionNotation>();
ConnectionNotation connection;
/* Length of the two rnas have to be the same */
if (areAntiparallel(one, two)) {
for (int i = 0; i < PolymerUtils.getTotalMonomerCount(one); i++) {
int backValue = PolymerUtils.getTotalMonomerCount(one) - i;
int firstValue = i + 1;
String details = firstValue + ":pair-" + backValue + ":pair";
connection = new ConnectionNotation(one.getPolymerID(), two.getPolymerID(), details);
connections.add(connection);
}
return connections;
} else {
throw new RNAUtilsException("The given RNAs are not antiparallel to each other");
}
} | java |
public static String getSequence(PolymerNotation one)
throws RNAUtilsException, HELM2HandledException, ChemistryException {
checkRNA(one);
List<Nucleotide> nucleotideList = getNucleotideList(one);
StringBuffer sb = new StringBuffer();
for (int i = 0; i < nucleotideList.size(); i++) {
sb.append(nucleotideList.get(i).getNaturalAnalog());
}
return sb.toString();
} | java |
public static String getModifiedNucleotideSequence(PolymerNotation polymer)
throws RNAUtilsException, HELM2HandledException, ChemistryException {
checkRNA(polymer);
List<Nucleotide> nucleotides = getNucleotideList(polymer);
StringBuilder sb = new StringBuilder();
for (Nucleotide nucleotide : nucleotides) {
sb.append(nucleotide.getSymbol());
}
return sb.toString();
} | java |
public static String getNucleotideSequence(PolymerNotation polymer) throws NotationException, RNAUtilsException,
HELM2HandledException, NucleotideLoadingException, ChemistryException {
List<Nucleotide> nucleotides = getNucleotideList(polymer);
StringBuffer sb = new StringBuffer();
int count = 0;
Map<String, String> reverseNucMap = NucleotideFactory.getInstance().getReverseNucleotideTemplateMap();
for (Nucleotide nuc : nucleotides) {
String nucleotide = nuc.getNotation();
String nucleoside = nuc.getNucleosideNotation();
String linker = nuc.getLinkerNotation();
// it is ok for the first nucleotide not to have a nucleoside
if (count == 0 && nucleoside.length() == 0) {
sb.append(nuc.getPhosphateMonomer().getAlternateId());
count++;
continue;
}
// it is ok for the last nucleotide not to have a linker
if (count == nucleotides.size() - 1 && linker.length() == 0) {
nucleotide = nucleotide + Monomer.ID_P;
}
if (reverseNucMap.containsKey(nucleotide)) {
sb.append(reverseNucMap.get(nucleotide));
} else {
throw new NotationException(
"Unknown nucleotide found for " + nucleotide + " : missing nucleotide template");
}
count++;
}
return sb.toString();
} | java |
public static List<Nucleotide> getNucleotideList(PolymerNotation polymer)
throws RNAUtilsException, HELM2HandledException, ChemistryException {
checkRNA(polymer);
List<Nucleotide> nucleotides = new ArrayList<Nucleotide>();
/* check for HELM2Elements */
List<MonomerNotation> monomerNotations = polymer.getPolymerElements().getListOfElements();
for (int i = 0; i < monomerNotations.size(); i++) {
MonomerNotation monomerNotation = monomerNotations.get(i);
if ((!(monomerNotation instanceof MonomerNotationUnitRNA))
|| Integer.parseInt(monomerNotation.getCount()) != 1) {
LOG.info("MonomerNotation contains HELM2 Elements " + monomerNotation);
throw new HELM2HandledException("HELM2 Elements are involved");
}
try {
boolean last = false;
if (i == monomerNotations.size() - 1) {
last = true;
}
nucleotides.add(NucleotideParser.convertToNucleotide(monomerNotation.getUnit(), last));
} catch (MonomerException | NucleotideLoadingException | NotationException
| org.helm.notation2.exception.NotationException e) {
e.printStackTrace();
throw new RNAUtilsException("Nucleotide can not be read " + e.getMessage());
}
}
return nucleotides;
} | java |
public static String getTrimmedNucleotideSequence(PolymerNotation polymer)
throws RNAUtilsException, HELM2HandledException, ChemistryException {
checkRNA(polymer);
List<Nucleotide> list = getNucleotideList(polymer);
int start = 0;
Nucleotide na = list.get(start);
while (null == na.getBaseMonomer()) {
start++;
na = list.get(start);
}
int end = list.size() - 1;
na = list.get(end);
while (null == na.getBaseMonomer()) {
end--;
na = list.get(end);
}
StringBuffer sb = new StringBuffer();
for (int i = start; i <= end; i++) {
sb.append(list.get(i).getNaturalAnalog());
}
return sb.toString();
} | java |
public static JKExceptionHandlerFactory getInstance() {
if (JKExceptionHandlerFactory.instance == null) {
JKExceptionHandlerFactory.instance = new JKExceptionHandlerFactory();
}
return JKExceptionHandlerFactory.instance;
} | java |
public void setHandler(final Class<? extends Throwable> clas, final JKExceptionHandler handler) {
this.handlers.put(clas, handler);
} | java |
public void registerHanders(String packageString) {
List<String> list = AnnotationDetector.scanAsList(ExceptionHandler.class, packageString);
for (String handler : list) {
// System.out.println(handler);
JKExceptionHandler<? extends Throwable> newInstance = JKObjectUtil.newInstance(handler);
Class<? extends Throwable> clas = JKObjectUtil.getGenericParamter(handler);
setHandler(clas, newInstance);
}
} | java |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.