static void lambdaTest() { Runnable r = () -> System.out.print("hello lambda"); r.run(); List<String> list = Arrays.asList("t1", "t2", "t334", "t4", "t567"); list.parallelStream().filter(s -> s.length() == 2).forEach(System.out::println); list = Arrays.asList("1", "2", "3", "4", "5", "6", "7", "8", "9", "15", "17"); Map<String, Integer> integers = list.stream() .map(Integer::new) .filter(e -> e % 2 != 0) .distinct() .collect(Collectors.toMap(Object::toString, e -> e)); System.out.println(integers); Stream.generate(Math::random).limit(10).forEach(System.out::println); new Thread(() -> System.out.println("hello lambda")).start(); new Thread( () -> { System.out.println("hello lambda"); }) .start(); List<String> words = Lists.newArrayList("ren", "wang", "li", "zhao", "ma"); words.sort((w1, w2) -> Integer.compare((w1.length()), w2.length())); List<Integer> ints = Ints.asList(1, 2, 3, 4, 5); ints.sort(Integer::compare); // words.forEach(e -> System.out.print(e)); words.forEach(System.out::println); // words.stream().map(w -> w.length()); words.stream().map(String::length); // words.stream().map(w -> new StringBuilder(w)); words.stream().map(StringBuilder::new); Converter<String, Integer> converter; // (f) -> Integer.valueOf(f); converter = Integer::valueOf; Integer converted = converter.convert("123"); System.out.println(converted); String[] arrayStr = new String[] {"a", "ab", "abc", "abcd"}; Arrays.sort(arrayStr, (first, second) -> Integer.compare(first.length(), second.length())); }
public void testStringConverter_convert() { Converter<String, TestEnum> converter = Enums.stringConverter(TestEnum.class); assertEquals(TestEnum.CHEETO, converter.convert("CHEETO")); assertEquals(TestEnum.HONDA, converter.convert("HONDA")); assertEquals(TestEnum.POODLE, converter.convert("POODLE")); assertNull(converter.convert(null)); assertNull(converter.reverse().convert(null)); }
public boolean addAt(int index, Object e) { if (index < 0) index = size(); while (index > size()) { if (!add(Converter.convert(null, type))) return false; } if (type != null) e = Converter.convert(e, type); super.add(index, e); return true; }
void readThis() throws OldFormatException { newSystemData(AbstractFreespaceManager.FM_LEGACY_RAM, StandardIdSystemFactory.LEGACY); blockSizeReadFromFile(1); _fileHeader = FileHeader.read(this); if (config().generateCommitTimestamps().isUnspecified()) { config().generateCommitTimestamps(_systemData.idToTimestampIndexId() != 0); } createStringIO(_systemData.stringEncoding()); createIdSystem(); initializeClassMetadataRepository(); initalizeWeakReferenceSupport(); setNextTimeStampId(systemData().lastTimeStampID()); classCollection().setID(_systemData.classCollectionID()); classCollection().read(systemTransaction()); Converter.convert(new ConversionStage.ClassCollectionAvailableStage(this)); _fileHeader.readIdentity(this); if (_config.isReadOnly()) { return; } if (!configImpl().commitRecoveryDisabled()) { _fileHeader.completeInterruptedTransaction(this); } FreespaceManager blockedFreespaceManager = AbstractFreespaceManager.createNew(this, _systemData.freespaceSystem()); installFreespaceManager(blockedFreespaceManager); blockedFreespaceManager.read(this, _systemData.inMemoryFreespaceSlot()); blockedFreespaceManager.start(_systemData.bTreeFreespaceId()); _fileHeader = _fileHeader.convert(this); if (freespaceMigrationRequired(blockedFreespaceManager)) { migrateFreespace(blockedFreespaceManager); } writeHeader(true, false); if (Converter.convert(new ConversionStage.SystemUpStage(this))) { _systemData.converterVersion(Converter.VERSION); _fileHeader.writeVariablePart(this); transaction().commit(); } }
private static NCube checkForConflicts( ApplicationID appId, Map<String, Map> errors, String message, NCubeInfoDto info, NCubeInfoDto head, boolean reverse) { Map<String, Object> map = new LinkedHashMap<>(); map.put("message", message); map.put("sha1", info.sha1); map.put("headSha1", head != null ? head.sha1 : null); try { if (head != null) { long branchCubeId = (long) Converter.convert(info.id, long.class); long headCubeId = (long) Converter.convert(head.id, long.class); NCube branchCube = getPersister().loadCubeById(branchCubeId); NCube headCube = getPersister().loadCubeById(headCubeId); if (info.headSha1 != null) { NCube baseCube = getPersister().loadCubeBySha1(appId, info.name, info.headSha1); Map delta1 = baseCube.getDelta(branchCube); Map delta2 = baseCube.getDelta(headCube); if (NCube.areDeltaSetsCompatible(delta1, delta2)) { if (reverse) { headCube.mergeCellChangeSet(delta1); return headCube; } else { branchCube.mergeCellChangeSet(delta2); return branchCube; } } } List<Delta> diff = branchCube.getDeltaDescription(headCube); if (diff.size() > 0) { map.put("diff", diff); } else { return branchCube; } } else { map.put("diff", null); } } catch (Exception e) { map.put("diff", e.getMessage()); } errors.put(info.name, map); return null; }
/** * Convert the specified value to an object of the specified class (if possible). Otherwise, * return a String representation of the value. * * @param value Value to be converted (may be null) * @param clazz Java class to be converted to * @return The converted value * @exception ConversionException if thrown by an underlying Converter */ public Object convert(final String value, final Class<?> clazz) { Converter converter = this.lookup(clazz); if (converter == null) { converter = this.lookup(String.class); } return converter.convert(clazz, value); }
@Override public Iterable<Object> convert(Converter converter, Type returnType, Object object) throws Exception { Iterable<Object> iterable; if (object == null) { iterable = Collections.emptyList(); } else if (object instanceof Map) { iterable = ((Map) object).entrySet(); } else { iterable = iterable(object); if (iterable == null) { iterable = Collections.singleton(object); } } if (returnType instanceof Class) { } else if (returnType instanceof ParameterizedType) { Type itemType = ((ParameterizedType) returnType).getActualTypeArguments()[0]; List<Object> list = new ArrayList<Object>(); for (Object item : iterable) { list.add(converter.convert(itemType, item)); } iterable = list; } else { throw new ConversionException(String.format("Can't convert to [%s]!", returnType), null); } return iterable; }
public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, NoSuchMethodException, InvocationTargetException, IOException { MyClass mc = new MyClass(); Converter converter = new Converter(); converter.convert(mc.getClass(), mc); }
public static void main(String[] args) { String rate = JOptionPane.showInputDialog( null, "Please a desired exchange rate between Dollars(US) and Euros: "); double userRate = Double.parseDouble(rate); Converter userConverter = new Converter(userRate); boolean completed = false; while (!completed) { String input = JOptionPane.showInputDialog( null, "Please enter the amount in US$ to be converted (Q to quit): "); if (input.equalsIgnoreCase("Q")) completed = true; else { double amount = Double.parseDouble(input); if (amount > 0) { double Coinexchange = userConverter.convert(amount); JOptionPane.showMessageDialog( null, "The conversion to Euro is: " + Coinexchange + " Euro"); } else completed = true; } } }
public void testStringConverter_convertError() { Converter<String, TestEnum> converter = Enums.stringConverter(TestEnum.class); try { converter.convert("xxx"); fail(); } catch (IllegalArgumentException expected) { } }
public Object set(int index, Object e) { Object old = get(index); if (index < 0 || index >= size()) add(index, e); else { if (type != null) e = Converter.convert(e, type); super.set(index, e); } return old; }
public static void main(String[] args) { Converter<String, Integer> converter = (from) -> Integer.valueOf(from); int converted = converter.convert("123"); System.out.println(converted); // 123 Converter<String, Integer> converter2 = Integer::valueOf; int converted2 = converter2.convert("123"); System.out.println(converted2); int num = 1; Converter<String, Integer> converter3 = (from) -> Integer.valueOf(from + num); int converted3 = converter3.convert("123"); System.out.println(converted3); PersonFactory<Person> personFactroy = Person::new; Person p = personFactroy.create("jackson", "qi"); System.out.println(p.firstName); }
private Object convert(Object value, Class dest) { for (Converter c : converters) { if (c.getTarget().isAssignableFrom(dest)) { return c.convert(value); } } throw new RuntimeException( "No converters are compatible with the dest class: " + dest.getCanonicalName()); }
/** * Convert the specified value into a String. If the specified value is an array, the first * element (converted to a String) will be returned. The registered {@link Converter} for the * <code>java.lang.String</code> class will be used, which allows applications to customize * Object->String conversions (the default implementation simply uses toString()). * * @param value Value to be converted (may be null) * @return The converted String value */ public String convert(Object value) { if (value == null) { return null; } else if (value.getClass().isArray()) { if (Array.getLength(value) < 1) { return null; } value = Array.get(value, 0); if (value == null) { return null; } else { Converter converter = this.lookup(String.class); return (String) converter.convert(String.class, value); } } else { Converter converter = this.lookup(String.class); return (String) converter.convert(String.class, value); } }
@SuppressWarnings({"unchecked"}) <T> T as(Class<T> type, Converter<T> converter) { if (isNull()) { return null; } else if (ClassUtils.isAssignableValue(type, object)) { return (T) object; } else { return converter.convert(type, object); } }
static NCube ensureLoaded(Object value) { if (value instanceof NCube) { return (NCube) value; } if (value instanceof NCubeInfoDto) { // Lazy load cube (make sure to apply any advices to it) NCubeInfoDto dto = (NCubeInfoDto) value; long id = (long) Converter.convert(dto.id, long.class); return prepareCube(getPersister().loadCubeById(id)); } throw new IllegalStateException("Failed to retrieve cube from cache, value: " + value); }
/** * Convert the value to an object of the specified class (if possible). * * @param value Value to be converted (may be null) * @param targetType Class of the value to be converted to * @return The converted value * @exception ConversionException if thrown by an underlying Converter */ public Object convert(final Object value, final Class<?> targetType) { Class<?> sourceType = value == null ? null : value.getClass(); Object converted = value; Converter converter = this.lookup(sourceType, targetType); if (converter != null) { converted = converter.convert(targetType, value); } if (targetType == String.class && converted != null && !(converted instanceof String)) { // NOTE: For backwards compatibility, if the Converter // doesn't handle conversion-->String then // use the registered String Converter converter = this.lookup(String.class); if (converter != null) { converted = converter.convert(String.class, converted); } // If the object still isn't a String, use toString() method if (converted != null && !(converted instanceof String)) { converted = converted.toString(); } } return converted; }
@SuppressWarnings({"unchecked", "rawtypes"}) private void truncate(Trace<?> dest, Trace<?> orig) throws IOException { long min_time = minTime * orig.ticsPerSecond(); long max_time = maxTime * orig.ticsPerSecond(); Converter truncater; if (orig.isStateful()) { truncater = new StatefulSubtraceConverter( (StatefulTrace<?, ?>) dest, (StatefulTrace<?, ?>) orig, min_time, max_time); } else { truncater = new SubtraceConverter(dest, orig, min_time, max_time); } truncater.convert(); }
public static <V, T> T convert(V value, Class<T> type) { Map<Object, Object> typeConverters = converters.get(value.getClass()); if (typeConverters == null) { throw new NoSuchElementException("No converters from type " + value.getClass()); } Converter converter = (Converter) typeConverters.get(type); if (converter == null) { throw new NoSuchElementException("No converter to type " + type); } return (T) converter.convert(value); }
/** * Convert an array of specified values to an array of objects of the specified class (if * possible). If the specified Java class is itself an array class, this class will be the type of * the returned value. Otherwise, an array will be constructed whose component type is the * specified class. * * @param values Array of values to be converted * @param clazz Java array or element class to be converted to * @return The converted value * @exception ConversionException if thrown by an underlying Converter */ public Object convert(final String[] values, final Class<?> clazz) { Class<?> type = clazz; if (clazz.isArray()) { type = clazz.getComponentType(); } Converter converter = this.lookup(type); if (converter == null) { converter = this.lookup(String.class); } Object array = Array.newInstance(type, values.length); for (int i = 0; i < values.length; i++) { Array.set(array, i, converter.convert(type, values[i])); } return array; }
@SuppressWarnings({"unchecked", "rawtypes"}) public static Object invoke(Object target, Method method, boolean strict, Object... args) { try { Object[] params; Class<?>[] paramTypes = method.getParameterTypes(); if (paramTypes.length == 0) { params = null; } else if (args.length == paramTypes.length) { // map one to one if (strict) { params = args; } else { params = new Object[paramTypes.length]; for (int i = 0; i < paramTypes.length; i++) { Object arg = args[i]; if (arg == null) params[i] = null; else { Converter converter = ConverterManager.getInstance().createConverter(arg.getClass(), paramTypes[i]); params[i] = converter.convert(arg); } } } } else { // map varargs params = new Object[paramTypes.length]; for (int i = 0; i < paramTypes.length - 1; i++) params[i] = (strict ? args[i] : AnyConverter.convert(args[i], paramTypes[i])); Class<?> varargsComponentType = paramTypes[paramTypes.length - 1].getComponentType(); Object varargs = Array.newInstance(varargsComponentType, args.length - paramTypes.length + 1); for (int i = 0; i < args.length - paramTypes.length + 1; i++) { Object param = args[paramTypes.length - 1 + i]; if (strict) param = AnyConverter.convert(param, varargsComponentType); Array.set(varargs, i, param); } params[params.length - 1] = varargs; } return method.invoke(target, params); } catch (IllegalAccessException e) { throw ExceptionMapper.configurationException(e, method); } catch (InvocationTargetException e) { throw ExceptionMapper.configurationException(e, method); } }
/** Coerces the object to the indicated type. */ public static Object coerce(TemplateContext ctx, Class<?> type, final Object o) { Object arg; if (o != null && type == o.getClass()) { arg = o; } else if (type == String.class) { arg = Types.toString(ctx, o); } else if (type == int.class || type == Integer.class) { arg = Types.toInteger(ctx, o); } else if (type == long.class || type == Long.class) { arg = Types.toLong(ctx, o); } else if (type == float.class || type == Float.class || type == double.class || type == Double.class) { arg = Types.toDouble(ctx, o); } else if (type == boolean.class || type == Boolean.class) { arg = Types.toBoolean(ctx, o); } else if (type == Iterator.class) { arg = Types.toIterator(ctx, o); } else { if (o == null) { arg = null; } else { final Converter<Object, Object> converter = ctx.getConverter(o.getClass(), type); if (converter == null) { arg = o; } else { try { arg = converter.convert(o); } catch (ConverterException e) { ctx.warn("Conversion error", e); return null; } } } } return arg; }
@Test public void test() { ExtendA a = new ExtendA(); a.setA("a"); a.setB("b"); Sub sub = new Sub(); sub.setV(1); a.setSub(sub); CommonSub commonSub = new CommonSub(); commonSub.setCommonString("comA"); a.setCommonSub(commonSub); a.setList(new ListSub()); a.getList().getList().add(sub); try { ExtendB b = Converter.convert(a, ExtendB.class); a.getCommonSub().setCommonString("c"); System.out.println("Original: ".concat(a.toString())); System.out.println("Copy:" + b.toString()); } catch (Converter.ConverterException ex) { Logger.getLogger(ConverterTest.class.getName()).log(Level.SEVERE, null, ex); } }
public Object convert(Class<?> clazz, String s) { Converter<?> c = map.get(clazz); return c.convert(s); }
/* Stylesheet is useless and just kept to keep the consistency with * builddoc V1 */ public String process(String sourceDoc, String styleSheet) throws Throwable { String fileToExec = null; if (!new File(sourceDoc).isFile()) { System.err.println("Could not find master document: " + sourceDoc); return null; } try { Converter converter = null; ImageConverter imgConvert = new ImageConverter(); switch (format) { case JAVAHELP: if (!isToolbox) { imgConvert.loadMD5s(ScilabConstants.SCI.getPath() + "/modules/helptools/etc"); } converter = new JavaHelpDocbookTagConverter(sourceDoc, this, imgConvert); break; case HTML: converter = new HTMLDocbookTagConverter(sourceDoc, this, imgConvert); break; case WEB: if (!isToolbox) { imgConvert.loadMD5s(ScilabConstants.SCI.getPath() + "/modules/helptools/etc"); } converter = new HTMLDocbookTagConverter(sourceDoc, this, imgConvert); break; case CHM: if (!isToolbox) { imgConvert.loadMD5s(ScilabConstants.SCI.getPath() + "/modules/helptools/etc"); } converter = new CHMDocbookTagConverter(sourceDoc, this, imgConvert); break; case FO: converter = new FODocbookTagConverter(sourceDoc, this, imgConvert); break; case JAR_ONLY: converter = new JarOnlyConverter(this); break; case PDF: case PS: converter = new FopConverter(this); break; default: System.err.printf("%s is not a supported format.\n", format); return null; } converter.registerAllExternalXMLHandlers(); converter.convert(); converter.install(); if (imgConvert.getScilabImageConverter() != null) { fileToExec = imgConvert.getScilabImageConverter().getFileWithScilabCode(); } } catch (SAXException e) { System.err.println("An error occurred during the conversion:"); System.err.println(e.toString()); } catch (Throwable e) { System.err.println("An error occurred during the conversion:\n"); e.printStackTrace(); throw e; } return fileToExec; }
public void testStringConverter_nullConversions() { Converter<String, TestEnum> converter = Enums.stringConverter(TestEnum.class); assertNull(converter.convert(null)); assertNull(converter.reverse().convert(null)); }
/** * Get List<NCubeInfoDto> of n-cube record DTOs for the given ApplicationID (branch only). If * using For any cube record loaded, for which there is no entry in the app's cube cache, an entry * is added mapping the cube name to the cube record (NCubeInfoDto). This will be replaced by an * NCube if more than the name is required. one (1) character. This is universal whether using a * SQL perister or Mongo persister. */ public static List<NCubeInfoDto> getBranchChangesFromDatabase(ApplicationID appId) { validateAppId(appId); if (appId.getBranch().equals(ApplicationID.HEAD)) { throw new IllegalArgumentException("Cannot get branch changes from HEAD"); } ApplicationID headAppId = appId.asHead(); Map<String, NCubeInfoDto> headMap = new TreeMap<>(); Map<String, Object> searchChangedRecordOptions = new HashMap<>(); searchChangedRecordOptions.put(SEARCH_CHANGED_RECORDS_ONLY, true); List<NCubeInfoDto> branchList = search(appId, null, null, searchChangedRecordOptions); Map<String, Object> options = new HashMap<>(); options.put(SEARCH_ACTIVE_RECORDS_ONLY, false); List<NCubeInfoDto> headList = search(headAppId, null, null, options); List<NCubeInfoDto> list = new ArrayList<>(); // build map of head objects for reference. for (NCubeInfoDto info : headList) { headMap.put(info.name, info); } // Loop through changed (added, deleted, created, restored, updated) records for (NCubeInfoDto info : branchList) { long revision = (long) Converter.convert(info.revision, long.class); NCubeInfoDto head = headMap.get(info.name); if (head == null) { if (revision >= 0) { info.changeType = ChangeType.CREATED.getCode(); list.add(info); } } else if (info.headSha1 == null) { // we created this guy locally // someone added this one to the head already info.changeType = ChangeType.CONFLICT.getCode(); list.add(info); } else { if (StringUtilities.equalsIgnoreCase(info.headSha1, head.sha1)) { if (StringUtilities.equalsIgnoreCase(info.sha1, info.headSha1)) { // only net change could be revision deleted or restored. check head. long headRev = Long.parseLong(head.revision); if (headRev < 0 != revision < 0) { if (revision < 0) { info.changeType = ChangeType.DELETED.getCode(); } else { info.changeType = ChangeType.RESTORED.getCode(); } list.add(info); } } else { info.changeType = ChangeType.UPDATED.getCode(); list.add(info); } } else { info.changeType = ChangeType.CONFLICT.getCode(); list.add(info); } } } cacheCubes(appId, list); return list; }
@Override public List<Piece> getGenes() { return Converter.convert(pieces); }
/** * Commit the passed in changed cube records identified by NCubeInfoDtos. * * @return array of NCubeInfoDtos that are to be committed. */ public static List<NCubeInfoDto> commitBranch( ApplicationID appId, Object[] infoDtos, String username) { validateAppId(appId); appId.validateBranchIsNotHead(); appId.validateStatusIsNotRelease(); ApplicationID headAppId = appId.asHead(); Map<String, NCubeInfoDto> headMap = new TreeMap<>(); Map<String, Object> options = new HashMap<>(); options.put(SEARCH_ACTIVE_RECORDS_ONLY, false); List<NCubeInfoDto> headInfo = search(headAppId, null, null, options); // build map of head objects for reference. for (NCubeInfoDto info : headInfo) { headMap.put(info.name, info); } List<NCubeInfoDto> dtosToUpdate = new ArrayList<>(infoDtos.length); List<NCubeInfoDto> dtosMerged = new ArrayList<>(); Map<String, Map> errors = new LinkedHashMap<>(); for (Object dto : infoDtos) { NCubeInfoDto branchCubeInfo = (NCubeInfoDto) dto; if (!branchCubeInfo.isChanged()) { continue; } if (branchCubeInfo.sha1 == null) { branchCubeInfo.sha1 = ""; } // All changes go through here. NCubeInfoDto headCubeInfo = headMap.get(branchCubeInfo.name); long infoRev = (long) Converter.convert(branchCubeInfo.revision, long.class); if (headCubeInfo == null) { // No matching head cube, CREATE case if (infoRev >= 0) { // Only create if the cube in the branch is active (revision number not // negative) dtosToUpdate.add(branchCubeInfo); } } else if (StringUtilities.equalsIgnoreCase( branchCubeInfo.headSha1, headCubeInfo .sha1)) { // HEAD cube has not changed (at least in terms of SHA-1 it could have it's // revision sign changed) if (StringUtilities.equalsIgnoreCase( branchCubeInfo.sha1, branchCubeInfo .headSha1)) { // Cubes are same, but active status could be opposite (delete or // restore case) long headRev = (long) Converter.convert(headCubeInfo.revision, long.class); if ((infoRev < 0) != (headRev < 0)) { dtosToUpdate.add(branchCubeInfo); } } else { // Regular update case (branch updated cube that was not touched in HEAD) dtosToUpdate.add(branchCubeInfo); } } else if (StringUtilities.equalsIgnoreCase( branchCubeInfo.sha1, headCubeInfo .sha1)) { // Branch headSha1 does not match HEAD sha1, but it's SHA-1 matches the HEAD // SHA-1. // This means that the branch cube and HEAD cube are identical, but the HEAD was // different when the branch was created. dtosToUpdate.add(branchCubeInfo); } else { String msg; if (branchCubeInfo.headSha1 == null) { msg = ". A cube with the same name was added to HEAD since your branch was created."; } else { msg = ". The cube changed since your last update branch."; } String message = "Conflict merging " + branchCubeInfo.name + msg; NCube mergedCube = checkForConflicts(appId, errors, message, branchCubeInfo, headCubeInfo, false); if (mergedCube != null) { NCubeInfoDto mergedDto = getPersister().commitMergedCubeToHead(appId, mergedCube, username); dtosMerged.add(mergedDto); } } } if (!errors.isEmpty()) { throw new BranchMergeException( errors.size() + " merge conflict(s) committing branch. Update your branch and retry commit.", errors); } List<NCubeInfoDto> committedCubes = new ArrayList<>(dtosToUpdate.size()); Object[] ids = new Object[dtosToUpdate.size()]; int i = 0; for (NCubeInfoDto dto : dtosToUpdate) { ids[i++] = dto.id; } committedCubes.addAll(getPersister().commitCubes(appId, ids, username)); committedCubes.addAll(dtosMerged); clearCache(appId); clearCache(headAppId); broadcast(appId); return committedCubes; }
/** * Update a branch from the HEAD. Changes from the HEAD are merged into the supplied branch. If * the merge cannot be done perfectly, an exception is thrown indicating the cubes that are in * conflict. */ public static Map<String, Object> updateBranch(ApplicationID appId, String username) { validateAppId(appId); appId.validateBranchIsNotHead(); appId.validateStatusIsNotRelease(); ApplicationID headAppId = appId.asHead(); Map<String, Object> options = new HashMap<>(); options.put(SEARCH_ACTIVE_RECORDS_ONLY, false); List<NCubeInfoDto> records = search(appId, null, null, options); Map<String, NCubeInfoDto> branchRecordMap = new CaseInsensitiveMap<>(); for (NCubeInfoDto info : records) { branchRecordMap.put(info.name, info); } List<NCubeInfoDto> updates = new ArrayList<>(); List<NCubeInfoDto> dtosMerged = new ArrayList<>(); Map<String, Map> conflicts = new CaseInsensitiveMap<>(); List<NCubeInfoDto> headRecords = search(headAppId, null, null, options); for (NCubeInfoDto head : headRecords) { NCubeInfoDto info = branchRecordMap.get(head.name); if (info == null) { // HEAD has cube that branch does not have updates.add(head); continue; } long infoRev = (long) Converter.convert(info.revision, long.class); long headRev = (long) Converter.convert(head.revision, long.class); boolean activeStatusMatches = (infoRev < 0) == (headRev < 0); // Did branch change? if (!info.isChanged()) { // No change on branch if (!activeStatusMatches || !StringUtilities.equalsIgnoreCase( info.headSha1, head.sha1)) { // 1. The active/deleted statuses don't match, or // 2. HEAD has different SHA1 but branch cube did not change, safe to update branch (fast // forward) // In both cases, the cube was marked NOT changed in the branch, so safe to update. updates.add(head); } } else if (StringUtilities.equalsIgnoreCase( info.sha1, head.sha1)) { // If branch is 'changed' but has same SHA-1 as head, then see if branch // needs Fast-Forward if (!StringUtilities.equalsIgnoreCase(info.headSha1, head.sha1)) { // Fast-Forward branch // Update HEAD SHA-1 on branch directly (no need to insert) getPersister() .updateBranchCubeHeadSha1((Long) Converter.convert(info.id, Long.class), head.sha1); } } else { if (!StringUtilities.equalsIgnoreCase( info.headSha1, head.sha1)) { // Cube is different than HEAD, AND it is not based on same HEAD cube, but // it could be merge-able. String message = "Cube was changed in both branch and HEAD"; NCube cube = checkForConflicts(appId, conflicts, message, info, head, true); if (cube != null) { NCubeInfoDto mergedDto = getPersister().commitMergedCubeToBranch(appId, cube, head.sha1, username); dtosMerged.add(mergedDto); } } } } List<NCubeInfoDto> finalUpdates = new ArrayList<>(updates.size()); Object[] ids = new Object[updates.size()]; int i = 0; for (NCubeInfoDto dto : updates) { ids[i++] = dto.id; } finalUpdates.addAll(getPersister().pullToBranch(appId, ids, username)); clearCache(appId); Map<String, Object> ret = new LinkedHashMap<>(); ret.put(BRANCH_UPDATES, finalUpdates); ret.put(BRANCH_MERGES, dtosMerged); ret.put(BRANCH_CONFLICTS, conflicts); return ret; }