code stringlengths 73 34.1k | label stringclasses 1 value |
|---|---|
public static void dumpBeansNames() {
DefaultListableBeanFactory f = (DefaultListableBeanFactory) context.getBeanFactory();
String[] beanDefinitionNames = f.getBeanDefinitionNames();
for (String name : beanDefinitionNames) {
JK.print(name, " for class :", f.getBean(name).getClass().getName());
}
} | java |
protected static Configuration getConfig(String path) {
if (cfg == null) {
cfg = new Configuration();
cfg.setClassForTemplateLoading(TemplateUtil.class, path == null ? "/templates" : path);
cfg.setLocale(Locale.US);
cfg.setTemplateExceptionHandler(TemplateExceptionHandler.RETHROW_HANDLER);
}
return cfg;
} | java |
protected void handleClient(final Socket client) throws IOException {
final ClientHandler handler = new ClientHandler(client);
this.executorService.execute(handler);
} | java |
public synchronized void stop() throws IOException {
this.stopped = true;
if (this.server != null && this.waitingClient) {
this.server.close();
this.server = null;
}
} | java |
private void resetConfigToDefault() {
isUseWebservice = true;
isUpdateAutomatic = true;
isUseExternalMonomers = false;
isUseExternalNucleotides = false;
setUseExternalAttachments(false);
webserviceMonomersURL = "http://localhost:8080/HELM2MonomerService/rest";
webserviceMonomersPath = "monomer/";
webserviceMonomersPutPath = "monomer/";
webserviceEditorCategorizationURL = "http://localhost:8080";
webserviceEditorCategorizationPath = "";
externalNucleotidesPath = "";
externalMonomersPath = "";
setExternalAttachmentsPath("");
} | java |
public void refresh() {
File configFile = new File(CONFIG_FILE_PATH);
if (!configFile.exists()) {
BufferedWriter writer = null;
BufferedReader reader = null;
try {
configFile.createNewFile();
InputStream in = Chemistry.class.getResourceAsStream("/org/helm/notation2/resources/MonomerStoreConfig.properties");
reader = new BufferedReader(new InputStreamReader(in));
writer = new BufferedWriter(new FileWriter(configFile));
String line;
while ((line = reader.readLine()) != null) {
writer.write(line + System.getProperty("line.separator"));
}
} catch (Exception e) {
resetConfigToDefault();
e.printStackTrace();
} finally {
try {
if (writer != null) {
writer.close();
}
if (reader != null) {
reader.close();
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
try
{
PropertiesConfiguration conf = new PropertiesConfiguration(CONFIG_FILE_PATH);
isUseWebservice = conf.getBoolean(USE_WEBSERVICE);
isUpdateAutomatic = conf.getBoolean(UPDATE_AUTOMATIC);
webserviceMonomersURL = conf.getString(WEBSERVICE_MONOMERS_URL);
webserviceMonomersPath = conf.getString(WEBSERVICE_MONOMERS_PATH);
webserviceMonomersPutPath = conf.getString(WEBSERVICE_MONOMERS_PUT_PATH);
webserviceNucleotidesURL = conf.getString(WEBSERVICE_NUCLEOTIDES_URL);
webserviceNucleotidesPath = conf.getString(WEBSERVICE_NUCLEOTIDES_PATH);
webserviceNucleotidesPutPath = conf.getString(WEBSERVICE_NUCLEOTIDES_PUT_PATH);
webserviceEditorCategorizationURL = conf.getString(WEBSERVICE_EDITOR_CATEGORIZATION_URL);
webserviceEditorCategorizationPath = conf.getString(WEBSERVICE_EDITOR_CATEGORIZATION_PATH);
/* load from external xml file */
isUseExternalMonomers = conf.getBoolean(USE_EXTERNAL_MONOMERS);
externalMonomersPath = conf.getString(EXTERNAL_MONOMERS_PATH);
isUseExternalNucleotides = conf.getBoolean(USE_EXTERNAL_NUCLEOTIDES);
externalNucleotidesPath = conf.getString(EXTERNAL_NUCLEOTIDES_PATH);
isUseExternalAttachments = conf.getBoolean(USE_EXTERNAL_ATTACHMENTS);
externalAttachmentsPath = conf.getString(EXTERNAL_ATTACHMENTS_PATH);
} catch (ConfigurationException | NoSuchElementException e) {
resetConfigToDefault();
e.printStackTrace();
}
} | java |
private static void addEntry(final ArrayList<String> aStringArray) {
try {
final MagicMimeEntry magicEntry = new MagicMimeEntry(aStringArray);
mMagicMimeEntries.add(magicEntry);
} catch (final InvalidMagicMimeEntryException e) {
}
} | java |
private static String getMagicMimeType(final byte[] bytes) throws IOException {
final int len = mMagicMimeEntries.size();
for (int i = 0; i < len; i++) {
final MagicMimeEntry me = mMagicMimeEntries.get(i);
final String mtype = me.getMatch(bytes);
if (mtype != null) {
return mtype;
}
}
return null;
} | java |
public static String getMimeType(final byte[] data) {
String mimeType = null;
try {
mimeType = MimeUtil.getMagicMimeType(data);
} catch (final Exception e) {
} finally {
if (mimeType == null) {
mimeType = UNKNOWN_MIME_TYPE;
}
}
return mimeType;
} | java |
private static void parse(final Reader r) throws IOException {
final BufferedReader br = new BufferedReader(r);
String line;
final ArrayList<String> sequence = new ArrayList<String>();
line = br.readLine();
while (true) {
if (line == null) {
break;
}
line = line.trim();
if (line.length() == 0 || line.charAt(0) == '#') {
line = br.readLine();
continue;
}
sequence.add(line);
// read the following lines until a line does not begin with '>' or
// EOF
while (true) {
line = br.readLine();
if (line == null) {
addEntry(sequence);
sequence.clear();
break;
}
line = line.trim();
if (line.length() == 0 || line.charAt(0) == '#') {
continue;
}
if (line.charAt(0) != '>') {
addEntry(sequence);
sequence.clear();
break;
}
sequence.add(line);
}
}
if (!sequence.isEmpty()) {
addEntry(sequence);
}
} | java |
public static JKContext getCurrentContext() {
JKContext context = (JKContext) JKThreadLocal.getValue(JKContextConstants.JK_CONTEXT);
if (context == null) {
context = getInstance().createDesktopContext();
JKThreadLocal.setValue(JKContextConstants.JK_CONTEXT, context);
}
return context;
} | java |
public static byte[] generateImageHELMMolecule(HELM2Notation helm2notation) throws BuilderMoleculeException, CTKException, IOException, ChemistryException {
LOG.info("Image generation process of HELM molecule starts");
/* get SMILES representation for the whole molecule */
String smiles = SMILES.getSMILESForAll(helm2notation);
LOG.info("Get for the whole HELMNotation the smiles representation");
AbstractMolecule molecule = Chemistry.getInstance().getManipulator().getMolecule(smiles, null);
LOG.info("Molecule was created using the smiles generation");
String molFile = Chemistry.getInstance().getManipulator().convertMolecule(molecule, AbstractChemistryManipulator.StType.MOLFILE);
LOG.info("Generate molfile for the built molecule(s)");
return Chemistry.getInstance().getManipulator().renderMol(molFile, OutputType.PNG, PICTURE_WIDTH, PICTURE_HEIGHT, (int) Long.parseLong("D3D3D3", 16));
} | java |
public static List<String> getAminoAcidList(String peptideSequence)
throws MonomerException, NotationException, MonomerLoadingException, ChemistryException {
if (null == peptideSequence) {
throw new NotationException("Peptide Sequence must be specified");
}
String cleanSeq = cleanup(peptideSequence);
Map<String, Monomer> peptideMap = MonomerFactory.getInstance().getMonomerDB().get(Monomer.PEPTIDE_POLYMER_TYPE);
Set<String> keySet = peptideMap.keySet();
// walk the sequence
List<String> l = new ArrayList<String>();
int pos = 0;
while (pos < cleanSeq.length()) {
boolean found = false;
for (Iterator i = keySet.iterator(); i.hasNext();) {
String symbol = (String) i.next();
if (cleanSeq.startsWith(symbol, pos)) {
found = true;
l.add(symbol);
pos = pos + symbol.length();
break;
}
}
if (!found) {
throw new NotationException(
"Sequence contains unknown amino acid starting at "
+ cleanSeq.substring(pos));
}
}
return l;
} | java |
public static List<String> getAminoAcidList(String peptideSequence,
String delimiter) throws MonomerException, NotationException,
MonomerLoadingException, ChemistryException {
if (null == peptideSequence) {
throw new NotationException("Peptide Sequence must be specified");
}
if (null == delimiter || delimiter.length() == 0) {
return getAminoAcidList(peptideSequence);
} else {
if (!isValidDelimiter(delimiter))
throw new NotationException("Invalid sequence delimiter ["
+ delimiter + "], only the following are supported: ["
+ getValidDelimiters() + "]");
}
List<String> blocks = new ArrayList<String>();
StringTokenizer st = new StringTokenizer(peptideSequence, delimiter);
while (st.hasMoreTokens()) {
blocks.add(st.nextToken());
}
List<String> l = new ArrayList<String>();
for (String block : blocks) {
List<String> tmpL = getAminoAcidList(block);
l.addAll(tmpL);
}
return l;
} | java |
public static String cleanup(String sequence) {
String result = sequence.replaceAll("\\s", ""); // remove all white
// space
if (result.equals(result.toLowerCase())) {
result = result.toUpperCase();
}
return result;
} | java |
public static void downloadFile(final String fileUrl, final String localFile) throws IOException {
final URL url = new URL(fileUrl);
final HttpURLConnection connection = (HttpURLConnection) url.openConnection();
final byte[] data = JKIOUtil.readStream(connection.getInputStream());
JKIOUtil.writeBytesToFile(data, localFile);
} | java |
public static File downloadFileToTemp(final String fileUrl, final String ext) throws IOException {
final File file = File.createTempFile("jk-", ext);
JKHttpUtil.downloadFile(fileUrl, file.getAbsolutePath());
return file;
} | java |
public static String requestUrl(final String url, final String method, final Properties header, final String body) {
try {
final URL siteUrl = new URL(url);
final HttpURLConnection connection = (HttpURLConnection) siteUrl.openConnection();
connection.setRequestMethod(method);
final Enumeration<?> keys = header.keys();
while (keys.hasMoreElements()) {
final String key = (String) keys.nextElement();
connection.addRequestProperty(key, header.getProperty(key));
}
connection.setDoOutput(true);
final OutputStream out = connection.getOutputStream();
out.write(body.getBytes());
connection.connect();
final int errorCode = connection.getResponseCode();
if (errorCode != HttpURLConnection.HTTP_OK) {
throw new JKHttpException(connection.getResponseMessage(), errorCode);
}
final String response = JKIOUtil.convertToString(connection.getInputStream());
return response;
} catch (IOException e) {
throw new JKHttpException(e);
}
} | java |
public static String getUrlContents(String urlString) {
HttpURLConnection con = null;
try {
URL url = new URL(urlString);
con = (HttpURLConnection) url.openConnection();
con.connect();
InputStream inputStream = con.getInputStream();
BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
StringBuffer contents = new StringBuffer();
String line;
while ((line = reader.readLine()) != null) {
contents.append(line);
contents.append(JK.NEW_LINE);
}
inputStream.close();
return contents.toString();
} catch (Exception e) {
JKExceptionUtil.handle(e);
return null;// unreachable
} finally {
if (con != null) {
con.disconnect();
}
}
} | java |
public static String getValueFromUrl(String url, String preText, int length) {
String urlContents = getUrlContents(url);
int indexOf = urlContents.indexOf(preText);
if (indexOf != -1) {
indexOf += preText.length();
String substring = urlContents.substring(indexOf, indexOf + length);
return substring;
}
return null;
} | java |
public static InputStream getUrlInputStream(String urlString) {
URL url;
try {
url = new URL(urlString);
HttpURLConnection con = (HttpURLConnection) url.openConnection();
con.connect();
return con.getInputStream();
} catch (Exception e) {
throw new JKException(e);
}
} | java |
public static <T> T readUrlAsObject(String url, Class<T> type) {
String contents = getUrlContents(url);
ObjectMapper mapper = new ObjectMapper();
mapper.enableDefaultTyping();
try {
return mapper.readValue(contents, type);
} catch (IOException e) {
JK.throww(e);
return null;
}
} | java |
public static Password createPassword(char[] password) {
byte[] salt = JKSecurityUtil.salt();
byte[] hash = JKSecurityUtil.hash(password, salt);
Password pass = new Password();
pass.setHash(encodeInToBase64(hash));
pass.setSalt(encodeInToBase64(salt));
return pass;
} | java |
public Class<?> getJavaType() {
if(javaType==null) {
javaType=JKTypeMapping.getType(getCode()).getClass();
if(javaType==null) {
JK.error("JKType cannot by null, and code not avaiable %s",code);
}
}
return javaType;
} | java |
public String getName() {
if (name == null) {
name = JKMessage.get(getJavaType().getSimpleName());
}
return name;
} | java |
public JKTimeObject toTimeObject(Date date, Date time) {
JKTimeObject fsTimeObject = new JKTimeObject();
Calendar timeInstance = Calendar.getInstance();
timeInstance.setTimeInMillis(time.getTime());
fsTimeObject.setHour(timeInstance.get(Calendar.HOUR_OF_DAY));
fsTimeObject.setMunite(timeInstance.get(Calendar.MINUTE));
Calendar dateInstance = Calendar.getInstance();
dateInstance.setTime(date);
fsTimeObject.setYear(dateInstance.get(Calendar.YEAR));
fsTimeObject.setMonth(dateInstance.get(Calendar.MONTH));
fsTimeObject.setDay(dateInstance.get(Calendar.DAY_OF_MONTH));
return fsTimeObject;
} | java |
public static RgroupStructure buildMoleculefromSinglePolymer(final PolymerNotation polymernotation) throws BuilderMoleculeException, HELM2HandledException, ChemistryException {
LOG.info("Build molecule for single Polymer " + polymernotation.getPolymerID().getId());
/* Case 1: BLOB -> throw exception */
if (polymernotation.getPolymerID() instanceof BlobEntity) {
LOG.error("Molecule can't be build for BLOB");
throw new BuilderMoleculeException("Molecule can't be build for BLOB");
} /* Case 2: CHEM */ else if (polymernotation.getPolymerID() instanceof ChemEntity) {
List<Monomer> validMonomers = MethodsMonomerUtils.getListOfHandledMonomers(polymernotation.getPolymerElements().getListOfElements());
return buildMoleculefromCHEM(polymernotation.getPolymerID().getId(), validMonomers);
} /* Case 3: RNA or PEPTIDE */ else if (polymernotation.getPolymerID() instanceof RNAEntity
|| polymernotation.getPolymerID() instanceof PeptideEntity) {
List<Monomer> validMonomers =
MethodsMonomerUtils.getListOfHandledMonomers(polymernotation.getPolymerElements().getListOfElements());
return buildMoleculefromPeptideOrRNA(polymernotation.getPolymerID().getId(), validMonomers);
} else {
LOG.error("Molecule can't be build for unknown polymer type");
throw new BuilderMoleculeException("Molecule can't be build for unknown polymer type");
}
} | java |
private static RgroupStructure buildMoleculefromCHEM(final String id, final List<Monomer> validMonomers) throws BuilderMoleculeException, ChemistryException {
LOG.info("Build molecule for chemical component");
/* a chemical molecule should only contain one monomer */
if (validMonomers.size() == 1) {
try {
Monomer monomer = validMonomers.get(0);
String input = getInput(monomer);
if (input != null) {
/* Build monomer + Rgroup information! */
List<Attachment> listAttachments = monomer.getAttachmentList();
AttachmentList list = new AttachmentList();
for (Attachment attachment : listAttachments) {
list.add(new org.helm.chemtoolkit.Attachment(attachment.getAlternateId(), attachment.getLabel(), attachment.getCapGroupName(), attachment.getCapGroupSMILES()));
}
AbstractMolecule molecule = Chemistry.getInstance().getManipulator().getMolecule(input, list);
RgroupStructure result = new RgroupStructure();
result.setMolecule(molecule);
result.setRgroupMap(generateRgroupMap(id + ":" + "1", molecule));
return result;
} else {
LOG.error("Chemical molecule should have canonical smiles");
throw new BuilderMoleculeException("Chemical molecule should have canoncial smiles");
}
} catch (NullPointerException ex) {
throw new BuilderMoleculeException("Monomer is not stored in the monomer database");
} catch (IOException | CTKException e) {
LOG.error("Molecule can't be built " + e.getMessage());
throw new BuilderMoleculeException("Molecule can't be built " + e.getMessage());
}
} else {
LOG.error("Chemical molecule should contain exactly one monomer");
throw new BuilderMoleculeException("Chemical molecule should contain exactly one monomer");
}
} | java |
private static AttachmentList generateAttachmentList(final List<Attachment> listAttachments) {
AttachmentList list = new AttachmentList();
for (Attachment attachment : listAttachments) {
list.add(new org.helm.chemtoolkit.Attachment(attachment.getAlternateId(), attachment.getLabel(), attachment.getCapGroupName(), attachment.getCapGroupSMILES()));
}
return list;
} | java |
public static AbstractMolecule mergeRgroups(AbstractMolecule molecule) throws BuilderMoleculeException, ChemistryException {
try {
boolean flag = true;
// while (flag) {
// if (molecule.getAttachments().size() > 0) {
for (int i = molecule.getAttachments().size() - 1; i > -1; i--) {
org.helm.chemtoolkit.Attachment attachment = molecule.getAttachments().get(i);
int groupId = AbstractMolecule.getIdFromLabel(attachment.getLabel());
AbstractMolecule rMol = Chemistry.getInstance().getManipulator().getMolecule(attachment.getSmiles(), null);
molecule = Chemistry.getInstance().getManipulator().merge(molecule, molecule.getRGroupAtom(groupId, true), rMol, rMol.getRGroupAtom(groupId, true));
}
return molecule;
} catch (NullPointerException | IOException | CTKException e) {
throw new BuilderMoleculeException("Unused rgroups can't be merged into the molecule" + e.getMessage());
}
} | java |
public static AbstractMolecule getMoleculeForMonomer(final Monomer monomer) throws BuilderMoleculeException, ChemistryException {
String input = getInput(monomer);
if (input != null) {
List<Attachment> listAttachments = monomer.getAttachmentList();
AttachmentList list = new AttachmentList();
for (Attachment attachment : listAttachments) {
list.add(new org.helm.chemtoolkit.Attachment(attachment.getAlternateId(), attachment.getLabel(), attachment.getCapGroupName(), attachment.getCapGroupSMILES()));
}
try {
return Chemistry.getInstance().getManipulator().getMolecule(input, list);
} catch (IOException | CTKException e) {
throw new BuilderMoleculeException("Molecule can't be built for the given monomer");
}
}
return null;
} | java |
void addEntry(final String aLine) {
final String trimmed = aLine.replaceAll("^>*", "");
String[] tokens = trimmed.split("\t");
// Now strip the empty entries
final Vector<String> v = new Vector<String>();
for (int i = 0; i < tokens.length; i++) {
if (!"".equals(tokens[i])) {
v.add(tokens[i]);
}
}
tokens = new String[v.size()];
tokens = v.toArray(tokens);
if (tokens.length > 0) {
final String tok = tokens[0].trim();
try {
if (tok.startsWith("0x")) {
this.checkBytesFrom = Integer.parseInt(tok.substring(2), 16);
} else {
this.checkBytesFrom = Integer.parseInt(tok);
}
} catch (final NumberFormatException e) {
// We could have a space delinitaed entry so lets try to handle
// this anyway
addEntry(trimmed.replaceAll(" ", "\t"));
return;
}
}
if (tokens.length > 1) {
this.typeStr = tokens[1].trim();
this.type = getType(this.typeStr);
}
if (tokens.length > 2) {
// We don't trim the content
this.content = ltrim(tokens[2]);
this.content = stringWithEscapeSubstitutions(this.content);
}
if (tokens.length > 3) {
this.mimeType = tokens[3].trim();
}
if (tokens.length > 4) {
this.mimeEnc = tokens[4].trim();
}
} | java |
public String getMatch(final byte[] content) throws IOException {
final ByteBuffer buf = readBuffer(content);
if (buf == null) {
return null;
}
buf.position(0);
final boolean matches = match(buf);
if (matches) {
final int subLen = this.subEntries.size();
final String myMimeType = getMimeType();
if (subLen > 0) {
String mtype = null;
for (int k = 0; k < subLen; k++) {
final MagicMimeEntry me = this.subEntries.get(k);
mtype = me.getMatch(content);
if (mtype != null) {
return mtype;
}
}
if (myMimeType != null) {
return myMimeType;
}
} else {
return myMimeType;
}
}
return null;
} | java |
private int howManyGreaterThans(final String aLine) {
if (aLine == null) {
return -1;
}
int i = 0;
final int len = aLine.length();
while (i < len) {
if (aLine.charAt(i) == '>') {
i++;
} else {
break;
}
}
return i;
} | java |
private boolean matchByte(final ByteBuffer bbuf) throws IOException {
final byte b = bbuf.get(0);
return b == getContent().charAt(0);
} | java |
private boolean matchLong(final ByteBuffer bbuf, final ByteOrder bo, final boolean needMask, final long lMask) throws IOException {
bbuf.order(bo);
long got;
final String testContent = getContent();
if (testContent.startsWith("0x")) {
got = Long.parseLong(testContent.substring(2), 16);
} else if (testContent.startsWith("&")) {
got = Long.parseLong(testContent.substring(3), 16);
} else {
got = Long.parseLong(testContent);
}
long found = bbuf.getInt();
if (needMask) {
found = (short) (found & lMask);
}
if (got != found) {
return false;
}
return true;
} | java |
private boolean matchShort(final ByteBuffer bbuf, final ByteOrder bo, final boolean needMask, final short sMask) throws IOException {
bbuf.order(bo);
short got;
final String testContent = getContent();
if (testContent.startsWith("0x")) {
got = (short) Integer.parseInt(testContent.substring(2), 16);
} else if (testContent.startsWith("&")) {
got = (short) Integer.parseInt(testContent.substring(3), 16);
} else {
got = (short) Integer.parseInt(testContent);
}
short found = bbuf.getShort();
if (needMask) {
found = (short) (found & sMask);
}
if (got != found) {
return false;
}
return true;
} | java |
private boolean matchString(final ByteBuffer bbuf) throws IOException {
if (this.isBetween) {
final String buffer = new String(bbuf.array());
if (buffer.contains(getContent())) {
return true;
}
return false;
}
final int read = getContent().length();
for (int j = 0; j < read; j++) {
if ((bbuf.get(j) & 0xFF) != getContent().charAt(j)) {
return false;
}
}
return true;
} | java |
@SuppressWarnings("unused")
private ByteBuffer readBuffer(final RandomAccessFile raf) throws IOException {
final int startPos = getCheckBytesFrom();
if (startPos > raf.length()) {
return null;
}
raf.seek(startPos);
ByteBuffer buf;
switch (getType()) {
case MagicMimeEntry.STRING_TYPE: {
int len = 0;
// Lets check if its a between test
final int index = this.typeStr.indexOf(">");
if (index != -1) {
len = Integer.parseInt(this.typeStr.substring(index + 1, this.typeStr.length() - 1));
this.isBetween = true;
} else {
len = getContent().length();
}
buf = ByteBuffer.allocate(len + 1);
raf.read(buf.array(), 0, len);
break;
}
case MagicMimeEntry.SHORT_TYPE:
case MagicMimeEntry.LESHORT_TYPE:
case MagicMimeEntry.BESHORT_TYPE: {
buf = ByteBuffer.allocate(2);
raf.read(buf.array(), 0, 2);
break;
}
case MagicMimeEntry.LELONG_TYPE:
case MagicMimeEntry.BELONG_TYPE: {
buf = ByteBuffer.allocate(4);
raf.read(buf.array(), 0, 4);
break;
}
case MagicMimeEntry.BYTE_TYPE: {
buf = ByteBuffer.allocate(1);
raf.read(buf.array(), 0, 1);
}
default: {
buf = null;
break;
}
}
return buf;
} | java |
public void traverseAndPrint(final String tabs) {
logger.info(tabs + toString());
final int len = this.subEntries.size();
for (int i = 0; i < len; i++) {
final MagicMimeEntry me = this.subEntries.get(i);
me.traverseAndPrint(tabs + "\t");
}
} | java |
public void addEmptyValue(final JKTableColumn col) {
final JKTableColumnValue value = new JKTableColumnValue(col);
this.columnsValues.add(value);
} | java |
public Double getColumnValueAsDouble(final int col, final double defaultValue) {
Double value = getColumnValueAsDouble(col);
if (value == null) {
value = defaultValue;
}
return value;
} | java |
public static String getSMILESForAll(HELM2Notation helm2notation)
throws BuilderMoleculeException, CTKException, ChemistryException {
/* Build Molecues */
LOG.debug("Build single molecule(s)");
List<AbstractMolecule> molecules = BuilderMolecule.buildMoleculefromPolymers(helm2notation.getListOfPolymers(),
HELM2NotationUtils.getAllEdgeConnections(helm2notation.getListOfConnections()));
/* get for every molecule the smiles */
LOG.debug("Built single molecule(s)");
StringBuffer sb = new StringBuffer();
for (AbstractMolecule molecule : molecules) {
molecule = BuilderMolecule.mergeRgroups(molecule);
sb.append(Chemistry.getInstance().getManipulator().convertMolecule(molecule,
AbstractChemistryManipulator.StType.SMILES) + ".");
}
sb.setLength(sb.length() - 1);
LOG.debug("SMILES-All :" + sb.toString());
return sb.toString();
} | java |
public static boolean containsGenericStructurePolymer(List<PolymerNotation> polymers)
throws HELM2HandledException, ChemistryException, IOException, CTKException {
for (PolymerNotation polymer : polymers) {
if (polymer.getPolymerID() instanceof ChemEntity) {
Monomer monomer = MethodsMonomerUtils
.getListOfHandledMonomers(polymer.getPolymerElements().getListOfElements()).get(0);
if (null == monomer.getCanSMILES() || monomer.getCanSMILES().length() == 0) {
return true;
}
if (monomer.containAnyAtom()) {
return true;
}
}
}
return false;
} | java |
public static String getCanonicalSMILESForPolymer(PolymerNotation polymer) throws BuilderMoleculeException,
HELM2HandledException, CTKSmilesException, CTKException, NotationException, ChemistryException {
AbstractMolecule molecule = BuilderMolecule.buildMoleculefromSinglePolymer(polymer).getMolecule();
molecule = BuilderMolecule.mergeRgroups(molecule);
return Chemistry.getInstance().getManipulator().canonicalize(Chemistry.getInstance().getManipulator()
.convertMolecule(molecule, AbstractChemistryManipulator.StType.SMILES));
} | java |
public static String convertMolToSMILESWithAtomMapping(String molfile, List<Attachment> attachments)
throws CTKException, ChemistryException {
String smiles = Chemistry.getInstance().getManipulator().convertMolIntoSmilesWithAtomMapping(molfile);
for (Attachment attachment : attachments) {
int r = Integer.valueOf(attachment.getLabel().replaceAll("\\D+", ""));
smiles = smiles.replace("[*:" + r + "]", "[" + attachment.getCapGroupName() + ":" + r + "]");
}
return smiles;
} | java |
public static boolean isConnected(String molfile) throws CTKException, ChemistryException {
return Chemistry.getInstance().getManipulator().isConnected(molfile);
} | java |
protected static CloseableHttpResponse putResource(String json, String fullURL) throws ClientProtocolException,
IOException, URISyntaxException {
try (CloseableHttpClient httpclient = HttpClients.createDefault()) {
// There is no need to provide user credentials
// HttpClient will attempt to access current user security context
// through Windows platform specific methods via JNI.
HttpPut httpput = new HttpPut(new URIBuilder(fullURL).build());
httpput.setHeader("Content-Type", "application/json;charset=UTF-8");
httpput.setEntity(new StringEntity(json, "UTF-8"));
LOG.debug("Executing request " + httpput.getRequestLine());
return httpclient.execute(httpput);
}
} | java |
protected static CloseableHttpResponse getResource(String fullURL) throws IOException,
URISyntaxException {
URI uri = new URIBuilder(fullURL).build();
try (CloseableHttpClient httpclient = HttpClients.createDefault()) {
/* read url */
HttpGet httpget = new HttpGet(uri);
LOG.debug("Executing request " + httpget.getRequestLine());
return httpclient.execute(httpget);
}
} | java |
public static String getXHELM(HELM2Notation helm2notation) throws MonomerException, HELM1FormatException,
IOException, JDOMException, NotationException, CTKException, ValidationException, ChemistryException {
set = new HashSet<Monomer>();
Element root = new Element(xHelmNotationExporter.XHELM_ELEMENT);
Document doc = new Document(root);
Element helmElement = new Element(xHelmNotationExporter.HELM_NOTATION_ELEMENT);
helmElement.setText(HELM1Utils.getStandard(helm2notation));
root.addContent(helmElement);
Element monomerListElement = new Element(xHelmNotationExporter.MONOMER_LIST_ELEMENT);
/* save all adhocMonomers in the set */
for (MonomerNotation monomernotation : MethodsMonomerUtils.getListOfMonomerNotation(helm2notation.getListOfPolymers())) {
/* get all elements of an rna */
if (monomernotation instanceof MonomerNotationUnitRNA) {
for (MonomerNotationUnit unit : ((MonomerNotationUnitRNA) monomernotation).getContents()) {
addAdHocMonomer(unit);
}
} else {
addAdHocMonomer(monomernotation);
}
}
/* give adhoc monomer's information */
for (Monomer distinctmonomer : set) {
Element monomerElement = MonomerParser.getMonomerElement(distinctmonomer);
monomerListElement.getChildren().add(monomerElement);
}
root.addContent(monomerListElement);
XMLOutputter xmlOutput = new XMLOutputter();
// display nice
xmlOutput.setFormat(Format.getPrettyFormat());
return xmlOutput.outputString(doc);
} | java |
private static void addAdHocMonomer(MonomerNotation monomerNotation) throws IOException, JDOMException, ChemistryException {
Monomer monomer = MonomerFactory.getInstance().getMonomerStore().getMonomer(monomerNotation.getType(), monomerNotation.getUnit().replace("[", "").replace("]", ""));
if (monomer.isAdHocMonomer()) {
set.add(monomer);
}
} | java |
private List<Attachment> deserializeAttachmentList(JsonParser parser, Map<String, Attachment> attachmentDB)
throws JsonParseException, IOException {
List<Attachment> attachments = new ArrayList<Attachment>();
Attachment currentAttachment = null;
while (!JsonToken.END_ARRAY.equals(parser.nextToken())) {
String fieldName = parser.getCurrentName();
JsonToken token = parser.getCurrentToken();
if (JsonToken.START_OBJECT.equals(token)) {
currentAttachment = new Attachment();
} else if (JsonToken.END_OBJECT.equals(token)) {
/*
* Issue 4 all attachment points have to be fully defined for
* any new monomer
*/
if (AttachmentLoader.validateAttachment(currentAttachment)) {
currentAttachment.setCapGroupSMILES(
attachmentDB.get(currentAttachment.getAlternateId()).getCapGroupSMILES());
attachments.add(currentAttachment);
}
}
if (fieldName != null) {
switch (fieldName) {
case "id":
parser.nextToken();
if (parser.getText() != null) {
currentAttachment.setId(Integer.parseInt(parser.getText()));
}
break;
case "alternateId":
parser.nextToken();
currentAttachment.setAlternateId(parser.getText());
break;
case "label":
parser.nextToken();
currentAttachment.setLabel(parser.getText());
break;
case "capGroupName":
parser.nextToken();
currentAttachment.setCapGroupName(parser.getText());
break;
case "capGroupSMILES":
parser.nextToken();
currentAttachment.setCapGroupSMILES(parser.getText());
break;
default:
break;
}
}
}
return attachments;
} | java |
private static List<CategorizedMonomer> deserializeEditorCategorizationConfig(JsonParser parser)
throws JsonParseException, IOException {
List<CategorizedMonomer> config = new LinkedList<CategorizedMonomer>();
CategorizedMonomer currentMonomer = null;
parser.nextToken();
while (parser.hasCurrentToken()) {
String fieldName = parser.getCurrentName();
JsonToken token = parser.getCurrentToken();
if (JsonToken.START_OBJECT.equals(token)) {
currentMonomer = new CategorizedMonomer();
} else if (JsonToken.END_OBJECT.equals(token)) {
config.add(currentMonomer);
}
if (fieldName != null) {
switch (fieldName) {
// id is first field
case "monomerID":
parser.nextToken();
currentMonomer.setMonomerID(parser.getText());
break;
case "monomerName":
parser.nextToken();
currentMonomer.setMonomerName(parser.getText());
break;
case "naturalAnalogon":
parser.nextToken();
currentMonomer.setNaturalAnalogon(parser.getText());
break;
case "monomerType":
parser.nextToken();
currentMonomer.setMonomerType(parser.getText());
break;
case "polymerType":
parser.nextToken();
currentMonomer.setPolymerType(parser.getText());
break;
case "category":
parser.nextToken();
currentMonomer.setCategory(parser.getText());
break;
case "shape":
parser.nextToken();
currentMonomer.setShape(parser.getText());
break;
case "fontColor":
parser.nextToken();
currentMonomer.setFontColor(parser.getText());
break;
case "backgroundColor":
parser.nextToken();
currentMonomer.setBackgroundColor(parser.getText());
break;
default:
break;
}
}
parser.nextToken();
}
return config;
} | java |
public static Attachment getAttachment(Element attachment) {
Namespace ns = attachment.getNamespace();
Attachment att = new Attachment();
att.setAlternateId(attachment.getChildText(ATTACHEMENT_ID_ELEMENT, ns));
att.setLabel(attachment.getChildText(ATTACHEMENT_LABEL_ELEMENT, ns));
att.setCapGroupName(attachment.getChildText(CAP_GROUP_NAME_ELEMENT, ns));
att.setCapGroupSMILES(attachment.getChildText(CAP_GROUP_SMILES_ELEMENT, ns));
return att;
} | java |
public static Element getAttachementElement(Attachment att) {
Element attachment = new Element(ATTACHEMENT_ELEMENT);
if (null != att.getAlternateId() && att.getAlternateId().length() > 0) {
Element e = new Element(ATTACHEMENT_ID_ELEMENT);
e.setText(att.getAlternateId());
attachment.getChildren().add(e);
}
if (null != att.getLabel() && att.getLabel().length() > 0) {
Element e = new Element(ATTACHEMENT_LABEL_ELEMENT);
e.setText(att.getLabel());
attachment.getChildren().add(e);
}
if (null != att.getCapGroupName() && att.getCapGroupName().length() > 0) {
Element e = new Element(CAP_GROUP_NAME_ELEMENT);
e.setText(att.getCapGroupName());
attachment.getChildren().add(e);
}
if (null != att.getCapGroupSMILES()
&& att.getCapGroupSMILES().length() > 0) {
Element e = new Element(CAP_GROUP_SMILES_ELEMENT);
e.setText(att.getCapGroupSMILES());
attachment.getChildren().add(e);
}
return attachment;
} | java |
public static boolean validateAttachement(Attachment attachment)
throws MonomerException, IOException, ChemistryException {
String alternateId = attachment.getAlternateId();
if (null == alternateId) {
throw new MonomerException("Attachment must have unique ID");
}
String smiles = attachment.getCapGroupSMILES();
if (null != smiles) {
if (!Chemistry.getInstance().getManipulator().validateSMILES(smiles)) {
throw new MonomerException(
"Attachment cap group SMILES is invalid");
}
List<String> labels = getAttachmentLabels(smiles);
if (null == labels || labels.size() != 1) {
throw new MonomerException(
"Attachment must have one R group in SMILES");
}
if (!(labels.get(0).equals(attachment.getLabel()))) {
throw new MonomerException(
"R group in monomer SMILES and R group label must match");
}
}
return true;
} | java |
public static Monomer getMonomer(Element monomer) throws MonomerException {
Monomer m = new Monomer();
Namespace ns = monomer.getNamespace();
m.setAlternateId(monomer.getChildText(MONOMER_ID_ELEMENT, ns));
m.setCanSMILES(monomer.getChildText(MONOMER_SMILES_ELEMENT, ns));
String encodedMolfile = monomer.getChildText(MONOMER_MOL_FILE_ELEMENT, ns);
String molfile = null;
try {
molfile = MolfileEncoder.decode(encodedMolfile);
} catch (EncoderException ex) {
throw new MonomerException("Invalid monomer molfile");
}
m.setMolfile(molfile);
m.setMonomerType(monomer.getChildText(MONOMER_TYPE_ELEMENT, ns));
m.setPolymerType(monomer.getChildText(POLYMER_TYPE_ELEMENT, ns));
m.setNaturalAnalog(monomer.getChildText(NATURAL_ANALOG_ELEMENT, ns));
m.setName(monomer.getChildText(MONOMER_NAME_ELEMENT, ns));
Element attachmentElement = monomer.getChild(ATTACHEMENTS_ELEMENT, ns);
if (null != attachmentElement) {
List attachments = attachmentElement.getChildren(ATTACHEMENT_ELEMENT, ns);
List<Attachment> l = new ArrayList<Attachment>();
Iterator i = attachments.iterator();
while (i.hasNext()) {
Element attachment = (Element) i.next();
Attachment att = getAttachment(attachment);
l.add(att);
}
m.setAttachmentList(l);
}
return m;
} | java |
public static Element getMonomerElement(Monomer monomer)
throws MonomerException {
Element element = new Element(MONOMER_ELEMENT);
if (null != monomer.getAlternateId()) {
Element e = new Element(MONOMER_ID_ELEMENT);
e.setText(monomer.getAlternateId());
element.getChildren().add(e);
}
if (null != monomer.getCanSMILES()) {
Element e = new Element(MONOMER_SMILES_ELEMENT);
e.setText(monomer.getCanSMILES());
element.getChildren().add(e);
}
if (null != monomer.getMolfile()) {
Element e = new Element(MONOMER_MOL_FILE_ELEMENT);
String encodedMolfile = null;
try {
encodedMolfile = MolfileEncoder.encode(monomer.getMolfile());
} catch (EncoderException ex) {
throw new MonomerException("Invalid monomer molfile");
}
// CDATA cdata = new CDATA(monomer.getMolfile());
// e.setContent(cdata);
e.setText(encodedMolfile);
element.getChildren().add(e);
}
if (null != monomer.getMonomerType()) {
Element e = new Element(MONOMER_TYPE_ELEMENT);
e.setText(monomer.getMonomerType());
element.getChildren().add(e);
}
if (null != monomer.getPolymerType()) {
Element e = new Element(POLYMER_TYPE_ELEMENT);
e.setText(monomer.getPolymerType());
element.getChildren().add(e);
}
if (null != monomer.getNaturalAnalog()) {
Element e = new Element(NATURAL_ANALOG_ELEMENT);
e.setText(monomer.getNaturalAnalog());
element.getChildren().add(e);
}
if (null != monomer.getName()) {
Element e = new Element(MONOMER_NAME_ELEMENT);
e.setText(monomer.getName());
element.getChildren().add(e);
}
List<Attachment> l = monomer.getAttachmentList();
if (null != l && l.size() > 0) {
Element attachments = new Element(ATTACHEMENTS_ELEMENT);
for (int i = 0; i < l.size(); i++) {
Attachment att = l.get(i);
Element attachment = getAttachementElement(att);
attachments.getChildren().add(attachment);
}
element.getChildren().add(attachments);
}
return element;
} | java |
private static boolean areAttachmentLabelsUnique(List<String> labels) {
Map<String, String> map = new TreeMap<String, String>(String.CASE_INSENSITIVE_ORDER);
for (int i = 0; i < labels.size(); i++) {
map.put(labels.get(i), labels.get(i));
}
if (labels.size() == map.size()) {
return true;
} else {
return false;
}
} | java |
public Attachment getAttachment(String label) {
for (Attachment attachment : attachmentList) {
if (attachment.getLabel().equalsIgnoreCase(label)) {
return attachment;
}
}
return null;
} | java |
public MoleculeProperty getCapMoleculeInfo(String label) throws
CTKException, ChemistryException, IOException {
for (Attachment attachment : attachmentList) {
if (attachment.getLabel().equalsIgnoreCase(label)) {
String capSmi = attachment.getCapGroupSMILES();
org.helm.chemtoolkit.MoleculeInfo info = Chemistry.getInstance().getManipulator().getMoleculeInfo(Chemistry.getInstance().getManipulator().getMolecule(capSmi, null));
MoleculeProperty moleculeinfo = new MoleculeProperty();
moleculeinfo.setExactMass(info.getExactMass());
moleculeinfo.setMolecularFormula(info.getMolecularFormula());
moleculeinfo.setMolecularWeight(info.getMolecularWeight());
return moleculeinfo;
}
}
return null;
} | java |
public boolean addAttachment(Attachment attachment) {
boolean isExist = false;
for (Attachment a : attachmentList) {
if (a.getLabel().equalsIgnoreCase(attachment.getLabel())) {
isExist = true;
}
}
if (!isExist) {
return attachmentList.add(attachment);
}
return false;
} | java |
public static JKCacheManager getCacheManager() {
if (JKCacheFactory.defaultCacheManager == null) {
logger.debug("init cacheManager");
defaultCacheManager = new JKDefaultCacheManager();
}
return JKCacheFactory.defaultCacheManager;
} | java |
public JKTableColumn getTableColumn(final int col, final boolean visibleIndex) {
int actualIndex;
if (visibleIndex) {
actualIndex = this.visibilityManager.getActualIndexFromVisibleIndex(col);
} else {
actualIndex = col;
}
return this.tableColumns.get(actualIndex);
} | java |
public int getValueAtAsInteger(final int row, final int col) {
final Object valueAt = getValueAt(row, col);
int number = 0;
if (valueAt != null && !valueAt.toString().equals("")) {
number = Integer.parseInt(valueAt.toString().trim());
}
return number;
} | java |
public boolean isEditable(final int row, final int column) {
if (isEditable(column)) {
final int actualIndex = getTableColumn(column).getIndex();
final JKTableRecord record = getRecord(row);
return record.isColumnEnabled(actualIndex);
}
return false;
} | java |
public void setEditable(final int row, final int col, final boolean enable) {
final int actualIndex = getTableColumn(col).getIndex();
getRecord(row).setColumnEnabled(actualIndex, enable);
} | java |
public void addJKTableColumn(String keyLabel) {
JKTableColumn col = new JKTableColumn();
col.setName(keyLabel);
addJKTableColumn(col);
} | java |
public void insertConstructor(InsertableConstructor insertableConstructor) throws CannotCompileException, AfterBurnerImpossibleException,
NotFoundException {
// create or complete onViewCreated
List<CtConstructor> constructorList = extractExistingConstructors(insertableConstructor);
log.info("constructor : " + constructorList.toString());
if (!constructorList.isEmpty()) {
for (CtConstructor constructor : constructorList) {
constructor
.insertBeforeBody(insertableConstructor
.getConstructorBody(constructor
.getParameterTypes()));
}
} else {
throw new AfterBurnerImpossibleException("No suitable constructor was found in class " + insertableConstructor.getClassToInsertInto().getName() + ". Add a constructor that is accepted by the InsertableConstructor. Don't use non static inner classes.");
}
} | java |
protected ValidationResult getCachedResult(String certFingerprint) {
CachedValidationResult cvr = validationResultsCache.get(certFingerprint);
if (cvr == null)
return null;
if (!cachedValidationResultHasExpired(cvr, System.currentTimeMillis())) {
return cvr.getResult();
}
validationResultsCache.remove(certFingerprint, cvr);
return null;
} | java |
public ValidationResult validate(X509Certificate[] certChain) {
certChainSanityChecks(certChain);
String certFingerprint = null;
try {
certFingerprint = FingerprintHelper
.getFingerprint(certChain[certChain.length - 1]);
} catch (Throwable t) {
String errorMsg = String.format("Error computing fingerprint for "
+ "certificate: %s. Cause: %s",
CertificateUtils.format(certChain[0], FormatMode.COMPACT_ONE_LINE),
t.getMessage());
throw new VOMSError(errorMsg, t);
}
ValidationResult res = getCachedResult(certFingerprint);
if (res == null) {
res = validator.validate(certChain);
validationResultsCache.putIfAbsent(certFingerprint,
new CachedValidationResult(certFingerprint, res));
}
return res;
} | java |
public int minChannel() {
int c = 0;
if(getValue(c) > getValue(1)) c=1;
if(getValue(c) > getValue(2)) c=2;
return c;
} | java |
public int maxChannel() {
int c = 0;
if(getValue(c) < getValue(1)) c=1;
if(getValue(c) < getValue(2)) c=2;
return c;
} | java |
public JsTopicControls getJsTopicControlsFromProxyClass(Class<?> proxy) {
Class<?> realClass = unProxyClassServices.getRealClass(proxy);
return realClass.getAnnotation(JsTopicControls.class);
} | java |
public void readStacktraceConfig(@Observes @Initialized(ApplicationScoped.class) ServletContext sc) {
String stacktrace;
if(ocelotConfigurationsStack.isUnsatisfied()) {
stacktrace = sc.getInitParameter(Constants.Options.STACKTRACE_LENGTH);
if(stacktrace==null) {
stacktrace = DEFAULTSTACKTRACE;
} else {
logger.debug("Read '{}' option in web.xml : '{}'.", Constants.Options.STACKTRACE_LENGTH, stacktrace);
}
} else {
stacktrace = ocelotConfigurationsStack.get();
logger.debug("Read '{}' option from producer : '{}'.", Constants.Options.STACKTRACE_LENGTH, stacktrace);
}
int stacktracelenght = Integer.parseInt(stacktrace);
logger.debug("'{}' value : '{}'.", Constants.Options.STACKTRACE_LENGTH, stacktracelenght);
setStacktracelength(stacktracelenght);
} | java |
public static String generateBasepath(final String ip, Short port) {
if (isEmpty(ip)) {
throw new IllegalArgumentException(NULL_SERVER_IP_MSG);
}
if (port == null) {
port = 80;
}
StringBuilder basePath = new StringBuilder();
basePath.append("http://").append(ip).append(":").append(port).append("/rest");
return basePath.toString();
} | java |
@Override
public Object convertJsonToJava(String jsonArg, Type paramType, Annotation[] parameterAnnotations) throws JsonUnmarshallingException, JsonMarshallerException {
if ("null".equals(jsonArg)) {
return null;
}
JsonUnmarshaller juma = getJsonUnmarshallerAnnotation(parameterAnnotations);
if (null != juma) {
Object result = getResult(jsonArg, argumentServices.getIJsonMarshallerInstance(juma.value()), juma.type());
argumentServices.checkType(result, paramType);
return result;
} else {
return convertArgument(jsonArg, paramType);
}
} | java |
JsonUnmarshaller getJsonUnmarshallerAnnotation(Annotation[] annotations) {
for (Annotation annotation : annotations) {
if (JsonUnmarshaller.class.isInstance(annotation)) {
return (JsonUnmarshaller) annotation;
}
}
return null;
} | java |
Class<? extends IJsonMarshaller> getMarshallerAnnotation(Annotation[] annotations) {
JsonUnmarshaller ju = getJsonUnmarshallerAnnotation(annotations);
return (ju != null) ? ju.value() : null;
} | java |
Object convertArgument(String arg, Type paramType) throws IllegalArgumentException {
Object result = null;
if (null == arg || "null".equals(arg)) {
return result;
}
logger.debug("Try to convert {} : param = {} : {}", new Object[]{arg, paramType, paramType.getClass()});
try { // GenericArrayType, ParameterizedType, TypeVariable<D>, WildcardType, Class
if (ParameterizedType.class.isInstance(paramType)) {
JavaType javaType = getJavaType(paramType);
logger.debug("Try to convert '{}' to JavaType : '{}'", arg, paramType);
result = getObjectMapper().readValue(arg, javaType);
logger.debug("Conversion of '{}' to '{}' : OK", arg, paramType);
} else if (Class.class.isInstance(paramType)) {
Class cls = (Class) paramType;
logger.debug("Try to convert '{}' to Class '{}'", arg, paramType);
checkStringArgument(cls, arg);
result = getObjectMapper().readValue(arg, cls);
logger.debug("Conversion of '{}' to '{}' : OK", arg, paramType);
} else { // GenericArrayType, TypeVariable<D>, WildcardType
logger.warn("Conversion of '{}' to '{}' not yet supported", arg, paramType);
}
} catch (IOException ex) {
logger.debug("Conversion of '{}' to '{}' failed", arg, paramType);
throw new IllegalArgumentException(paramType.toString());
}
return result;
} | java |
void checkStringArgument(Class cls, String arg) throws IOException {
if (arg.startsWith(Constants.QUOTE)) { // ca ressemble à une string
if (!cls.equals(String.class)) { // et on veut pas une string
throw new IOException();
}
} else // ca ressemble pas à une string
if (cls.equals(String.class)) { // mais on veut une string
throw new IOException();
}
} | java |
private void compareApiUsage() throws ApiException, JsonProcessingException {
LOG.info("The Compare API usage.");
Compare compareApiInstance = retinaApisInstance.compareApi();
LOG.info("Compare API: compare");
Metric metric = compareApiInstance.compare(new Term("apple"), new Term("banana"));
logMetric(metric);
String inputText =
"Gustav Klimt (July 14, 1862 – February 6, 1918) was an Austrian symbolist painter and one "
+ "of the most prominent members of the Vienna Secession movement. Klimt is noted for his paintings, "
+ "murals, sketches, and other objets d'art. Klimt's primary subject was the female body;[1] "
+ "his works are marked by a frank eroticism.[2]";
metric = compareApiInstance.compare(new Term("painter"), new Text(inputText));
logMetric(metric);
LOG.info("Compare API: compareBulk");
CompareModels toCompare1 = new CompareModels(new Term("apple"), new Term("banana"));
CompareModels toCompare2 = new CompareModels(new Term("banana"), new Term("fruit"));
CompareModels toCompare3 = new CompareModels(new Term("apple"), new Term("orange"));
CompareModels[] toCompareBulk = {
toCompare1,
toCompare2,
toCompare3
};
Metric[] metrics = compareApiInstance.compareBulk(toCompareBulk);
for (Metric metricFromBulk: metrics) {
logMetric(metricFromBulk);
}
} | java |
private void imageApiUsage() throws ApiException, IOException {
LOG.info("The Image API usage.");
Images api = retinaApisInstance.imageApi();
LOG.info("Image API: getImageForExpression");
try (ByteArrayInputStream inputStream = api.getImage(TEXT_1)) {
//get image's stream;
if (inputStream.read() == 0) {
throw new IllegalStateException("A image stream cannot be received.");
}
}
LOG.info("Image API: getOverlayImage");
try (ByteArrayInputStream inputStream = api.compare(TEXT_1, TEXT_2)) {
//get image's stream;
if (inputStream.read() == 0) {
throw new IllegalStateException("A image stream cannot be received.");
}
}
LOG.info("Image API: getImageForBulkExpressions");
List<Image> images = api.getImageBulk(TEXT_1, TERM_1);
for (Image image : images) {
LOG.info("Image: imageData size: " + image.getImageData().length);
}
} | java |
private void retinasApiUsage() throws ApiException {
LOG.info("The Retinas API usage.");
Retinas api = getInfo("api.cortical.io", API_KEY);
LOG.info("Retinas API: getRetinas");
List<Retina> retinas = api.getAllRetinas();
for (Retina retina : retinas) {
LOG.info("Retina: Name: " + retina.getRetinaName() + " Description: " + retina.getRetinaDescription()
+ " Terms in the retina: " + retina.getNumberOfTermsInRetina());
}
Retina retina = api.retinaByName(RETINA_NAME);
LOG.info("Retina: Name: " + retina.getRetinaName() + " Description: " + retina.getRetinaDescription()
+ " Terms in the retina: " + retina.getNumberOfTermsInRetina());
} | java |
private void termsApiUsage() throws JsonProcessingException, ApiException {
/**
*
*/
LOG.info("The Terms API usage.");
Terms api = retinaApisInstance.termsApi();
/**
*
*/
LOG.info("Terms API: getContextsForTerm");
List<Context> contexts = api.getContexts("apple");
logContext(contexts);
contexts = api.getContexts("apple", new Pagination(0, 2), true);
logContext(contexts);
/**
*
*/
List<Term> terms;
LOG.info("Terms API: getSimilarTerms");
terms = api.getSimilarTerms("tiger");
logTerms(terms);
terms = api.getSimilarTerms("tiger", null, PosType.NOUN);
logTerms(terms);
//**** ERROR *****
terms = api.getSimilarTerms("tiger", null, PosType.NOUN, true);
logTerms(terms);
/**
*
*/
LOG.info("Terms API: getTerm");
terms = api.getTerm("apple");
logTerms(terms);
System.out.println();
terms = api.getTerm("banana", new Pagination(0, 2), true);
logTerms(terms);
System.out.println();
LOG.info("Terms API: getTerm NULL TEST");
terms = api.getTerm(null);
logTerms(terms);
} | java |
private void textApiUsage() throws ApiException, JsonProcessingException {
/**
*
*/
String text =
"Toll IPEC has been an industry leader in environmental sustainability through its purchase of compressed natural gas powered trucks";
String text2 =
"Shellshock can serve as a highway for worms and malware to hit your Unix, Linux, and Mac servers, but you can defend against it.";
String text3 = "However, Shellshock is not as bad as HeartBleed. Not yet, anyway.";
/**
*
*/
LOG.info("The Text API usage.");
Texts api = retinaApisInstance.textApi();
/**
*
*/
LOG.info("Text API: getKeywordsForText");
List<String> keywords = api.getKeywords(text);
logKeywords(keywords);
/**
*
*/
LOG.info("Text API: getRepresentationForText");
List<Fingerprint> fingerprints = api.getFingerprints(text2);
logFingerprints(fingerprints);
/**
*
*/
LOG.info("Text API: getRepresentationsForBulkText");
fingerprints = api.getFingerprintBulk(0.1, TEXT_1, TEXT_2);
logFingerprints(fingerprints);
/**
*
*/
LOG.info("Text API: getSlicesForText");
List<Text> texts = api.getSlices(text);
logTexts(texts);
texts = api.getSlices(text3, new Pagination(0, 2), true);
logTexts(texts);
LOG.info("Text API: getTokensForText");
List<String> tokens = api.getTokens(text2, new PosTag[] { PosTag.CC, PosTag.LRB });
logTokens(tokens);
tokens = api.getTokens(text2, new PosTag[] { });
logTokens(tokens);
} | java |
public void doEvents() {
while (!isInterrupted()) {
Iterator<Map.Entry<Timer, Runnable>> it = timerMap.entrySet().iterator();
if (it.hasNext()) {
long timeout = it.next().getKey().uptime - System.currentTimeMillis();
doEvents(timeout > 0 ? timeout : 0);
} else {
doEvents(-1);
}
}
} | java |
public <T> T getField(String field, ExtensionFieldType<T> extensionFieldType) {
if (field == null || field.isEmpty()) {
throw new IllegalArgumentException("Invalid field name");
}
if (extensionFieldType == null) {
throw new IllegalArgumentException("Invalid field type");
}
if (!isFieldPresent(field)) {
throw new NoSuchElementException("Field " + field + " not valid in this extension");
}
return extensionFieldType.fromString(fields.get(field).value);
} | java |
protected List getProjectClasspathElements() throws DependencyResolutionRequiredException {
Set results = new LinkedHashSet();
Set includes = getClasspathIncludes();
if (includes.contains(CLASSPATH_INCLUDE_ALL) || includes.contains(CLASSPATH_INCLUDE_RUNTIME)) {
for (Iterator i = project.getRuntimeClasspathElements().iterator(); i.hasNext();) {
String fileName = (String) i.next();
try {
results.add(new File(fileName).getCanonicalPath());
}
catch (IOException e) {
throw new RuntimeException("Classpath element not found: " + fileName, e);
}
}
}
if (includes.contains(CLASSPATH_INCLUDE_ALL) || includes.contains(CLASSPATH_INCLUDE_ARTIFACTS)) {
for (Iterator i = project.getArtifacts().iterator(); i.hasNext();) {
Artifact artifact = (Artifact) i.next();
if (artifact.getType().equals("jar") && artifact.getClassifier() == null) {
try {
results.add(artifact.getFile().getCanonicalPath());
}
catch (IOException e) {
throw new RuntimeException("Maven artifact file not found: " + artifact, e);
}
}
}
}
if (includes.contains(CLASSPATH_INCLUDE_ALL) || includes.contains(CLASSPATH_INCLUDE_PLUGINS)) {
for (Iterator i = pluginArtifacts.iterator(); i.hasNext();) {
Artifact artifact = (Artifact) i.next();
if (artifact.getType().equals("jar") && artifact.getClassifier() == null) {
try {
results.add(artifact.getFile().getCanonicalPath());
}
catch (IOException e) {
throw new RuntimeException("Maven plugin-artifact file not found: " + artifact, e);
}
}
}
}
return new ArrayList(results);
} | java |
private Map findProviders() {
Map providers = getContainer().getComponentDescriptorMap(Provider.class.getName());
if (providers == null) {
throw new Error("No providers discovered");
}
Set keys = providers.keySet();
Map found = null;
for (Iterator iter = keys.iterator(); iter.hasNext();) {
String key = (String)iter.next();
Provider provider;
try {
provider = (Provider) getContainer().lookup(Provider.class.getName(), key);
}
catch (Exception e) {
log.warn("Failed to lookup provider for key: {}", key, e);
continue;
}
if (provider != null) {
if (found == null) {
found = new HashMap();
}
found.put(key, provider);
}
}
return found;
} | java |
void writeDependencies(Writer writer, String deco, String... dependencies) throws IOException {
boolean first = true;
for (String dependency : dependencies) {
if (!first) {
writer.append(COMMA).append(SPACEOPTIONAL);
}
writer.append(deco).append(dependency).append(deco);
first = false;
}
} | java |
public void writeCloseFunction(Writer writer) throws IOException {
writer.append(TAB).append(CLOSEBRACE).append(CR);
} | java |
void writeArguments(Iterator<String> names, Writer writer) throws IOException {
while(names.hasNext()) {
String name = names.next();
writer.append(name); // argname
if(names.hasNext()) {
writer.append(COMMA).append(SPACEOPTIONAL); //,
}
}
} | java |
void writeReturnComment(TypeMirror returnType, Writer writer) throws IOException {
String type = returnType.toString();
if (!"void".equals(type)) {
writer.append(TAB2).append(" * @return ").append(OPENBRACE).append(type).append(CLOSEBRACE).append(CR);
}
} | java |
void writeArgumentsComment(Iterator<String> argumentsType, Iterator<String> argumentsName, Writer writer) throws IOException {
while(argumentsType.hasNext()) {
String type = argumentsType.next();
String name = argumentsName.next();
writer.append(TAB2).append(" * @param ").append(OPENBRACE).append(type).append(CLOSEBRACE).append(SPACE).append(name).append(CR);
}
} | java |
void writeJavadocComment(String methodComment, Writer writer) throws IOException {
// From javadoc
if (methodComment != null) {
methodComment = methodComment.split("@")[0];
int lastIndexOf = methodComment.lastIndexOf("\n");
if (lastIndexOf >= 0) {
methodComment = methodComment.substring(0, lastIndexOf);
}
String comment = methodComment.replaceAll("\n", CR+TAB2+" *");
writer.append(TAB2).append(" *").append(comment).append(CR);
}
} | java |
void createMethodBody(String classname, ExecutableElement methodElement, List<String> arguments, Writer writer) throws IOException {
String methodName = getMethodName(methodElement);
boolean ws = isWebsocketDataService(methodElement);
String args = stringJoinAndDecorate(arguments, COMMA, new NothingDecorator());
String keys = computeKeys(methodElement, arguments);
createReturnOcelotPromiseFactory(classname, methodName, ws, args, keys, writer);
} | java |
String computeKeys(ExecutableElement methodElement, List<String> arguments) {
String keys = stringJoinAndDecorate(arguments, COMMA, new NothingDecorator());
if (arguments != null && !arguments.isEmpty()) {
JsCacheResult jcr = methodElement.getAnnotation(JsCacheResult.class);
// if there is a jcr annotation with value diferrent of *, so we dont use all arguments
if (!considerateAllArgs(jcr)) {
keys = stringJoinAndDecorate(Arrays.asList(jcr.keys()), COMMA, new KeyForArgDecorator());
}
}
return keys;
} | java |
void createReturnOcelotPromiseFactory(String classname, String methodName, boolean ws, String args, String keys, Writer writer) throws IOException {
String md5 = keyMaker.getMd5(classname + DOT + methodName);
writer.append(TAB3).append("return promiseFactory.create").append(OPENPARENTHESIS).append("_ds").append(COMMA).append(SPACEOPTIONAL)
.append(QUOTE).append(md5).append(UNDERSCORE).append(QUOTE)
.append(" + JSON.stringify([").append(keys).append("]).md5()").append(COMMA).append(SPACEOPTIONAL)
.append(QUOTE).append(methodName).append(QUOTE).append(COMMA).append(SPACEOPTIONAL).append(""+ws).append(COMMA)
.append(SPACEOPTIONAL).append(OPENBRACKET).append(args).append(CLOSEBRACKET).append(CLOSEPARENTHESIS)
.append(SEMICOLON).append(CR);
} | java |
String stringJoinAndDecorate(final List<String> list, final String sep, StringDecorator decorator) {
if (decorator == null) {
decorator = new NothingDecorator();
}
StringBuilder sb = new StringBuilder();
if (list != null) {
boolean first = true;
for (String argument : list) {
if (!first) {
sb.append(sep);
}
sb.append(decorator.decorate(argument));
first = false;
}
}
return sb.toString();
} | java |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.