protected IMessagePublication createMessagePublication(T message) { Collection<Subscription> subscriptions = getSubscriptionsByMessageType(message.getClass()); if ((subscriptions == null || subscriptions.isEmpty()) && !message.getClass().equals(DeadMessage.class)) { // DeadMessage Event subscriptions = getSubscriptionsByMessageType(DeadMessage.class); return getPublicationFactory() .createPublication(runtime, subscriptions, new DeadMessage(message)); } else { return getPublicationFactory().createPublication(runtime, subscriptions, message); } }
/** * Checks equality of two objects based on the equality of their fields, items, or .equals() * method. * * @param obj1 * @param obj2 * @return */ public static <T> boolean equal(T obj1, T obj2) { if (obj1 == null || obj2 == null) { // If they're both null, we call this equal if (obj1 == null && obj2 == null) return true; else return false; } if (!obj1.getClass().equals(obj2.getClass())) return false; if (obj1.equals(obj2)) return true; List<Pair> vals = new ArrayList<Pair>(); // If obj1 and obj2 are Collections, get the objects in them if (Collection.class.isAssignableFrom(obj1.getClass())) { Collection c1 = (Collection) obj1; Collection c2 = (Collection) obj2; if (c1.size() != c2.size()) return false; Iterator itr1 = c1.iterator(); Iterator itr2 = c2.iterator(); while (itr1.hasNext() && itr2.hasNext()) { vals.add(new Pair(itr1.next(), itr2.next())); } } // Get field values from obj1 and obj2 PropertyDescriptor[] properties = PropertyUtils.getPropertyDescriptors(obj1); for (PropertyDescriptor property : properties) { // ignore getClass() and isEmpty() if (property.getName().equals("class") || property.getName().equals("empty")) continue; Object val1 = invokeMethod(obj1, property.getReadMethod(), null, property.getName()); Object val2 = invokeMethod(obj2, property.getReadMethod(), null, property.getName()); vals.add(new Pair(val1, val2)); } if (vals.isEmpty()) return false; for (Pair pair : vals) { if (!equal(pair.left, pair.right)) return false; } return true; }
@Override public <T> T getService(Class<T> serviceClass) { //noinspection unchecked T service = (T) myServices.get(serviceClass); if (service == null) { final Iterator<T> iterator = ServiceLoader.load(serviceClass, serviceClass.getClassLoader()).iterator(); if (!iterator.hasNext()) { throw new ServiceConfigurationError("Implementation for " + serviceClass + " not found"); } service = iterator.next(); if (iterator.hasNext()) { throw new ServiceConfigurationError( "More than one implementation for " + serviceClass + " found: " + service.getClass() + " and " + iterator.next().getClass()); } myServices.putIfAbsent(serviceClass, service); //noinspection unchecked service = (T) myServices.get(serviceClass); } return service; }
/** Set the value for the key in this context. */ public <T> void put(Key<T> key, T data) { DEBUG.P(this, "put(Key<T> key, T data)"); if (data != null) DEBUG.P("data=" + data.getClass().getName()); else DEBUG.P("data=" + data); // DEBUG.P("context前="+toString()); /*例如: Context context = new Context(); Context.Key<Context.Factory> factoryKey =new Context.Key<Context.Factory>(); context.put(factoryKey,new Context.Factory<String>(){public String make() {return "";}}); 出现如下类似异常: Exception in thread "main" java.lang.AssertionError: T extends Context.Factory 因为Context.Key<T>的参数化类型不允许是Context.Key<Context.Factory> */ if (data instanceof Factory) throw new AssertionError("T extends Context.Factory"); checkState(ht); Object old = ht.put(key, data); if (old != null && !(old instanceof Factory) && old != data && data != null) throw new AssertionError("duplicate context value"); DEBUG.P("context后=" + toString()); DEBUG.P(0, this, "put(Key<T> key, T data)"); }
public BatchOptions(T options) { super(options.getClass()); this.options = options; numParametersLabel = this.options.addLabel(""); addFirstOptions(); addChildOptions(WRAPPED_OPTIONS_KEY, "", null, options); SimpleListener listener = new SimpleListener() { @Override public void objectChanged() { int batchSize = getBatchSize(); numParametersLabel.setValue("Total number of parameter sets: " + batchSize); if (batchSize > 10000) { numParametersLabel.setWarningMessage( "Too many results can cause Geneious to become unusable"); } else if (batchSize > 500) { numParametersLabel.setWarningMessage( "A lot of results will cause Geneious to slow down"); } else { numParametersLabel.setWarningMessage(null); } } }; addMinMaxOptionsAndHideOriginal(options, listener); }
/** * Copy from the copy method in StructUtil. Did not want to drag that code in. maybe this actually * should go to struct. * * @param from * @param to * @param excludes * @return * @throws Exception */ public static <T extends struct> T xcopy(struct from, T to, String... excludes) throws Exception { Arrays.sort(excludes); for (Field f : from.fields()) { if (Arrays.binarySearch(excludes, f.getName()) >= 0) continue; Object o = f.get(from); if (o == null) continue; Field tof = to.getField(f.getName()); if (tof != null) try { tof.set(to, Converter.cnv(tof.getGenericType(), o)); } catch (Exception e) { System.out.println( "Failed to convert " + f.getName() + " from " + from.getClass() + " to " + to.getClass() + " value " + o + " exception " + e); } } return to; }
/** * Sets up the mocks defined in the given mock class. * * <p>If the type {@linkplain MockClass#realClass referred to} by the mock class is actually an * interface, then a {@linkplain #newEmptyProxy(ClassLoader, Class) new empty proxy} is created. * * @param mockClassOrInstance the mock class itself (given by its {@code Class} literal), or an * instance of the mock class * @return the new proxy instance created for the mocked interface, or {@code null} otherwise * @throws IllegalArgumentException if a given mock class fails to specify the corresponding real * class using the {@code @MockClass(realClass = ...)} annotation; or if a mock class defines * a mock method for which no corresponding real method or constructor exists in the real * class; or if the real method matching a mock method is {@code abstract} * @see #setUpMock(Class, Object) * @see #setUpMocks(Object...) * @see <a * href="http://code.google.com/p/jmockit/source/browse/trunk/main/test/mockit/MockAnnotationsTest.java#696"> * Example</a> */ public static <T> T setUpMock(Object mockClassOrInstance) { Class<?> mockClass; Object mock; if (mockClassOrInstance instanceof Class<?>) { mockClass = (Class<?>) mockClassOrInstance; mock = null; } else { mockClass = mockClassOrInstance.getClass(); mock = mockClassOrInstance; } MockClassSetup setup = new MockClassSetup(mock, mockClass); Class<?> realClass = setup.getRealClass(); T proxy = null; if (realClass.isInterface()) { //noinspection unchecked proxy = (T) newEmptyProxy(mockClass.getClassLoader(), realClass); setup.setRealClass(proxy.getClass()); } setup.redefineMethods(); return proxy; }
/** * Method to convert a List of beans to a List of Array of Strings. * * @param beans the List of Beans. * @param addNewHeader the new String Array for the Header row. * @param <T> generic value. * @return the List of Array of String content of the csv. */ @SuppressWarnings("unchecked") public static <T> List<String[]> toStringArray(List<T> beans, String[] addNewHeader) { List<String[]> records = new ArrayList<>(); // add header record // records.add(new String[]{"ID","Name","Role","Salary"}); if (addNewHeader != null) records.add(addNewHeader); for (T bean : beans) { // beans.stream().map((bean) -> { List<String> record = new ArrayList<>(); // invoke getter method and convert to String Class<T> clazz = (Class<T>) bean.getClass(); // T t = ReflectionUtilities.invokeConstructor(clazz); List<Method> getter = (List<Method>) ReflectionUtilities.findGetters(clazz, true); for (Method method : getter) { record.add(String.valueOf(ReflectionUtilities.invokeGetter(bean, method))); } // getter.stream().forEach((method) -> // record.add(String.valueOf(ReflectionUtilities.invokeGetter(bean,method)))); // return record; // }).forEach((record) -> records.add(ListUtilities.toArray(record))); records.add(ListUtilities.toArray(record)); } return records; }
/** Adds the given listener to this ServletContext. */ @Override public <T extends EventListener> void addListener(T t) { if (SecurityUtil.isPackageProtectionEnabled()) { doPrivileged( "addListener", new Class[] {EventListener.class}, new Object[] {t.getClass().getName()}); } else { context.addListener(t); } }
/** * This function returns a map whose entries hold the coordinates of the sequence as keys and the * coordinates of the target sequences as values.</br> If a coordinate in sequence corresponds to * a gap in another sequence, then -1 is assigned to that position.</br> For example suppose we * have the sequences:</br> seq1: AAT-GCT-TCG</br> seq2: G--C-CTCT-C</br> seq3: A-T--GT-AG-</br> * Then, if we wish to find the mapping of seq1's coordinates to seq2's coordinates, this will * give us: 0 -> 0, 1 -> -1, 2 -> -1, 3 -> -1, 4 -> 2, 5 -> 3, 6 -> 5, 7 -> -1, 8 -> 6.</br> Also, * if we wish to find the mapping of seq1's coordinates to seq2's and seq3's coordinates, this * will give us: 0 -> {0, 0}, 1 -> {-1, -1}, 2 -> {-1, 1}, 3 -> {-1, -1}, 4 -> {2, 2}, 5 -> {3, * 3}, 6 -> {5, 4}, 7 -> {-1, 5}, 8 -> {6, -1}. * * @param <T> This could be either the serial number of the sequence (valid range: [0, * sequences.length-1]) or the sequence names * @param <E> * @param seqID The sequence ID (either serial number or name) which we wish to map</br> Note that * the valid range of serial numbers is [0, sequences.length-1] * @param targetSeqIDs The (target) sequences IDs (either serial numbers or names) * @return A map whose keys are the sequence coordinates and values the corresponding coordinates * of the target sequences * @throws IllegalArgumentException * @see GappedAlignmentString */ public <T extends Object> Map mapSeqCoords2SeqsCoords( T generic_seqID, Vector<T> generic_targetSeqIDs) throws IllegalArgumentException, IndexOutOfBoundsException { GappedAlignmentString gas_seq; GappedAlignmentString[] gas_targetSeqs; String[] speciesNames = species(); // Check if generic_seqID is mistakenly included in the generic_targetSeqIDs set if (generic_targetSeqIDs.contains(generic_seqID)) generic_targetSeqIDs.remove(generic_seqID); if (generic_targetSeqIDs.size() + 1 > speciesNames.length) throw new IndexOutOfBoundsException("You entered more sequences than are in the file."); Map map = new HashMap(); // Check whether sequence IDs are inputed as serial numbers or as names String seqsClassName = generic_seqID.getClass().getSimpleName(); // if( generic_seqID.getClass() instanceof java.lang.Integer ) // System.out.println("XAXA"); if (seqsClassName.equals("Integer")) { Integer seqID = (Integer) generic_seqID; Integer[] seqIDs = generic_targetSeqIDs.toArray(new Integer[generic_targetSeqIDs.size()]); if ((StatUtil.findMax(seqIDs).getFirst() > speciesNames.length - 1) || (StatUtil.findMin(seqIDs).getFirst() < 0)) throw new IndexOutOfBoundsException( "The sequence IDs (aka, serial numbers have to lie inside" + " the range 0 to speciesNames.length -1"); gas_seq = getGappedAlignment(speciesNames[seqID]); gas_targetSeqs = new GappedAlignmentString[seqIDs.length]; for (int i = 0; i < seqIDs.length; i++) gas_targetSeqs[i] = getGappedAlignment(speciesNames[seqIDs[i]]); } else if (seqsClassName.equals("String")) { String seqID = (String) generic_seqID; String[] seqIDs = generic_targetSeqIDs.toArray(new String[generic_targetSeqIDs.size()]); gas_seq = getGappedAlignment(seqID); gas_targetSeqs = new GappedAlignmentString[seqIDs.length]; for (int i = 0; i < seqIDs.length; i++) gas_targetSeqs[i] = getGappedAlignment(seqIDs[i]); } else { throw new IllegalArgumentException("Sequence IDs should be either of type Integer or String"); } // Pairwise Alignment if (gas_targetSeqs.length == 1) { map = doMapSeq2Seq(gas_seq, gas_targetSeqs); } // Multiple Alignment else { map = doMapSeq2Seqs(gas_seq, gas_targetSeqs); } return map; } // end of mapSeqCoords2SeqsCoords method
/** * Computes the display string for any value. * * @param t the value to print * @return the formatted string */ public static <T> String print(T t) { if (t == null) { return ""; } if (conversion.canConvert(t.getClass(), String.class)) { return conversion.convert(t, String.class); } else { return t.toString(); } }
public <T> void put(Class<T> clazz, T data) { DEBUG.P(this, "put(Class<T> clazz, T data)"); if (data != null) DEBUG.P("data=" + data.getClass().getName()); else DEBUG.P("data=" + data); // DEBUG.P("context前="+toString()); put(key(clazz), data); // DEBUG.P("context后="+toString()); DEBUG.P(0, this, "put(Class<T> clazz, T data)"); }
private void assertEQ(T t, Object returned) { if (rtype.isArray()) { Asserts.assertEQ(t.getClass(), returned.getClass()); int n = Array.getLength(t); Asserts.assertEQ(n, Array.getLength(returned)); for (int i = 0; i < n; ++i) { Asserts.assertEQ(Array.get(t, i), Array.get(returned, i)); } } else { Asserts.assertEQ(t, returned); } }
@Nonnull public static <T> T requireAnnotation( @Nonnull T instance, @Nonnull Class<? extends Annotation> annotationType) { if (!isAnnotatedWith(instance, annotationType)) { throw new IllegalArgumentException( "Instance of " + instance.getClass() + " is not annotated with " + annotationType.getName()); } return instance; }
private static <T extends UnnamedConfigurable> T createConfigurable( @NotNull ConfigurableEP<T> ep, boolean log) { long time = System.currentTimeMillis(); T configurable = ep.createConfigurable(); if (configurable instanceof Configurable) { ConfigurableCardPanel.warn((Configurable) configurable, "init", time); if (log) { LOG.debug("cannot create configurable wrapper for " + configurable.getClass()); } } return configurable; }
/** * Computes the display string for any value, for a specific type. * * @param desc the field descriptor - custom formatters are extracted from this descriptor. * @param t the value to print * @return the formatted string */ public static <T> String print(TypeDescriptor desc, T t) { if (t == null) { return ""; } if (desc != null && conversion.canConvert(desc, TypeDescriptor.valueOf(String.class))) { return (String) conversion.convert(t, desc, TypeDescriptor.valueOf(String.class)); } else if (conversion.canConvert(t.getClass(), String.class)) { return conversion.convert(t, String.class); } else { return t.toString(); } }
@SuppressWarnings("unchecked") public static <T> T clone(T object) { try { Method cloneMethod = object.getClass().getMethod("clone"); return (T) cloneMethod.invoke(object); } catch (NoSuchMethodException e) { throw new RuntimeException("Unexpected exception", e); // This is not supposed to happen } catch (IllegalAccessException e) { throw new RuntimeException("Unexpected exception", e); // This is not supposed to happen } catch (InvocationTargetException e) { throw new RuntimeException("Execption occured in clone() method", e); } }
@Override public <T extends Enum> void listen(EventListener<T, ?> el, T... events) { if (events == null || events.length == 0) { throw new IllegalArgumentException("Must subscribe to at least one event type"); } for (T event : events) { if (event != null) { regsiterListener(el, (Class<T>) event.getClass(), Arrays.asList(events)); break; } } }
/** * Convenience method for testing purposes. If you know that the type of the value is correct, it * is preferable to create a ConfigEntry object and apply it to the component (no type checking * necessary). * * @param <T> Type of the config option (Integer, String etc.). * @param component A component. * @param optionName The name of the config option. * @param value The value of the config option. */ @SuppressWarnings("unchecked") public <T> void applyConfigEntry(AbstractComponent component, String optionName, T value) { logger.trace(component); logger.trace(optionName); logger.trace(value); logger.trace(value.getClass()); // first we look whether the component is registered if (components.contains(component.getClass())) { // look for a config option with the specified name ConfigOption<?> option = (ConfigOption<?>) componentOptionsByName.get(component.getClass()).get(optionName); if (option != null) { // check whether the given object has the correct type if (!option.checkType(value)) { System.out.println( "Warning: value " + value + " is not valid for option " + optionName + " in component " + component + ". It does not have the correct type."); return; } // we have checked the type, hence it should now be safe to // typecast and // create a ConfigEntry object ConfigEntry<T> entry = null; try { entry = new ConfigEntry<T>((ConfigOption<T>) option, value); component.applyConfigEntry(entry); pool.addConfigEntry(component, entry, true); } catch (InvalidConfigOptionValueException e) { pool.addConfigEntry(component, entry, false); System.out.println( "Warning: value " + value + " is not valid for option " + optionName + " in component " + component); } } else { logger.warn("Warning: undefined option " + optionName + " in component " + component); } } else { logger.warn("Warning: unregistered component " + component); } }
@SuppressWarnings({"unchecked"}) @NotNull public static <T extends PsiType> T originalize(@NotNull T type) { if (!type.isValid()) { return type; } T result = new PsiTypeMapper() { private final Set<PsiClassType> myVisited = ContainerUtil.newIdentityTroveSet(); @Override public PsiType visitClassType(final PsiClassType classType) { if (!myVisited.add(classType)) return classType; final PsiClassType.ClassResolveResult classResolveResult = classType.resolveGenerics(); final PsiClass psiClass = classResolveResult.getElement(); final PsiSubstitutor substitutor = classResolveResult.getSubstitutor(); if (psiClass == null) return classType; return new PsiImmediateClassType( CompletionUtil.getOriginalOrSelf(psiClass), originalizeSubstitutor(substitutor)); } private PsiSubstitutor originalizeSubstitutor(final PsiSubstitutor substitutor) { PsiSubstitutor originalSubstitutor = PsiSubstitutor.EMPTY; for (final Map.Entry<PsiTypeParameter, PsiType> entry : substitutor.getSubstitutionMap().entrySet()) { final PsiType value = entry.getValue(); originalSubstitutor = originalSubstitutor.put( CompletionUtil.getOriginalOrSelf(entry.getKey()), value == null ? null : mapType(value)); } return originalSubstitutor; } @Override public PsiType visitType(PsiType type) { return type; } }.mapType(type); if (result == null) { throw new AssertionError("Null result for type " + type + " of class " + type.getClass()); } return result; }
@Override public <T> T cloneInternal(T o, Map<Object, Object> clones) throws IllegalAccessException { if (o == null) { return null; } @SuppressWarnings("unchecked") T clone = (T) cache.get(o); if (clone != null) { return clone; } T t = super.cloneInternal(o, clones); if (t != null && t != o && !t.getClass().isArray()) { cache.put(t, t); } return t; }
/** Return the value of an enum of the given type. Prefix allows a shortened form of the enum */ @SuppressWarnings("unchecked") public <T extends Enum<T>> T getEnum(String prop, String prefix, T dflt) { Enum<?> v = dflt; String s = getProperty(prop); if (s == null || s.length() == 0) return dflt; if (prefix != null && !s.startsWith(prefix)) s = prefix + s; Object[] vals = dflt.getClass().getEnumConstants(); if (vals == null) return dflt; for (int i = 0; i < vals.length; ++i) { Enum<?> e = (Enum<?>) vals[i]; if (e.name().equalsIgnoreCase(s)) { v = e; break; } } return (T) v; }
@SuppressWarnings("unchecked") private <T> T clone(final T o, final Map<Object, Object> clones) throws IllegalAccessException { if (o == null) return null; if (ignoredInstances.containsKey(o)) return o; final Class<T> clz = (Class<T>) o.getClass(); if (clz.isEnum()) return o; // skip cloning ignored classes if (ignored.contains(clz)) return o; final Object clonedPreviously = clones != null ? clones.get(o) : null; if (clonedPreviously != null) return (T) clonedPreviously; if (clz.isArray()) { final int length = Array.getLength(o); final T newInstance = (T) Array.newInstance(clz.getComponentType(), length); clones.put(o, newInstance); for (int i = 0; i < length; i++) { final Object v = Array.get(o, i); final Object clone = clones != null ? clone(v, clones) : v; Array.set(newInstance, i, clone); } return newInstance; } T newInstance = null; try { newInstance = newInstance(clz); } catch (InstantiationException e) { e.printStackTrace(); } if (clones != null) { clones.put(o, newInstance); } final List<Field> fields = allFields(clz); for (final Field field : fields) { if (!Modifier.isStatic(field.getModifiers())) { field.setAccessible(true); final Object fieldObject = field.get(o); final Object fieldObjectClone = clones != null ? clone(fieldObject, clones) : fieldObject; field.set(newInstance, fieldObjectClone); } } return newInstance; }
private <S, R, T> R createByExample( S from, Class<R> relationType, T to, Map<PrimitivePropertyMethodMetadata<PropertyMetadata>, Object> example) { MetadataProvider<EntityMetadata, EntityDiscriminator, RelationMetadata, RelationDiscriminator> metadataProvider = sessionContext.getMetadataProvider(); AbstractRelationPropertyMethodMetadata<?> fromProperty = metadataProvider.getPropertyMetadata(from.getClass(), relationType, FROM); AbstractRelationPropertyMethodMetadata<?> toProperty = metadataProvider.getPropertyMetadata(to.getClass(), relationType, TO); Entity entity = sessionContext.getEntityInstanceManager().getDatastoreType(from); R instance = sessionContext .getEntityPropertyManager() .createRelationReference(entity, fromProperty, to, toProperty, example); sessionContext.getInstanceListenerService().postCreate(instance); return instance; }
/** * Creates an iterator that returns an {@link Options} containing each possible parameter set * defined by these {@link * com.biomatters.plugins.barcoding.validator.research.options.BatchOptions}. Note that the {@link * Options} object returned is always the same to save on initializing multiple copies. Each time * {@link java.util.Iterator#next()} is called the next parameter set is set on the {@link * Options}. * * @return An iterator that will iterate over all possible parameter sets specified by this {@link * com.biomatters.plugins.barcoding.validator.research.options.BatchOptions} * @throws DocumentOperationException if there is a problem creating the {@link Options} object */ public Iterator<T> iterator() throws DocumentOperationException { List<Set<OptionToSet>> possibleValues = new ArrayList<Set<OptionToSet>>(); Map<String, MultiValueOption<?>> multiValueOptions = getMultiValueOptions("", options); for (Map.Entry<String, MultiValueOption<?>> entry : multiValueOptions.entrySet()) { possibleValues.add(getOptionsToSet(entry.getKey(), entry.getValue())); } Set<List<OptionToSet>> lists = Sets.cartesianProduct(possibleValues); final Iterator<List<OptionToSet>> possibilityIterator = lists.iterator(); final T template; try { //noinspection unchecked template = (T) options.getClass().newInstance(); // getClass() doesn't return Class<T> :( template.valuesFromXML(options.valuesToXML(XMLSerializable.ROOT_ELEMENT_NAME)); } catch (InstantiationException e) { throw new DocumentOperationException("Failed to create Options: " + e.getMessage(), e); } catch (IllegalAccessException e) { throw new DocumentOperationException("Failed to create Options: " + e.getMessage(), e); } return new Iterator<T>() { @Override public boolean hasNext() { return possibilityIterator.hasNext(); } @Override public T next() { List<OptionToSet> possibility = possibilityIterator.next(); for (OptionToSet optionToSet : possibility) { template.setValue(optionToSet.name, optionToSet.value); } return template; } @Override public void remove() { new UnsupportedOperationException(); } }; }
@SuppressWarnings("unchecked") public static <T extends JsonElement> T deepCopy(T from) { if (from == null) { throw new IllegalArgumentException("from must not be null"); } if (from instanceof JsonObject) { return (T) deepCopyObj((JsonObject) from); } if (from instanceof JsonArray) { return (T) deepCopyArr((JsonArray) from); } if (from instanceof JsonNull) { return (T) JsonNull.INSTANCE; } if (from instanceof JsonPrimitive) { // Nulls and primitives are immutable return from; } throw new AssertionError("Unknown element type " + from.getClass().getName()); }
@Nullable public static <T extends PsiElement> T getOriginalElement(@NotNull T psi) { final PsiFile file = psi.getContainingFile(); if (file != null && file != file.getOriginalFile() && psi.getTextRange() != null) { TextRange range = psi.getTextRange(); Integer start = range.getStartOffset(); Integer end = range.getEndOffset(); final Document document = file.getViewProvider().getDocument(); if (document != null) { Document hostDocument = document instanceof DocumentWindowImpl ? ((DocumentWindowImpl) document).getDelegate() : document; OffsetTranslator translator = hostDocument.getUserData(RANGE_TRANSLATION); if (translator != null) { if (document instanceof DocumentWindowImpl) { start = ((DocumentWindowImpl) document).injectedToHost(start); end = ((DocumentWindowImpl) document).injectedToHost(end); } start = translator.translateOffset(start); end = translator.translateOffset(end); if (start == null || end == null) { return null; } if (document instanceof DocumentWindowImpl) { start = ((DocumentWindowImpl) document).hostToInjected(start); end = ((DocumentWindowImpl) document).hostToInjected(end); } } } //noinspection unchecked return (T) PsiTreeUtil.findElementOfClassAtRange(file.getOriginalFile(), start, end, psi.getClass()); } return psi; }
/** * Method use OpenCsv Library for * * @param clazz the Class of the Bean. * @param fileInputCsv the File CSV to parse. * @param separator the char separator. * @param <T> the generic variable. * @return the List of Bean parsed from the CSV file. */ public static <T> List<T> parseCSVFileAsList(Class<T> clazz, File fileInputCsv, char separator) { try { List<T> beans; try ( // create CSVReader object CSVReader reader = new CSVReader(new FileReader(fileInputCsv), separator)) { beans = new ArrayList<>(); // read line by line String[] record; // skip header row String[] headers = reader.readNext(); // read content while ((record = reader.readNext()) != null) { T t = ReflectionUtilities.invokeConstructor(clazz); for (int i = 0; i < record.length; i++) { String nameMethod = "set" + org.apache.commons.lang3.StringUtils.capitalize(headers[i]); // invoke setter method if (ReflectionUtilities.checkMethod(clazz, nameMethod)) { ReflectionUtilities.invokeSetter(t, nameMethod, record[i]); } else { logger.warn( "Not exists the Method with name:" + nameMethod + " on the Bean:" + t.getClass().getName()); } } beans.add(t); } } return beans; } catch (IOException e) { logger.error( "Can't parse the CSV file:" + fileInputCsv.getAbsolutePath() + " -> " + e.getMessage(), e); return new ArrayList<>(); } }
@NotNull public static <T extends DomElement> T getOriginalElement(@NotNull final T domElement) { final XmlElement psiElement = domElement.getXmlElement(); if (psiElement == null) return domElement; final PsiFile psiFile = psiElement.getContainingFile().getOriginalFile(); final TextRange range = psiElement.getTextRange(); final PsiElement element = psiFile.findElementAt(range.getStartOffset()); final int maxLength = range.getLength(); final boolean isAttribute = psiElement instanceof XmlAttribute; final Class<? extends XmlElement> clazz = isAttribute ? XmlAttribute.class : XmlTag.class; final DomManager domManager = domElement.getManager(); DomElement current = null; for (XmlElement next = PsiTreeUtil.getParentOfType(element, clazz, false); next != null && next.getTextLength() <= maxLength; next = PsiTreeUtil.getParentOfType(next, clazz, true)) { current = isAttribute ? domManager.getDomElement((XmlAttribute) next) : domManager.getDomElement((XmlTag) next); if (current != null && domElement.getClass() != current.getClass()) current = null; } return (T) current; }
public Query buildQuery(Integer type, T example, String... orden) { StringBuilder qry; List<String> ids = new ArrayList<String>(); if (type == 1) { qry = new StringBuilder(SELECT_COUNT); qry.append(example.getClass().getSimpleName()); } else { qry = new StringBuilder(SELECT); qry.append(example.getClass().getSimpleName()); ids = this.obtenerId(example); } qry.append(FROM); qry.append(WHERE); List<Object> parametros = new ArrayList(); Criterio criterio = new Criterio(); Map<String, Object> propiedades = this.obtenerPropiedades(example); criterio.contruccion(propiedades); Set<String> igualdad = criterio.igualdad.keySet(); Integer idx = 1; for (String key : igualdad) { if (idx > 1) { qry.append(AND); } qry.append(OBJ); qry.append(key); qry.append(EQ); qry.append(idx); parametros.add(criterio.igualdad.get(key)); idx++; } Set<String> likeKeys = criterio.like.keySet(); for (String key : likeKeys) { if (idx > 1) { qry.append(AND); } Object valor = criterio.like.get(key); if (valor instanceof String) { qry.append(LOWER); qry.append(OBJ); qry.append(key); qry.append(")"); qry.append(LIKE); qry.append(idx); parametros.add(((String) valor).toLowerCase()); } else { qry.append(OBJ); qry.append(key); qry.append(LIKE); qry.append(idx); parametros.add(valor); } idx++; } Set<String> compositeKeys = criterio.compuesto.keySet(); for (String key : compositeKeys) { Object value = criterio.compuesto.get(key); try { if (value.toString().startsWith("class java.util")) { continue; } else if (StringUtils.containsIgnoreCase(key, "pk")) { Map<String, Object> propsComposites = this.obtenerPropiedades(value, key); Criterio criterioCompuesto = new Criterio(); criterioCompuesto.contruccion(propsComposites); if (!criterioCompuesto.igualdad.isEmpty()) { Set<String> eqKeysPK = criterioCompuesto.igualdad.keySet(); for (String keyPK : eqKeysPK) { if (idx > 1) { qry.append(AND); } qry.append(OBJ); qry.append(keyPK); qry.append(EQ); qry.append(idx); parametros.add(criterioCompuesto.igualdad.get(keyPK)); idx++; } } if (!criterioCompuesto.like.isEmpty()) { Set<String> likeKeysPK = criterioCompuesto.like.keySet(); for (String keyPK : likeKeysPK) { if (idx > 1) { qry.append(AND); } Object valor = criterioCompuesto.like.get(keyPK); if (valor instanceof String) { qry.append(LOWER); qry.append(OBJ); qry.append(keyPK); qry.append(")"); qry.append(LIKE); qry.append(idx); parametros.add(((String) valor).toLowerCase()); } else { qry.append(OBJ); qry.append(keyPK); qry.append(LIKE); qry.append(idx); parametros.add(valor); } idx++; } } } else { Map<String, Object> propsComposites = this.obtenerPropiedades(value); Criterio criterioCompuesto = new Criterio(); criterioCompuesto.contruccion(propsComposites); if (!criterioCompuesto.igualdad.isEmpty()) { Set<String> eqKeysPK = criterioCompuesto.igualdad.keySet(); for (String keyPK : eqKeysPK) { if (idx > 1) { qry.append(AND); } qry.append(OBJ); qry.append(key); qry.append("."); qry.append(keyPK); qry.append(EQ); qry.append(idx); parametros.add(criterioCompuesto.igualdad.get(keyPK)); idx++; } } if (!criterioCompuesto.like.isEmpty()) { Set<String> likeKeysPK = criterioCompuesto.like.keySet(); for (String keyPK : likeKeysPK) { System.out.println( "Compuesto LIKE: " + keyPK + ", " + criterioCompuesto.igualdad.get(keyPK)); if (idx > 1) { qry.append(AND); } Object valor = criterioCompuesto.like.get(keyPK); if (valor instanceof String) { qry.append(LOWER); qry.append(OBJ); qry.append(key); qry.append("."); qry.append(keyPK); qry.append(")"); qry.append(LIKE); qry.append(idx); parametros.add(((String) valor).toLowerCase()); } else { qry.append(OBJ); qry.append(key); qry.append("."); qry.append(keyPK); qry.append(LIKE); qry.append(idx); parametros.add(valor); } idx++; } } } } catch (RuntimeException e) { continue; } } if (idx == 1) { qry.append(" 1=1"); } if (!ids.isEmpty()) { qry.append(ORDER); } else { qry.append(" "); } if (orden.length > 0) { for (String ord : orden) { qry.append(OBJ); qry.append(ord.substring(2)); if (ord.startsWith("A,")) { qry.append(ASC); } else if (ord.startsWith("D,")) { qry.append(DESC); } } } else { for (String id : ids) { if (!id.contains("_persistence")) { qry.append(OBJ); qry.append(id); qry.append(ASC); } } } System.out.println(qry.substring(0, qry.length() - 2)); Query query = this.em.createQuery(qry.substring(0, qry.length() - 2)); if (!parametros.isEmpty()) { int i = 1; for (Object obj : parametros) { query.setParameter(i, obj); i++; } } return query; }