code stringlengths 73 34.1k | label stringclasses 1 value |
|---|---|
public boolean unmodifiedWithoutPhosphate() {
if (getNotation() == null) {
return true;
} else {
// System.out.println("Contains [ " + getNotation().contains("[") +
// "\tContainsX " + getNotation().contains("["));
if (getNotation().contains("[") || getNotation().contains("X")) {
return false;
} else {
return true;
}
}
} | java |
public Monomer getBaseMonomer(MonomerStore monomerStore) {
String baseSymbol = getBaseSymbol();
if (baseSymbol != null && !baseSymbol.equalsIgnoreCase("")) {
try {
Map<String, Monomer> monomers = monomerStore.getMonomers(Monomer.NUCLIEC_ACID_POLYMER_TYPE);
Monomer m = monomers.get(baseSymbol);
return m;
} catch (Exception ex) {
LOG.info("Unable to get base monomer for "
+ baseSymbol);
return null;
}
} else {
return null;
}
} | java |
public Monomer getSugarMonomer(MonomerStore monomerStore) {
String sugarSymbol = getSugarSymbol();
if (sugarSymbol != null && !sugarSymbol.equalsIgnoreCase("")) {
try {
Map<String, Monomer> monomers = monomerStore.getMonomers(Monomer.NUCLIEC_ACID_POLYMER_TYPE);
Monomer m = monomers.get(sugarSymbol);
return m;
} catch (Exception ex) {
LOG.info("Unable to get sugar monomer for "
+ sugarSymbol);
return null;
}
} else {
return null;
}
} | java |
public String getLinkerNotation() {
String pSymbol = getPhosphateSymbol();
String result = null;
if (null == pSymbol || pSymbol.length() == 0) {
result = "";
} else {
if (pSymbol.length() > 1)
result = "[" + pSymbol + "]";
else
result = pSymbol;
}
return result;
} | java |
public String getNucleosideNotation() {
int linkerLen = getLinkerNotation().length();
return notation.substring(0, notation.length() - linkerLen);
} | java |
public void addMonomer(Monomer monomer, boolean dbChanged)
throws IOException, MonomerException {
Map<String, Monomer> monomerMap = monomerDB.get(monomer.getPolymerType());
String polymerType = monomer.getPolymerType();
String alternateId = monomer.getAlternateId();
String smilesString = monomer.getCanSMILES();
try {
smilesString = SMILES.getUniqueExtendedSMILES(smilesString);
} catch (Exception e) {
smilesString = monomer.getCanSMILES();
}
boolean hasSmilesString = (smilesString != null && smilesString.length() > 0);
if (null == monomerMap) {
monomerMap = new TreeMap<String, Monomer>(String.CASE_INSENSITIVE_ORDER);
monomerDB.put(polymerType, monomerMap);
}
Monomer copyMonomer = DeepCopy.copy(monomer);
// ensure the canonical SMILES is indexed in the monomer store
if (hasSmilesString) {
copyMonomer.setCanSMILES(smilesString);
}
boolean alreadyAdded = false;
alreadyAdded = monomerMap.containsKey(alternateId);
if (!alreadyAdded) {
monomerMap.put(alternateId, copyMonomer);
boolean alreadyInSMILESMap = hasSmilesString
&& (smilesMonomerDB.containsKey(smilesString));
if (!alreadyInSMILESMap) {
smilesMonomerDB.put(smilesString, copyMonomer);
}
}
if (dbChanged) {
MonomerFactory.setDBChanged(true);
}
} | java |
public boolean hasMonomer(String polymerType, String alternateId) {
return ((monomerDB.get(polymerType) != null) && getMonomer(polymerType, alternateId) != null);
} | java |
public Monomer getMonomer(String polymerType, String alternateId) {
Map<String, Monomer> map1 = monomerDB.get(polymerType);
//alternateId = alternateId.toUpperCase();
return monomerDB.get(polymerType).get(alternateId);
} | java |
public synchronized void addNewMonomer(Monomer monomer) throws IOException,
MonomerException {
monomer.setNewMonomer(true);
addMonomer(monomer, true);
} | java |
public List<Monomer> getAllMonomersList() {
List<Monomer> monomers = new ArrayList<Monomer>();
for (String polymerType : getPolymerTypeSet()) {
Map<String, Monomer> map = getMonomers(polymerType);
monomers.addAll(map.values());
}
return monomers;
} | java |
public final static void addAnnotation(final AnnotationNotation notation, final int position,
final HELM2Notation helm2notation) {
helm2notation.getListOfAnnotations().add(position, notation);
} | java |
public final static void changeAnnotation(final AnnotationNotation notation, final int position,
final HELM2Notation helm2notation) {
helm2notation.getListOfAnnotations().set(position, notation);
} | java |
public final static void addConnection(final ConnectionNotation notation, final int position,
final HELM2Notation helm2notation) {
helm2notation.getListOfConnections().add(position, notation);
} | java |
public final static void changeConnection(final int position, final ConnectionNotation notation,
final HELM2Notation helm2notation) {
helm2notation.getListOfConnections().set(position, notation);
} | java |
public final static void addAnnotationToConnection(final int position, final String annotation,
final HELM2Notation helm2notation) {
helm2notation.getListOfConnections().get(position).setAnnotation(annotation);
} | java |
public final static void addGroup(final GroupingNotation notation, final int position,
final HELM2Notation helm2notation) {
helm2notation.getListOfGroupings().add(position, notation);
} | java |
public final static void changeGroup(final GroupingNotation notation, final int position,
final HELM2Notation helm2notation) {
helm2notation.getListOfGroupings().set(position, notation);
} | java |
public final static PolymerNotation addAnnotationToPolymer(final PolymerNotation polymer, final String annotation) {
if (polymer.getAnnotation() != null) {
return new PolymerNotation(polymer.getPolymerID(), polymer.getPolymerElements(),
polymer.getAnnotation() + " | " + annotation);
}
return new PolymerNotation(polymer.getPolymerID(), polymer.getPolymerElements(), annotation);
} | java |
public final static PolymerNotation removeAnnotationOfPolmyer(PolymerNotation polymer) {
return new PolymerNotation(polymer.getPolymerID(), polymer.getPolymerElements(), null);
} | java |
public final static PolymerNotation addMonomerNotation(int position, PolymerNotation polymer,
MonomerNotation monomerNotation) {
polymer.getPolymerElements().getListOfElements().add(position, monomerNotation);
return polymer;
} | java |
public final static void changeMonomerNotation(int position, PolymerNotation polymer, MonomerNotation not) {
polymer.getPolymerElements().getListOfElements().set(position, not);
} | java |
public final static void deleteMonomerNotation(int position, PolymerNotation polymer) throws NotationException {
MonomerNotation monomerNotation = polymer.getPolymerElements().getListOfElements().get(position);
if (polymer.getPolymerElements().getListOfElements().size() == 1) {
throw new NotationException(monomerNotation.toString()
+ " can't be removed. Polymer has to have at least one Monomer Notation");
}
polymer.getPolymerElements().getListOfElements().remove(monomerNotation);
} | java |
public final static void addAnnotationToMonomerNotation(PolymerNotation polymer, int position, String annotation) {
polymer.getPolymerElements().getListOfElements().get(position).setAnnotation(annotation);
} | java |
public final static void addCountToMonomerNotation(PolymerNotation polymer, int position, String count) {
polymer.getPolymerElements().getListOfElements().get(position).setCount(count);
} | java |
public final static void deleteAnnotationFromMonomerNotation(PolymerNotation polymer, int position) {
polymer.getPolymerElements().getListOfElements().get(position).setAnnotation(null);
} | java |
public final static void changePolymerNotation(int position, PolymerNotation polymer, HELM2Notation helm2notation) {
helm2notation.getListOfPolymers().set(position, polymer);
} | java |
public final static void addPolymerNotation(int position, PolymerNotation polymer, HELM2Notation helm2notation) {
helm2notation.getListOfPolymers().add(position, polymer);
} | java |
public final static void replaceMonomer(HELM2Notation helm2notation, String polymerType, String existingMonomerID,
String newMonomerID) throws NotationException, MonomerException,
ChemistryException, CTKException, IOException, JDOMException {
validateMonomerReplacement(polymerType, existingMonomerID, newMonomerID);
/*
* if(newMonomerID.length()> 1){ if( !( newMonomerID.startsWith("[") &&
* newMonomerID.endsWith("]"))){ newMonomerID = "[" + newMonomerID +
* "]"; } }
*/
for (int i = 0; i < helm2notation.getListOfPolymers().size(); i++) {
if (helm2notation.getListOfPolymers().get(i).getPolymerID().getType().equals(polymerType)) {
for (int j = 0; j < helm2notation.getListOfPolymers().get(i).getPolymerElements().getListOfElements()
.size(); j++) {
MonomerNotation monomerNotation = replaceMonomerNotation(
helm2notation.getListOfPolymers().get(i).getPolymerElements().getListOfElements().get(j),
existingMonomerID, newMonomerID);
if (monomerNotation != null) {
helm2notation.getListOfPolymers().get(i).getPolymerElements().getListOfElements().set(j,
monomerNotation);
}
}
}
}
} | java |
public final static MonomerNotation replaceMonomerNotation(MonomerNotation monomerNotation,
String existingMonomerID, String newMonomerID)
throws NotationException, ChemistryException, CTKException, MonomerLoadingException {
/* Nucleotide */
if (monomerNotation instanceof MonomerNotationUnitRNA) {
List<String> result = generateIDForNucleotide(((MonomerNotationUnitRNA) monomerNotation), existingMonomerID,
newMonomerID);
if (result.get(1) != null) {
MonomerNotationUnitRNA newObject = new MonomerNotationUnitRNA(result.get(0), monomerNotation.getType());
newObject.setCount(monomerNotation.getCount());
if (monomerNotation.isAnnotationTrue()) {
newObject.setAnnotation(monomerNotation.getAnnotation());
}
return newObject;
}
} else if (monomerNotation instanceof MonomerNotationUnit) {
/* Simple MonomerNotationUnit */
if (monomerNotation.getUnit().equals(existingMonomerID)) {
return produceMonomerNotationUnitWithOtherID(monomerNotation, newMonomerID);
}
} else if (monomerNotation instanceof MonomerNotationList) {
/* MonomerNotationList */
monomerNotation = replaceMonomerNotationList(((MonomerNotationList) monomerNotation), existingMonomerID,
newMonomerID);
if (monomerNotation != null) {
return monomerNotation;
}
} else if (monomerNotation instanceof MonomerNotationGroup) {
/* MonomerNotatationGroup */
monomerNotation = replaceMonomerNotationGroup(((MonomerNotationGroup) monomerNotation), existingMonomerID,
newMonomerID);
if (monomerNotation != null) {
return monomerNotation;
}
} else {
throw new NotationException("Unknown MonomerNotation Type " + monomerNotation.getClass());
}
return null;
} | java |
public final static MonomerNotationGroup replaceMonomerNotationGroup(MonomerNotationGroup monomerNotation,
String existingMonomerID, String newMonomerID) throws NotationException {
MonomerNotationGroup newObject = null;
boolean hasChanged = false;
StringBuilder sb = new StringBuilder();
String id = "";
for (MonomerNotationGroupElement object : monomerNotation.getListOfElements()) {
if (object.getMonomerNotation().getUnit().equals(existingMonomerID)) {
hasChanged = true;
id = generateGroupElement(newMonomerID, object.getValue());
} else {
id = generateGroupElement(object.getMonomerNotation().getUnit(), object.getValue());
}
if (monomerNotation instanceof MonomerNotationGroupOr) {
sb.append(id + ",");
} else {
sb.append(id + "+");
}
}
if (hasChanged) {
sb.setLength(sb.length() - 1);
if (monomerNotation instanceof MonomerNotationGroupOr) {
newObject = new MonomerNotationGroupOr(sb.toString(), monomerNotation.getType());
} else {
newObject = new MonomerNotationGroupMixture(sb.toString(), monomerNotation.getType());
}
}
return newObject;
} | java |
public final static MonomerNotationUnit produceMonomerNotationUnitWithOtherID(MonomerNotation monomerNotation,
String newID) throws NotationException {
MonomerNotationUnit result = new MonomerNotationUnit(newID, monomerNotation.getType());
if (monomerNotation.isAnnotationTrue()) {
result.setAnnotation(monomerNotation.getAnnotation());
}
result.setCount(monomerNotation.getCount());
return result;
} | java |
public final static MonomerNotationList replaceMonomerNotationList(MonomerNotationList object,
String existingMonomerID, String newMonomerID)
throws NotationException, ChemistryException, CTKException, MonomerLoadingException {
MonomerNotationList newObject = null;
boolean hasChanged = false;
StringBuilder sb = new StringBuilder();
String id = "";
for (MonomerNotation element : object.getListofMonomerUnits()) {
if (element instanceof MonomerNotationUnitRNA) {
List<String> result = generateIDForNucleotide(((MonomerNotationUnitRNA) element), existingMonomerID,
newMonomerID);
id = result.get(0);
if (result.get(1) != null) {
hasChanged = true;
}
} else {
if (element.getUnit().equals(existingMonomerID)) {
hasChanged = true;
id = generateIDMonomerNotation(newMonomerID, element.getCount(), element.getAnnotation());
} else {
id = generateIDMonomerNotation(element.getUnit(), element.getCount(), element.getAnnotation());
}
}
sb.append(id + ".");
}
if (hasChanged) {
sb.setLength(sb.length() - 1);
newObject = new MonomerNotationList(sb.toString(), object.getType());
newObject.setCount(object.getCount());
if (object.isAnnotationTrue()) {
newObject.setAnnotation(object.getAnnotation());
}
}
return newObject;
} | java |
private final static String generateIDMonomerNotation(String id, String count, String annotation) {
if (id.length() > 1) {
id = "[" + id + "]";
}
String result = id;
try {
if (!(Integer.parseInt(count) == 1)) {
result += "'" + count + "'";
}
} catch (NumberFormatException e) {
result += "'" + count + "'";
}
if (annotation != null) {
result += "\"" + annotation + "\"";
}
return result;
} | java |
private final static String generateIDRNA(String id, String count, String annotation)
throws MonomerLoadingException, ChemistryException, CTKException {
String result = id;
if (result.startsWith("[") && result.endsWith("]")) {
result = id.substring(1, id.length() - 1);
}
if (MonomerFactory.getInstance().getMonomerStore().getMonomer("RNA", result).getMonomerType()
.equals(Monomer.BRANCH_MOMONER_TYPE)) {
if (id.length() > 1) {
result = "[" + id + "]";
}
result = "(" + result + ")";
} else {
if (id.length() > 1) {
result = "[" + id + "]";
}
}
try {
if (!(Integer.parseInt(count) == 1)) {
result += "'" + count + "'";
}
} catch (NumberFormatException e) {
result += "'" + count + "'";
}
if (annotation != null) {
result += "\"" + annotation + "\"";
}
return result;
} | java |
private final static List<String> generateIDForNucleotide(MonomerNotationUnitRNA object, String existingMonomerID,
String newMonomerID) throws MonomerLoadingException, ChemistryException, CTKException {
List<String> result = new ArrayList<String>();
String hasChanged = null;
StringBuilder sb = new StringBuilder();
String id = "";
for (MonomerNotation element : object.getContents()) {
if (element.getUnit().equals(existingMonomerID)) {
hasChanged = "";
id = generateIDRNA(newMonomerID, element.getCount(), element.getAnnotation());
} else {
id = generateIDRNA(element.getUnit(), element.getCount(), element.getAnnotation());
}
sb.append(id);
}
try {
if (!(Integer.parseInt(object.getCount()) == 1)) {
sb.append("'" + object.getCount() + "'");
}
} catch (NumberFormatException e) {
sb.append("'" + object.getCount() + "'");
}
if (object.getAnnotation() != null) {
sb.append("\"" + object.getAnnotation() + "\"");
}
result.add(sb.toString());
result.add(hasChanged);
return result;
} | java |
private static String generateGroupElement(String id, List<Double> list) {
StringBuilder sb = new StringBuilder();
if (list.size() == 1) {
if (list.get(0) == -1.0) {
sb.append(id + ":");
sb.append("?" + "-");
} else if (list.get(0) == 1.0) {
sb.append(id + ":");
} else {
sb.append(id + ":" + list.get(0) + "-");
}
} else {
sb.append(id + ":");
for (Double item : list) {
sb.append(item + "-");
}
}
sb.setLength(sb.length() - 1);
return sb.toString();
} | java |
public static final void replaceSMILESWithTemporaryIds(HELM2Notation helm2notation) throws NotationException,
HELM2HandledException, ChemistryException, CTKException, MonomerLoadingException, JDOMException {
for (int i = 0; i < helm2notation.getListOfPolymers().size(); i++) {
/* First save intern smiles to the MonomerFactory */
MethodsMonomerUtils.getListOfHandledMonomers(helm2notation.getListOfPolymers().get(i).getListMonomers());
for (int j = 0; j < helm2notation.getListOfPolymers().get(i).getPolymerElements().getListOfElements()
.size(); j++) {
MonomerNotation monomerNotation = replaceSMILESWithTemporaryIdsMonomerNotation(
helm2notation.getListOfPolymers().get(i).getPolymerElements().getListOfElements().get(j));
if (monomerNotation != null) {
helm2notation.getListOfPolymers().get(i).getPolymerElements().getListOfElements().set(j,
monomerNotation);
}
}
}
} | java |
public static void hybridize(HELM2Notation helm2notation) throws NotationException, RNAUtilsException,
HELM2HandledException, org.helm.notation2.exception.NotationException, ChemistryException {
if (HELM2NotationUtils.getAllBasePairConnections(helm2notation.getListOfConnections()).isEmpty()
&& HELM2NotationUtils.getRNAPolymers(helm2notation.getListOfPolymers()).size() == 2) {
List<ConnectionNotation> connections = RNAUtils.hybridize(
HELM2NotationUtils.getRNAPolymers(helm2notation.getListOfPolymers()).get(0),
HELM2NotationUtils.getRNAPolymers(helm2notation.getListOfPolymers()).get(1));
for (ConnectionNotation connection : connections) {
addConnection(connection, helm2notation.getListOfConnections().size(), helm2notation);
}
}
} | java |
public void setApplicationMap(final Map<String, Object> applicationMap) {
JKThreadLocal.setValue(JKContextConstants.APPLICATION_MAP, applicationMap);
} | java |
public void setRequestMap(final Map<String, Object> requestMap) {
JKThreadLocal.setValue(JKContextConstants.HTTP_REQUEST_MAP, requestMap);
} | java |
public void setSessionMap(final Map<String, Object> sessionMap) {
JKThreadLocal.setValue(JKContextConstants.HTTP_SESSION_MAP, sessionMap);
} | java |
private static String compress(String str) throws EncoderException {
ByteArrayOutputStream rstBao = null;
GZIPOutputStream zos = null;
try {
rstBao = new ByteArrayOutputStream();
zos = new GZIPOutputStream(rstBao);
zos.write(str.getBytes());
IOUtils.closeQuietly(zos);
byte[] bytes = rstBao.toByteArray();
return Base64.encodeBase64String(bytes);
} catch(Exception e){
throw new EncoderException("Molfile could not be compressed. " + str);
} finally{
IOUtils.closeQuietly(zos);
}
} | java |
private static String decompress(String str) throws EncoderException {
/* First base64 decode the string */
byte[] bytes = Base64.decodeBase64(str);
GZIPInputStream zi = null;
try {
zi = new GZIPInputStream(new ByteArrayInputStream(bytes));
InputStreamReader reader = new InputStreamReader(zi);
BufferedReader in = new BufferedReader(reader);
StringBuilder sb = new StringBuilder();
String read;
while ((read = in.readLine()) != null) {
sb.append(read + "\n");
}
String molfile = sb.toString();
reader.close();
in.close();
zi.close();
return molfile;
} catch (IOException e) {
throw new EncoderException("Molfile could not be decompressed. " + str);
} finally {
IOUtils.closeQuietly(zi);
}
} | java |
public MemoryFileAttributes addDir( EightyPath dir, Principals principals ) {
if( content.get( dir ).isPresent() ) {
throw new IllegalArgumentException( "path exists already" );
}
if( !dir.isAbsolute() || dir.getParent() == null ) {
throw new IllegalArgumentException( "path not absolute or without parent" );
}
PathContent parentContent = content.getOrThrow( childGetParent( dir ),
() -> new IllegalArgumentException( "parent does not exist" ) );
content.put( dir, PathContent.newDir( principals ) );
parentContent.kids.add( dir );
parentContent.attis.setLastModifiedTime();
parentContent.attis.setLastAccessTime();
return parentContent.attis;
} | java |
public static Map<String, Attachment> loadAttachments(InputStream in) throws IOException {
ObjectMapper mapper = new ObjectMapper();
TypeReference<TreeMap<String, Attachment>> typeRef = new TypeReference<TreeMap<String, Attachment>>() {
};
TreeMap<String, Attachment> attachments;
try {
attachments = mapper.readValue(in, typeRef);
LOG.info("Attachments could be loaded");
for (Map.Entry<String, Attachment> entry : attachments.entrySet()) {
Attachment currentAttachment = entry.getValue();
if (!validateAttachment(currentAttachment)) {
throw new IOException("Attachment is not valid: " + currentAttachment.getAlternateId());
}
}
return attachments;
} catch (IOException e) {
throw new IOException("Attachments in the given file can not be loaded.");
}
} | java |
public static boolean validateAttachment(Attachment currentAttachment) {
try {
currentAttachment.getId();
if (currentAttachment.getAlternateId() == "null" || currentAttachment.getAlternateId().isEmpty()) {
return false;
}
if (currentAttachment.getCapGroupName() == "null" || currentAttachment.getCapGroupName().isEmpty()) {
return false;
}
if (currentAttachment.getCapGroupSMILES() == "null" || currentAttachment.getCapGroupSMILES().isEmpty()) {
return false;
}
if (currentAttachment.getLabel().equals("null") || currentAttachment.getLabel().equals(" ")) {
return false;
}
} catch (Exception e) {
return false;
}
return true;
} | java |
public static void checkAllowedPrivilige(final JKPrivilige privilige) {
logger.debug("checkAllowedPrivilige() : ", privilige);
final JKAuthorizer auth = getAuthorizer();
auth.checkAllowed(privilige);
} | java |
public static boolean matchPassword(String plain, JKUser user) {
JK.implementMe();
return JKSecurityUtil.encode(plain).equals(user.getPassword());
} | java |
public static JKPrivilige createPrivilige(String name, JKPrivilige parent, int number) {
logger.trace("createPriviligeObject(): Id : ", ".name", name, ", Parent:[", parent, "] , ", number);
JKPrivilige p = new JKPrivilige(name, parent, number);
p.setDesc(p.getFullName());
return p;
} | java |
public static HELM2Notation readPeptide(String notation)
throws FastaFormatException, NotationException, ChemistryException {
HELM2Notation helm2notation = new HELM2Notation();
PolymerNotation polymer = new PolymerNotation("PEPTIDE1");
helm2notation.addPolymer(new PolymerNotation(polymer.getPolymerID(),
FastaFormat.generateElementsOfPeptide(notation, polymer.getPolymerID())));
return helm2notation;
} | java |
public static String getPeptideSequenceFromNotation(HELM2Notation helm2notation) throws HELM2HandledException,
PeptideUtilsException, org.helm.notation2.exception.NotationException, ChemistryException {
List<PolymerNotation> polymers = helm2notation.getListOfPolymers();
StringBuffer sb = new StringBuffer();
for (PolymerNotation polymer : polymers) {
sb.append(PeptideUtils.getSequence(polymer) + " ");
}
sb.setLength(sb.length() - 1);
return sb.toString();
} | java |
public static String getNucleotideNaturalAnalogSequenceFromNotation(HELM2Notation helm2Notation)
throws NotationException, HELM2HandledException, ChemistryException {
List<PolymerNotation> polymers = helm2Notation.getListOfPolymers();
StringBuffer sb = new StringBuffer();
for (PolymerNotation polymer : polymers) {
try {
sb.append(RNAUtils.getNaturalAnalogSequence(polymer) + " ");
} catch (RNAUtilsException e) {
e.printStackTrace();
throw new NotationException("Input complex notation contains non-nucleid acid polymer");
}
}
sb.setLength(sb.length() - 1);
return sb.toString();
} | java |
public static String getPeptideNaturalAnalogSequenceFromNotation(HELM2Notation helm2Notation)
throws HELM2HandledException, PeptideUtilsException, NotationException, ChemistryException {
List<PolymerNotation> polymers = helm2Notation.getListOfPolymers();
StringBuffer sb = new StringBuffer();
for (PolymerNotation polymer : polymers) {
if (!(polymer.getPolymerID() instanceof PeptideEntity)) {
throw new NotationException("Input complex notation contains non-peptide polymer(s)");
}
sb.append(PeptideUtils.getNaturalAnalogueSequence(polymer) + " ");
}
sb.setLength(sb.length() - 1);
return sb.toString();
} | java |
public static void setDefaultExecutor(Executor executor) {
Class<?> c = null;
Field field = null;
try {
c = Class.forName("android.os.AsyncTask");
field = c.getDeclaredField("sDefaultExecutor");
field.setAccessible(true);
field.set(null, executor);
field.setAccessible(false);
} catch (IllegalArgumentException e) {
e.printStackTrace();
Log.e("IllegalArgumentException", e);
} catch (ClassNotFoundException e) {
e.printStackTrace();
Log.e("ClassNotFoundException", e);
} catch (NoSuchFieldException e) {
e.printStackTrace();
Log.e("NoSuchFieldException", e);
} catch (IllegalAccessException e) {
e.printStackTrace();
Log.e("IllegalAccessException", e);
}
} | java |
public static Executor getDefaultExecutor() {
Executor exec = null;
Class<?> c = null;
Field field = null;
try {
c = Class.forName("android.os.AsyncTask");
field = c.getDeclaredField("sDefaultExecutor");
field.setAccessible(true);
exec = (Executor) field.get(null);
field.setAccessible(false);
} catch (IllegalArgumentException e) {
e.printStackTrace();
Log.e("IllegalArgumentException", e);
} catch (ClassNotFoundException e) {
e.printStackTrace();
Log.e("ClassNotFoundException", e);
} catch (NoSuchFieldException e) {
e.printStackTrace();
Log.e("NoSuchFieldException", e);
} catch (IllegalAccessException e) {
e.printStackTrace();
Log.e("IllegalAccessException", e);
}
return exec;
} | java |
public static Nucleotide convertToNucleotide(String id, boolean last) throws MonomerException, org.helm.notation2.exception.NotationException, ChemistryException, NucleotideLoadingException,
NotationException {
Map<String, String> reverseNucMap = NucleotideFactory.getInstance().getReverseNucleotideTemplateMap();
// last nucleotide will be handled differently
String tmpNotation = id;
String symbol = null;
// if (i == (notations.length - 1) && notation.endsWith(")")) {
if (last && id.endsWith(")")) {
tmpNotation = id + "P";
}
if (reverseNucMap.containsKey(tmpNotation)) {
symbol = reverseNucMap.get(tmpNotation);
} else {
char[] chars = id.toCharArray();
String base = null;
symbol = "X";
// find base
for (int j = 0; j < chars.length; j++) {
char letter = chars[j];
// skip modifications if not in branch
if (letter == MODIFICATION_START_SYMBOL) {
int matchingPos = NucleotideParser.getMatchingBracketPosition(chars, j, MODIFICATION_START_SYMBOL, MODIFICATION_END_SYMBOL);
j++;
if (matchingPos == -1) {
throw new NotationException(
"Invalid Polymer Notation: Could not find matching bracket");
}
j = matchingPos;
}
// base is always a branch monomer
else if (letter == BRANCH_START_SYMBOL) {
int matchingPos = NucleotideParser.getMatchingBracketPosition(chars, j, BRANCH_START_SYMBOL, BRANCH_END_SYMBOL);
j++;
if (matchingPos == -1) {
throw new NotationException(
"Invalid Polymer Notation: Could not find matching bracket");
}
base = id.substring(j, matchingPos);
if (base.length() == 1) {
symbol = base;
} else {
Monomer monomer = MethodsMonomerUtils.getMonomer("RNA", base, "");
if (null == monomer.getNaturalAnalog()) {
symbol = "X";
} else {
symbol = monomer.getNaturalAnalog();
}
}
j = matchingPos;
}
}
}
Nucleotide nuc = new Nucleotide(symbol, id);
return nuc;
} | java |
public static boolean validateSimpleNotationForRNA(String polymerNotation) throws org.helm.notation2.parser.exceptionparser.NotationException {
getMonomerIDListFromNucleotide(polymerNotation);
return true;
} | java |
@Override
public void dragged(IEventMotion e) {
if(paletteDiagram.getSelectedCommand() == ECommands.SELECT.toString()) {
if(!itWasDragging) {
itWasDragging = asmDiagramUml.tryToDragging(e.getX(), e.getY());
}
else {
asmDiagramUml.tryToDragging(e.getX(), e.getY());
}
}
} | java |
public static HELM2Notation generatePeptidePolymersFromFASTAFormatHELM1(String fasta)
throws FastaFormatException, ChemistryException {
helm2notation = new HELM2Notation();
if (null == fasta) {
LOG.error("Peptide Sequence must be specified");
throw new FastaFormatException("Peptide Sequence must be specified");
}
initMapAminoAcid();
StringBuilder elements = new StringBuilder();
int counter = 0;
PolymerNotation polymer;
try {
polymer = new PolymerNotation("PEPTIDE" + "1");
} catch (org.helm.notation2.parser.exceptionparser.NotationException e) {
e.printStackTrace();
throw new FastaFormatException(e.getMessage());
}
String annotation = "";
for (String line : fasta.split("\n")) {
if (line.startsWith(">")) {
counter++;
if (counter > 1) {
helm2notation.addPolymer(new PolymerNotation(polymer.getPolymerID(),
generateElementsOfPeptide(elements.toString(), polymer.getPolymerID()), annotation));
elements = new StringBuilder();
try {
polymer = new PolymerNotation("PEPTIDE" + counter);
} catch (org.helm.notation2.parser.exceptionparser.NotationException e) {
e.printStackTrace();
throw new FastaFormatException(e.getMessage());
}
}
annotation = line.substring(1);
} else {
line = cleanup(line);
elements.append(line);
}
}
helm2notation.addPolymer(new PolymerNotation(polymer.getPolymerID(),
generateElementsOfPeptide(elements.toString(), polymer.getPolymerID()), annotation));
return helm2notation;
} | java |
private static void initMapNucleotides() throws FastaFormatException {
try {
nucleotides = NucleotideFactory.getInstance().getNucleotideTemplates().get("HELM Notation");
} catch (IOException e) {
e.printStackTrace();
LOG.error("NucleotideFactory can not be initialized");
throw new FastaFormatException(e.getMessage());
}
} | java |
private static void initMapTransformNucleotides() {
transformNucleotides = new HashMap<String, String>();
for (Map.Entry e : nucleotides.entrySet()) {
transformNucleotides.put(e.getValue().toString(), e.getKey().toString());
}
} | java |
private static void initMapNucleotidesNaturalAnalog() throws FastaFormatException, ChemistryException {
try {
nucleotidesNaturalAnalog = MonomerFactory.getInstance().getMonomerDB().get("RNA");
} catch (IOException e) {
e.printStackTrace();
LOG.error("Nucleotides can not be initialized");
throw new FastaFormatException(e.getMessage());
}
} | java |
private static void initMapAminoAcid() throws FastaFormatException, ChemistryException {
try {
aminoacids = MonomerFactory.getInstance().getMonomerDB().get("PEPTIDE");
} catch (IOException e) {
e.printStackTrace();
LOG.error("AminoAcids can not be initialized");
throw new FastaFormatException(e.getMessage());
}
} | java |
protected static String generateFastaFromPeptide(List<Monomer> monomers) {
StringBuilder fasta = new StringBuilder();
for (Monomer monomer : monomers) {
fasta.append(monomer.getNaturalAnalog());
}
return fasta.toString();
} | java |
public static String generateFastaFromRNAPolymer(List<PolymerNotation> polymers)
throws FastaFormatException, ChemistryException {
StringBuilder fasta = new StringBuilder();
for (PolymerNotation polymer : polymers) {
String header = polymer.getPolymerID().getId();
if (polymer.getAnnotation() != null) {
header = polymer.getAnnotation();
}
fasta.append(">" + header + "\n");
try {
fasta.append(
generateFastaFromRNA(MethodsMonomerUtils.getListOfHandledMonomers(polymer.getListMonomers()))
+ "\n");
} catch (HELM2HandledException e) {
e.printStackTrace();
throw new FastaFormatException(e.getMessage());
}
}
return fasta.toString();
} | java |
protected static String generateFastaFromRNA(List<Monomer> monomers) {
StringBuilder fasta = new StringBuilder();
for (Monomer monomer : monomers) {
if (monomer.getMonomerType().equals(Monomer.BRANCH_MOMONER_TYPE)) {
fasta.append(monomer.getNaturalAnalog());
}
}
return fasta.toString();
} | java |
public static String generateFasta(HELM2Notation helm2Notation2) throws FastaFormatException, ChemistryException {
List<PolymerNotation> polymersPeptides = new ArrayList<PolymerNotation>();
List<PolymerNotation> polymerNucleotides = new ArrayList<PolymerNotation>();
StringBuilder fasta = new StringBuilder();
for (PolymerNotation polymer : helm2Notation2.getListOfPolymers()) {
if (polymer.getPolymerID() instanceof RNAEntity) {
polymerNucleotides.add(polymer);
}
if (polymer.getPolymerID() instanceof PeptideEntity) {
polymersPeptides.add(polymer);
}
}
fasta.append(generateFastaFromPeptidePolymer(polymersPeptides));
fasta.append(generateFastaFromRNAPolymer(polymerNucleotides));
return fasta.toString();
} | java |
public static HELM2Notation convertIntoAnalogSequence(HELM2Notation helm2Notation)
throws FastaFormatException, AnalogSequenceException, ChemistryException, CTKException {
initMapAminoAcid();
initMapNucleotides();
initMapNucleotidesNaturalAnalog();
initMapTransformNucleotides();
/*
* transform/convert only the peptides + rnas into the analog sequence
*/
List<PolymerNotation> polymers = helm2Notation.getListOfPolymers();
for (int i = 0; i < helm2Notation.getListOfPolymers().size(); i++) {
if (helm2Notation.getListOfPolymers().get(i).getPolymerID() instanceof RNAEntity) {
helm2Notation.getListOfPolymers().set(i, convertRNAIntoAnalogSequence(polymers.get(i)));
}
if (helm2Notation.getListOfPolymers().get(i).getPolymerID() instanceof PeptideEntity) {
helm2Notation.getListOfPolymers().set(i, convertPeptideIntoAnalogSequence(polymers.get(i)));
}
}
return helm2Notation;
} | java |
private static PolymerNotation convertPeptideIntoAnalogSequence(PolymerNotation polymer)
throws AnalogSequenceException {
for (int i = 0; i < polymer.getPolymerElements().getListOfElements().size(); i++) {
/* Change current MonomerNotation */
polymer.getPolymerElements().getListOfElements().set(i,
generateMonomerNotationPeptide(polymer.getPolymerElements().getListOfElements().get(i)));
}
return polymer;
} | java |
private static MonomerNotation generateMonomerNotationRNA(MonomerNotation current) throws AnalogSequenceException {
MonomerNotation change = null;
try {
/* simple MonomerNotationUnit */
if (current instanceof MonomerNotationUnit) {
change = new MonomerNotationUnit(changeIdForRNA(current), current.getType());
} else if (current instanceof MonomerNotationGroup) {
if (current instanceof MonomerNotationGroupOr) {
StringBuilder sb = new StringBuilder();
for (MonomerNotationGroupElement element : ((MonomerNotationGroup) current).getListOfElements()) {
sb.append(changeIdForRNA(element.getMonomerNotation()) + ",");
}
sb.setLength(sb.length() - 1);
change = new MonomerNotationGroupOr(sb.toString(), current.getType());
} else if (current instanceof MonomerNotationGroupMixture) {
StringBuilder sb = new StringBuilder();
for (MonomerNotationGroupElement element : ((MonomerNotationGroup) current).getListOfElements()) {
sb.append(changeIdForRNA(element.getMonomerNotation()) + "+");
}
sb.setLength(sb.length() - 1);
change = new MonomerNotationGroupMixture(sb.toString(), current.getType());
} else {
/* throw new exception */
throw new AnalogSequenceException("Unknown MonomerNotationGroup " + current.getClass());
}
} else if (current instanceof MonomerNotationList) {
StringBuilder sb = new StringBuilder();
for (MonomerNotation element : ((MonomerNotationList) current).getListofMonomerUnits()) {
sb.append(changeIdForRNA(element) + ".");
}
sb.setLength(sb.length() - 1);
change = new MonomerNotationList(sb.toString(), current.getType());
} else {
/* throw new exception */
throw new AnalogSequenceException("Unknown MonomerNotation " + current.getClass());
}
change.setCount(current.getCount());
if (current.getAnnotation() != null) {
change.setAnnotation(current.getAnnotation());
}
return change;
} catch (NotationException e) {
e.printStackTrace();
throw new AnalogSequenceException("Notation object can not be built");
}
} | java |
private static PolymerNotation convertRNAIntoAnalogSequence(PolymerNotation polymer)
throws AnalogSequenceException {
/* change only if it is possible */
for (int i = 0; i < polymer.getPolymerElements().getListOfElements().size(); i++) {
polymer.getPolymerElements().getListOfElements().set(i,
generateMonomerNotationRNA(polymer.getPolymerElements().getListOfElements().get(i)));
}
return polymer;
} | java |
private static String changeIdForRNA(MonomerNotation monomerNotation) {
if (monomerNotation instanceof MonomerNotationUnitRNA) {
StringBuilder changeid = new StringBuilder();
for (MonomerNotation not : ((MonomerNotationUnitRNA) monomerNotation).getContents()) {
Monomer monomer = nucleotidesNaturalAnalog.get(not.getUnit().replace("[", "").replace("]", ""));
String id = monomer.getNaturalAnalog();
if (monomer.getMonomerType().equals(Monomer.BRANCH_MOMONER_TYPE)) {
id = "(" + id + ")";
}
changeid.append(id);
}
return changeid.toString();
} else {
Monomer monomer = nucleotidesNaturalAnalog.get(monomerNotation.getUnit().replace("[", "").replace("]", ""));
String id = monomer.getNaturalAnalog();
if (monomer.getMonomerType().equals(Monomer.BRANCH_MOMONER_TYPE)) {
id = "(" + id + ")";
}
return id;
}
} | java |
private boolean checkHostPart(final String label, final Problems problems, final String compName) {
boolean result = true;
if (label.length() > 63) {
problems.add(ValidationBundle.getMessage(HostNameValidator.class, "LABEL_TOO_LONG", label)); // NOI18N
result = false;
}
if (label.length() == 0) {
problems.add(ValidationBundle.getMessage(HostNameValidator.class, "LABEL_EMPTY", compName, label)); // NOI18N
}
if (result) {
try {
Integer.parseInt(label);
problems.add(ValidationBundle.getMessage(HostNameValidator.class, "NUMBER_PART_IN_HOSTNAME", label)); // NOI18N
result = false;
} catch (final NumberFormatException e) {
// do nothing
}
if (result) {
if (result) {
result = new EncodableInCharsetValidator().validate(problems, compName, label);
if (result) {
for (final char c : label.toLowerCase().toCharArray()) {
if (c >= 'a' && c <= 'z' || c >= '0' && c <= '9' || c == '-') { // NOI18N
continue;
}
problems.add(ValidationBundle.getMessage(HostNameValidator.class, "BAD_CHAR_IN_HOSTNAME", new String(new char[] { c }))); // NOI18N
result = false;
}
}
}
}
}
return result;
} | java |
public static String getMacAddress() {
try {
List<String> macAddress = new ArrayList<String>();
Enumeration<NetworkInterface> enumNetWorkInterface = NetworkInterface.getNetworkInterfaces();
while (enumNetWorkInterface.hasMoreElements()) {
NetworkInterface netWorkInterface = enumNetWorkInterface.nextElement();
byte[] hardwareAddress = netWorkInterface.getHardwareAddress();
if (hardwareAddress != null && netWorkInterface.isUp() && !netWorkInterface.isVirtual()) {
String displayName = netWorkInterface.getDisplayName().toLowerCase();
if (!displayName.contains("virtual") && !displayName.contains("tunnel")) {
String strMac = "";
for (int i = 0; i < hardwareAddress.length; i++) {
strMac += String.format("%02X%s", hardwareAddress[i], (i < hardwareAddress.length - 1) ? "-" : "");
}
if (strMac.trim().length() > 0) {
macAddress.add(strMac);
}
}
}
}
return macAddress.toString().replace(",", ";").replace("[", "").replace("]", "");
} catch (Exception e) {
throw new JKException(e);
}
} | java |
public static Properties getSystemInfo() {
logger.debug("getSystemInfo()");
if (MachineInfo.systemInfo == null) {
if (!JKIOUtil.isWindows()) {
throw new IllegalStateException("this feature is only supported on windows");
}
final byte[] sourceFileContents = JKIOUtil.readFileAsByteArray("/native/jk.dll");
if (sourceFileContents.length > 0) {
logger.debug("dll found");
// copy the dll to the new exe file
logger.debug("move to temp folder");
final File hardDiskReaderFile = JKIOUtil.writeDataToTempFile(sourceFileContents, ".exe");
// execute the file
logger.debug("execute process");
final Process p = JKIOUtil.executeFile(hardDiskReaderFile.getAbsolutePath());
String input = new String(JKIOUtil.readStream(p.getInputStream()));
input = input.replace(":", "=");
logger.debug("input : ", input);
final String lines[] = input.split(JK.NEW_LINE);
MachineInfo.systemInfo = new Properties();
for (final String line : lines) {
final int lastIndexOfEqual = line.lastIndexOf('=');
if (lastIndexOfEqual != -1 && lastIndexOfEqual != line.length()) {
String key = line.substring(0, lastIndexOfEqual).trim().toUpperCase();
key = key.replace("_", "");// remove old underscores
key = key.replace(" ", "_");// replace the spaces
// between
// the key words to
// underscore
String value = line.substring(lastIndexOfEqual + 1).trim();
value = value.replace("[", "");
value = value.replace("]", "");
value = value.trim();
String oldValue = systemInfo.getProperty(key);
if (oldValue == null) {
systemInfo.setProperty(key, value);
} else {
if (!oldValue.contains(value)) {
systemInfo.setProperty(key, oldValue.concat(";").concat(value));
}
}
}
}
logger.debug("destory process");
p.destroy();
logger.debug("delete file");
hardDiskReaderFile.delete();
}
}
return MachineInfo.systemInfo;
} | java |
public static Class<?> getExceptionCallerClass(final Throwable t) {
final StackTraceElement[] stackTrace = t.getStackTrace();
for (final StackTraceElement stackTraceElement : stackTrace) {
logger.debug(stackTraceElement.getClassName().concat(".").concat(stackTraceElement.getMethodName()));
}
return null;
} | java |
public static String getMainClassName() {
StackTraceElement trace[] = Thread.currentThread().getStackTrace();
if (trace.length > 0) {
return trace[trace.length - 1].getClassName();
}
return "Unknown";
} | java |
public static HELM2Notation getSiRNANotation(String senseSeq, String antiSenseSeq)
throws NotationException, FastaFormatException, HELM2HandledException, RNAUtilsException,
org.helm.notation2.exception.NotationException, ChemistryException, CTKException,
NucleotideLoadingException {
return getSirnaNotation(senseSeq, antiSenseSeq, NucleotideParser.RNA_DESIGN_NONE);
} | java |
public static HELM2Notation getSirnaNotation(String senseSeq, String antiSenseSeq, String rnaDesignType)
throws NotationException, FastaFormatException, HELM2HandledException, RNAUtilsException,
org.helm.notation2.exception.NotationException, ChemistryException, CTKException,
NucleotideLoadingException {
HELM2Notation helm2notation = null;
if (senseSeq != null && senseSeq.length() > 0) {
helm2notation = SequenceConverter.readRNA(senseSeq);
}
if (antiSenseSeq != null && antiSenseSeq.length() > 0) {
PolymerNotation antisense = new PolymerNotation("RNA2");
antisense = new PolymerNotation(antisense.getPolymerID(),
FastaFormat.generateElementsforRNA(antiSenseSeq, antisense.getPolymerID()));
helm2notation.addPolymer(antisense);
}
validateSiRNADesign(helm2notation.getListOfPolymers().get(0), helm2notation.getListOfPolymers().get(1),
rnaDesignType);
helm2notation.getListOfConnections().addAll(hybridization(helm2notation.getListOfPolymers().get(0),
helm2notation.getListOfPolymers().get(1), rnaDesignType));
ChangeObjects.addAnnotation(new AnnotationNotation("RNA1{ss}|RNA2{as}"), 0, helm2notation);
return helm2notation;
} | java |
private static List<ConnectionNotation> hybridization(PolymerNotation one, PolymerNotation two,
String rnaDesignType) throws NotationException, HELM2HandledException, RNAUtilsException,
org.helm.notation2.exception.NotationException, ChemistryException, NucleotideLoadingException {
List<ConnectionNotation> connections = new ArrayList<ConnectionNotation>();
ConnectionNotation connection;
if (one.getPolymerElements().getListOfElements() != null
&& one.getPolymerElements().getListOfElements().size() > 0
&& two.getPolymerElements().getListOfElements() != null
&& two.getPolymerElements().getListOfElements().size() > 0) {
String analogSeqSS = RNAUtils.getNaturalAnalogSequence(one).replaceAll("T", "U");
String analogSeqAS = new StringBuilder(RNAUtils.getNaturalAnalogSequence(two).replaceAll("T", "U"))
.toString();
if (NucleotideParser.RNA_DESIGN_NONE.equalsIgnoreCase(rnaDesignType)) {
String normalCompAS = RNAUtils.getNaturalAnalogSequence(RNAUtils.getComplement(two)).replace("T", "U");
String maxMatch = RNAUtils.getMaxMatchFragment(analogSeqSS,
new StringBuilder(normalCompAS).reverse().toString());
if (maxMatch.length() > 0) {
int ssStart = analogSeqSS.indexOf(maxMatch);
int normalCompStart = new StringBuilder(normalCompAS).reverse().toString().indexOf(maxMatch);
int asStart = analogSeqAS.length() - maxMatch.length() - normalCompStart;
for (int i = 0; i < maxMatch.length(); i++) {
int ssPos = (i + ssStart) * 3 + 2;
int asPos = (asStart + maxMatch.length() - 1 - i) * 3 + 2;
String details = ssPos + ":pair-" + asPos + ":pair";
connection = new ConnectionNotation(one.getPolymerID(), two.getPolymerID(), details);
connections.add(connection);
}
}
} else if (NucleotideParser.RNA_DESIGN_TUSCHL_19_PLUS_2.equalsIgnoreCase(rnaDesignType)) {
int matchLength = 19;
connections = hybridizationWithLengthFromStart(one, two, analogSeqSS, analogSeqAS, matchLength);
} else if (NucleotideParser.RNA_DESIGN_DICER_27_R.equalsIgnoreCase(rnaDesignType)) {
int matchLength = 25;
connections = hybridizationWithLengthFromStart(one, two, analogSeqSS, analogSeqAS, matchLength);
} else if (NucleotideParser.RNA_DESIGN_DICER_27_L.equalsIgnoreCase(rnaDesignType)) {
int matchLength = 25;
connections = hybridizationWithLengthFromStart(one, two, analogSeqSS, analogSeqAS, matchLength);
} else {
new RNAUtilsException("RNA-Design-Type " + rnaDesignType + " is unknown");
}
}
return connections;
} | java |
private static List<ConnectionNotation> hybridizationWithLengthFromStart(PolymerNotation one, PolymerNotation two,
String senseAnalogSeq, String antisenseAnalogSeq, int lengthFromStart) throws NotationException {
List<ConnectionNotation> connections = new ArrayList<ConnectionNotation>();
ConnectionNotation connection;
for (int i = 0; i < lengthFromStart; i++) {
int ssPos = i * 3 + 2;
int asPos = (lengthFromStart - 1 - i) * 3 + 2;
String ssChar = String.valueOf(senseAnalogSeq.charAt(i));
String asChar = String.valueOf(antisenseAnalogSeq.charAt(lengthFromStart - 1 - i));
if (complementMap.get(ssChar).equalsIgnoreCase(asChar)) {
String details = ssPos + ":pair-" + asPos + ":pair";
connection = new ConnectionNotation(one.getPolymerID(), two.getPolymerID(), details);
connections.add(connection);
}
}
return connections;
} | java |
private static boolean validateSiRNADesign(PolymerNotation one, PolymerNotation two, String rnaDesignType)
throws RNAUtilsException, HELM2HandledException, NotationException, ChemistryException {
if (NucleotideParser.RNA_DESIGN_NONE.equalsIgnoreCase(rnaDesignType)) {
return true;
}
if (!NucleotideParser.SUPPORTED_DESIGN_LIST.contains(rnaDesignType)) {
throw new NotationException("Unsupported RNA Design Type '" + rnaDesignType + "'");
}
List<Nucleotide> senseNucList = RNAUtils.getNucleotideList(one);
List<Nucleotide> antisenseNucList = RNAUtils.getNucleotideList(two);
if (rnaDesignType.equals(NucleotideParser.RNA_DESIGN_TUSCHL_19_PLUS_2)) {
if (senseNucList.size() != 21) {
throw new NotationException("Sense strand for Tuschl 19+2 design must have 21 nucleotides");
}
if (antisenseNucList.size() != 21) {
throw new NotationException("Antisense strand for Tuschl 19+2 design must have 21 nucleotides");
}
} else if (rnaDesignType.equals(NucleotideParser.RNA_DESIGN_DICER_27_R)) {
if (senseNucList.size() != 25) {
throw new NotationException("Sense strand for Dicer 27R design must have 25 nucleotides");
}
if (antisenseNucList.size() != 27) {
throw new NotationException("Antisense strand for Dicer 27R design must have 27 nucleotides");
}
} else if (rnaDesignType.equals(NucleotideParser.RNA_DESIGN_DICER_27_L)) {
if (senseNucList.size() != 27) {
throw new NotationException("Sense strand for Dicer 27L design must have 27 nucleotides");
}
if (antisenseNucList.size() != 25) {
throw new NotationException("Antisense strand for Dicer 27L design must have 25 nucleotides");
}
}
return true;
} | java |
public synchronized Map<String, Map<String, Monomer>> getMonomerDB(boolean includeNewMonomers) {
if (includeNewMonomers) {
return monomerDB;
} else {
Map<String, Map<String, Monomer>> reducedMonomerDB = new TreeMap<String, Map<String, Monomer>>(
String.CASE_INSENSITIVE_ORDER);
for (String polymerType : monomerDB.keySet()) {
Map<String, Monomer> monomerMap = monomerDB.get(polymerType);
reducedMonomerDB.put(polymerType, excludeNewMonomers(monomerMap));
}
return reducedMonomerDB;
}
} | java |
public static MonomerFactory getInstance() throws MonomerLoadingException, ChemistryException {
if (null == instance) {
refreshMonomerCache();
}
else if (MonomerStoreConfiguration.getInstance().isUseWebservice()
&& MonomerStoreConfiguration.getInstance().isUpdateAutomatic()) {
refreshMonomerCache();
}
return instance;
} | java |
public synchronized void addNewMonomer(Monomer monomer) throws IOException, MonomerException {
monomer.setNewMonomer(true);
addMonomer(monomerDB, smilesMonomerDB, monomer);
dbChanged = true;
} | java |
public MonomerCache buildMonomerCacheFromXML(String monomerDBXML)
throws MonomerException, IOException, JDOMException, ChemistryException, CTKException {
ByteArrayInputStream bais = new ByteArrayInputStream(monomerDBXML.getBytes());
return buildMonomerCacheFromXML(bais);
} | java |
public synchronized void merge(MonomerCache remoteMonomerCache) throws IOException, MonomerException {
Map<Monomer, Monomer> conflicts = getConflictedMonomerMap(remoteMonomerCache);
if (conflicts.size() > 0) {
throw new MonomerException("Local new monomer and remote monomer database conflict found");
} else {
Map<String, Map<String, Monomer>> monoDB = remoteMonomerCache.getMonomerDB();
Set<String> polymerTypeSet = monoDB.keySet();
for (Iterator i = polymerTypeSet.iterator(); i.hasNext();) {
String polymerType = (String) i.next();
Map<String, Monomer> map = monoDB.get(polymerType);
Set<String> monomerSet = map.keySet();
for (Iterator it = monomerSet.iterator(); it.hasNext();) {
String id = (String) it.next();
Monomer m = map.get(id);
addMonomer(monomerDB, smilesMonomerDB, m);
}
}
}
dbChanged = true;
} | java |
public synchronized void setMonomerCache(MonomerCache remoteMonomerCache) throws IOException, MonomerException {
monomerDB = remoteMonomerCache.getMonomerDB();
attachmentDB = remoteMonomerCache.getAttachmentDB();
smilesMonomerDB = remoteMonomerCache.getSmilesMonomerDB();
dbChanged = true;
} | java |
private static Map<String, Attachment> buildAttachmentDB() throws IOException {
Map<String, Attachment> map = new TreeMap<String, Attachment>(String.CASE_INSENSITIVE_ORDER);
if (MonomerStoreConfiguration.getInstance().isUseExternalAttachments()) {
map = AttachmentLoader.loadAttachments(
new FileInputStream(MonomerStoreConfiguration.getInstance().getExternalAttachmentsPath()));
} else {
InputStream in = MonomerFactory.class.getResourceAsStream(ATTACHMENTS_RESOURCE);
map = AttachmentLoader.loadAttachments(in);
}
return map;
} | java |
public void saveMonomerCache() throws IOException, MonomerException {
File f = new File(NOTATION_DIRECTORY);
if (!f.exists()) {
f.mkdir();
}
MonomerCache cache = new MonomerCache();
cache.setMonomerDB(getMonomerDB(false));
cache.setAttachmentDB(getAttachmentDB());
cache.setSmilesMonomerDB(getSmilesMonomerDB(false));
serializeMonomerCache(cache, MONOMER_CACHE_FILE_PATH);
String monomerDbXML = buildMonomerDbXMLFromCache(cache);
FileOutputStream fos = new FileOutputStream(MONOMER_DB_FILE_PATH);
fos.write(monomerDbXML.getBytes());
fos.close();
} | java |
public static void scan(final Class<? extends Annotation> clas, final String[] basePackage, final AnnotationHandler handler) {
final ClassPathScanningCandidateComponentProvider scanner = new ClassPathScanningCandidateComponentProvider(false);
scanner.setResourceLoader(new PathMatchingResourcePatternResolver(Thread.currentThread().getContextClassLoader()));
scanner.addIncludeFilter(new AnnotationTypeFilter(clas));
for (final String pck : basePackage) {
for (final BeanDefinition bd : scanner.findCandidateComponents(pck)) {
handler.handleAnnotationFound(bd.getBeanClassName());
}
}
} | java |
public static List<String> scanAsList(final Class<? extends Annotation> clas, final String... basePackage) {
final List<String> classes = new ArrayList<>();
scan(clas, basePackage, new AnnotationHandler() {
@Override
public void handleAnnotationFound(String className) {
classes.add(className);
}
});
return classes;
} | java |
@Override
public void refreshGuiAndShowFile(File file) {
if(rootNode.getChildCount() > 0) {
rootNode.removeAllChildren();
treeModel.reload();
}
if(guiMain.getAsmProjectUml().getProjectUml() != null) {
addTreeNodes(file);
guiMain.getMenuMain().setVisibleProjectMenu(true);
}
else {
guiMain.getMenuMain().setVisibleProjectMenu(false);
}
} | java |
public static String buildToString(Object... params) {
StringBuffer finalMessage = new StringBuffer();
int i = 0;
for (Object object : params) {
if (i++ > 0) {
finalMessage.append(FIELD_SEPARATOR);
}
if (object instanceof List<?>) {
finalMessage.append(JKCollectionUtil.toString((List<?>) object));
} else {
finalMessage.append(JKObjectUtil.toString(object, true));
}
}
String fullText = finalMessage.toString();
return fullText;
} | java |
public static Map toMap(Object[] keys, Object[] values) {
Map map = new HashMap<>();
int i = 0;
for (Object key : keys) {
map.put(key, values[i++]);
}
return map;
} | java |
public static void validateNull(String name, Object object) {
if (object == null) {
throw new IllegalStateException(name.concat(" cannot be null"));
}
} | java |
public static void addToSystemConfig(String prefix, Properties prop) {
for (Entry<Object, Object> entry : prop.entrySet()) {
String key = prefix.concat(entry.getKey().toString());
String value = entry.getValue().toString();
System.setProperty(key, value);
}
} | java |
public static char[] readPassword(String msg) {
Console console = System.console();
if (console != null) {
return console.readPassword();
}
// console not available, most likely because of running inside IDE, try normal
scanner = getScanner();
System.out.print(msg);
return scanner.nextLine().toCharArray();
} | java |
public static void printOnce(Object msg) {
if (messagesCache.get(msg.hashCode()) == null) {
JK.printBlock(msg);
messagesCache.put(msg.hashCode(), msg);
}
} | java |
public static String getAppName() {
String appName=System.getProperty(JKContextConstants.JK_APP_NAME);
if (appName == null) {
String mainClassName = JKDebugUtil.getMainClassName();
return mainClassName.substring(0, mainClassName.lastIndexOf("."));
}
return appName;
} | java |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.