Datasets:
jitx
/
Methods2Test_java_unit_test_code

Dataset card Data Studio Files Community
target
stringlengths
20
113k
src_fm
stringlengths
11
86.3k
src_fm_fc
stringlengths
21
86.4k
src_fm_fc_co
stringlengths
30
86.4k
src_fm_fc_ms
stringlengths
42
86.8k
src_fm_fc_ms_ff
stringlengths
43
86.8k
@Test public void testCentralWithProfiles() throws Exception { SettingsBuilder settingsBuilder = new DefaultSettingsBuilderFactory().newInstance(); SettingsBuildingRequest settingsRequest = new DefaultSettingsBuildingRequest(); settingsRequest.setUserSettingsFile(new File("src/test/resources/profiles/settings.xml")); Settings settings = settingsBuilder.build(settingsRequest).getEffectiveSettings(); MavenContainer container = new MavenContainer(); List<RemoteRepository> remoteRepositories = MavenRepositories.getRemoteRepositories(container, settings); Assert.assertEquals(2, remoteRepositories.size()); Assert.assertEquals("test-repository", remoteRepositories.get(1).getId()); List<RemoteRepository> centralRepos = remoteRepositories.stream().filter(repo -> repo.getId().equals("central")).collect(Collectors.toList()); Assert.assertEquals(1, centralRepos.size()); Assert.assertEquals(MavenRepositories.MAVEN_CENTRAL_REPO, centralRepos.get(0).getUrl()); }
public static List<RemoteRepository> getRemoteRepositories(MavenContainer container, Settings settings) { Set<RemoteRepository> remoteRepos = new HashSet<>(); remoteRepos.addAll(container.getEnabledRepositoriesFromProfile(settings)); String centralRepoURL = getCentralMirrorURL(settings).orElse(MAVEN_CENTRAL_REPO); remoteRepos.add(convertToMavenRepo("central", centralRepoURL, settings)); return new ArrayList<>(remoteRepos); }
MavenRepositories { public static List<RemoteRepository> getRemoteRepositories(MavenContainer container, Settings settings) { Set<RemoteRepository> remoteRepos = new HashSet<>(); remoteRepos.addAll(container.getEnabledRepositoriesFromProfile(settings)); String centralRepoURL = getCentralMirrorURL(settings).orElse(MAVEN_CENTRAL_REPO); remoteRepos.add(convertToMavenRepo("central", centralRepoURL, settings)); return new ArrayList<>(remoteRepos); } }
MavenRepositories { public static List<RemoteRepository> getRemoteRepositories(MavenContainer container, Settings settings) { Set<RemoteRepository> remoteRepos = new HashSet<>(); remoteRepos.addAll(container.getEnabledRepositoriesFromProfile(settings)); String centralRepoURL = getCentralMirrorURL(settings).orElse(MAVEN_CENTRAL_REPO); remoteRepos.add(convertToMavenRepo("central", centralRepoURL, settings)); return new ArrayList<>(remoteRepos); } }
MavenRepositories { public static List<RemoteRepository> getRemoteRepositories(MavenContainer container, Settings settings) { Set<RemoteRepository> remoteRepos = new HashSet<>(); remoteRepos.addAll(container.getEnabledRepositoriesFromProfile(settings)); String centralRepoURL = getCentralMirrorURL(settings).orElse(MAVEN_CENTRAL_REPO); remoteRepos.add(convertToMavenRepo("central", centralRepoURL, settings)); return new ArrayList<>(remoteRepos); } static List<RemoteRepository> getRemoteRepositories(MavenContainer container, Settings settings); }
MavenRepositories { public static List<RemoteRepository> getRemoteRepositories(MavenContainer container, Settings settings) { Set<RemoteRepository> remoteRepos = new HashSet<>(); remoteRepos.addAll(container.getEnabledRepositoriesFromProfile(settings)); String centralRepoURL = getCentralMirrorURL(settings).orElse(MAVEN_CENTRAL_REPO); remoteRepos.add(convertToMavenRepo("central", centralRepoURL, settings)); return new ArrayList<>(remoteRepos); } static List<RemoteRepository> getRemoteRepositories(MavenContainer container, Settings settings); }
@Test public void testSingleValue() { String[] data = new String[] { "a" }; int index = 0; String[] result = Arrays.removeElementAtIndex(data, index); Assert.assertEquals(1, data.length); Assert.assertEquals(0, result.length); }
public static <ELEMENTTYPE> ELEMENTTYPE[] removeElementAtIndex(ELEMENTTYPE[] array, int index) { Assert.isTrue(array.length > 0, "Cannot remove an element from an already empty array."); ELEMENTTYPE[] result = java.util.Arrays.copyOf(array, array.length - 1); if (result.length > 0 && array.length + 1 != index && index != result.length) System.arraycopy(array, index + 1, result, index, array.length - (array.length - index)); return result; }
Arrays { public static <ELEMENTTYPE> ELEMENTTYPE[] removeElementAtIndex(ELEMENTTYPE[] array, int index) { Assert.isTrue(array.length > 0, "Cannot remove an element from an already empty array."); ELEMENTTYPE[] result = java.util.Arrays.copyOf(array, array.length - 1); if (result.length > 0 && array.length + 1 != index && index != result.length) System.arraycopy(array, index + 1, result, index, array.length - (array.length - index)); return result; } }
Arrays { public static <ELEMENTTYPE> ELEMENTTYPE[] removeElementAtIndex(ELEMENTTYPE[] array, int index) { Assert.isTrue(array.length > 0, "Cannot remove an element from an already empty array."); ELEMENTTYPE[] result = java.util.Arrays.copyOf(array, array.length - 1); if (result.length > 0 && array.length + 1 != index && index != result.length) System.arraycopy(array, index + 1, result, index, array.length - (array.length - index)); return result; } }
Arrays { public static <ELEMENTTYPE> ELEMENTTYPE[] removeElementAtIndex(ELEMENTTYPE[] array, int index) { Assert.isTrue(array.length > 0, "Cannot remove an element from an already empty array."); ELEMENTTYPE[] result = java.util.Arrays.copyOf(array, array.length - 1); if (result.length > 0 && array.length + 1 != index && index != result.length) System.arraycopy(array, index + 1, result, index, array.length - (array.length - index)); return result; } @SafeVarargs static ELEMENTTYPE[] append(ELEMENTTYPE[] array, ELEMENTTYPE... elements); @SafeVarargs static ELEMENTTYPE[] prepend(ELEMENTTYPE[] array, ELEMENTTYPE... elements); static ELEMENTTYPE[] copy(ELEMENTTYPE[] source, ELEMENTTYPE[] target); static ELEMENTTYPE[] shiftLeft(ELEMENTTYPE[] source, ELEMENTTYPE[] target); static boolean contains(ELEMENTTYPE[] array, ELEMENTTYPE value); static int indexOf(ELEMENTTYPE[] array, ELEMENTTYPE value); static ELEMENTTYPE[] removeElementAtIndex(ELEMENTTYPE[] array, int index); }
Arrays { public static <ELEMENTTYPE> ELEMENTTYPE[] removeElementAtIndex(ELEMENTTYPE[] array, int index) { Assert.isTrue(array.length > 0, "Cannot remove an element from an already empty array."); ELEMENTTYPE[] result = java.util.Arrays.copyOf(array, array.length - 1); if (result.length > 0 && array.length + 1 != index && index != result.length) System.arraycopy(array, index + 1, result, index, array.length - (array.length - index)); return result; } @SafeVarargs static ELEMENTTYPE[] append(ELEMENTTYPE[] array, ELEMENTTYPE... elements); @SafeVarargs static ELEMENTTYPE[] prepend(ELEMENTTYPE[] array, ELEMENTTYPE... elements); static ELEMENTTYPE[] copy(ELEMENTTYPE[] source, ELEMENTTYPE[] target); static ELEMENTTYPE[] shiftLeft(ELEMENTTYPE[] source, ELEMENTTYPE[] target); static boolean contains(ELEMENTTYPE[] array, ELEMENTTYPE value); static int indexOf(ELEMENTTYPE[] array, ELEMENTTYPE value); static ELEMENTTYPE[] removeElementAtIndex(ELEMENTTYPE[] array, int index); }
@Test public void testRemoveElementAtIndex() { String[] data = new String[] { "a", "b", "c", "d", "e" }; int index = 2; String[] result = Arrays.removeElementAtIndex(data, index); Assert.assertEquals(data[0], result[0]); Assert.assertEquals(data[1], result[1]); Assert.assertEquals(data[3], result[2]); Assert.assertEquals(data[4], result[3]); }
public static <ELEMENTTYPE> ELEMENTTYPE[] removeElementAtIndex(ELEMENTTYPE[] array, int index) { Assert.isTrue(array.length > 0, "Cannot remove an element from an already empty array."); ELEMENTTYPE[] result = java.util.Arrays.copyOf(array, array.length - 1); if (result.length > 0 && array.length + 1 != index && index != result.length) System.arraycopy(array, index + 1, result, index, array.length - (array.length - index)); return result; }
Arrays { public static <ELEMENTTYPE> ELEMENTTYPE[] removeElementAtIndex(ELEMENTTYPE[] array, int index) { Assert.isTrue(array.length > 0, "Cannot remove an element from an already empty array."); ELEMENTTYPE[] result = java.util.Arrays.copyOf(array, array.length - 1); if (result.length > 0 && array.length + 1 != index && index != result.length) System.arraycopy(array, index + 1, result, index, array.length - (array.length - index)); return result; } }
Arrays { public static <ELEMENTTYPE> ELEMENTTYPE[] removeElementAtIndex(ELEMENTTYPE[] array, int index) { Assert.isTrue(array.length > 0, "Cannot remove an element from an already empty array."); ELEMENTTYPE[] result = java.util.Arrays.copyOf(array, array.length - 1); if (result.length > 0 && array.length + 1 != index && index != result.length) System.arraycopy(array, index + 1, result, index, array.length - (array.length - index)); return result; } }
Arrays { public static <ELEMENTTYPE> ELEMENTTYPE[] removeElementAtIndex(ELEMENTTYPE[] array, int index) { Assert.isTrue(array.length > 0, "Cannot remove an element from an already empty array."); ELEMENTTYPE[] result = java.util.Arrays.copyOf(array, array.length - 1); if (result.length > 0 && array.length + 1 != index && index != result.length) System.arraycopy(array, index + 1, result, index, array.length - (array.length - index)); return result; } @SafeVarargs static ELEMENTTYPE[] append(ELEMENTTYPE[] array, ELEMENTTYPE... elements); @SafeVarargs static ELEMENTTYPE[] prepend(ELEMENTTYPE[] array, ELEMENTTYPE... elements); static ELEMENTTYPE[] copy(ELEMENTTYPE[] source, ELEMENTTYPE[] target); static ELEMENTTYPE[] shiftLeft(ELEMENTTYPE[] source, ELEMENTTYPE[] target); static boolean contains(ELEMENTTYPE[] array, ELEMENTTYPE value); static int indexOf(ELEMENTTYPE[] array, ELEMENTTYPE value); static ELEMENTTYPE[] removeElementAtIndex(ELEMENTTYPE[] array, int index); }
Arrays { public static <ELEMENTTYPE> ELEMENTTYPE[] removeElementAtIndex(ELEMENTTYPE[] array, int index) { Assert.isTrue(array.length > 0, "Cannot remove an element from an already empty array."); ELEMENTTYPE[] result = java.util.Arrays.copyOf(array, array.length - 1); if (result.length > 0 && array.length + 1 != index && index != result.length) System.arraycopy(array, index + 1, result, index, array.length - (array.length - index)); return result; } @SafeVarargs static ELEMENTTYPE[] append(ELEMENTTYPE[] array, ELEMENTTYPE... elements); @SafeVarargs static ELEMENTTYPE[] prepend(ELEMENTTYPE[] array, ELEMENTTYPE... elements); static ELEMENTTYPE[] copy(ELEMENTTYPE[] source, ELEMENTTYPE[] target); static ELEMENTTYPE[] shiftLeft(ELEMENTTYPE[] source, ELEMENTTYPE[] target); static boolean contains(ELEMENTTYPE[] array, ELEMENTTYPE value); static int indexOf(ELEMENTTYPE[] array, ELEMENTTYPE value); static ELEMENTTYPE[] removeElementAtIndex(ELEMENTTYPE[] array, int index); }
@Test public void testRemoveElementAtLastIndex() { String[] data = new String[] { "a", "b", "c", "d", "e" }; int index = 4; String[] result = Arrays.removeElementAtIndex(data, index); Assert.assertEquals(data[0], result[0]); Assert.assertEquals(data[1], result[1]); Assert.assertEquals(data[2], result[2]); Assert.assertEquals(data[3], result[3]); Assert.assertEquals(4, result.length); }
public static <ELEMENTTYPE> ELEMENTTYPE[] removeElementAtIndex(ELEMENTTYPE[] array, int index) { Assert.isTrue(array.length > 0, "Cannot remove an element from an already empty array."); ELEMENTTYPE[] result = java.util.Arrays.copyOf(array, array.length - 1); if (result.length > 0 && array.length + 1 != index && index != result.length) System.arraycopy(array, index + 1, result, index, array.length - (array.length - index)); return result; }
Arrays { public static <ELEMENTTYPE> ELEMENTTYPE[] removeElementAtIndex(ELEMENTTYPE[] array, int index) { Assert.isTrue(array.length > 0, "Cannot remove an element from an already empty array."); ELEMENTTYPE[] result = java.util.Arrays.copyOf(array, array.length - 1); if (result.length > 0 && array.length + 1 != index && index != result.length) System.arraycopy(array, index + 1, result, index, array.length - (array.length - index)); return result; } }
Arrays { public static <ELEMENTTYPE> ELEMENTTYPE[] removeElementAtIndex(ELEMENTTYPE[] array, int index) { Assert.isTrue(array.length > 0, "Cannot remove an element from an already empty array."); ELEMENTTYPE[] result = java.util.Arrays.copyOf(array, array.length - 1); if (result.length > 0 && array.length + 1 != index && index != result.length) System.arraycopy(array, index + 1, result, index, array.length - (array.length - index)); return result; } }
Arrays { public static <ELEMENTTYPE> ELEMENTTYPE[] removeElementAtIndex(ELEMENTTYPE[] array, int index) { Assert.isTrue(array.length > 0, "Cannot remove an element from an already empty array."); ELEMENTTYPE[] result = java.util.Arrays.copyOf(array, array.length - 1); if (result.length > 0 && array.length + 1 != index && index != result.length) System.arraycopy(array, index + 1, result, index, array.length - (array.length - index)); return result; } @SafeVarargs static ELEMENTTYPE[] append(ELEMENTTYPE[] array, ELEMENTTYPE... elements); @SafeVarargs static ELEMENTTYPE[] prepend(ELEMENTTYPE[] array, ELEMENTTYPE... elements); static ELEMENTTYPE[] copy(ELEMENTTYPE[] source, ELEMENTTYPE[] target); static ELEMENTTYPE[] shiftLeft(ELEMENTTYPE[] source, ELEMENTTYPE[] target); static boolean contains(ELEMENTTYPE[] array, ELEMENTTYPE value); static int indexOf(ELEMENTTYPE[] array, ELEMENTTYPE value); static ELEMENTTYPE[] removeElementAtIndex(ELEMENTTYPE[] array, int index); }
Arrays { public static <ELEMENTTYPE> ELEMENTTYPE[] removeElementAtIndex(ELEMENTTYPE[] array, int index) { Assert.isTrue(array.length > 0, "Cannot remove an element from an already empty array."); ELEMENTTYPE[] result = java.util.Arrays.copyOf(array, array.length - 1); if (result.length > 0 && array.length + 1 != index && index != result.length) System.arraycopy(array, index + 1, result, index, array.length - (array.length - index)); return result; } @SafeVarargs static ELEMENTTYPE[] append(ELEMENTTYPE[] array, ELEMENTTYPE... elements); @SafeVarargs static ELEMENTTYPE[] prepend(ELEMENTTYPE[] array, ELEMENTTYPE... elements); static ELEMENTTYPE[] copy(ELEMENTTYPE[] source, ELEMENTTYPE[] target); static ELEMENTTYPE[] shiftLeft(ELEMENTTYPE[] source, ELEMENTTYPE[] target); static boolean contains(ELEMENTTYPE[] array, ELEMENTTYPE value); static int indexOf(ELEMENTTYPE[] array, ELEMENTTYPE value); static ELEMENTTYPE[] removeElementAtIndex(ELEMENTTYPE[] array, int index); }
@Test public void testExceptionHierarchyFindsThrowable() throws Exception { Class<?>[] hierarchy = ProxyTypeInspector.getCompatibleClassHierarchy(getClass().getClassLoader(), MockException.class); Assert.assertEquals(2, hierarchy.length); Assert.assertEquals(Exception.class, hierarchy[0]); Assert.assertEquals(Serializable.class, hierarchy[1]); }
public static Class<?>[] getCompatibleClassHierarchy(ClassLoader loader, Class<?> origin) { Set<Class<?>> hierarchy = new LinkedHashSet<Class<?>>(); Class<?> baseClass = origin; while (baseClass != null && Modifier.isFinal(baseClass.getModifiers())) { baseClass = baseClass.getSuperclass(); } while (baseClass != null && !baseClass.isInterface() && baseClass.getSuperclass() != null && !baseClass.getSuperclass().equals(Object.class) && !Proxies.isInstantiable(baseClass)) { baseClass = baseClass.getSuperclass(); } if (baseClass != null && ClassLoaders.containsClass(loader, baseClass.getName()) && !Object.class.equals(baseClass) && (Proxies.isInstantiable(baseClass) || baseClass.isInterface())) { hierarchy.add(ClassLoaders.loadClass(loader, baseClass)); } baseClass = origin; while (baseClass != null) { for (Class<?> type : baseClass.getInterfaces()) { if (ClassLoaders.containsClass(loader, type.getName())) hierarchy.add(ClassLoaders.loadClass(loader, type)); else hierarchy.addAll(java.util.Arrays.asList(getCompatibleClassHierarchy(loader, type))); } baseClass = baseClass.getSuperclass(); } return hierarchy.toArray(new Class<?>[hierarchy.size()]); }
ProxyTypeInspector { public static Class<?>[] getCompatibleClassHierarchy(ClassLoader loader, Class<?> origin) { Set<Class<?>> hierarchy = new LinkedHashSet<Class<?>>(); Class<?> baseClass = origin; while (baseClass != null && Modifier.isFinal(baseClass.getModifiers())) { baseClass = baseClass.getSuperclass(); } while (baseClass != null && !baseClass.isInterface() && baseClass.getSuperclass() != null && !baseClass.getSuperclass().equals(Object.class) && !Proxies.isInstantiable(baseClass)) { baseClass = baseClass.getSuperclass(); } if (baseClass != null && ClassLoaders.containsClass(loader, baseClass.getName()) && !Object.class.equals(baseClass) && (Proxies.isInstantiable(baseClass) || baseClass.isInterface())) { hierarchy.add(ClassLoaders.loadClass(loader, baseClass)); } baseClass = origin; while (baseClass != null) { for (Class<?> type : baseClass.getInterfaces()) { if (ClassLoaders.containsClass(loader, type.getName())) hierarchy.add(ClassLoaders.loadClass(loader, type)); else hierarchy.addAll(java.util.Arrays.asList(getCompatibleClassHierarchy(loader, type))); } baseClass = baseClass.getSuperclass(); } return hierarchy.toArray(new Class<?>[hierarchy.size()]); } }
ProxyTypeInspector { public static Class<?>[] getCompatibleClassHierarchy(ClassLoader loader, Class<?> origin) { Set<Class<?>> hierarchy = new LinkedHashSet<Class<?>>(); Class<?> baseClass = origin; while (baseClass != null && Modifier.isFinal(baseClass.getModifiers())) { baseClass = baseClass.getSuperclass(); } while (baseClass != null && !baseClass.isInterface() && baseClass.getSuperclass() != null && !baseClass.getSuperclass().equals(Object.class) && !Proxies.isInstantiable(baseClass)) { baseClass = baseClass.getSuperclass(); } if (baseClass != null && ClassLoaders.containsClass(loader, baseClass.getName()) && !Object.class.equals(baseClass) && (Proxies.isInstantiable(baseClass) || baseClass.isInterface())) { hierarchy.add(ClassLoaders.loadClass(loader, baseClass)); } baseClass = origin; while (baseClass != null) { for (Class<?> type : baseClass.getInterfaces()) { if (ClassLoaders.containsClass(loader, type.getName())) hierarchy.add(ClassLoaders.loadClass(loader, type)); else hierarchy.addAll(java.util.Arrays.asList(getCompatibleClassHierarchy(loader, type))); } baseClass = baseClass.getSuperclass(); } return hierarchy.toArray(new Class<?>[hierarchy.size()]); } }
ProxyTypeInspector { public static Class<?>[] getCompatibleClassHierarchy(ClassLoader loader, Class<?> origin) { Set<Class<?>> hierarchy = new LinkedHashSet<Class<?>>(); Class<?> baseClass = origin; while (baseClass != null && Modifier.isFinal(baseClass.getModifiers())) { baseClass = baseClass.getSuperclass(); } while (baseClass != null && !baseClass.isInterface() && baseClass.getSuperclass() != null && !baseClass.getSuperclass().equals(Object.class) && !Proxies.isInstantiable(baseClass)) { baseClass = baseClass.getSuperclass(); } if (baseClass != null && ClassLoaders.containsClass(loader, baseClass.getName()) && !Object.class.equals(baseClass) && (Proxies.isInstantiable(baseClass) || baseClass.isInterface())) { hierarchy.add(ClassLoaders.loadClass(loader, baseClass)); } baseClass = origin; while (baseClass != null) { for (Class<?> type : baseClass.getInterfaces()) { if (ClassLoaders.containsClass(loader, type.getName())) hierarchy.add(ClassLoaders.loadClass(loader, type)); else hierarchy.addAll(java.util.Arrays.asList(getCompatibleClassHierarchy(loader, type))); } baseClass = baseClass.getSuperclass(); } return hierarchy.toArray(new Class<?>[hierarchy.size()]); } static Class<?>[] getCompatibleClassHierarchy(ClassLoader loader, Class<?> origin); static boolean superclassHierarchyContains(Class<?> haystack, Class<?> needle); }
ProxyTypeInspector { public static Class<?>[] getCompatibleClassHierarchy(ClassLoader loader, Class<?> origin) { Set<Class<?>> hierarchy = new LinkedHashSet<Class<?>>(); Class<?> baseClass = origin; while (baseClass != null && Modifier.isFinal(baseClass.getModifiers())) { baseClass = baseClass.getSuperclass(); } while (baseClass != null && !baseClass.isInterface() && baseClass.getSuperclass() != null && !baseClass.getSuperclass().equals(Object.class) && !Proxies.isInstantiable(baseClass)) { baseClass = baseClass.getSuperclass(); } if (baseClass != null && ClassLoaders.containsClass(loader, baseClass.getName()) && !Object.class.equals(baseClass) && (Proxies.isInstantiable(baseClass) || baseClass.isInterface())) { hierarchy.add(ClassLoaders.loadClass(loader, baseClass)); } baseClass = origin; while (baseClass != null) { for (Class<?> type : baseClass.getInterfaces()) { if (ClassLoaders.containsClass(loader, type.getName())) hierarchy.add(ClassLoaders.loadClass(loader, type)); else hierarchy.addAll(java.util.Arrays.asList(getCompatibleClassHierarchy(loader, type))); } baseClass = baseClass.getSuperclass(); } return hierarchy.toArray(new Class<?>[hierarchy.size()]); } static Class<?>[] getCompatibleClassHierarchy(ClassLoader loader, Class<?> origin); static boolean superclassHierarchyContains(Class<?> haystack, Class<?> needle); }
@Test public void testClassWithInstantiableBaseClass() throws Exception { Class<?>[] hierarchy = ProxyTypeInspector.getCompatibleClassHierarchy(getClass().getClassLoader(), MockExtendsImplementsExternal.class); Assert.assertEquals(MockBaseClassExternal.class, hierarchy[0]); Assert.assertEquals(MockInterface.class, hierarchy[1]); Assert.assertEquals(MockNestedInterface.class, hierarchy[2]); }
public static Class<?>[] getCompatibleClassHierarchy(ClassLoader loader, Class<?> origin) { Set<Class<?>> hierarchy = new LinkedHashSet<Class<?>>(); Class<?> baseClass = origin; while (baseClass != null && Modifier.isFinal(baseClass.getModifiers())) { baseClass = baseClass.getSuperclass(); } while (baseClass != null && !baseClass.isInterface() && baseClass.getSuperclass() != null && !baseClass.getSuperclass().equals(Object.class) && !Proxies.isInstantiable(baseClass)) { baseClass = baseClass.getSuperclass(); } if (baseClass != null && ClassLoaders.containsClass(loader, baseClass.getName()) && !Object.class.equals(baseClass) && (Proxies.isInstantiable(baseClass) || baseClass.isInterface())) { hierarchy.add(ClassLoaders.loadClass(loader, baseClass)); } baseClass = origin; while (baseClass != null) { for (Class<?> type : baseClass.getInterfaces()) { if (ClassLoaders.containsClass(loader, type.getName())) hierarchy.add(ClassLoaders.loadClass(loader, type)); else hierarchy.addAll(java.util.Arrays.asList(getCompatibleClassHierarchy(loader, type))); } baseClass = baseClass.getSuperclass(); } return hierarchy.toArray(new Class<?>[hierarchy.size()]); }
ProxyTypeInspector { public static Class<?>[] getCompatibleClassHierarchy(ClassLoader loader, Class<?> origin) { Set<Class<?>> hierarchy = new LinkedHashSet<Class<?>>(); Class<?> baseClass = origin; while (baseClass != null && Modifier.isFinal(baseClass.getModifiers())) { baseClass = baseClass.getSuperclass(); } while (baseClass != null && !baseClass.isInterface() && baseClass.getSuperclass() != null && !baseClass.getSuperclass().equals(Object.class) && !Proxies.isInstantiable(baseClass)) { baseClass = baseClass.getSuperclass(); } if (baseClass != null && ClassLoaders.containsClass(loader, baseClass.getName()) && !Object.class.equals(baseClass) && (Proxies.isInstantiable(baseClass) || baseClass.isInterface())) { hierarchy.add(ClassLoaders.loadClass(loader, baseClass)); } baseClass = origin; while (baseClass != null) { for (Class<?> type : baseClass.getInterfaces()) { if (ClassLoaders.containsClass(loader, type.getName())) hierarchy.add(ClassLoaders.loadClass(loader, type)); else hierarchy.addAll(java.util.Arrays.asList(getCompatibleClassHierarchy(loader, type))); } baseClass = baseClass.getSuperclass(); } return hierarchy.toArray(new Class<?>[hierarchy.size()]); } }
ProxyTypeInspector { public static Class<?>[] getCompatibleClassHierarchy(ClassLoader loader, Class<?> origin) { Set<Class<?>> hierarchy = new LinkedHashSet<Class<?>>(); Class<?> baseClass = origin; while (baseClass != null && Modifier.isFinal(baseClass.getModifiers())) { baseClass = baseClass.getSuperclass(); } while (baseClass != null && !baseClass.isInterface() && baseClass.getSuperclass() != null && !baseClass.getSuperclass().equals(Object.class) && !Proxies.isInstantiable(baseClass)) { baseClass = baseClass.getSuperclass(); } if (baseClass != null && ClassLoaders.containsClass(loader, baseClass.getName()) && !Object.class.equals(baseClass) && (Proxies.isInstantiable(baseClass) || baseClass.isInterface())) { hierarchy.add(ClassLoaders.loadClass(loader, baseClass)); } baseClass = origin; while (baseClass != null) { for (Class<?> type : baseClass.getInterfaces()) { if (ClassLoaders.containsClass(loader, type.getName())) hierarchy.add(ClassLoaders.loadClass(loader, type)); else hierarchy.addAll(java.util.Arrays.asList(getCompatibleClassHierarchy(loader, type))); } baseClass = baseClass.getSuperclass(); } return hierarchy.toArray(new Class<?>[hierarchy.size()]); } }
ProxyTypeInspector { public static Class<?>[] getCompatibleClassHierarchy(ClassLoader loader, Class<?> origin) { Set<Class<?>> hierarchy = new LinkedHashSet<Class<?>>(); Class<?> baseClass = origin; while (baseClass != null && Modifier.isFinal(baseClass.getModifiers())) { baseClass = baseClass.getSuperclass(); } while (baseClass != null && !baseClass.isInterface() && baseClass.getSuperclass() != null && !baseClass.getSuperclass().equals(Object.class) && !Proxies.isInstantiable(baseClass)) { baseClass = baseClass.getSuperclass(); } if (baseClass != null && ClassLoaders.containsClass(loader, baseClass.getName()) && !Object.class.equals(baseClass) && (Proxies.isInstantiable(baseClass) || baseClass.isInterface())) { hierarchy.add(ClassLoaders.loadClass(loader, baseClass)); } baseClass = origin; while (baseClass != null) { for (Class<?> type : baseClass.getInterfaces()) { if (ClassLoaders.containsClass(loader, type.getName())) hierarchy.add(ClassLoaders.loadClass(loader, type)); else hierarchy.addAll(java.util.Arrays.asList(getCompatibleClassHierarchy(loader, type))); } baseClass = baseClass.getSuperclass(); } return hierarchy.toArray(new Class<?>[hierarchy.size()]); } static Class<?>[] getCompatibleClassHierarchy(ClassLoader loader, Class<?> origin); static boolean superclassHierarchyContains(Class<?> haystack, Class<?> needle); }
ProxyTypeInspector { public static Class<?>[] getCompatibleClassHierarchy(ClassLoader loader, Class<?> origin) { Set<Class<?>> hierarchy = new LinkedHashSet<Class<?>>(); Class<?> baseClass = origin; while (baseClass != null && Modifier.isFinal(baseClass.getModifiers())) { baseClass = baseClass.getSuperclass(); } while (baseClass != null && !baseClass.isInterface() && baseClass.getSuperclass() != null && !baseClass.getSuperclass().equals(Object.class) && !Proxies.isInstantiable(baseClass)) { baseClass = baseClass.getSuperclass(); } if (baseClass != null && ClassLoaders.containsClass(loader, baseClass.getName()) && !Object.class.equals(baseClass) && (Proxies.isInstantiable(baseClass) || baseClass.isInterface())) { hierarchy.add(ClassLoaders.loadClass(loader, baseClass)); } baseClass = origin; while (baseClass != null) { for (Class<?> type : baseClass.getInterfaces()) { if (ClassLoaders.containsClass(loader, type.getName())) hierarchy.add(ClassLoaders.loadClass(loader, type)); else hierarchy.addAll(java.util.Arrays.asList(getCompatibleClassHierarchy(loader, type))); } baseClass = baseClass.getSuperclass(); } return hierarchy.toArray(new Class<?>[hierarchy.size()]); } static Class<?>[] getCompatibleClassHierarchy(ClassLoader loader, Class<?> origin); static boolean superclassHierarchyContains(Class<?> haystack, Class<?> needle); }
@Test public void testInnerClassWithNonInstantiableBaseClass() throws Exception { Class<?>[] hierarchy = ProxyTypeInspector.getCompatibleClassHierarchy(getClass().getClassLoader(), MockExtendsImplementsInternal.class); Assert.assertEquals(MockInterface.class, hierarchy[0]); Assert.assertEquals(MockNestedInterface.class, hierarchy[1]); }
public static Class<?>[] getCompatibleClassHierarchy(ClassLoader loader, Class<?> origin) { Set<Class<?>> hierarchy = new LinkedHashSet<Class<?>>(); Class<?> baseClass = origin; while (baseClass != null && Modifier.isFinal(baseClass.getModifiers())) { baseClass = baseClass.getSuperclass(); } while (baseClass != null && !baseClass.isInterface() && baseClass.getSuperclass() != null && !baseClass.getSuperclass().equals(Object.class) && !Proxies.isInstantiable(baseClass)) { baseClass = baseClass.getSuperclass(); } if (baseClass != null && ClassLoaders.containsClass(loader, baseClass.getName()) && !Object.class.equals(baseClass) && (Proxies.isInstantiable(baseClass) || baseClass.isInterface())) { hierarchy.add(ClassLoaders.loadClass(loader, baseClass)); } baseClass = origin; while (baseClass != null) { for (Class<?> type : baseClass.getInterfaces()) { if (ClassLoaders.containsClass(loader, type.getName())) hierarchy.add(ClassLoaders.loadClass(loader, type)); else hierarchy.addAll(java.util.Arrays.asList(getCompatibleClassHierarchy(loader, type))); } baseClass = baseClass.getSuperclass(); } return hierarchy.toArray(new Class<?>[hierarchy.size()]); }
ProxyTypeInspector { public static Class<?>[] getCompatibleClassHierarchy(ClassLoader loader, Class<?> origin) { Set<Class<?>> hierarchy = new LinkedHashSet<Class<?>>(); Class<?> baseClass = origin; while (baseClass != null && Modifier.isFinal(baseClass.getModifiers())) { baseClass = baseClass.getSuperclass(); } while (baseClass != null && !baseClass.isInterface() && baseClass.getSuperclass() != null && !baseClass.getSuperclass().equals(Object.class) && !Proxies.isInstantiable(baseClass)) { baseClass = baseClass.getSuperclass(); } if (baseClass != null && ClassLoaders.containsClass(loader, baseClass.getName()) && !Object.class.equals(baseClass) && (Proxies.isInstantiable(baseClass) || baseClass.isInterface())) { hierarchy.add(ClassLoaders.loadClass(loader, baseClass)); } baseClass = origin; while (baseClass != null) { for (Class<?> type : baseClass.getInterfaces()) { if (ClassLoaders.containsClass(loader, type.getName())) hierarchy.add(ClassLoaders.loadClass(loader, type)); else hierarchy.addAll(java.util.Arrays.asList(getCompatibleClassHierarchy(loader, type))); } baseClass = baseClass.getSuperclass(); } return hierarchy.toArray(new Class<?>[hierarchy.size()]); } }
ProxyTypeInspector { public static Class<?>[] getCompatibleClassHierarchy(ClassLoader loader, Class<?> origin) { Set<Class<?>> hierarchy = new LinkedHashSet<Class<?>>(); Class<?> baseClass = origin; while (baseClass != null && Modifier.isFinal(baseClass.getModifiers())) { baseClass = baseClass.getSuperclass(); } while (baseClass != null && !baseClass.isInterface() && baseClass.getSuperclass() != null && !baseClass.getSuperclass().equals(Object.class) && !Proxies.isInstantiable(baseClass)) { baseClass = baseClass.getSuperclass(); } if (baseClass != null && ClassLoaders.containsClass(loader, baseClass.getName()) && !Object.class.equals(baseClass) && (Proxies.isInstantiable(baseClass) || baseClass.isInterface())) { hierarchy.add(ClassLoaders.loadClass(loader, baseClass)); } baseClass = origin; while (baseClass != null) { for (Class<?> type : baseClass.getInterfaces()) { if (ClassLoaders.containsClass(loader, type.getName())) hierarchy.add(ClassLoaders.loadClass(loader, type)); else hierarchy.addAll(java.util.Arrays.asList(getCompatibleClassHierarchy(loader, type))); } baseClass = baseClass.getSuperclass(); } return hierarchy.toArray(new Class<?>[hierarchy.size()]); } }
ProxyTypeInspector { public static Class<?>[] getCompatibleClassHierarchy(ClassLoader loader, Class<?> origin) { Set<Class<?>> hierarchy = new LinkedHashSet<Class<?>>(); Class<?> baseClass = origin; while (baseClass != null && Modifier.isFinal(baseClass.getModifiers())) { baseClass = baseClass.getSuperclass(); } while (baseClass != null && !baseClass.isInterface() && baseClass.getSuperclass() != null && !baseClass.getSuperclass().equals(Object.class) && !Proxies.isInstantiable(baseClass)) { baseClass = baseClass.getSuperclass(); } if (baseClass != null && ClassLoaders.containsClass(loader, baseClass.getName()) && !Object.class.equals(baseClass) && (Proxies.isInstantiable(baseClass) || baseClass.isInterface())) { hierarchy.add(ClassLoaders.loadClass(loader, baseClass)); } baseClass = origin; while (baseClass != null) { for (Class<?> type : baseClass.getInterfaces()) { if (ClassLoaders.containsClass(loader, type.getName())) hierarchy.add(ClassLoaders.loadClass(loader, type)); else hierarchy.addAll(java.util.Arrays.asList(getCompatibleClassHierarchy(loader, type))); } baseClass = baseClass.getSuperclass(); } return hierarchy.toArray(new Class<?>[hierarchy.size()]); } static Class<?>[] getCompatibleClassHierarchy(ClassLoader loader, Class<?> origin); static boolean superclassHierarchyContains(Class<?> haystack, Class<?> needle); }
ProxyTypeInspector { public static Class<?>[] getCompatibleClassHierarchy(ClassLoader loader, Class<?> origin) { Set<Class<?>> hierarchy = new LinkedHashSet<Class<?>>(); Class<?> baseClass = origin; while (baseClass != null && Modifier.isFinal(baseClass.getModifiers())) { baseClass = baseClass.getSuperclass(); } while (baseClass != null && !baseClass.isInterface() && baseClass.getSuperclass() != null && !baseClass.getSuperclass().equals(Object.class) && !Proxies.isInstantiable(baseClass)) { baseClass = baseClass.getSuperclass(); } if (baseClass != null && ClassLoaders.containsClass(loader, baseClass.getName()) && !Object.class.equals(baseClass) && (Proxies.isInstantiable(baseClass) || baseClass.isInterface())) { hierarchy.add(ClassLoaders.loadClass(loader, baseClass)); } baseClass = origin; while (baseClass != null) { for (Class<?> type : baseClass.getInterfaces()) { if (ClassLoaders.containsClass(loader, type.getName())) hierarchy.add(ClassLoaders.loadClass(loader, type)); else hierarchy.addAll(java.util.Arrays.asList(getCompatibleClassHierarchy(loader, type))); } baseClass = baseClass.getSuperclass(); } return hierarchy.toArray(new Class<?>[hierarchy.size()]); } static Class<?>[] getCompatibleClassHierarchy(ClassLoader loader, Class<?> origin); static boolean superclassHierarchyContains(Class<?> haystack, Class<?> needle); }
@Test public void testCreateTempDir() { File tmpDir = OperatingSystemUtils.createTempDir(); tmpDir.deleteOnExit(); Assert.assertThat(tmpDir.isDirectory(), is(true)); }
public static File createTempDir() throws IllegalStateException { File baseDir = getTempDirectory(); try { return Files.createTempDirectory(baseDir.toPath(), "tmpdir").toFile(); } catch (IOException e) { throw new IllegalStateException("Error while creating temporary directory", e); } }
OperatingSystemUtils { public static File createTempDir() throws IllegalStateException { File baseDir = getTempDirectory(); try { return Files.createTempDirectory(baseDir.toPath(), "tmpdir").toFile(); } catch (IOException e) { throw new IllegalStateException("Error while creating temporary directory", e); } } }
OperatingSystemUtils { public static File createTempDir() throws IllegalStateException { File baseDir = getTempDirectory(); try { return Files.createTempDirectory(baseDir.toPath(), "tmpdir").toFile(); } catch (IOException e) { throw new IllegalStateException("Error while creating temporary directory", e); } } }
OperatingSystemUtils { public static File createTempDir() throws IllegalStateException { File baseDir = getTempDirectory(); try { return Files.createTempDirectory(baseDir.toPath(), "tmpdir").toFile(); } catch (IOException e) { throw new IllegalStateException("Error while creating temporary directory", e); } } static String getOsName(); static boolean isWindows(); static boolean isOSX(); static boolean isLinux(); static File getWorkingDir(); static File getForgeHomeDir(); static File getUserHomeDir(); static String getUserHomePath(); static File getUserForgeDir(); static void setPretendWindows(boolean value); static String getLineSeparator(); static String getSafeFilename(String filename); static File createTempDir(); static File getTempDirectory(); static boolean isJava8(); }
OperatingSystemUtils { public static File createTempDir() throws IllegalStateException { File baseDir = getTempDirectory(); try { return Files.createTempDirectory(baseDir.toPath(), "tmpdir").toFile(); } catch (IOException e) { throw new IllegalStateException("Error while creating temporary directory", e); } } static String getOsName(); static boolean isWindows(); static boolean isOSX(); static boolean isLinux(); static File getWorkingDir(); static File getForgeHomeDir(); static File getUserHomeDir(); static String getUserHomePath(); static File getUserForgeDir(); static void setPretendWindows(boolean value); static String getLineSeparator(); static String getSafeFilename(String filename); static File createTempDir(); static File getTempDirectory(); static boolean isJava8(); }
@Test public void testParseVersionRange() throws Exception { VersionRange range = Versions.parseVersionRange("[0,15]"); Assert.assertEquals(SingleVersion.valueOf("0"), range.getMin()); Assert.assertEquals(SingleVersion.valueOf("15"), range.getMax()); Assert.assertTrue(range.isMinInclusive()); Assert.assertTrue(range.isMaxInclusive()); }
public static VersionRange parseVersionRange(String range) throws VersionException { Assert.notNull(range, "Version range must not be null."); boolean lowerBoundInclusive = range.startsWith("["); boolean upperBoundInclusive = range.endsWith("]"); String process = range.substring(1, range.length() - 1).trim(); VersionRange result; int index = process.indexOf(","); if (index < 0) { if (!lowerBoundInclusive || !upperBoundInclusive) { throw new VersionException("Single version must be surrounded by []: " + range); } Version version = SingleVersion.valueOf(process); result = new DefaultVersionRange(version, lowerBoundInclusive, version, upperBoundInclusive); } else { String lowerBound = process.substring(0, index).trim(); String upperBound = process.substring(index + 1).trim(); if (lowerBound.equals(upperBound)) { throw new VersionException("Range cannot have identical boundaries: " + range); } Version lowerVersion = null; if (lowerBound.length() > 0) { lowerVersion = SingleVersion.valueOf(lowerBound); } Version upperVersion = null; if (upperBound.length() > 0) { upperVersion = SingleVersion.valueOf(upperBound); } if (upperVersion != null && lowerVersion != null && upperVersion.compareTo(lowerVersion) < 0) { throw new VersionException("Range defies version ordering: " + range); } result = new DefaultVersionRange(lowerVersion, lowerBoundInclusive, upperVersion, upperBoundInclusive); } return result; }
Versions { public static VersionRange parseVersionRange(String range) throws VersionException { Assert.notNull(range, "Version range must not be null."); boolean lowerBoundInclusive = range.startsWith("["); boolean upperBoundInclusive = range.endsWith("]"); String process = range.substring(1, range.length() - 1).trim(); VersionRange result; int index = process.indexOf(","); if (index < 0) { if (!lowerBoundInclusive || !upperBoundInclusive) { throw new VersionException("Single version must be surrounded by []: " + range); } Version version = SingleVersion.valueOf(process); result = new DefaultVersionRange(version, lowerBoundInclusive, version, upperBoundInclusive); } else { String lowerBound = process.substring(0, index).trim(); String upperBound = process.substring(index + 1).trim(); if (lowerBound.equals(upperBound)) { throw new VersionException("Range cannot have identical boundaries: " + range); } Version lowerVersion = null; if (lowerBound.length() > 0) { lowerVersion = SingleVersion.valueOf(lowerBound); } Version upperVersion = null; if (upperBound.length() > 0) { upperVersion = SingleVersion.valueOf(upperBound); } if (upperVersion != null && lowerVersion != null && upperVersion.compareTo(lowerVersion) < 0) { throw new VersionException("Range defies version ordering: " + range); } result = new DefaultVersionRange(lowerVersion, lowerBoundInclusive, upperVersion, upperBoundInclusive); } return result; } }
Versions { public static VersionRange parseVersionRange(String range) throws VersionException { Assert.notNull(range, "Version range must not be null."); boolean lowerBoundInclusive = range.startsWith("["); boolean upperBoundInclusive = range.endsWith("]"); String process = range.substring(1, range.length() - 1).trim(); VersionRange result; int index = process.indexOf(","); if (index < 0) { if (!lowerBoundInclusive || !upperBoundInclusive) { throw new VersionException("Single version must be surrounded by []: " + range); } Version version = SingleVersion.valueOf(process); result = new DefaultVersionRange(version, lowerBoundInclusive, version, upperBoundInclusive); } else { String lowerBound = process.substring(0, index).trim(); String upperBound = process.substring(index + 1).trim(); if (lowerBound.equals(upperBound)) { throw new VersionException("Range cannot have identical boundaries: " + range); } Version lowerVersion = null; if (lowerBound.length() > 0) { lowerVersion = SingleVersion.valueOf(lowerBound); } Version upperVersion = null; if (upperBound.length() > 0) { upperVersion = SingleVersion.valueOf(upperBound); } if (upperVersion != null && lowerVersion != null && upperVersion.compareTo(lowerVersion) < 0) { throw new VersionException("Range defies version ordering: " + range); } result = new DefaultVersionRange(lowerVersion, lowerBoundInclusive, upperVersion, upperBoundInclusive); } return result; } }
Versions { public static VersionRange parseVersionRange(String range) throws VersionException { Assert.notNull(range, "Version range must not be null."); boolean lowerBoundInclusive = range.startsWith("["); boolean upperBoundInclusive = range.endsWith("]"); String process = range.substring(1, range.length() - 1).trim(); VersionRange result; int index = process.indexOf(","); if (index < 0) { if (!lowerBoundInclusive || !upperBoundInclusive) { throw new VersionException("Single version must be surrounded by []: " + range); } Version version = SingleVersion.valueOf(process); result = new DefaultVersionRange(version, lowerBoundInclusive, version, upperBoundInclusive); } else { String lowerBound = process.substring(0, index).trim(); String upperBound = process.substring(index + 1).trim(); if (lowerBound.equals(upperBound)) { throw new VersionException("Range cannot have identical boundaries: " + range); } Version lowerVersion = null; if (lowerBound.length() > 0) { lowerVersion = SingleVersion.valueOf(lowerBound); } Version upperVersion = null; if (upperBound.length() > 0) { upperVersion = SingleVersion.valueOf(upperBound); } if (upperVersion != null && lowerVersion != null && upperVersion.compareTo(lowerVersion) < 0) { throw new VersionException("Range defies version ordering: " + range); } result = new DefaultVersionRange(lowerVersion, lowerBoundInclusive, upperVersion, upperBoundInclusive); } return result; } static boolean isApiCompatible(Version runtimeVersion, Version addonApiVersion); static VersionRange parseVersionRange(String range); static MultipleVersionRange parseMultipleVersionRange(String intersection); static VersionRange intersection(VersionRange... ranges); static VersionRange intersection(Collection<VersionRange> ranges); static boolean isSnapshot(Version version); static Version getSpecificationVersionFor(Class<?> type); static Version getImplementationVersionFor(Class<?> type); }
Versions { public static VersionRange parseVersionRange(String range) throws VersionException { Assert.notNull(range, "Version range must not be null."); boolean lowerBoundInclusive = range.startsWith("["); boolean upperBoundInclusive = range.endsWith("]"); String process = range.substring(1, range.length() - 1).trim(); VersionRange result; int index = process.indexOf(","); if (index < 0) { if (!lowerBoundInclusive || !upperBoundInclusive) { throw new VersionException("Single version must be surrounded by []: " + range); } Version version = SingleVersion.valueOf(process); result = new DefaultVersionRange(version, lowerBoundInclusive, version, upperBoundInclusive); } else { String lowerBound = process.substring(0, index).trim(); String upperBound = process.substring(index + 1).trim(); if (lowerBound.equals(upperBound)) { throw new VersionException("Range cannot have identical boundaries: " + range); } Version lowerVersion = null; if (lowerBound.length() > 0) { lowerVersion = SingleVersion.valueOf(lowerBound); } Version upperVersion = null; if (upperBound.length() > 0) { upperVersion = SingleVersion.valueOf(upperBound); } if (upperVersion != null && lowerVersion != null && upperVersion.compareTo(lowerVersion) < 0) { throw new VersionException("Range defies version ordering: " + range); } result = new DefaultVersionRange(lowerVersion, lowerBoundInclusive, upperVersion, upperBoundInclusive); } return result; } static boolean isApiCompatible(Version runtimeVersion, Version addonApiVersion); static VersionRange parseVersionRange(String range); static MultipleVersionRange parseMultipleVersionRange(String intersection); static VersionRange intersection(VersionRange... ranges); static VersionRange intersection(Collection<VersionRange> ranges); static boolean isSnapshot(Version version); static Version getSpecificationVersionFor(Class<?> type); static Version getImplementationVersionFor(Class<?> type); }
@Test public void nextCameraState() { assertEquals(CameraState.BLOCKED, stateMachine.getCameraState()); stateMachine.nextCameraState(); assertEquals(CameraState.BLACK_PICTURE, stateMachine.getCameraState()); stateMachine.nextCameraState(); assertEquals(CameraState.NEUTRAL_PICTURE, stateMachine.getCameraState()); stateMachine.nextCameraState(); assertEquals(CameraState.PIXEL_PERSONS, stateMachine.getCameraState()); stateMachine.nextCameraState(); }
public void nextCameraState() { switch (cameraState) { case BLOCKED: cameraState = CameraState.BLACK_PICTURE; jsonParser.setCameraState("softBlackPicture"); break; case BLACK_PICTURE: cameraState = CameraState.NEUTRAL_PICTURE; jsonParser.setCameraState("softNeutralPicture"); break; } }
StateMachine { public void nextCameraState() { switch (cameraState) { case BLOCKED: cameraState = CameraState.BLACK_PICTURE; jsonParser.setCameraState("softBlackPicture"); break; case BLACK_PICTURE: cameraState = CameraState.NEUTRAL_PICTURE; jsonParser.setCameraState("softNeutralPicture"); break; } } }
StateMachine { public void nextCameraState() { switch (cameraState) { case BLOCKED: cameraState = CameraState.BLACK_PICTURE; jsonParser.setCameraState("softBlackPicture"); break; case BLACK_PICTURE: cameraState = CameraState.NEUTRAL_PICTURE; jsonParser.setCameraState("softNeutralPicture"); break; } } StateMachine(); }
StateMachine { public void nextCameraState() { switch (cameraState) { case BLOCKED: cameraState = CameraState.BLACK_PICTURE; jsonParser.setCameraState("softBlackPicture"); break; case BLACK_PICTURE: cameraState = CameraState.NEUTRAL_PICTURE; jsonParser.setCameraState("softNeutralPicture"); break; } } StateMachine(); MicrophoneState getMicrophoneState(); CameraState getCameraState(); void nextMicrophoneState(); void nextCameraState(); }
StateMachine { public void nextCameraState() { switch (cameraState) { case BLOCKED: cameraState = CameraState.BLACK_PICTURE; jsonParser.setCameraState("softBlackPicture"); break; case BLACK_PICTURE: cameraState = CameraState.NEUTRAL_PICTURE; jsonParser.setCameraState("softNeutralPicture"); break; } } StateMachine(); MicrophoneState getMicrophoneState(); CameraState getCameraState(); void nextMicrophoneState(); void nextCameraState(); }
@Test public void nextMicrophoneState() { assertEquals(MicrophoneState.BLOCKED, stateMachine.getMicrophoneState()); stateMachine.nextMicrophoneState(); assertEquals(MicrophoneState.NO_SOUND, stateMachine.getMicrophoneState()); stateMachine.nextMicrophoneState(); assertEquals(MicrophoneState.NEUTRAL_SOUND, stateMachine.getMicrophoneState()); stateMachine.nextMicrophoneState(); }
public void nextMicrophoneState() { switch (getMicrophoneState()) { case BLOCKED: microphoneState = MicrophoneState.NO_SOUND; jsonParser.setMicrophoneState("softEmptyNoise"); break; case NO_SOUND: microphoneState = MicrophoneState.NEUTRAL_SOUND; jsonParser.setMicrophoneState("softSignalNoise"); break; } }
StateMachine { public void nextMicrophoneState() { switch (getMicrophoneState()) { case BLOCKED: microphoneState = MicrophoneState.NO_SOUND; jsonParser.setMicrophoneState("softEmptyNoise"); break; case NO_SOUND: microphoneState = MicrophoneState.NEUTRAL_SOUND; jsonParser.setMicrophoneState("softSignalNoise"); break; } } }
StateMachine { public void nextMicrophoneState() { switch (getMicrophoneState()) { case BLOCKED: microphoneState = MicrophoneState.NO_SOUND; jsonParser.setMicrophoneState("softEmptyNoise"); break; case NO_SOUND: microphoneState = MicrophoneState.NEUTRAL_SOUND; jsonParser.setMicrophoneState("softSignalNoise"); break; } } StateMachine(); }
StateMachine { public void nextMicrophoneState() { switch (getMicrophoneState()) { case BLOCKED: microphoneState = MicrophoneState.NO_SOUND; jsonParser.setMicrophoneState("softEmptyNoise"); break; case NO_SOUND: microphoneState = MicrophoneState.NEUTRAL_SOUND; jsonParser.setMicrophoneState("softSignalNoise"); break; } } StateMachine(); MicrophoneState getMicrophoneState(); CameraState getCameraState(); void nextMicrophoneState(); void nextCameraState(); }
StateMachine { public void nextMicrophoneState() { switch (getMicrophoneState()) { case BLOCKED: microphoneState = MicrophoneState.NO_SOUND; jsonParser.setMicrophoneState("softEmptyNoise"); break; case NO_SOUND: microphoneState = MicrophoneState.NEUTRAL_SOUND; jsonParser.setMicrophoneState("softSignalNoise"); break; } } StateMachine(); MicrophoneState getMicrophoneState(); CameraState getCameraState(); void nextMicrophoneState(); void nextCameraState(); }
@Test public void testCleanDatabase() { assertThat(profileRepository.count()).isEqualTo(this.outdatedProfiles.length + this.upToDateProfiles.length); clearanceService.cleanDatabase(); assertThat(profileRepository.count()).isEqualTo(this.upToDateProfiles.length); Iterable<Profile> listUpToDateProfilesInDB = profileRepository.findAll(); assertThat(listUpToDateProfilesInDB.toString()).isEqualTo(Arrays.asList(this.upToDateProfiles).toString()); String[] outdatedProfilesIds = new String[outdatedProfiles.length]; for (int i = 0; i < outdatedProfiles.length; ++i) { outdatedProfilesIds[i] = outdatedProfiles[i].get_id(); } Iterable<Profile> listOutdatedProfilesInDB = profileRepository.findAll(Arrays.asList(outdatedProfilesIds)); assertThat(listOutdatedProfilesInDB).isNullOrEmpty(); }
public void cleanDatabase() { Calendar cal = GregorianCalendar.getInstance(Locale.GERMANY); cal.set(Calendar.DATE, cal.get(Calendar.DATE) - (30 * monthsBeforeDeletion)); System.out.println("************************************************"); System.out.println("\t Clearance-Prozess gestartet um " + GregorianCalendar.getInstance(Locale.GERMANY).getTime()); Iterable<Profile> unusedProfiles = profileRepository.findAllByLastProfileContactBefore(cal.getTime()); System.out.println("\t Anzahl geloeschter Profile: " + unusedProfiles.spliterator().getExactSizeIfKnown()); profileRepository.delete(unusedProfiles); try { RestTemplate restTemplate = new RestTemplate(); String url = adress + ":" + port + "/" + databaseName + "/" + "_compact"; HttpHeaders headers = new HttpHeaders(); headers.setContentType(MediaType.APPLICATION_JSON); HttpEntity<String> entity = new HttpEntity<String>("", headers); restTemplate.exchange(url, HttpMethod.POST, entity, String.class); System.out.println("\t Compact-Befehl durchgeführt: true"); } catch (Exception e) { System.out.println("\t Compact-Befehl durchgeführt: false"); e.printStackTrace(); } System.out.println("\t Clearance-Prozess beendet um " + GregorianCalendar.getInstance(Locale.GERMANY).getTime()); System.out.println("************************************************"); }
ClearanceService { public void cleanDatabase() { Calendar cal = GregorianCalendar.getInstance(Locale.GERMANY); cal.set(Calendar.DATE, cal.get(Calendar.DATE) - (30 * monthsBeforeDeletion)); System.out.println("************************************************"); System.out.println("\t Clearance-Prozess gestartet um " + GregorianCalendar.getInstance(Locale.GERMANY).getTime()); Iterable<Profile> unusedProfiles = profileRepository.findAllByLastProfileContactBefore(cal.getTime()); System.out.println("\t Anzahl geloeschter Profile: " + unusedProfiles.spliterator().getExactSizeIfKnown()); profileRepository.delete(unusedProfiles); try { RestTemplate restTemplate = new RestTemplate(); String url = adress + ":" + port + "/" + databaseName + "/" + "_compact"; HttpHeaders headers = new HttpHeaders(); headers.setContentType(MediaType.APPLICATION_JSON); HttpEntity<String> entity = new HttpEntity<String>("", headers); restTemplate.exchange(url, HttpMethod.POST, entity, String.class); System.out.println("\t Compact-Befehl durchgeführt: true"); } catch (Exception e) { System.out.println("\t Compact-Befehl durchgeführt: false"); e.printStackTrace(); } System.out.println("\t Clearance-Prozess beendet um " + GregorianCalendar.getInstance(Locale.GERMANY).getTime()); System.out.println("************************************************"); } }
ClearanceService { public void cleanDatabase() { Calendar cal = GregorianCalendar.getInstance(Locale.GERMANY); cal.set(Calendar.DATE, cal.get(Calendar.DATE) - (30 * monthsBeforeDeletion)); System.out.println("************************************************"); System.out.println("\t Clearance-Prozess gestartet um " + GregorianCalendar.getInstance(Locale.GERMANY).getTime()); Iterable<Profile> unusedProfiles = profileRepository.findAllByLastProfileContactBefore(cal.getTime()); System.out.println("\t Anzahl geloeschter Profile: " + unusedProfiles.spliterator().getExactSizeIfKnown()); profileRepository.delete(unusedProfiles); try { RestTemplate restTemplate = new RestTemplate(); String url = adress + ":" + port + "/" + databaseName + "/" + "_compact"; HttpHeaders headers = new HttpHeaders(); headers.setContentType(MediaType.APPLICATION_JSON); HttpEntity<String> entity = new HttpEntity<String>("", headers); restTemplate.exchange(url, HttpMethod.POST, entity, String.class); System.out.println("\t Compact-Befehl durchgeführt: true"); } catch (Exception e) { System.out.println("\t Compact-Befehl durchgeführt: false"); e.printStackTrace(); } System.out.println("\t Clearance-Prozess beendet um " + GregorianCalendar.getInstance(Locale.GERMANY).getTime()); System.out.println("************************************************"); } ClearanceService(); }
ClearanceService { public void cleanDatabase() { Calendar cal = GregorianCalendar.getInstance(Locale.GERMANY); cal.set(Calendar.DATE, cal.get(Calendar.DATE) - (30 * monthsBeforeDeletion)); System.out.println("************************************************"); System.out.println("\t Clearance-Prozess gestartet um " + GregorianCalendar.getInstance(Locale.GERMANY).getTime()); Iterable<Profile> unusedProfiles = profileRepository.findAllByLastProfileContactBefore(cal.getTime()); System.out.println("\t Anzahl geloeschter Profile: " + unusedProfiles.spliterator().getExactSizeIfKnown()); profileRepository.delete(unusedProfiles); try { RestTemplate restTemplate = new RestTemplate(); String url = adress + ":" + port + "/" + databaseName + "/" + "_compact"; HttpHeaders headers = new HttpHeaders(); headers.setContentType(MediaType.APPLICATION_JSON); HttpEntity<String> entity = new HttpEntity<String>("", headers); restTemplate.exchange(url, HttpMethod.POST, entity, String.class); System.out.println("\t Compact-Befehl durchgeführt: true"); } catch (Exception e) { System.out.println("\t Compact-Befehl durchgeführt: false"); e.printStackTrace(); } System.out.println("\t Clearance-Prozess beendet um " + GregorianCalendar.getInstance(Locale.GERMANY).getTime()); System.out.println("************************************************"); } ClearanceService(); void cleanDatabase(); }
ClearanceService { public void cleanDatabase() { Calendar cal = GregorianCalendar.getInstance(Locale.GERMANY); cal.set(Calendar.DATE, cal.get(Calendar.DATE) - (30 * monthsBeforeDeletion)); System.out.println("************************************************"); System.out.println("\t Clearance-Prozess gestartet um " + GregorianCalendar.getInstance(Locale.GERMANY).getTime()); Iterable<Profile> unusedProfiles = profileRepository.findAllByLastProfileContactBefore(cal.getTime()); System.out.println("\t Anzahl geloeschter Profile: " + unusedProfiles.spliterator().getExactSizeIfKnown()); profileRepository.delete(unusedProfiles); try { RestTemplate restTemplate = new RestTemplate(); String url = adress + ":" + port + "/" + databaseName + "/" + "_compact"; HttpHeaders headers = new HttpHeaders(); headers.setContentType(MediaType.APPLICATION_JSON); HttpEntity<String> entity = new HttpEntity<String>("", headers); restTemplate.exchange(url, HttpMethod.POST, entity, String.class); System.out.println("\t Compact-Befehl durchgeführt: true"); } catch (Exception e) { System.out.println("\t Compact-Befehl durchgeführt: false"); e.printStackTrace(); } System.out.println("\t Clearance-Prozess beendet um " + GregorianCalendar.getInstance(Locale.GERMANY).getTime()); System.out.println("************************************************"); } ClearanceService(); void cleanDatabase(); }
@Test public void noEqualsSign() throws Exception { assertThat(Cookie.parse("foo")).isNull(); assertThat(Cookie.parse("foo; Path=/")).isNull(); }
public static Cookie parse(String setCookie) { return parse(System.currentTimeMillis(), setCookie); }
Cookie { public static Cookie parse(String setCookie) { return parse(System.currentTimeMillis(), setCookie); } }
Cookie { public static Cookie parse(String setCookie) { return parse(System.currentTimeMillis(), setCookie); } private Cookie(String name, String value, long expiresAt, String domain, String path, boolean secure, boolean httpOnly, boolean hostOnly, boolean persistent); private Cookie(Builder builder); }
Cookie { public static Cookie parse(String setCookie) { return parse(System.currentTimeMillis(), setCookie); } private Cookie(String name, String value, long expiresAt, String domain, String path, boolean secure, boolean httpOnly, boolean hostOnly, boolean persistent); private Cookie(Builder builder); String getName(); String getValue(); boolean getPersistent(); long getExpiresAt(); boolean getHostOnly(); String getDomain(); String getPath(); boolean getHttpOnly(); boolean getSecure(); static List<Cookie> parseAll(List<String> cookieStrings); static Cookie parse(String setCookie); @Override String toString(); boolean similarTo(Cookie other); @Override boolean equals(Object other); @Override int hashCode(); }
Cookie { public static Cookie parse(String setCookie) { return parse(System.currentTimeMillis(), setCookie); } private Cookie(String name, String value, long expiresAt, String domain, String path, boolean secure, boolean httpOnly, boolean hostOnly, boolean persistent); private Cookie(Builder builder); String getName(); String getValue(); boolean getPersistent(); long getExpiresAt(); boolean getHostOnly(); String getDomain(); String getPath(); boolean getHttpOnly(); boolean getSecure(); static List<Cookie> parseAll(List<String> cookieStrings); static Cookie parse(String setCookie); @Override String toString(); boolean similarTo(Cookie other); @Override boolean equals(Object other); @Override int hashCode(); }
@Test public void builderExpiresAt() throws Exception { Cookie cookie = new Cookie.Builder() .name("a") .value("b") .hostOnlyDomain("example.com") .expiresAt(date("1970-01-01T00:00:01.000+0000").getTime()) .build(); assertThat(cookie.toString()).isEqualTo( "a=b; expires=Thu, 01 Jan 1970 00:00:01 GMT; path=/"); }
@Override public String toString() { StringBuilder result = new StringBuilder(); result.append(name); result.append('='); result.append(value); if (persistent) { if (expiresAt == Long.MIN_VALUE) { result.append("; max-age=0"); } else { result.append("; expires=").append(STANDARD_DATE_FORMAT.format(new Date(expiresAt))); } } if (!hostOnly) { result.append("; domain="); result.append(domain); } result.append("; path=").append(path); if (secure) { result.append("; secure"); } if (httpOnly) { result.append("; httponly"); } return result.toString(); }
Cookie { @Override public String toString() { StringBuilder result = new StringBuilder(); result.append(name); result.append('='); result.append(value); if (persistent) { if (expiresAt == Long.MIN_VALUE) { result.append("; max-age=0"); } else { result.append("; expires=").append(STANDARD_DATE_FORMAT.format(new Date(expiresAt))); } } if (!hostOnly) { result.append("; domain="); result.append(domain); } result.append("; path=").append(path); if (secure) { result.append("; secure"); } if (httpOnly) { result.append("; httponly"); } return result.toString(); } }
Cookie { @Override public String toString() { StringBuilder result = new StringBuilder(); result.append(name); result.append('='); result.append(value); if (persistent) { if (expiresAt == Long.MIN_VALUE) { result.append("; max-age=0"); } else { result.append("; expires=").append(STANDARD_DATE_FORMAT.format(new Date(expiresAt))); } } if (!hostOnly) { result.append("; domain="); result.append(domain); } result.append("; path=").append(path); if (secure) { result.append("; secure"); } if (httpOnly) { result.append("; httponly"); } return result.toString(); } private Cookie(String name, String value, long expiresAt, String domain, String path, boolean secure, boolean httpOnly, boolean hostOnly, boolean persistent); private Cookie(Builder builder); }
Cookie { @Override public String toString() { StringBuilder result = new StringBuilder(); result.append(name); result.append('='); result.append(value); if (persistent) { if (expiresAt == Long.MIN_VALUE) { result.append("; max-age=0"); } else { result.append("; expires=").append(STANDARD_DATE_FORMAT.format(new Date(expiresAt))); } } if (!hostOnly) { result.append("; domain="); result.append(domain); } result.append("; path=").append(path); if (secure) { result.append("; secure"); } if (httpOnly) { result.append("; httponly"); } return result.toString(); } private Cookie(String name, String value, long expiresAt, String domain, String path, boolean secure, boolean httpOnly, boolean hostOnly, boolean persistent); private Cookie(Builder builder); String getName(); String getValue(); boolean getPersistent(); long getExpiresAt(); boolean getHostOnly(); String getDomain(); String getPath(); boolean getHttpOnly(); boolean getSecure(); static List<Cookie> parseAll(List<String> cookieStrings); static Cookie parse(String setCookie); @Override String toString(); boolean similarTo(Cookie other); @Override boolean equals(Object other); @Override int hashCode(); }
Cookie { @Override public String toString() { StringBuilder result = new StringBuilder(); result.append(name); result.append('='); result.append(value); if (persistent) { if (expiresAt == Long.MIN_VALUE) { result.append("; max-age=0"); } else { result.append("; expires=").append(STANDARD_DATE_FORMAT.format(new Date(expiresAt))); } } if (!hostOnly) { result.append("; domain="); result.append(domain); } result.append("; path=").append(path); if (secure) { result.append("; secure"); } if (httpOnly) { result.append("; httponly"); } return result.toString(); } private Cookie(String name, String value, long expiresAt, String domain, String path, boolean secure, boolean httpOnly, boolean hostOnly, boolean persistent); private Cookie(Builder builder); String getName(); String getValue(); boolean getPersistent(); long getExpiresAt(); boolean getHostOnly(); String getDomain(); String getPath(); boolean getHttpOnly(); boolean getSecure(); static List<Cookie> parseAll(List<String> cookieStrings); static Cookie parse(String setCookie); @Override String toString(); boolean similarTo(Cookie other); @Override boolean equals(Object other); @Override int hashCode(); }
@Test public void builderClampsMinDate() throws Exception { Cookie cookie = new Cookie.Builder() .name("a") .value("b") .hostOnlyDomain("example.com") .expiresAt(date("1970-01-01T00:00:00.000+0000").getTime()) .build(); assertThat(cookie.toString()).isEqualTo("a=b; max-age=0; path=/"); }
@Override public String toString() { StringBuilder result = new StringBuilder(); result.append(name); result.append('='); result.append(value); if (persistent) { if (expiresAt == Long.MIN_VALUE) { result.append("; max-age=0"); } else { result.append("; expires=").append(STANDARD_DATE_FORMAT.format(new Date(expiresAt))); } } if (!hostOnly) { result.append("; domain="); result.append(domain); } result.append("; path=").append(path); if (secure) { result.append("; secure"); } if (httpOnly) { result.append("; httponly"); } return result.toString(); }
Cookie { @Override public String toString() { StringBuilder result = new StringBuilder(); result.append(name); result.append('='); result.append(value); if (persistent) { if (expiresAt == Long.MIN_VALUE) { result.append("; max-age=0"); } else { result.append("; expires=").append(STANDARD_DATE_FORMAT.format(new Date(expiresAt))); } } if (!hostOnly) { result.append("; domain="); result.append(domain); } result.append("; path=").append(path); if (secure) { result.append("; secure"); } if (httpOnly) { result.append("; httponly"); } return result.toString(); } }
Cookie { @Override public String toString() { StringBuilder result = new StringBuilder(); result.append(name); result.append('='); result.append(value); if (persistent) { if (expiresAt == Long.MIN_VALUE) { result.append("; max-age=0"); } else { result.append("; expires=").append(STANDARD_DATE_FORMAT.format(new Date(expiresAt))); } } if (!hostOnly) { result.append("; domain="); result.append(domain); } result.append("; path=").append(path); if (secure) { result.append("; secure"); } if (httpOnly) { result.append("; httponly"); } return result.toString(); } private Cookie(String name, String value, long expiresAt, String domain, String path, boolean secure, boolean httpOnly, boolean hostOnly, boolean persistent); private Cookie(Builder builder); }
Cookie { @Override public String toString() { StringBuilder result = new StringBuilder(); result.append(name); result.append('='); result.append(value); if (persistent) { if (expiresAt == Long.MIN_VALUE) { result.append("; max-age=0"); } else { result.append("; expires=").append(STANDARD_DATE_FORMAT.format(new Date(expiresAt))); } } if (!hostOnly) { result.append("; domain="); result.append(domain); } result.append("; path=").append(path); if (secure) { result.append("; secure"); } if (httpOnly) { result.append("; httponly"); } return result.toString(); } private Cookie(String name, String value, long expiresAt, String domain, String path, boolean secure, boolean httpOnly, boolean hostOnly, boolean persistent); private Cookie(Builder builder); String getName(); String getValue(); boolean getPersistent(); long getExpiresAt(); boolean getHostOnly(); String getDomain(); String getPath(); boolean getHttpOnly(); boolean getSecure(); static List<Cookie> parseAll(List<String> cookieStrings); static Cookie parse(String setCookie); @Override String toString(); boolean similarTo(Cookie other); @Override boolean equals(Object other); @Override int hashCode(); }
Cookie { @Override public String toString() { StringBuilder result = new StringBuilder(); result.append(name); result.append('='); result.append(value); if (persistent) { if (expiresAt == Long.MIN_VALUE) { result.append("; max-age=0"); } else { result.append("; expires=").append(STANDARD_DATE_FORMAT.format(new Date(expiresAt))); } } if (!hostOnly) { result.append("; domain="); result.append(domain); } result.append("; path=").append(path); if (secure) { result.append("; secure"); } if (httpOnly) { result.append("; httponly"); } return result.toString(); } private Cookie(String name, String value, long expiresAt, String domain, String path, boolean secure, boolean httpOnly, boolean hostOnly, boolean persistent); private Cookie(Builder builder); String getName(); String getValue(); boolean getPersistent(); long getExpiresAt(); boolean getHostOnly(); String getDomain(); String getPath(); boolean getHttpOnly(); boolean getSecure(); static List<Cookie> parseAll(List<String> cookieStrings); static Cookie parse(String setCookie); @Override String toString(); boolean similarTo(Cookie other); @Override boolean equals(Object other); @Override int hashCode(); }
@Test public void builderPath() throws Exception { Cookie cookie = new Cookie.Builder() .name("a") .value("b") .hostOnlyDomain("example.com") .path("/foo") .build(); assertThat(cookie.getPath()).isEqualTo("/foo"); }
public String getPath() { return path; }
Cookie { public String getPath() { return path; } }
Cookie { public String getPath() { return path; } private Cookie(String name, String value, long expiresAt, String domain, String path, boolean secure, boolean httpOnly, boolean hostOnly, boolean persistent); private Cookie(Builder builder); }
Cookie { public String getPath() { return path; } private Cookie(String name, String value, long expiresAt, String domain, String path, boolean secure, boolean httpOnly, boolean hostOnly, boolean persistent); private Cookie(Builder builder); String getName(); String getValue(); boolean getPersistent(); long getExpiresAt(); boolean getHostOnly(); String getDomain(); String getPath(); boolean getHttpOnly(); boolean getSecure(); static List<Cookie> parseAll(List<String> cookieStrings); static Cookie parse(String setCookie); @Override String toString(); boolean similarTo(Cookie other); @Override boolean equals(Object other); @Override int hashCode(); }
Cookie { public String getPath() { return path; } private Cookie(String name, String value, long expiresAt, String domain, String path, boolean secure, boolean httpOnly, boolean hostOnly, boolean persistent); private Cookie(Builder builder); String getName(); String getValue(); boolean getPersistent(); long getExpiresAt(); boolean getHostOnly(); String getDomain(); String getPath(); boolean getHttpOnly(); boolean getSecure(); static List<Cookie> parseAll(List<String> cookieStrings); static Cookie parse(String setCookie); @Override String toString(); boolean similarTo(Cookie other); @Override boolean equals(Object other); @Override int hashCode(); }
@Test public void builderSecure() throws Exception { Cookie cookie = new Cookie.Builder() .name("a") .value("b") .hostOnlyDomain("example.com") .secure(true) .build(); assertThat(cookie.getSecure()).isTrue(); }
public boolean getSecure() { return secure; }
Cookie { public boolean getSecure() { return secure; } }
Cookie { public boolean getSecure() { return secure; } private Cookie(String name, String value, long expiresAt, String domain, String path, boolean secure, boolean httpOnly, boolean hostOnly, boolean persistent); private Cookie(Builder builder); }
Cookie { public boolean getSecure() { return secure; } private Cookie(String name, String value, long expiresAt, String domain, String path, boolean secure, boolean httpOnly, boolean hostOnly, boolean persistent); private Cookie(Builder builder); String getName(); String getValue(); boolean getPersistent(); long getExpiresAt(); boolean getHostOnly(); String getDomain(); String getPath(); boolean getHttpOnly(); boolean getSecure(); static List<Cookie> parseAll(List<String> cookieStrings); static Cookie parse(String setCookie); @Override String toString(); boolean similarTo(Cookie other); @Override boolean equals(Object other); @Override int hashCode(); }
Cookie { public boolean getSecure() { return secure; } private Cookie(String name, String value, long expiresAt, String domain, String path, boolean secure, boolean httpOnly, boolean hostOnly, boolean persistent); private Cookie(Builder builder); String getName(); String getValue(); boolean getPersistent(); long getExpiresAt(); boolean getHostOnly(); String getDomain(); String getPath(); boolean getHttpOnly(); boolean getSecure(); static List<Cookie> parseAll(List<String> cookieStrings); static Cookie parse(String setCookie); @Override String toString(); boolean similarTo(Cookie other); @Override boolean equals(Object other); @Override int hashCode(); }
@Test public void builderHttpOnly() throws Exception { Cookie cookie = new Cookie.Builder() .name("a") .value("b") .hostOnlyDomain("example.com") .httpOnly(true) .build(); assertThat(cookie.getHttpOnly()).isTrue(); }
public boolean getHttpOnly() { return httpOnly; }
Cookie { public boolean getHttpOnly() { return httpOnly; } }
Cookie { public boolean getHttpOnly() { return httpOnly; } private Cookie(String name, String value, long expiresAt, String domain, String path, boolean secure, boolean httpOnly, boolean hostOnly, boolean persistent); private Cookie(Builder builder); }
Cookie { public boolean getHttpOnly() { return httpOnly; } private Cookie(String name, String value, long expiresAt, String domain, String path, boolean secure, boolean httpOnly, boolean hostOnly, boolean persistent); private Cookie(Builder builder); String getName(); String getValue(); boolean getPersistent(); long getExpiresAt(); boolean getHostOnly(); String getDomain(); String getPath(); boolean getHttpOnly(); boolean getSecure(); static List<Cookie> parseAll(List<String> cookieStrings); static Cookie parse(String setCookie); @Override String toString(); boolean similarTo(Cookie other); @Override boolean equals(Object other); @Override int hashCode(); }
Cookie { public boolean getHttpOnly() { return httpOnly; } private Cookie(String name, String value, long expiresAt, String domain, String path, boolean secure, boolean httpOnly, boolean hostOnly, boolean persistent); private Cookie(Builder builder); String getName(); String getValue(); boolean getPersistent(); long getExpiresAt(); boolean getHostOnly(); String getDomain(); String getPath(); boolean getHttpOnly(); boolean getSecure(); static List<Cookie> parseAll(List<String> cookieStrings); static Cookie parse(String setCookie); @Override String toString(); boolean similarTo(Cookie other); @Override boolean equals(Object other); @Override int hashCode(); }
@Test public void builderIpv6() throws Exception { Cookie cookie = new Cookie.Builder() .name("a") .value("b") .domain("0:0:0:0:0:0:0:1") .build(); assertThat(cookie.getDomain()).isEqualTo("0:0:0:0:0:0:0:1"); }
public String getDomain() { return domain; }
Cookie { public String getDomain() { return domain; } }
Cookie { public String getDomain() { return domain; } private Cookie(String name, String value, long expiresAt, String domain, String path, boolean secure, boolean httpOnly, boolean hostOnly, boolean persistent); private Cookie(Builder builder); }
Cookie { public String getDomain() { return domain; } private Cookie(String name, String value, long expiresAt, String domain, String path, boolean secure, boolean httpOnly, boolean hostOnly, boolean persistent); private Cookie(Builder builder); String getName(); String getValue(); boolean getPersistent(); long getExpiresAt(); boolean getHostOnly(); String getDomain(); String getPath(); boolean getHttpOnly(); boolean getSecure(); static List<Cookie> parseAll(List<String> cookieStrings); static Cookie parse(String setCookie); @Override String toString(); boolean similarTo(Cookie other); @Override boolean equals(Object other); @Override int hashCode(); }
Cookie { public String getDomain() { return domain; } private Cookie(String name, String value, long expiresAt, String domain, String path, boolean secure, boolean httpOnly, boolean hostOnly, boolean persistent); private Cookie(Builder builder); String getName(); String getValue(); boolean getPersistent(); long getExpiresAt(); boolean getHostOnly(); String getDomain(); String getPath(); boolean getHttpOnly(); boolean getSecure(); static List<Cookie> parseAll(List<String> cookieStrings); static Cookie parse(String setCookie); @Override String toString(); boolean similarTo(Cookie other); @Override boolean equals(Object other); @Override int hashCode(); }
@Test public void emptyName() throws Exception { assertThat(Cookie.parse("=b")).isNull(); assertThat(Cookie.parse(" =b")).isNull(); assertThat(Cookie.parse("\r\t \n=b")).isNull(); }
public static Cookie parse(String setCookie) { return parse(System.currentTimeMillis(), setCookie); }
Cookie { public static Cookie parse(String setCookie) { return parse(System.currentTimeMillis(), setCookie); } }
Cookie { public static Cookie parse(String setCookie) { return parse(System.currentTimeMillis(), setCookie); } private Cookie(String name, String value, long expiresAt, String domain, String path, boolean secure, boolean httpOnly, boolean hostOnly, boolean persistent); private Cookie(Builder builder); }
Cookie { public static Cookie parse(String setCookie) { return parse(System.currentTimeMillis(), setCookie); } private Cookie(String name, String value, long expiresAt, String domain, String path, boolean secure, boolean httpOnly, boolean hostOnly, boolean persistent); private Cookie(Builder builder); String getName(); String getValue(); boolean getPersistent(); long getExpiresAt(); boolean getHostOnly(); String getDomain(); String getPath(); boolean getHttpOnly(); boolean getSecure(); static List<Cookie> parseAll(List<String> cookieStrings); static Cookie parse(String setCookie); @Override String toString(); boolean similarTo(Cookie other); @Override boolean equals(Object other); @Override int hashCode(); }
Cookie { public static Cookie parse(String setCookie) { return parse(System.currentTimeMillis(), setCookie); } private Cookie(String name, String value, long expiresAt, String domain, String path, boolean secure, boolean httpOnly, boolean hostOnly, boolean persistent); private Cookie(Builder builder); String getName(); String getValue(); boolean getPersistent(); long getExpiresAt(); boolean getHostOnly(); String getDomain(); String getPath(); boolean getHttpOnly(); boolean getSecure(); static List<Cookie> parseAll(List<String> cookieStrings); static Cookie parse(String setCookie); @Override String toString(); boolean similarTo(Cookie other); @Override boolean equals(Object other); @Override int hashCode(); }
@Test public void invalidCharacters() throws Exception { assertThat(Cookie.parse("a\u0000b=cd")).isNull(); assertThat(Cookie.parse("ab=c\u0000d")).isNull(); assertThat(Cookie.parse("a\u0001b=cd")).isNull(); assertThat(Cookie.parse("ab=c\u0001d")).isNull(); assertThat(Cookie.parse("a\u0009b=cd")).isNull(); assertThat(Cookie.parse("ab=c\u0009d")).isNull(); assertThat(Cookie.parse("a\u001fb=cd")).isNull(); assertThat(Cookie.parse("ab=c\u001fd")).isNull(); assertThat(Cookie.parse("a\u007fb=cd")).isNull(); assertThat(Cookie.parse("ab=c\u007fd")).isNull(); assertThat(Cookie.parse("a\u0080b=cd")).isNull(); assertThat(Cookie.parse("ab=c\u0080d")).isNull(); assertThat(Cookie.parse("a\u00ffb=cd")).isNull(); assertThat(Cookie.parse("ab=c\u00ffd")).isNull(); }
public static Cookie parse(String setCookie) { return parse(System.currentTimeMillis(), setCookie); }
Cookie { public static Cookie parse(String setCookie) { return parse(System.currentTimeMillis(), setCookie); } }
Cookie { public static Cookie parse(String setCookie) { return parse(System.currentTimeMillis(), setCookie); } private Cookie(String name, String value, long expiresAt, String domain, String path, boolean secure, boolean httpOnly, boolean hostOnly, boolean persistent); private Cookie(Builder builder); }
Cookie { public static Cookie parse(String setCookie) { return parse(System.currentTimeMillis(), setCookie); } private Cookie(String name, String value, long expiresAt, String domain, String path, boolean secure, boolean httpOnly, boolean hostOnly, boolean persistent); private Cookie(Builder builder); String getName(); String getValue(); boolean getPersistent(); long getExpiresAt(); boolean getHostOnly(); String getDomain(); String getPath(); boolean getHttpOnly(); boolean getSecure(); static List<Cookie> parseAll(List<String> cookieStrings); static Cookie parse(String setCookie); @Override String toString(); boolean similarTo(Cookie other); @Override boolean equals(Object other); @Override int hashCode(); }
Cookie { public static Cookie parse(String setCookie) { return parse(System.currentTimeMillis(), setCookie); } private Cookie(String name, String value, long expiresAt, String domain, String path, boolean secure, boolean httpOnly, boolean hostOnly, boolean persistent); private Cookie(Builder builder); String getName(); String getValue(); boolean getPersistent(); long getExpiresAt(); boolean getHostOnly(); String getDomain(); String getPath(); boolean getHttpOnly(); boolean getSecure(); static List<Cookie> parseAll(List<String> cookieStrings); static Cookie parse(String setCookie); @Override String toString(); boolean similarTo(Cookie other); @Override boolean equals(Object other); @Override int hashCode(); }
@Test public void maxAge() throws Exception { assertThat(parseCookie(50000L, "a=b; Max-Age=1").getExpiresAt()) .isEqualTo(51000L); assertThat(parseCookie(50000L, "a=b; Max-Age=9223372036854724").getExpiresAt()) .isEqualTo(MAX_DATE); assertThat(parseCookie(50000L, "a=b; Max-Age=9223372036854725").getExpiresAt()) .isEqualTo(MAX_DATE); assertThat(parseCookie(50000L, "a=b; Max-Age=9223372036854726").getExpiresAt()) .isEqualTo(MAX_DATE); assertThat(parseCookie(9223372036854773807L, "a=b; Max-Age=1").getExpiresAt()) .isEqualTo(MAX_DATE); assertThat(parseCookie(9223372036854773807L, "a=b; Max-Age=2").getExpiresAt()) .isEqualTo(MAX_DATE); assertThat(parseCookie(9223372036854773807L, "a=b; Max-Age=3").getExpiresAt()) .isEqualTo(MAX_DATE); assertThat(parseCookie(50000L, "a=b; Max-Age=10000000000000000000").getExpiresAt()) .isEqualTo(MAX_DATE); assertThat(parseCookie(50000L, "a=b; Max-Age=For-Eva").getExpiresAt()) .isEqualTo(MAX_DATE); }
public long getExpiresAt() { return expiresAt; }
Cookie { public long getExpiresAt() { return expiresAt; } }
Cookie { public long getExpiresAt() { return expiresAt; } private Cookie(String name, String value, long expiresAt, String domain, String path, boolean secure, boolean httpOnly, boolean hostOnly, boolean persistent); private Cookie(Builder builder); }
Cookie { public long getExpiresAt() { return expiresAt; } private Cookie(String name, String value, long expiresAt, String domain, String path, boolean secure, boolean httpOnly, boolean hostOnly, boolean persistent); private Cookie(Builder builder); String getName(); String getValue(); boolean getPersistent(); long getExpiresAt(); boolean getHostOnly(); String getDomain(); String getPath(); boolean getHttpOnly(); boolean getSecure(); static List<Cookie> parseAll(List<String> cookieStrings); static Cookie parse(String setCookie); @Override String toString(); boolean similarTo(Cookie other); @Override boolean equals(Object other); @Override int hashCode(); }
Cookie { public long getExpiresAt() { return expiresAt; } private Cookie(String name, String value, long expiresAt, String domain, String path, boolean secure, boolean httpOnly, boolean hostOnly, boolean persistent); private Cookie(Builder builder); String getName(); String getValue(); boolean getPersistent(); long getExpiresAt(); boolean getHostOnly(); String getDomain(); String getPath(); boolean getHttpOnly(); boolean getSecure(); static List<Cookie> parseAll(List<String> cookieStrings); static Cookie parse(String setCookie); @Override String toString(); boolean similarTo(Cookie other); @Override boolean equals(Object other); @Override int hashCode(); }
@Test public void maxAgeNonPositive() throws Exception { assertThat(parseCookie(50000L, "a=b; Max-Age=-1").getExpiresAt()) .isEqualTo(Long.MIN_VALUE); assertThat(parseCookie(50000L, "a=b; Max-Age=0").getExpiresAt()) .isEqualTo(Long.MIN_VALUE); assertThat(parseCookie(50000L, "a=b; Max-Age=-9223372036854775808").getExpiresAt()) .isEqualTo(Long.MIN_VALUE); assertThat(parseCookie(50000L, "a=b; Max-Age=-9223372036854775809").getExpiresAt()) .isEqualTo(Long.MIN_VALUE); assertThat(parseCookie(50000L, "a=b; Max-Age=-10000000000000000000").getExpiresAt()) .isEqualTo(Long.MIN_VALUE); }
public long getExpiresAt() { return expiresAt; }
Cookie { public long getExpiresAt() { return expiresAt; } }
Cookie { public long getExpiresAt() { return expiresAt; } private Cookie(String name, String value, long expiresAt, String domain, String path, boolean secure, boolean httpOnly, boolean hostOnly, boolean persistent); private Cookie(Builder builder); }
Cookie { public long getExpiresAt() { return expiresAt; } private Cookie(String name, String value, long expiresAt, String domain, String path, boolean secure, boolean httpOnly, boolean hostOnly, boolean persistent); private Cookie(Builder builder); String getName(); String getValue(); boolean getPersistent(); long getExpiresAt(); boolean getHostOnly(); String getDomain(); String getPath(); boolean getHttpOnly(); boolean getSecure(); static List<Cookie> parseAll(List<String> cookieStrings); static Cookie parse(String setCookie); @Override String toString(); boolean similarTo(Cookie other); @Override boolean equals(Object other); @Override int hashCode(); }
Cookie { public long getExpiresAt() { return expiresAt; } private Cookie(String name, String value, long expiresAt, String domain, String path, boolean secure, boolean httpOnly, boolean hostOnly, boolean persistent); private Cookie(Builder builder); String getName(); String getValue(); boolean getPersistent(); long getExpiresAt(); boolean getHostOnly(); String getDomain(); String getPath(); boolean getHttpOnly(); boolean getSecure(); static List<Cookie> parseAll(List<String> cookieStrings); static Cookie parse(String setCookie); @Override String toString(); boolean similarTo(Cookie other); @Override boolean equals(Object other); @Override int hashCode(); }
@Test public void maxAgeTakesPrecedenceOverExpires() throws Exception { assertThat(parseCookie( 0L, "a=b; Max-Age=1; Expires=Thu, 01 Jan 1970 00:00:02 GMT").getExpiresAt()).isEqualTo( 1000L); assertThat(parseCookie( 0L, "a=b; Expires=Thu, 01 Jan 1970 00:00:02 GMT; Max-Age=1").getExpiresAt()).isEqualTo( 1000L); assertThat(parseCookie( 0L, "a=b; Max-Age=2; Expires=Thu, 01 Jan 1970 00:00:01 GMT").getExpiresAt()).isEqualTo( 2000L); assertThat(parseCookie( 0L, "a=b; Expires=Thu, 01 Jan 1970 00:00:01 GMT; Max-Age=2").getExpiresAt()).isEqualTo( 2000L); }
public long getExpiresAt() { return expiresAt; }
Cookie { public long getExpiresAt() { return expiresAt; } }
Cookie { public long getExpiresAt() { return expiresAt; } private Cookie(String name, String value, long expiresAt, String domain, String path, boolean secure, boolean httpOnly, boolean hostOnly, boolean persistent); private Cookie(Builder builder); }
Cookie { public long getExpiresAt() { return expiresAt; } private Cookie(String name, String value, long expiresAt, String domain, String path, boolean secure, boolean httpOnly, boolean hostOnly, boolean persistent); private Cookie(Builder builder); String getName(); String getValue(); boolean getPersistent(); long getExpiresAt(); boolean getHostOnly(); String getDomain(); String getPath(); boolean getHttpOnly(); boolean getSecure(); static List<Cookie> parseAll(List<String> cookieStrings); static Cookie parse(String setCookie); @Override String toString(); boolean similarTo(Cookie other); @Override boolean equals(Object other); @Override int hashCode(); }
Cookie { public long getExpiresAt() { return expiresAt; } private Cookie(String name, String value, long expiresAt, String domain, String path, boolean secure, boolean httpOnly, boolean hostOnly, boolean persistent); private Cookie(Builder builder); String getName(); String getValue(); boolean getPersistent(); long getExpiresAt(); boolean getHostOnly(); String getDomain(); String getPath(); boolean getHttpOnly(); boolean getSecure(); static List<Cookie> parseAll(List<String> cookieStrings); static Cookie parse(String setCookie); @Override String toString(); boolean similarTo(Cookie other); @Override boolean equals(Object other); @Override int hashCode(); }
@Test public void lastMaxAgeWins() throws Exception { assertThat(parseCookie( 0L, "a=b; Max-Age=2; Max-Age=4; Max-Age=1; Max-Age=3").getExpiresAt()).isEqualTo(3000L); }
public long getExpiresAt() { return expiresAt; }
Cookie { public long getExpiresAt() { return expiresAt; } }
Cookie { public long getExpiresAt() { return expiresAt; } private Cookie(String name, String value, long expiresAt, String domain, String path, boolean secure, boolean httpOnly, boolean hostOnly, boolean persistent); private Cookie(Builder builder); }
Cookie { public long getExpiresAt() { return expiresAt; } private Cookie(String name, String value, long expiresAt, String domain, String path, boolean secure, boolean httpOnly, boolean hostOnly, boolean persistent); private Cookie(Builder builder); String getName(); String getValue(); boolean getPersistent(); long getExpiresAt(); boolean getHostOnly(); String getDomain(); String getPath(); boolean getHttpOnly(); boolean getSecure(); static List<Cookie> parseAll(List<String> cookieStrings); static Cookie parse(String setCookie); @Override String toString(); boolean similarTo(Cookie other); @Override boolean equals(Object other); @Override int hashCode(); }
Cookie { public long getExpiresAt() { return expiresAt; } private Cookie(String name, String value, long expiresAt, String domain, String path, boolean secure, boolean httpOnly, boolean hostOnly, boolean persistent); private Cookie(Builder builder); String getName(); String getValue(); boolean getPersistent(); long getExpiresAt(); boolean getHostOnly(); String getDomain(); String getPath(); boolean getHttpOnly(); boolean getSecure(); static List<Cookie> parseAll(List<String> cookieStrings); static Cookie parse(String setCookie); @Override String toString(); boolean similarTo(Cookie other); @Override boolean equals(Object other); @Override int hashCode(); }
@Test public void lastExpiresAtWins() throws Exception { assertThat(parseCookie(0L, "a=b; " + "Expires=Thu, 01 Jan 1970 00:00:02 GMT; " + "Expires=Thu, 01 Jan 1970 00:00:04 GMT; " + "Expires=Thu, 01 Jan 1970 00:00:01 GMT; " + "Expires=Thu, 01 Jan 1970 00:00:03 GMT").getExpiresAt()).isEqualTo(3000L); }
public long getExpiresAt() { return expiresAt; }
Cookie { public long getExpiresAt() { return expiresAt; } }
Cookie { public long getExpiresAt() { return expiresAt; } private Cookie(String name, String value, long expiresAt, String domain, String path, boolean secure, boolean httpOnly, boolean hostOnly, boolean persistent); private Cookie(Builder builder); }
Cookie { public long getExpiresAt() { return expiresAt; } private Cookie(String name, String value, long expiresAt, String domain, String path, boolean secure, boolean httpOnly, boolean hostOnly, boolean persistent); private Cookie(Builder builder); String getName(); String getValue(); boolean getPersistent(); long getExpiresAt(); boolean getHostOnly(); String getDomain(); String getPath(); boolean getHttpOnly(); boolean getSecure(); static List<Cookie> parseAll(List<String> cookieStrings); static Cookie parse(String setCookie); @Override String toString(); boolean similarTo(Cookie other); @Override boolean equals(Object other); @Override int hashCode(); }
Cookie { public long getExpiresAt() { return expiresAt; } private Cookie(String name, String value, long expiresAt, String domain, String path, boolean secure, boolean httpOnly, boolean hostOnly, boolean persistent); private Cookie(Builder builder); String getName(); String getValue(); boolean getPersistent(); long getExpiresAt(); boolean getHostOnly(); String getDomain(); String getPath(); boolean getHttpOnly(); boolean getSecure(); static List<Cookie> parseAll(List<String> cookieStrings); static Cookie parse(String setCookie); @Override String toString(); boolean similarTo(Cookie other); @Override boolean equals(Object other); @Override int hashCode(); }
@Test public void maxAgeOrExpiresMakesCookiePersistent() throws Exception { assertThat(parseCookie(0L, "a=b").getPersistent()).isFalse(); assertThat(parseCookie(0L, "a=b; Max-Age=1").getPersistent()).isTrue(); assertThat(parseCookie(0L, "a=b; Expires=Thu, 01 Jan 1970 00:00:01 GMT").getPersistent()) .isTrue(); }
public boolean getPersistent() { return persistent; }
Cookie { public boolean getPersistent() { return persistent; } }
Cookie { public boolean getPersistent() { return persistent; } private Cookie(String name, String value, long expiresAt, String domain, String path, boolean secure, boolean httpOnly, boolean hostOnly, boolean persistent); private Cookie(Builder builder); }
Cookie { public boolean getPersistent() { return persistent; } private Cookie(String name, String value, long expiresAt, String domain, String path, boolean secure, boolean httpOnly, boolean hostOnly, boolean persistent); private Cookie(Builder builder); String getName(); String getValue(); boolean getPersistent(); long getExpiresAt(); boolean getHostOnly(); String getDomain(); String getPath(); boolean getHttpOnly(); boolean getSecure(); static List<Cookie> parseAll(List<String> cookieStrings); static Cookie parse(String setCookie); @Override String toString(); boolean similarTo(Cookie other); @Override boolean equals(Object other); @Override int hashCode(); }
Cookie { public boolean getPersistent() { return persistent; } private Cookie(String name, String value, long expiresAt, String domain, String path, boolean secure, boolean httpOnly, boolean hostOnly, boolean persistent); private Cookie(Builder builder); String getName(); String getValue(); boolean getPersistent(); long getExpiresAt(); boolean getHostOnly(); String getDomain(); String getPath(); boolean getHttpOnly(); boolean getSecure(); static List<Cookie> parseAll(List<String> cookieStrings); static Cookie parse(String setCookie); @Override String toString(); boolean similarTo(Cookie other); @Override boolean equals(Object other); @Override int hashCode(); }
@Test public void builderClampsMaxDate() throws Exception { Cookie cookie = new Cookie.Builder() .name("a") .value("b") .hostOnlyDomain("example.com") .expiresAt(Long.MAX_VALUE) .build(); assertThat(cookie.toString()).isEqualTo( "a=b; expires=Fri, 31 Dec 9999 23:59:59 GMT; path=/"); }
@Override public String toString() { StringBuilder result = new StringBuilder(); result.append(name); result.append('='); result.append(value); if (persistent) { if (expiresAt == Long.MIN_VALUE) { result.append("; max-age=0"); } else { result.append("; expires=").append(STANDARD_DATE_FORMAT.format(new Date(expiresAt))); } } if (!hostOnly) { result.append("; domain="); result.append(domain); } result.append("; path=").append(path); if (secure) { result.append("; secure"); } if (httpOnly) { result.append("; httponly"); } return result.toString(); }
Cookie { @Override public String toString() { StringBuilder result = new StringBuilder(); result.append(name); result.append('='); result.append(value); if (persistent) { if (expiresAt == Long.MIN_VALUE) { result.append("; max-age=0"); } else { result.append("; expires=").append(STANDARD_DATE_FORMAT.format(new Date(expiresAt))); } } if (!hostOnly) { result.append("; domain="); result.append(domain); } result.append("; path=").append(path); if (secure) { result.append("; secure"); } if (httpOnly) { result.append("; httponly"); } return result.toString(); } }
Cookie { @Override public String toString() { StringBuilder result = new StringBuilder(); result.append(name); result.append('='); result.append(value); if (persistent) { if (expiresAt == Long.MIN_VALUE) { result.append("; max-age=0"); } else { result.append("; expires=").append(STANDARD_DATE_FORMAT.format(new Date(expiresAt))); } } if (!hostOnly) { result.append("; domain="); result.append(domain); } result.append("; path=").append(path); if (secure) { result.append("; secure"); } if (httpOnly) { result.append("; httponly"); } return result.toString(); } private Cookie(String name, String value, long expiresAt, String domain, String path, boolean secure, boolean httpOnly, boolean hostOnly, boolean persistent); private Cookie(Builder builder); }
Cookie { @Override public String toString() { StringBuilder result = new StringBuilder(); result.append(name); result.append('='); result.append(value); if (persistent) { if (expiresAt == Long.MIN_VALUE) { result.append("; max-age=0"); } else { result.append("; expires=").append(STANDARD_DATE_FORMAT.format(new Date(expiresAt))); } } if (!hostOnly) { result.append("; domain="); result.append(domain); } result.append("; path=").append(path); if (secure) { result.append("; secure"); } if (httpOnly) { result.append("; httponly"); } return result.toString(); } private Cookie(String name, String value, long expiresAt, String domain, String path, boolean secure, boolean httpOnly, boolean hostOnly, boolean persistent); private Cookie(Builder builder); String getName(); String getValue(); boolean getPersistent(); long getExpiresAt(); boolean getHostOnly(); String getDomain(); String getPath(); boolean getHttpOnly(); boolean getSecure(); static List<Cookie> parseAll(List<String> cookieStrings); static Cookie parse(String setCookie); @Override String toString(); boolean similarTo(Cookie other); @Override boolean equals(Object other); @Override int hashCode(); }
Cookie { @Override public String toString() { StringBuilder result = new StringBuilder(); result.append(name); result.append('='); result.append(value); if (persistent) { if (expiresAt == Long.MIN_VALUE) { result.append("; max-age=0"); } else { result.append("; expires=").append(STANDARD_DATE_FORMAT.format(new Date(expiresAt))); } } if (!hostOnly) { result.append("; domain="); result.append(domain); } result.append("; path=").append(path); if (secure) { result.append("; secure"); } if (httpOnly) { result.append("; httponly"); } return result.toString(); } private Cookie(String name, String value, long expiresAt, String domain, String path, boolean secure, boolean httpOnly, boolean hostOnly, boolean persistent); private Cookie(Builder builder); String getName(); String getValue(); boolean getPersistent(); long getExpiresAt(); boolean getHostOnly(); String getDomain(); String getPath(); boolean getHttpOnly(); boolean getSecure(); static List<Cookie> parseAll(List<String> cookieStrings); static Cookie parse(String setCookie); @Override String toString(); boolean similarTo(Cookie other); @Override boolean equals(Object other); @Override int hashCode(); }
@Test public void getSegmentSplitByPolygon() throws Exception { Vector2D start = GeometryFactory.createVector(-5,0); Vector2D end = GeometryFactory.createVector(5,0); Segment2D segment = GeometryFactory.createSegment(start, end); ArrayList<Vector2D> nodeArray = new ArrayList<>(); nodeArray.add(GeometryFactory.createVector(-2, -2)); nodeArray.add(GeometryFactory.createVector(2, -2)); nodeArray.add(GeometryFactory.createVector(2, 2)); nodeArray.add(GeometryFactory.createVector(-2, 2)); Polygon2D polygon = GeometryFactory.createPolygon(nodeArray); ArrayList<Segment2D> splittedSegment = segment.getSegmentSplitByPolygon(polygon); assertEquals(3, splittedSegment.size()); assertEquals(-5, splittedSegment.get(0).getFirstPoint().getXComponent(), PRECISION); assertEquals(0, splittedSegment.get(0).getFirstPoint().getYComponent(), PRECISION); assertEquals(-2, splittedSegment.get(0).getLastPoint().getXComponent(), PRECISION); assertEquals(0, splittedSegment.get(0).getLastPoint().getYComponent(), PRECISION); assertEquals(-2, splittedSegment.get(1).getFirstPoint().getXComponent(), PRECISION); assertEquals(0, splittedSegment.get(1).getFirstPoint().getYComponent(), PRECISION); assertEquals(2, splittedSegment.get(1).getLastPoint().getXComponent(), PRECISION); assertEquals(0, splittedSegment.get(1).getLastPoint().getYComponent(), PRECISION); assertEquals(2, splittedSegment.get(2).getFirstPoint().getXComponent(), PRECISION); assertEquals(0, splittedSegment.get(2).getFirstPoint().getYComponent(), PRECISION); assertEquals(5, splittedSegment.get(2).getLastPoint().getXComponent(), PRECISION); assertEquals(0, splittedSegment.get(2).getLastPoint().getYComponent(), PRECISION); System.out.println(splittedSegment.toString()); }
public ArrayList<Segment2D> getSegmentSplitByPolygon(Polygon2D polygon) { ArrayList<Segment2D> segmentList = new ArrayList<>(); ArrayList<Vector2D> segmentListPoints = new ArrayList<>(); segmentListPoints.add(this.getFirstPoint()); segmentListPoints.addAll(this.getIntersection(polygon)); segmentListPoints.add(this.getLastPoint()); Comparator<Vector2D> byDistance = (e1, e2) -> Double.compare( e1.distance(this.getFirstPoint()), e2.distance(this.getFirstPoint())); segmentListPoints = segmentListPoints.stream() .sorted(byDistance) .collect(Collectors.toCollection(ArrayList::new)); Vector2D tempPosPrevious = null; for(Vector2D tempPosCurrent : segmentListPoints) { if(tempPosPrevious == null) { tempPosPrevious = tempPosCurrent; continue; } if(!tempPosPrevious.equals(tempPosCurrent)) { segmentList.add(GeometryFactory.createSegment(tempPosPrevious, tempPosCurrent)); tempPosPrevious = tempPosCurrent; } } return segmentList; }
Segment2D extends Geometry2D { public ArrayList<Segment2D> getSegmentSplitByPolygon(Polygon2D polygon) { ArrayList<Segment2D> segmentList = new ArrayList<>(); ArrayList<Vector2D> segmentListPoints = new ArrayList<>(); segmentListPoints.add(this.getFirstPoint()); segmentListPoints.addAll(this.getIntersection(polygon)); segmentListPoints.add(this.getLastPoint()); Comparator<Vector2D> byDistance = (e1, e2) -> Double.compare( e1.distance(this.getFirstPoint()), e2.distance(this.getFirstPoint())); segmentListPoints = segmentListPoints.stream() .sorted(byDistance) .collect(Collectors.toCollection(ArrayList::new)); Vector2D tempPosPrevious = null; for(Vector2D tempPosCurrent : segmentListPoints) { if(tempPosPrevious == null) { tempPosPrevious = tempPosCurrent; continue; } if(!tempPosPrevious.equals(tempPosCurrent)) { segmentList.add(GeometryFactory.createSegment(tempPosPrevious, tempPosCurrent)); tempPosPrevious = tempPosCurrent; } } return segmentList; } }
Segment2D extends Geometry2D { public ArrayList<Segment2D> getSegmentSplitByPolygon(Polygon2D polygon) { ArrayList<Segment2D> segmentList = new ArrayList<>(); ArrayList<Vector2D> segmentListPoints = new ArrayList<>(); segmentListPoints.add(this.getFirstPoint()); segmentListPoints.addAll(this.getIntersection(polygon)); segmentListPoints.add(this.getLastPoint()); Comparator<Vector2D> byDistance = (e1, e2) -> Double.compare( e1.distance(this.getFirstPoint()), e2.distance(this.getFirstPoint())); segmentListPoints = segmentListPoints.stream() .sorted(byDistance) .collect(Collectors.toCollection(ArrayList::new)); Vector2D tempPosPrevious = null; for(Vector2D tempPosCurrent : segmentListPoints) { if(tempPosPrevious == null) { tempPosPrevious = tempPosCurrent; continue; } if(!tempPosPrevious.equals(tempPosCurrent)) { segmentList.add(GeometryFactory.createSegment(tempPosPrevious, tempPosCurrent)); tempPosPrevious = tempPosCurrent; } } return segmentList; } Segment2D(Vector2D point1, Vector2D point2); Segment2D(List<Vector2D> nodeArray); Segment2D(Vector2D[] nodeArray); }
Segment2D extends Geometry2D { public ArrayList<Segment2D> getSegmentSplitByPolygon(Polygon2D polygon) { ArrayList<Segment2D> segmentList = new ArrayList<>(); ArrayList<Vector2D> segmentListPoints = new ArrayList<>(); segmentListPoints.add(this.getFirstPoint()); segmentListPoints.addAll(this.getIntersection(polygon)); segmentListPoints.add(this.getLastPoint()); Comparator<Vector2D> byDistance = (e1, e2) -> Double.compare( e1.distance(this.getFirstPoint()), e2.distance(this.getFirstPoint())); segmentListPoints = segmentListPoints.stream() .sorted(byDistance) .collect(Collectors.toCollection(ArrayList::new)); Vector2D tempPosPrevious = null; for(Vector2D tempPosCurrent : segmentListPoints) { if(tempPosPrevious == null) { tempPosPrevious = tempPosCurrent; continue; } if(!tempPosPrevious.equals(tempPosCurrent)) { segmentList.add(GeometryFactory.createSegment(tempPosPrevious, tempPosCurrent)); tempPosPrevious = tempPosCurrent; } } return segmentList; } Segment2D(Vector2D point1, Vector2D point2); Segment2D(List<Vector2D> nodeArray); Segment2D(Vector2D[] nodeArray); List<Segment2D> getLineSegments(); @Override boolean equals(Object other); @Override synchronized List<Vector2D> getVertices(); double getLength(); double getLenghtDistance(); ArrayList<Vector2D> getIntersection(Segment2D openPolygon); ArrayList<Segment2D> getSegmentSplitByPolygon(Polygon2D polygon); @Override ArrayList<Vector2D> getIntersection(Polygon2D polygon); @Override ArrayList<Vector2D> getIntersection(Cycle2D cycle); Vector2D getFirstPoint(); Vector2D getLastPoint(); @Override boolean contains(Vector2D point); @Override boolean contains(Vector2D point, Transform transform); Vector2D getPointOnSegmentClosestToVector(Vector2D point); @Override void rotate(double theta, double x, double y); @Override void rotate(double theta); @Override void rotate(double theta, Vector2D point); @Override void translate(double x, double y); @Override void translate(Vector2D vector); @Override double distanceBetween(Vector2D point); @Override double minimalDistanceBetween(List<Vector2D> points); @Override Vector2D vectorBetween(Vector2D point); @Override Mass createMass(double density); @Override List<Segment2D> getSegments(); @Override double getRadius(); @Override double getRadius(Vector2D vector); @Override Vector2D getCenter(); @Override Vector2D getPointClosestToVector(Vector2D toVector); @Override boolean isOnLines(Vector2D vector, double precision); @Override boolean isOnCorners(Vector2D vector, double precision); List<Vector2D> getNormals(); List<Segment2D> getLineSegmentsSplit(double maxLength); List<Segment2D> getLineSegmentsSplitEqually(double maxLength, Double roundPrecision); ArrayList<Segment2D> calculateLineSegmentsToEquallySplit(double maxLength, Double roundPrecision); Double getSmallestVertixValueOfX(); Double getSmallestVertixValueOfY(); Double getLargestVertixValueOfX(); Double getLargestVertixValueOfY(); @Override double area(); }
Segment2D extends Geometry2D { public ArrayList<Segment2D> getSegmentSplitByPolygon(Polygon2D polygon) { ArrayList<Segment2D> segmentList = new ArrayList<>(); ArrayList<Vector2D> segmentListPoints = new ArrayList<>(); segmentListPoints.add(this.getFirstPoint()); segmentListPoints.addAll(this.getIntersection(polygon)); segmentListPoints.add(this.getLastPoint()); Comparator<Vector2D> byDistance = (e1, e2) -> Double.compare( e1.distance(this.getFirstPoint()), e2.distance(this.getFirstPoint())); segmentListPoints = segmentListPoints.stream() .sorted(byDistance) .collect(Collectors.toCollection(ArrayList::new)); Vector2D tempPosPrevious = null; for(Vector2D tempPosCurrent : segmentListPoints) { if(tempPosPrevious == null) { tempPosPrevious = tempPosCurrent; continue; } if(!tempPosPrevious.equals(tempPosCurrent)) { segmentList.add(GeometryFactory.createSegment(tempPosPrevious, tempPosCurrent)); tempPosPrevious = tempPosCurrent; } } return segmentList; } Segment2D(Vector2D point1, Vector2D point2); Segment2D(List<Vector2D> nodeArray); Segment2D(Vector2D[] nodeArray); List<Segment2D> getLineSegments(); @Override boolean equals(Object other); @Override synchronized List<Vector2D> getVertices(); double getLength(); double getLenghtDistance(); ArrayList<Vector2D> getIntersection(Segment2D openPolygon); ArrayList<Segment2D> getSegmentSplitByPolygon(Polygon2D polygon); @Override ArrayList<Vector2D> getIntersection(Polygon2D polygon); @Override ArrayList<Vector2D> getIntersection(Cycle2D cycle); Vector2D getFirstPoint(); Vector2D getLastPoint(); @Override boolean contains(Vector2D point); @Override boolean contains(Vector2D point, Transform transform); Vector2D getPointOnSegmentClosestToVector(Vector2D point); @Override void rotate(double theta, double x, double y); @Override void rotate(double theta); @Override void rotate(double theta, Vector2D point); @Override void translate(double x, double y); @Override void translate(Vector2D vector); @Override double distanceBetween(Vector2D point); @Override double minimalDistanceBetween(List<Vector2D> points); @Override Vector2D vectorBetween(Vector2D point); @Override Mass createMass(double density); @Override List<Segment2D> getSegments(); @Override double getRadius(); @Override double getRadius(Vector2D vector); @Override Vector2D getCenter(); @Override Vector2D getPointClosestToVector(Vector2D toVector); @Override boolean isOnLines(Vector2D vector, double precision); @Override boolean isOnCorners(Vector2D vector, double precision); List<Vector2D> getNormals(); List<Segment2D> getLineSegmentsSplit(double maxLength); List<Segment2D> getLineSegmentsSplitEqually(double maxLength, Double roundPrecision); ArrayList<Segment2D> calculateLineSegmentsToEquallySplit(double maxLength, Double roundPrecision); Double getSmallestVertixValueOfX(); Double getSmallestVertixValueOfY(); Double getLargestVertixValueOfX(); Double getLargestVertixValueOfY(); @Override double area(); }
@Test public void intersectionSegment() throws Exception { aStart = GeometryFactory.createVector(0,0); aDirection = GeometryFactory.createVector(1,0); a = GeometryFactory.createRay2D(aStart, aDirection); bStart = GeometryFactory.createVector(5,0); bDirection = GeometryFactory.createVector(-1,0); b = GeometryFactory.createRay2D(bStart, bDirection); Segment2D intersectionSegment = a.intersectionSegment(b); Assert.assertEquals(0, intersectionSegment.getFirstPoint().getXComponent(), PRECISION); Assert.assertEquals(0, intersectionSegment.getFirstPoint().getYComponent(), PRECISION); Assert.assertEquals(5, intersectionSegment.getLastPoint().getXComponent(), PRECISION); Assert.assertEquals(0, intersectionSegment.getLastPoint().getYComponent(), PRECISION); aStart = GeometryFactory.createVector(0,0); aDirection = GeometryFactory.createVector(0,1); a = GeometryFactory.createRay2D(aStart, aDirection); bStart = GeometryFactory.createVector(0,7); bDirection = GeometryFactory.createVector(0,-0.1); b = GeometryFactory.createRay2D(bStart, bDirection); intersectionSegment = a.intersectionSegment(b); Assert.assertEquals(0, intersectionSegment.getFirstPoint().getXComponent(), PRECISION); Assert.assertEquals(0, intersectionSegment.getFirstPoint().getYComponent(), PRECISION); Assert.assertEquals(0, intersectionSegment.getLastPoint().getXComponent(), PRECISION); Assert.assertEquals(7, intersectionSegment.getLastPoint().getYComponent(), PRECISION); bStart = GeometryFactory.createVector(5,5); bDirection = GeometryFactory.createVector(-1,0); b = GeometryFactory.createRay2D(bStart, bDirection); intersectionSegment = a.intersectionSegment(b); assertNull(intersectionSegment); }
public Segment2D intersectionSegment(Ray2D other) { if(this.contains(other.getStart()) && other.contains(this.getStart())) { return new Segment2D(this.getStart(), other.getStart()); } else { return null; } }
Ray2D { public Segment2D intersectionSegment(Ray2D other) { if(this.contains(other.getStart()) && other.contains(this.getStart())) { return new Segment2D(this.getStart(), other.getStart()); } else { return null; } } }
Ray2D { public Segment2D intersectionSegment(Ray2D other) { if(this.contains(other.getStart()) && other.contains(this.getStart())) { return new Segment2D(this.getStart(), other.getStart()); } else { return null; } } Ray2D(Vector2D start, Vector2D direction); }
Ray2D { public Segment2D intersectionSegment(Ray2D other) { if(this.contains(other.getStart()) && other.contains(this.getStart())) { return new Segment2D(this.getStart(), other.getStart()); } else { return null; } } Ray2D(Vector2D start, Vector2D direction); Vector2D getStart(); void setStart(Vector2D start); Vector2D getDirection(); void setDirection(Vector2D direction); Vector2D intersectionPoint(Ray2D other); Ray2D intersectionRay(Ray2D other); Segment2D intersectionSegment(Ray2D other); boolean contains(Vector2D point); boolean isParallel(Ray2D other); boolean equals(Ray2D other); String toString(); }
Ray2D { public Segment2D intersectionSegment(Ray2D other) { if(this.contains(other.getStart()) && other.contains(this.getStart())) { return new Segment2D(this.getStart(), other.getStart()); } else { return null; } } Ray2D(Vector2D start, Vector2D direction); Vector2D getStart(); void setStart(Vector2D start); Vector2D getDirection(); void setDirection(Vector2D direction); Vector2D intersectionPoint(Ray2D other); Ray2D intersectionRay(Ray2D other); Segment2D intersectionSegment(Ray2D other); boolean contains(Vector2D point); boolean isParallel(Ray2D other); boolean equals(Ray2D other); String toString(); }
@Test @Parameters({"/layout_graph_test/FromGraphConfigurationOperation_insideArea_test.xml"}) public void fromConfiguration_loadsSingleVertexInsideArea_WithSuccess(String configurationFile) throws Exception { createConfiguration(configurationFile); SimulationState state = mock(SimulationState.class); graphOperation.callPreProcessing(state); Vertex vertexInSideArea = scenarioManager.getGraph().getVertex(6); boolean isSeed = vertexInSideArea.isSeed(); boolean isInArea = scenarioManager.getArea(2).getGeometry().contains(vertexInSideArea.getGeometry().getCenter()); assertTrue(isSeed && isInArea); }
@Override public void callPreProcessing(SimulationState simulationState) { Integer graphId = this.properties.getIntegerProperty(graphIdName); Double precisionSeed = this.properties.getDoubleProperty(precisionSeedName); Boolean insideAreaSeed = this.properties.getBooleanProperty(insideAreaSeedName); GraphScenarioConfiguration graphConfiguration = null; for(GraphScenarioConfiguration graphScenarioConfiguration : configurations.get(0).getGraphs()) { if(graphScenarioConfiguration.getId().intValue() == graphId) { graphConfiguration = graphScenarioConfiguration; } } HashSet<Area> alreadySeedAreas = new HashSet<>(); Graph graph = GraphTheoryFactory.createGraph(graphConfiguration.getName()); graph.setId(graphConfiguration.getId()); this.scenarioManager.getGraphs().add(graph); for(VertexConfiguration vertexConfiguration : graphConfiguration.getVertices()) { Vertex newVertex = null; Vector2D center = GeometryFactory.createVector(vertexConfiguration.getPoint().getX(), vertexConfiguration.getPoint().getY()); boolean isSeed = this.scenarioManager.getAreas() .stream() .filter(area -> { if(precisionSeed != null && FastMath.abs(area.getPointOfInterest().distance(center)) < precisionSeed) { return true; } else if (insideAreaSeed != null && insideAreaSeed && area.getGeometry().contains(center)) { return true; } return false; }) .count() > 0; if(isSeed) { Area area = this.scenarioManager.getAreas() .stream() .filter(existingArea -> { if(!alreadySeedAreas.contains(existingArea)) { if(precisionSeed != null && FastMath.abs(existingArea.getPointOfInterest().distance(center)) < precisionSeed) { return true; } else if (insideAreaSeed != null && insideAreaSeed && existingArea.getGeometry().contains(center)) { return true; } } return false; }) .findFirst() .orElse(null); if(area != null) { alreadySeedAreas.add(area); newVertex = GraphTheoryFactory.createVertex(area.getGeometry(), true, vertexConfiguration.getId()); } else { newVertex = GraphTheoryFactory.createVertexCyleBased(center, vertexConfiguration.getId()); } } else { newVertex = GraphTheoryFactory.createVertexCyleBased(center, vertexConfiguration.getId()); } graph.addVertex(newVertex); } for(EdgeConfiguration edgeConfiguration : graphConfiguration.getEdges()) { Vertex left = graph.getVertex(edgeConfiguration.getIdLeft()); Vertex right = graph.getVertex(edgeConfiguration.getIdRight()); graph.doublyConnectVertices(left, right); } }
FromConfigurationOperation extends GraphOperation { @Override public void callPreProcessing(SimulationState simulationState) { Integer graphId = this.properties.getIntegerProperty(graphIdName); Double precisionSeed = this.properties.getDoubleProperty(precisionSeedName); Boolean insideAreaSeed = this.properties.getBooleanProperty(insideAreaSeedName); GraphScenarioConfiguration graphConfiguration = null; for(GraphScenarioConfiguration graphScenarioConfiguration : configurations.get(0).getGraphs()) { if(graphScenarioConfiguration.getId().intValue() == graphId) { graphConfiguration = graphScenarioConfiguration; } } HashSet<Area> alreadySeedAreas = new HashSet<>(); Graph graph = GraphTheoryFactory.createGraph(graphConfiguration.getName()); graph.setId(graphConfiguration.getId()); this.scenarioManager.getGraphs().add(graph); for(VertexConfiguration vertexConfiguration : graphConfiguration.getVertices()) { Vertex newVertex = null; Vector2D center = GeometryFactory.createVector(vertexConfiguration.getPoint().getX(), vertexConfiguration.getPoint().getY()); boolean isSeed = this.scenarioManager.getAreas() .stream() .filter(area -> { if(precisionSeed != null && FastMath.abs(area.getPointOfInterest().distance(center)) < precisionSeed) { return true; } else if (insideAreaSeed != null && insideAreaSeed && area.getGeometry().contains(center)) { return true; } return false; }) .count() > 0; if(isSeed) { Area area = this.scenarioManager.getAreas() .stream() .filter(existingArea -> { if(!alreadySeedAreas.contains(existingArea)) { if(precisionSeed != null && FastMath.abs(existingArea.getPointOfInterest().distance(center)) < precisionSeed) { return true; } else if (insideAreaSeed != null && insideAreaSeed && existingArea.getGeometry().contains(center)) { return true; } } return false; }) .findFirst() .orElse(null); if(area != null) { alreadySeedAreas.add(area); newVertex = GraphTheoryFactory.createVertex(area.getGeometry(), true, vertexConfiguration.getId()); } else { newVertex = GraphTheoryFactory.createVertexCyleBased(center, vertexConfiguration.getId()); } } else { newVertex = GraphTheoryFactory.createVertexCyleBased(center, vertexConfiguration.getId()); } graph.addVertex(newVertex); } for(EdgeConfiguration edgeConfiguration : graphConfiguration.getEdges()) { Vertex left = graph.getVertex(edgeConfiguration.getIdLeft()); Vertex right = graph.getVertex(edgeConfiguration.getIdRight()); graph.doublyConnectVertices(left, right); } } }
FromConfigurationOperation extends GraphOperation { @Override public void callPreProcessing(SimulationState simulationState) { Integer graphId = this.properties.getIntegerProperty(graphIdName); Double precisionSeed = this.properties.getDoubleProperty(precisionSeedName); Boolean insideAreaSeed = this.properties.getBooleanProperty(insideAreaSeedName); GraphScenarioConfiguration graphConfiguration = null; for(GraphScenarioConfiguration graphScenarioConfiguration : configurations.get(0).getGraphs()) { if(graphScenarioConfiguration.getId().intValue() == graphId) { graphConfiguration = graphScenarioConfiguration; } } HashSet<Area> alreadySeedAreas = new HashSet<>(); Graph graph = GraphTheoryFactory.createGraph(graphConfiguration.getName()); graph.setId(graphConfiguration.getId()); this.scenarioManager.getGraphs().add(graph); for(VertexConfiguration vertexConfiguration : graphConfiguration.getVertices()) { Vertex newVertex = null; Vector2D center = GeometryFactory.createVector(vertexConfiguration.getPoint().getX(), vertexConfiguration.getPoint().getY()); boolean isSeed = this.scenarioManager.getAreas() .stream() .filter(area -> { if(precisionSeed != null && FastMath.abs(area.getPointOfInterest().distance(center)) < precisionSeed) { return true; } else if (insideAreaSeed != null && insideAreaSeed && area.getGeometry().contains(center)) { return true; } return false; }) .count() > 0; if(isSeed) { Area area = this.scenarioManager.getAreas() .stream() .filter(existingArea -> { if(!alreadySeedAreas.contains(existingArea)) { if(precisionSeed != null && FastMath.abs(existingArea.getPointOfInterest().distance(center)) < precisionSeed) { return true; } else if (insideAreaSeed != null && insideAreaSeed && existingArea.getGeometry().contains(center)) { return true; } } return false; }) .findFirst() .orElse(null); if(area != null) { alreadySeedAreas.add(area); newVertex = GraphTheoryFactory.createVertex(area.getGeometry(), true, vertexConfiguration.getId()); } else { newVertex = GraphTheoryFactory.createVertexCyleBased(center, vertexConfiguration.getId()); } } else { newVertex = GraphTheoryFactory.createVertexCyleBased(center, vertexConfiguration.getId()); } graph.addVertex(newVertex); } for(EdgeConfiguration edgeConfiguration : graphConfiguration.getEdges()) { Vertex left = graph.getVertex(edgeConfiguration.getIdLeft()); Vertex right = graph.getVertex(edgeConfiguration.getIdRight()); graph.doublyConnectVertices(left, right); } } FromConfigurationOperation(ArrayList<ScenarioConfiguration> scenarioConfigurations); }
FromConfigurationOperation extends GraphOperation { @Override public void callPreProcessing(SimulationState simulationState) { Integer graphId = this.properties.getIntegerProperty(graphIdName); Double precisionSeed = this.properties.getDoubleProperty(precisionSeedName); Boolean insideAreaSeed = this.properties.getBooleanProperty(insideAreaSeedName); GraphScenarioConfiguration graphConfiguration = null; for(GraphScenarioConfiguration graphScenarioConfiguration : configurations.get(0).getGraphs()) { if(graphScenarioConfiguration.getId().intValue() == graphId) { graphConfiguration = graphScenarioConfiguration; } } HashSet<Area> alreadySeedAreas = new HashSet<>(); Graph graph = GraphTheoryFactory.createGraph(graphConfiguration.getName()); graph.setId(graphConfiguration.getId()); this.scenarioManager.getGraphs().add(graph); for(VertexConfiguration vertexConfiguration : graphConfiguration.getVertices()) { Vertex newVertex = null; Vector2D center = GeometryFactory.createVector(vertexConfiguration.getPoint().getX(), vertexConfiguration.getPoint().getY()); boolean isSeed = this.scenarioManager.getAreas() .stream() .filter(area -> { if(precisionSeed != null && FastMath.abs(area.getPointOfInterest().distance(center)) < precisionSeed) { return true; } else if (insideAreaSeed != null && insideAreaSeed && area.getGeometry().contains(center)) { return true; } return false; }) .count() > 0; if(isSeed) { Area area = this.scenarioManager.getAreas() .stream() .filter(existingArea -> { if(!alreadySeedAreas.contains(existingArea)) { if(precisionSeed != null && FastMath.abs(existingArea.getPointOfInterest().distance(center)) < precisionSeed) { return true; } else if (insideAreaSeed != null && insideAreaSeed && existingArea.getGeometry().contains(center)) { return true; } } return false; }) .findFirst() .orElse(null); if(area != null) { alreadySeedAreas.add(area); newVertex = GraphTheoryFactory.createVertex(area.getGeometry(), true, vertexConfiguration.getId()); } else { newVertex = GraphTheoryFactory.createVertexCyleBased(center, vertexConfiguration.getId()); } } else { newVertex = GraphTheoryFactory.createVertexCyleBased(center, vertexConfiguration.getId()); } graph.addVertex(newVertex); } for(EdgeConfiguration edgeConfiguration : graphConfiguration.getEdges()) { Vertex left = graph.getVertex(edgeConfiguration.getIdLeft()); Vertex right = graph.getVertex(edgeConfiguration.getIdRight()); graph.doublyConnectVertices(left, right); } } FromConfigurationOperation(ArrayList<ScenarioConfiguration> scenarioConfigurations); @Override void callPreProcessing(SimulationState simulationState); @Override void callPostProcessing(SimulationState simulationState); }
FromConfigurationOperation extends GraphOperation { @Override public void callPreProcessing(SimulationState simulationState) { Integer graphId = this.properties.getIntegerProperty(graphIdName); Double precisionSeed = this.properties.getDoubleProperty(precisionSeedName); Boolean insideAreaSeed = this.properties.getBooleanProperty(insideAreaSeedName); GraphScenarioConfiguration graphConfiguration = null; for(GraphScenarioConfiguration graphScenarioConfiguration : configurations.get(0).getGraphs()) { if(graphScenarioConfiguration.getId().intValue() == graphId) { graphConfiguration = graphScenarioConfiguration; } } HashSet<Area> alreadySeedAreas = new HashSet<>(); Graph graph = GraphTheoryFactory.createGraph(graphConfiguration.getName()); graph.setId(graphConfiguration.getId()); this.scenarioManager.getGraphs().add(graph); for(VertexConfiguration vertexConfiguration : graphConfiguration.getVertices()) { Vertex newVertex = null; Vector2D center = GeometryFactory.createVector(vertexConfiguration.getPoint().getX(), vertexConfiguration.getPoint().getY()); boolean isSeed = this.scenarioManager.getAreas() .stream() .filter(area -> { if(precisionSeed != null && FastMath.abs(area.getPointOfInterest().distance(center)) < precisionSeed) { return true; } else if (insideAreaSeed != null && insideAreaSeed && area.getGeometry().contains(center)) { return true; } return false; }) .count() > 0; if(isSeed) { Area area = this.scenarioManager.getAreas() .stream() .filter(existingArea -> { if(!alreadySeedAreas.contains(existingArea)) { if(precisionSeed != null && FastMath.abs(existingArea.getPointOfInterest().distance(center)) < precisionSeed) { return true; } else if (insideAreaSeed != null && insideAreaSeed && existingArea.getGeometry().contains(center)) { return true; } } return false; }) .findFirst() .orElse(null); if(area != null) { alreadySeedAreas.add(area); newVertex = GraphTheoryFactory.createVertex(area.getGeometry(), true, vertexConfiguration.getId()); } else { newVertex = GraphTheoryFactory.createVertexCyleBased(center, vertexConfiguration.getId()); } } else { newVertex = GraphTheoryFactory.createVertexCyleBased(center, vertexConfiguration.getId()); } graph.addVertex(newVertex); } for(EdgeConfiguration edgeConfiguration : graphConfiguration.getEdges()) { Vertex left = graph.getVertex(edgeConfiguration.getIdLeft()); Vertex right = graph.getVertex(edgeConfiguration.getIdRight()); graph.doublyConnectVertices(left, right); } } FromConfigurationOperation(ArrayList<ScenarioConfiguration> scenarioConfigurations); @Override void callPreProcessing(SimulationState simulationState); @Override void callPostProcessing(SimulationState simulationState); }
@Test @Parameters({"/layout_graph_test/FromGraphConfigurationOperation_insideArea_test.xml"}) public void fromConfiguration_loadsOnlySingleVertexInsideArea_WithSuccess(String configurationFile) throws Exception { createConfiguration(configurationFile); SimulationState state = mock(SimulationState.class); graphOperation.callPreProcessing(state); Vertex vertexInSideAreaFirst = scenarioManager.getGraph().getVertex(1); Vertex vertexInSideAreaSecond = scenarioManager.getGraph().getVertex(2); boolean isFirstSeed = vertexInSideAreaFirst.isSeed(); boolean isFirstInArea = scenarioManager.getArea(3).getGeometry().contains(vertexInSideAreaFirst.getGeometry().getCenter()); boolean isSecSeed = vertexInSideAreaSecond.isSeed(); boolean isSecInArea = scenarioManager.getArea(3).getGeometry().contains(vertexInSideAreaSecond.getGeometry().getCenter()); assertTrue( (isFirstSeed && isFirstInArea && !isSecSeed && isSecInArea) || (!isFirstSeed && isFirstInArea && isSecSeed && isSecInArea) ); }
@Override public void callPreProcessing(SimulationState simulationState) { Integer graphId = this.properties.getIntegerProperty(graphIdName); Double precisionSeed = this.properties.getDoubleProperty(precisionSeedName); Boolean insideAreaSeed = this.properties.getBooleanProperty(insideAreaSeedName); GraphScenarioConfiguration graphConfiguration = null; for(GraphScenarioConfiguration graphScenarioConfiguration : configurations.get(0).getGraphs()) { if(graphScenarioConfiguration.getId().intValue() == graphId) { graphConfiguration = graphScenarioConfiguration; } } HashSet<Area> alreadySeedAreas = new HashSet<>(); Graph graph = GraphTheoryFactory.createGraph(graphConfiguration.getName()); graph.setId(graphConfiguration.getId()); this.scenarioManager.getGraphs().add(graph); for(VertexConfiguration vertexConfiguration : graphConfiguration.getVertices()) { Vertex newVertex = null; Vector2D center = GeometryFactory.createVector(vertexConfiguration.getPoint().getX(), vertexConfiguration.getPoint().getY()); boolean isSeed = this.scenarioManager.getAreas() .stream() .filter(area -> { if(precisionSeed != null && FastMath.abs(area.getPointOfInterest().distance(center)) < precisionSeed) { return true; } else if (insideAreaSeed != null && insideAreaSeed && area.getGeometry().contains(center)) { return true; } return false; }) .count() > 0; if(isSeed) { Area area = this.scenarioManager.getAreas() .stream() .filter(existingArea -> { if(!alreadySeedAreas.contains(existingArea)) { if(precisionSeed != null && FastMath.abs(existingArea.getPointOfInterest().distance(center)) < precisionSeed) { return true; } else if (insideAreaSeed != null && insideAreaSeed && existingArea.getGeometry().contains(center)) { return true; } } return false; }) .findFirst() .orElse(null); if(area != null) { alreadySeedAreas.add(area); newVertex = GraphTheoryFactory.createVertex(area.getGeometry(), true, vertexConfiguration.getId()); } else { newVertex = GraphTheoryFactory.createVertexCyleBased(center, vertexConfiguration.getId()); } } else { newVertex = GraphTheoryFactory.createVertexCyleBased(center, vertexConfiguration.getId()); } graph.addVertex(newVertex); } for(EdgeConfiguration edgeConfiguration : graphConfiguration.getEdges()) { Vertex left = graph.getVertex(edgeConfiguration.getIdLeft()); Vertex right = graph.getVertex(edgeConfiguration.getIdRight()); graph.doublyConnectVertices(left, right); } }
FromConfigurationOperation extends GraphOperation { @Override public void callPreProcessing(SimulationState simulationState) { Integer graphId = this.properties.getIntegerProperty(graphIdName); Double precisionSeed = this.properties.getDoubleProperty(precisionSeedName); Boolean insideAreaSeed = this.properties.getBooleanProperty(insideAreaSeedName); GraphScenarioConfiguration graphConfiguration = null; for(GraphScenarioConfiguration graphScenarioConfiguration : configurations.get(0).getGraphs()) { if(graphScenarioConfiguration.getId().intValue() == graphId) { graphConfiguration = graphScenarioConfiguration; } } HashSet<Area> alreadySeedAreas = new HashSet<>(); Graph graph = GraphTheoryFactory.createGraph(graphConfiguration.getName()); graph.setId(graphConfiguration.getId()); this.scenarioManager.getGraphs().add(graph); for(VertexConfiguration vertexConfiguration : graphConfiguration.getVertices()) { Vertex newVertex = null; Vector2D center = GeometryFactory.createVector(vertexConfiguration.getPoint().getX(), vertexConfiguration.getPoint().getY()); boolean isSeed = this.scenarioManager.getAreas() .stream() .filter(area -> { if(precisionSeed != null && FastMath.abs(area.getPointOfInterest().distance(center)) < precisionSeed) { return true; } else if (insideAreaSeed != null && insideAreaSeed && area.getGeometry().contains(center)) { return true; } return false; }) .count() > 0; if(isSeed) { Area area = this.scenarioManager.getAreas() .stream() .filter(existingArea -> { if(!alreadySeedAreas.contains(existingArea)) { if(precisionSeed != null && FastMath.abs(existingArea.getPointOfInterest().distance(center)) < precisionSeed) { return true; } else if (insideAreaSeed != null && insideAreaSeed && existingArea.getGeometry().contains(center)) { return true; } } return false; }) .findFirst() .orElse(null); if(area != null) { alreadySeedAreas.add(area); newVertex = GraphTheoryFactory.createVertex(area.getGeometry(), true, vertexConfiguration.getId()); } else { newVertex = GraphTheoryFactory.createVertexCyleBased(center, vertexConfiguration.getId()); } } else { newVertex = GraphTheoryFactory.createVertexCyleBased(center, vertexConfiguration.getId()); } graph.addVertex(newVertex); } for(EdgeConfiguration edgeConfiguration : graphConfiguration.getEdges()) { Vertex left = graph.getVertex(edgeConfiguration.getIdLeft()); Vertex right = graph.getVertex(edgeConfiguration.getIdRight()); graph.doublyConnectVertices(left, right); } } }
FromConfigurationOperation extends GraphOperation { @Override public void callPreProcessing(SimulationState simulationState) { Integer graphId = this.properties.getIntegerProperty(graphIdName); Double precisionSeed = this.properties.getDoubleProperty(precisionSeedName); Boolean insideAreaSeed = this.properties.getBooleanProperty(insideAreaSeedName); GraphScenarioConfiguration graphConfiguration = null; for(GraphScenarioConfiguration graphScenarioConfiguration : configurations.get(0).getGraphs()) { if(graphScenarioConfiguration.getId().intValue() == graphId) { graphConfiguration = graphScenarioConfiguration; } } HashSet<Area> alreadySeedAreas = new HashSet<>(); Graph graph = GraphTheoryFactory.createGraph(graphConfiguration.getName()); graph.setId(graphConfiguration.getId()); this.scenarioManager.getGraphs().add(graph); for(VertexConfiguration vertexConfiguration : graphConfiguration.getVertices()) { Vertex newVertex = null; Vector2D center = GeometryFactory.createVector(vertexConfiguration.getPoint().getX(), vertexConfiguration.getPoint().getY()); boolean isSeed = this.scenarioManager.getAreas() .stream() .filter(area -> { if(precisionSeed != null && FastMath.abs(area.getPointOfInterest().distance(center)) < precisionSeed) { return true; } else if (insideAreaSeed != null && insideAreaSeed && area.getGeometry().contains(center)) { return true; } return false; }) .count() > 0; if(isSeed) { Area area = this.scenarioManager.getAreas() .stream() .filter(existingArea -> { if(!alreadySeedAreas.contains(existingArea)) { if(precisionSeed != null && FastMath.abs(existingArea.getPointOfInterest().distance(center)) < precisionSeed) { return true; } else if (insideAreaSeed != null && insideAreaSeed && existingArea.getGeometry().contains(center)) { return true; } } return false; }) .findFirst() .orElse(null); if(area != null) { alreadySeedAreas.add(area); newVertex = GraphTheoryFactory.createVertex(area.getGeometry(), true, vertexConfiguration.getId()); } else { newVertex = GraphTheoryFactory.createVertexCyleBased(center, vertexConfiguration.getId()); } } else { newVertex = GraphTheoryFactory.createVertexCyleBased(center, vertexConfiguration.getId()); } graph.addVertex(newVertex); } for(EdgeConfiguration edgeConfiguration : graphConfiguration.getEdges()) { Vertex left = graph.getVertex(edgeConfiguration.getIdLeft()); Vertex right = graph.getVertex(edgeConfiguration.getIdRight()); graph.doublyConnectVertices(left, right); } } FromConfigurationOperation(ArrayList<ScenarioConfiguration> scenarioConfigurations); }
FromConfigurationOperation extends GraphOperation { @Override public void callPreProcessing(SimulationState simulationState) { Integer graphId = this.properties.getIntegerProperty(graphIdName); Double precisionSeed = this.properties.getDoubleProperty(precisionSeedName); Boolean insideAreaSeed = this.properties.getBooleanProperty(insideAreaSeedName); GraphScenarioConfiguration graphConfiguration = null; for(GraphScenarioConfiguration graphScenarioConfiguration : configurations.get(0).getGraphs()) { if(graphScenarioConfiguration.getId().intValue() == graphId) { graphConfiguration = graphScenarioConfiguration; } } HashSet<Area> alreadySeedAreas = new HashSet<>(); Graph graph = GraphTheoryFactory.createGraph(graphConfiguration.getName()); graph.setId(graphConfiguration.getId()); this.scenarioManager.getGraphs().add(graph); for(VertexConfiguration vertexConfiguration : graphConfiguration.getVertices()) { Vertex newVertex = null; Vector2D center = GeometryFactory.createVector(vertexConfiguration.getPoint().getX(), vertexConfiguration.getPoint().getY()); boolean isSeed = this.scenarioManager.getAreas() .stream() .filter(area -> { if(precisionSeed != null && FastMath.abs(area.getPointOfInterest().distance(center)) < precisionSeed) { return true; } else if (insideAreaSeed != null && insideAreaSeed && area.getGeometry().contains(center)) { return true; } return false; }) .count() > 0; if(isSeed) { Area area = this.scenarioManager.getAreas() .stream() .filter(existingArea -> { if(!alreadySeedAreas.contains(existingArea)) { if(precisionSeed != null && FastMath.abs(existingArea.getPointOfInterest().distance(center)) < precisionSeed) { return true; } else if (insideAreaSeed != null && insideAreaSeed && existingArea.getGeometry().contains(center)) { return true; } } return false; }) .findFirst() .orElse(null); if(area != null) { alreadySeedAreas.add(area); newVertex = GraphTheoryFactory.createVertex(area.getGeometry(), true, vertexConfiguration.getId()); } else { newVertex = GraphTheoryFactory.createVertexCyleBased(center, vertexConfiguration.getId()); } } else { newVertex = GraphTheoryFactory.createVertexCyleBased(center, vertexConfiguration.getId()); } graph.addVertex(newVertex); } for(EdgeConfiguration edgeConfiguration : graphConfiguration.getEdges()) { Vertex left = graph.getVertex(edgeConfiguration.getIdLeft()); Vertex right = graph.getVertex(edgeConfiguration.getIdRight()); graph.doublyConnectVertices(left, right); } } FromConfigurationOperation(ArrayList<ScenarioConfiguration> scenarioConfigurations); @Override void callPreProcessing(SimulationState simulationState); @Override void callPostProcessing(SimulationState simulationState); }
FromConfigurationOperation extends GraphOperation { @Override public void callPreProcessing(SimulationState simulationState) { Integer graphId = this.properties.getIntegerProperty(graphIdName); Double precisionSeed = this.properties.getDoubleProperty(precisionSeedName); Boolean insideAreaSeed = this.properties.getBooleanProperty(insideAreaSeedName); GraphScenarioConfiguration graphConfiguration = null; for(GraphScenarioConfiguration graphScenarioConfiguration : configurations.get(0).getGraphs()) { if(graphScenarioConfiguration.getId().intValue() == graphId) { graphConfiguration = graphScenarioConfiguration; } } HashSet<Area> alreadySeedAreas = new HashSet<>(); Graph graph = GraphTheoryFactory.createGraph(graphConfiguration.getName()); graph.setId(graphConfiguration.getId()); this.scenarioManager.getGraphs().add(graph); for(VertexConfiguration vertexConfiguration : graphConfiguration.getVertices()) { Vertex newVertex = null; Vector2D center = GeometryFactory.createVector(vertexConfiguration.getPoint().getX(), vertexConfiguration.getPoint().getY()); boolean isSeed = this.scenarioManager.getAreas() .stream() .filter(area -> { if(precisionSeed != null && FastMath.abs(area.getPointOfInterest().distance(center)) < precisionSeed) { return true; } else if (insideAreaSeed != null && insideAreaSeed && area.getGeometry().contains(center)) { return true; } return false; }) .count() > 0; if(isSeed) { Area area = this.scenarioManager.getAreas() .stream() .filter(existingArea -> { if(!alreadySeedAreas.contains(existingArea)) { if(precisionSeed != null && FastMath.abs(existingArea.getPointOfInterest().distance(center)) < precisionSeed) { return true; } else if (insideAreaSeed != null && insideAreaSeed && existingArea.getGeometry().contains(center)) { return true; } } return false; }) .findFirst() .orElse(null); if(area != null) { alreadySeedAreas.add(area); newVertex = GraphTheoryFactory.createVertex(area.getGeometry(), true, vertexConfiguration.getId()); } else { newVertex = GraphTheoryFactory.createVertexCyleBased(center, vertexConfiguration.getId()); } } else { newVertex = GraphTheoryFactory.createVertexCyleBased(center, vertexConfiguration.getId()); } graph.addVertex(newVertex); } for(EdgeConfiguration edgeConfiguration : graphConfiguration.getEdges()) { Vertex left = graph.getVertex(edgeConfiguration.getIdLeft()); Vertex right = graph.getVertex(edgeConfiguration.getIdRight()); graph.doublyConnectVertices(left, right); } } FromConfigurationOperation(ArrayList<ScenarioConfiguration> scenarioConfigurations); @Override void callPreProcessing(SimulationState simulationState); @Override void callPostProcessing(SimulationState simulationState); }
@Test @Parameters({"/layout_graph_test/FromGraphConfigurationOperation_insideArea_test.xml"}) public void fromConfiguration_ignoresVertexOutsideArea_WithSuccess(String configurationFile) throws Exception { createConfiguration(configurationFile); SimulationState state = mock(SimulationState.class); graphOperation.callPreProcessing(state); Vertex vertexInSideArea = scenarioManager.getGraph().getVertex(3); boolean isSeed = vertexInSideArea.isSeed(); boolean isInArea = false; for(Area area : scenarioManager.getAreas()) { isInArea = isInArea || area.getGeometry().contains(vertexInSideArea.getGeometry().getCenter()); } assertTrue(!isSeed && !isInArea); }
@Override public void callPreProcessing(SimulationState simulationState) { Integer graphId = this.properties.getIntegerProperty(graphIdName); Double precisionSeed = this.properties.getDoubleProperty(precisionSeedName); Boolean insideAreaSeed = this.properties.getBooleanProperty(insideAreaSeedName); GraphScenarioConfiguration graphConfiguration = null; for(GraphScenarioConfiguration graphScenarioConfiguration : configurations.get(0).getGraphs()) { if(graphScenarioConfiguration.getId().intValue() == graphId) { graphConfiguration = graphScenarioConfiguration; } } HashSet<Area> alreadySeedAreas = new HashSet<>(); Graph graph = GraphTheoryFactory.createGraph(graphConfiguration.getName()); graph.setId(graphConfiguration.getId()); this.scenarioManager.getGraphs().add(graph); for(VertexConfiguration vertexConfiguration : graphConfiguration.getVertices()) { Vertex newVertex = null; Vector2D center = GeometryFactory.createVector(vertexConfiguration.getPoint().getX(), vertexConfiguration.getPoint().getY()); boolean isSeed = this.scenarioManager.getAreas() .stream() .filter(area -> { if(precisionSeed != null && FastMath.abs(area.getPointOfInterest().distance(center)) < precisionSeed) { return true; } else if (insideAreaSeed != null && insideAreaSeed && area.getGeometry().contains(center)) { return true; } return false; }) .count() > 0; if(isSeed) { Area area = this.scenarioManager.getAreas() .stream() .filter(existingArea -> { if(!alreadySeedAreas.contains(existingArea)) { if(precisionSeed != null && FastMath.abs(existingArea.getPointOfInterest().distance(center)) < precisionSeed) { return true; } else if (insideAreaSeed != null && insideAreaSeed && existingArea.getGeometry().contains(center)) { return true; } } return false; }) .findFirst() .orElse(null); if(area != null) { alreadySeedAreas.add(area); newVertex = GraphTheoryFactory.createVertex(area.getGeometry(), true, vertexConfiguration.getId()); } else { newVertex = GraphTheoryFactory.createVertexCyleBased(center, vertexConfiguration.getId()); } } else { newVertex = GraphTheoryFactory.createVertexCyleBased(center, vertexConfiguration.getId()); } graph.addVertex(newVertex); } for(EdgeConfiguration edgeConfiguration : graphConfiguration.getEdges()) { Vertex left = graph.getVertex(edgeConfiguration.getIdLeft()); Vertex right = graph.getVertex(edgeConfiguration.getIdRight()); graph.doublyConnectVertices(left, right); } }
FromConfigurationOperation extends GraphOperation { @Override public void callPreProcessing(SimulationState simulationState) { Integer graphId = this.properties.getIntegerProperty(graphIdName); Double precisionSeed = this.properties.getDoubleProperty(precisionSeedName); Boolean insideAreaSeed = this.properties.getBooleanProperty(insideAreaSeedName); GraphScenarioConfiguration graphConfiguration = null; for(GraphScenarioConfiguration graphScenarioConfiguration : configurations.get(0).getGraphs()) { if(graphScenarioConfiguration.getId().intValue() == graphId) { graphConfiguration = graphScenarioConfiguration; } } HashSet<Area> alreadySeedAreas = new HashSet<>(); Graph graph = GraphTheoryFactory.createGraph(graphConfiguration.getName()); graph.setId(graphConfiguration.getId()); this.scenarioManager.getGraphs().add(graph); for(VertexConfiguration vertexConfiguration : graphConfiguration.getVertices()) { Vertex newVertex = null; Vector2D center = GeometryFactory.createVector(vertexConfiguration.getPoint().getX(), vertexConfiguration.getPoint().getY()); boolean isSeed = this.scenarioManager.getAreas() .stream() .filter(area -> { if(precisionSeed != null && FastMath.abs(area.getPointOfInterest().distance(center)) < precisionSeed) { return true; } else if (insideAreaSeed != null && insideAreaSeed && area.getGeometry().contains(center)) { return true; } return false; }) .count() > 0; if(isSeed) { Area area = this.scenarioManager.getAreas() .stream() .filter(existingArea -> { if(!alreadySeedAreas.contains(existingArea)) { if(precisionSeed != null && FastMath.abs(existingArea.getPointOfInterest().distance(center)) < precisionSeed) { return true; } else if (insideAreaSeed != null && insideAreaSeed && existingArea.getGeometry().contains(center)) { return true; } } return false; }) .findFirst() .orElse(null); if(area != null) { alreadySeedAreas.add(area); newVertex = GraphTheoryFactory.createVertex(area.getGeometry(), true, vertexConfiguration.getId()); } else { newVertex = GraphTheoryFactory.createVertexCyleBased(center, vertexConfiguration.getId()); } } else { newVertex = GraphTheoryFactory.createVertexCyleBased(center, vertexConfiguration.getId()); } graph.addVertex(newVertex); } for(EdgeConfiguration edgeConfiguration : graphConfiguration.getEdges()) { Vertex left = graph.getVertex(edgeConfiguration.getIdLeft()); Vertex right = graph.getVertex(edgeConfiguration.getIdRight()); graph.doublyConnectVertices(left, right); } } }
FromConfigurationOperation extends GraphOperation { @Override public void callPreProcessing(SimulationState simulationState) { Integer graphId = this.properties.getIntegerProperty(graphIdName); Double precisionSeed = this.properties.getDoubleProperty(precisionSeedName); Boolean insideAreaSeed = this.properties.getBooleanProperty(insideAreaSeedName); GraphScenarioConfiguration graphConfiguration = null; for(GraphScenarioConfiguration graphScenarioConfiguration : configurations.get(0).getGraphs()) { if(graphScenarioConfiguration.getId().intValue() == graphId) { graphConfiguration = graphScenarioConfiguration; } } HashSet<Area> alreadySeedAreas = new HashSet<>(); Graph graph = GraphTheoryFactory.createGraph(graphConfiguration.getName()); graph.setId(graphConfiguration.getId()); this.scenarioManager.getGraphs().add(graph); for(VertexConfiguration vertexConfiguration : graphConfiguration.getVertices()) { Vertex newVertex = null; Vector2D center = GeometryFactory.createVector(vertexConfiguration.getPoint().getX(), vertexConfiguration.getPoint().getY()); boolean isSeed = this.scenarioManager.getAreas() .stream() .filter(area -> { if(precisionSeed != null && FastMath.abs(area.getPointOfInterest().distance(center)) < precisionSeed) { return true; } else if (insideAreaSeed != null && insideAreaSeed && area.getGeometry().contains(center)) { return true; } return false; }) .count() > 0; if(isSeed) { Area area = this.scenarioManager.getAreas() .stream() .filter(existingArea -> { if(!alreadySeedAreas.contains(existingArea)) { if(precisionSeed != null && FastMath.abs(existingArea.getPointOfInterest().distance(center)) < precisionSeed) { return true; } else if (insideAreaSeed != null && insideAreaSeed && existingArea.getGeometry().contains(center)) { return true; } } return false; }) .findFirst() .orElse(null); if(area != null) { alreadySeedAreas.add(area); newVertex = GraphTheoryFactory.createVertex(area.getGeometry(), true, vertexConfiguration.getId()); } else { newVertex = GraphTheoryFactory.createVertexCyleBased(center, vertexConfiguration.getId()); } } else { newVertex = GraphTheoryFactory.createVertexCyleBased(center, vertexConfiguration.getId()); } graph.addVertex(newVertex); } for(EdgeConfiguration edgeConfiguration : graphConfiguration.getEdges()) { Vertex left = graph.getVertex(edgeConfiguration.getIdLeft()); Vertex right = graph.getVertex(edgeConfiguration.getIdRight()); graph.doublyConnectVertices(left, right); } } FromConfigurationOperation(ArrayList<ScenarioConfiguration> scenarioConfigurations); }
FromConfigurationOperation extends GraphOperation { @Override public void callPreProcessing(SimulationState simulationState) { Integer graphId = this.properties.getIntegerProperty(graphIdName); Double precisionSeed = this.properties.getDoubleProperty(precisionSeedName); Boolean insideAreaSeed = this.properties.getBooleanProperty(insideAreaSeedName); GraphScenarioConfiguration graphConfiguration = null; for(GraphScenarioConfiguration graphScenarioConfiguration : configurations.get(0).getGraphs()) { if(graphScenarioConfiguration.getId().intValue() == graphId) { graphConfiguration = graphScenarioConfiguration; } } HashSet<Area> alreadySeedAreas = new HashSet<>(); Graph graph = GraphTheoryFactory.createGraph(graphConfiguration.getName()); graph.setId(graphConfiguration.getId()); this.scenarioManager.getGraphs().add(graph); for(VertexConfiguration vertexConfiguration : graphConfiguration.getVertices()) { Vertex newVertex = null; Vector2D center = GeometryFactory.createVector(vertexConfiguration.getPoint().getX(), vertexConfiguration.getPoint().getY()); boolean isSeed = this.scenarioManager.getAreas() .stream() .filter(area -> { if(precisionSeed != null && FastMath.abs(area.getPointOfInterest().distance(center)) < precisionSeed) { return true; } else if (insideAreaSeed != null && insideAreaSeed && area.getGeometry().contains(center)) { return true; } return false; }) .count() > 0; if(isSeed) { Area area = this.scenarioManager.getAreas() .stream() .filter(existingArea -> { if(!alreadySeedAreas.contains(existingArea)) { if(precisionSeed != null && FastMath.abs(existingArea.getPointOfInterest().distance(center)) < precisionSeed) { return true; } else if (insideAreaSeed != null && insideAreaSeed && existingArea.getGeometry().contains(center)) { return true; } } return false; }) .findFirst() .orElse(null); if(area != null) { alreadySeedAreas.add(area); newVertex = GraphTheoryFactory.createVertex(area.getGeometry(), true, vertexConfiguration.getId()); } else { newVertex = GraphTheoryFactory.createVertexCyleBased(center, vertexConfiguration.getId()); } } else { newVertex = GraphTheoryFactory.createVertexCyleBased(center, vertexConfiguration.getId()); } graph.addVertex(newVertex); } for(EdgeConfiguration edgeConfiguration : graphConfiguration.getEdges()) { Vertex left = graph.getVertex(edgeConfiguration.getIdLeft()); Vertex right = graph.getVertex(edgeConfiguration.getIdRight()); graph.doublyConnectVertices(left, right); } } FromConfigurationOperation(ArrayList<ScenarioConfiguration> scenarioConfigurations); @Override void callPreProcessing(SimulationState simulationState); @Override void callPostProcessing(SimulationState simulationState); }
FromConfigurationOperation extends GraphOperation { @Override public void callPreProcessing(SimulationState simulationState) { Integer graphId = this.properties.getIntegerProperty(graphIdName); Double precisionSeed = this.properties.getDoubleProperty(precisionSeedName); Boolean insideAreaSeed = this.properties.getBooleanProperty(insideAreaSeedName); GraphScenarioConfiguration graphConfiguration = null; for(GraphScenarioConfiguration graphScenarioConfiguration : configurations.get(0).getGraphs()) { if(graphScenarioConfiguration.getId().intValue() == graphId) { graphConfiguration = graphScenarioConfiguration; } } HashSet<Area> alreadySeedAreas = new HashSet<>(); Graph graph = GraphTheoryFactory.createGraph(graphConfiguration.getName()); graph.setId(graphConfiguration.getId()); this.scenarioManager.getGraphs().add(graph); for(VertexConfiguration vertexConfiguration : graphConfiguration.getVertices()) { Vertex newVertex = null; Vector2D center = GeometryFactory.createVector(vertexConfiguration.getPoint().getX(), vertexConfiguration.getPoint().getY()); boolean isSeed = this.scenarioManager.getAreas() .stream() .filter(area -> { if(precisionSeed != null && FastMath.abs(area.getPointOfInterest().distance(center)) < precisionSeed) { return true; } else if (insideAreaSeed != null && insideAreaSeed && area.getGeometry().contains(center)) { return true; } return false; }) .count() > 0; if(isSeed) { Area area = this.scenarioManager.getAreas() .stream() .filter(existingArea -> { if(!alreadySeedAreas.contains(existingArea)) { if(precisionSeed != null && FastMath.abs(existingArea.getPointOfInterest().distance(center)) < precisionSeed) { return true; } else if (insideAreaSeed != null && insideAreaSeed && existingArea.getGeometry().contains(center)) { return true; } } return false; }) .findFirst() .orElse(null); if(area != null) { alreadySeedAreas.add(area); newVertex = GraphTheoryFactory.createVertex(area.getGeometry(), true, vertexConfiguration.getId()); } else { newVertex = GraphTheoryFactory.createVertexCyleBased(center, vertexConfiguration.getId()); } } else { newVertex = GraphTheoryFactory.createVertexCyleBased(center, vertexConfiguration.getId()); } graph.addVertex(newVertex); } for(EdgeConfiguration edgeConfiguration : graphConfiguration.getEdges()) { Vertex left = graph.getVertex(edgeConfiguration.getIdLeft()); Vertex right = graph.getVertex(edgeConfiguration.getIdRight()); graph.doublyConnectVertices(left, right); } } FromConfigurationOperation(ArrayList<ScenarioConfiguration> scenarioConfigurations); @Override void callPreProcessing(SimulationState simulationState); @Override void callPostProcessing(SimulationState simulationState); }
@Test @Parameters({"/layout_graph_test/FromGraphConfigurationOperation_insideArea_test.xml"}) public void fromConfiguration_loadsSingleVertexOnBorderOfArea_WithoutSuccess(String configurationFile) throws Exception { createConfiguration(configurationFile); createConfiguration(configurationFile); SimulationState state = mock(SimulationState.class); graphOperation.callPreProcessing(state); Vertex vertexInSideArea = scenarioManager.getGraph().getVertex(5); boolean isSeed = vertexInSideArea.isSeed(); boolean isInArea = scenarioManager.getArea(1).getGeometry().contains(vertexInSideArea.getGeometry().getCenter()); assertTrue(!isSeed && !isInArea); }
@Override public void callPreProcessing(SimulationState simulationState) { Integer graphId = this.properties.getIntegerProperty(graphIdName); Double precisionSeed = this.properties.getDoubleProperty(precisionSeedName); Boolean insideAreaSeed = this.properties.getBooleanProperty(insideAreaSeedName); GraphScenarioConfiguration graphConfiguration = null; for(GraphScenarioConfiguration graphScenarioConfiguration : configurations.get(0).getGraphs()) { if(graphScenarioConfiguration.getId().intValue() == graphId) { graphConfiguration = graphScenarioConfiguration; } } HashSet<Area> alreadySeedAreas = new HashSet<>(); Graph graph = GraphTheoryFactory.createGraph(graphConfiguration.getName()); graph.setId(graphConfiguration.getId()); this.scenarioManager.getGraphs().add(graph); for(VertexConfiguration vertexConfiguration : graphConfiguration.getVertices()) { Vertex newVertex = null; Vector2D center = GeometryFactory.createVector(vertexConfiguration.getPoint().getX(), vertexConfiguration.getPoint().getY()); boolean isSeed = this.scenarioManager.getAreas() .stream() .filter(area -> { if(precisionSeed != null && FastMath.abs(area.getPointOfInterest().distance(center)) < precisionSeed) { return true; } else if (insideAreaSeed != null && insideAreaSeed && area.getGeometry().contains(center)) { return true; } return false; }) .count() > 0; if(isSeed) { Area area = this.scenarioManager.getAreas() .stream() .filter(existingArea -> { if(!alreadySeedAreas.contains(existingArea)) { if(precisionSeed != null && FastMath.abs(existingArea.getPointOfInterest().distance(center)) < precisionSeed) { return true; } else if (insideAreaSeed != null && insideAreaSeed && existingArea.getGeometry().contains(center)) { return true; } } return false; }) .findFirst() .orElse(null); if(area != null) { alreadySeedAreas.add(area); newVertex = GraphTheoryFactory.createVertex(area.getGeometry(), true, vertexConfiguration.getId()); } else { newVertex = GraphTheoryFactory.createVertexCyleBased(center, vertexConfiguration.getId()); } } else { newVertex = GraphTheoryFactory.createVertexCyleBased(center, vertexConfiguration.getId()); } graph.addVertex(newVertex); } for(EdgeConfiguration edgeConfiguration : graphConfiguration.getEdges()) { Vertex left = graph.getVertex(edgeConfiguration.getIdLeft()); Vertex right = graph.getVertex(edgeConfiguration.getIdRight()); graph.doublyConnectVertices(left, right); } }
FromConfigurationOperation extends GraphOperation { @Override public void callPreProcessing(SimulationState simulationState) { Integer graphId = this.properties.getIntegerProperty(graphIdName); Double precisionSeed = this.properties.getDoubleProperty(precisionSeedName); Boolean insideAreaSeed = this.properties.getBooleanProperty(insideAreaSeedName); GraphScenarioConfiguration graphConfiguration = null; for(GraphScenarioConfiguration graphScenarioConfiguration : configurations.get(0).getGraphs()) { if(graphScenarioConfiguration.getId().intValue() == graphId) { graphConfiguration = graphScenarioConfiguration; } } HashSet<Area> alreadySeedAreas = new HashSet<>(); Graph graph = GraphTheoryFactory.createGraph(graphConfiguration.getName()); graph.setId(graphConfiguration.getId()); this.scenarioManager.getGraphs().add(graph); for(VertexConfiguration vertexConfiguration : graphConfiguration.getVertices()) { Vertex newVertex = null; Vector2D center = GeometryFactory.createVector(vertexConfiguration.getPoint().getX(), vertexConfiguration.getPoint().getY()); boolean isSeed = this.scenarioManager.getAreas() .stream() .filter(area -> { if(precisionSeed != null && FastMath.abs(area.getPointOfInterest().distance(center)) < precisionSeed) { return true; } else if (insideAreaSeed != null && insideAreaSeed && area.getGeometry().contains(center)) { return true; } return false; }) .count() > 0; if(isSeed) { Area area = this.scenarioManager.getAreas() .stream() .filter(existingArea -> { if(!alreadySeedAreas.contains(existingArea)) { if(precisionSeed != null && FastMath.abs(existingArea.getPointOfInterest().distance(center)) < precisionSeed) { return true; } else if (insideAreaSeed != null && insideAreaSeed && existingArea.getGeometry().contains(center)) { return true; } } return false; }) .findFirst() .orElse(null); if(area != null) { alreadySeedAreas.add(area); newVertex = GraphTheoryFactory.createVertex(area.getGeometry(), true, vertexConfiguration.getId()); } else { newVertex = GraphTheoryFactory.createVertexCyleBased(center, vertexConfiguration.getId()); } } else { newVertex = GraphTheoryFactory.createVertexCyleBased(center, vertexConfiguration.getId()); } graph.addVertex(newVertex); } for(EdgeConfiguration edgeConfiguration : graphConfiguration.getEdges()) { Vertex left = graph.getVertex(edgeConfiguration.getIdLeft()); Vertex right = graph.getVertex(edgeConfiguration.getIdRight()); graph.doublyConnectVertices(left, right); } } }
FromConfigurationOperation extends GraphOperation { @Override public void callPreProcessing(SimulationState simulationState) { Integer graphId = this.properties.getIntegerProperty(graphIdName); Double precisionSeed = this.properties.getDoubleProperty(precisionSeedName); Boolean insideAreaSeed = this.properties.getBooleanProperty(insideAreaSeedName); GraphScenarioConfiguration graphConfiguration = null; for(GraphScenarioConfiguration graphScenarioConfiguration : configurations.get(0).getGraphs()) { if(graphScenarioConfiguration.getId().intValue() == graphId) { graphConfiguration = graphScenarioConfiguration; } } HashSet<Area> alreadySeedAreas = new HashSet<>(); Graph graph = GraphTheoryFactory.createGraph(graphConfiguration.getName()); graph.setId(graphConfiguration.getId()); this.scenarioManager.getGraphs().add(graph); for(VertexConfiguration vertexConfiguration : graphConfiguration.getVertices()) { Vertex newVertex = null; Vector2D center = GeometryFactory.createVector(vertexConfiguration.getPoint().getX(), vertexConfiguration.getPoint().getY()); boolean isSeed = this.scenarioManager.getAreas() .stream() .filter(area -> { if(precisionSeed != null && FastMath.abs(area.getPointOfInterest().distance(center)) < precisionSeed) { return true; } else if (insideAreaSeed != null && insideAreaSeed && area.getGeometry().contains(center)) { return true; } return false; }) .count() > 0; if(isSeed) { Area area = this.scenarioManager.getAreas() .stream() .filter(existingArea -> { if(!alreadySeedAreas.contains(existingArea)) { if(precisionSeed != null && FastMath.abs(existingArea.getPointOfInterest().distance(center)) < precisionSeed) { return true; } else if (insideAreaSeed != null && insideAreaSeed && existingArea.getGeometry().contains(center)) { return true; } } return false; }) .findFirst() .orElse(null); if(area != null) { alreadySeedAreas.add(area); newVertex = GraphTheoryFactory.createVertex(area.getGeometry(), true, vertexConfiguration.getId()); } else { newVertex = GraphTheoryFactory.createVertexCyleBased(center, vertexConfiguration.getId()); } } else { newVertex = GraphTheoryFactory.createVertexCyleBased(center, vertexConfiguration.getId()); } graph.addVertex(newVertex); } for(EdgeConfiguration edgeConfiguration : graphConfiguration.getEdges()) { Vertex left = graph.getVertex(edgeConfiguration.getIdLeft()); Vertex right = graph.getVertex(edgeConfiguration.getIdRight()); graph.doublyConnectVertices(left, right); } } FromConfigurationOperation(ArrayList<ScenarioConfiguration> scenarioConfigurations); }
FromConfigurationOperation extends GraphOperation { @Override public void callPreProcessing(SimulationState simulationState) { Integer graphId = this.properties.getIntegerProperty(graphIdName); Double precisionSeed = this.properties.getDoubleProperty(precisionSeedName); Boolean insideAreaSeed = this.properties.getBooleanProperty(insideAreaSeedName); GraphScenarioConfiguration graphConfiguration = null; for(GraphScenarioConfiguration graphScenarioConfiguration : configurations.get(0).getGraphs()) { if(graphScenarioConfiguration.getId().intValue() == graphId) { graphConfiguration = graphScenarioConfiguration; } } HashSet<Area> alreadySeedAreas = new HashSet<>(); Graph graph = GraphTheoryFactory.createGraph(graphConfiguration.getName()); graph.setId(graphConfiguration.getId()); this.scenarioManager.getGraphs().add(graph); for(VertexConfiguration vertexConfiguration : graphConfiguration.getVertices()) { Vertex newVertex = null; Vector2D center = GeometryFactory.createVector(vertexConfiguration.getPoint().getX(), vertexConfiguration.getPoint().getY()); boolean isSeed = this.scenarioManager.getAreas() .stream() .filter(area -> { if(precisionSeed != null && FastMath.abs(area.getPointOfInterest().distance(center)) < precisionSeed) { return true; } else if (insideAreaSeed != null && insideAreaSeed && area.getGeometry().contains(center)) { return true; } return false; }) .count() > 0; if(isSeed) { Area area = this.scenarioManager.getAreas() .stream() .filter(existingArea -> { if(!alreadySeedAreas.contains(existingArea)) { if(precisionSeed != null && FastMath.abs(existingArea.getPointOfInterest().distance(center)) < precisionSeed) { return true; } else if (insideAreaSeed != null && insideAreaSeed && existingArea.getGeometry().contains(center)) { return true; } } return false; }) .findFirst() .orElse(null); if(area != null) { alreadySeedAreas.add(area); newVertex = GraphTheoryFactory.createVertex(area.getGeometry(), true, vertexConfiguration.getId()); } else { newVertex = GraphTheoryFactory.createVertexCyleBased(center, vertexConfiguration.getId()); } } else { newVertex = GraphTheoryFactory.createVertexCyleBased(center, vertexConfiguration.getId()); } graph.addVertex(newVertex); } for(EdgeConfiguration edgeConfiguration : graphConfiguration.getEdges()) { Vertex left = graph.getVertex(edgeConfiguration.getIdLeft()); Vertex right = graph.getVertex(edgeConfiguration.getIdRight()); graph.doublyConnectVertices(left, right); } } FromConfigurationOperation(ArrayList<ScenarioConfiguration> scenarioConfigurations); @Override void callPreProcessing(SimulationState simulationState); @Override void callPostProcessing(SimulationState simulationState); }
FromConfigurationOperation extends GraphOperation { @Override public void callPreProcessing(SimulationState simulationState) { Integer graphId = this.properties.getIntegerProperty(graphIdName); Double precisionSeed = this.properties.getDoubleProperty(precisionSeedName); Boolean insideAreaSeed = this.properties.getBooleanProperty(insideAreaSeedName); GraphScenarioConfiguration graphConfiguration = null; for(GraphScenarioConfiguration graphScenarioConfiguration : configurations.get(0).getGraphs()) { if(graphScenarioConfiguration.getId().intValue() == graphId) { graphConfiguration = graphScenarioConfiguration; } } HashSet<Area> alreadySeedAreas = new HashSet<>(); Graph graph = GraphTheoryFactory.createGraph(graphConfiguration.getName()); graph.setId(graphConfiguration.getId()); this.scenarioManager.getGraphs().add(graph); for(VertexConfiguration vertexConfiguration : graphConfiguration.getVertices()) { Vertex newVertex = null; Vector2D center = GeometryFactory.createVector(vertexConfiguration.getPoint().getX(), vertexConfiguration.getPoint().getY()); boolean isSeed = this.scenarioManager.getAreas() .stream() .filter(area -> { if(precisionSeed != null && FastMath.abs(area.getPointOfInterest().distance(center)) < precisionSeed) { return true; } else if (insideAreaSeed != null && insideAreaSeed && area.getGeometry().contains(center)) { return true; } return false; }) .count() > 0; if(isSeed) { Area area = this.scenarioManager.getAreas() .stream() .filter(existingArea -> { if(!alreadySeedAreas.contains(existingArea)) { if(precisionSeed != null && FastMath.abs(existingArea.getPointOfInterest().distance(center)) < precisionSeed) { return true; } else if (insideAreaSeed != null && insideAreaSeed && existingArea.getGeometry().contains(center)) { return true; } } return false; }) .findFirst() .orElse(null); if(area != null) { alreadySeedAreas.add(area); newVertex = GraphTheoryFactory.createVertex(area.getGeometry(), true, vertexConfiguration.getId()); } else { newVertex = GraphTheoryFactory.createVertexCyleBased(center, vertexConfiguration.getId()); } } else { newVertex = GraphTheoryFactory.createVertexCyleBased(center, vertexConfiguration.getId()); } graph.addVertex(newVertex); } for(EdgeConfiguration edgeConfiguration : graphConfiguration.getEdges()) { Vertex left = graph.getVertex(edgeConfiguration.getIdLeft()); Vertex right = graph.getVertex(edgeConfiguration.getIdRight()); graph.doublyConnectVertices(left, right); } } FromConfigurationOperation(ArrayList<ScenarioConfiguration> scenarioConfigurations); @Override void callPreProcessing(SimulationState simulationState); @Override void callPostProcessing(SimulationState simulationState); }
@Test @Parameters({"/layout_graph_test/FromGraphConfigurationOperation_withPrecisionSeed_test.xml"}) public void fromConfiguration_loadsSingleVertexWithPrecision_WithSuccess(String configurationFile) throws Exception { createConfiguration(configurationFile); createConfiguration(configurationFile); SimulationState state = mock(SimulationState.class); graphOperation.callPreProcessing(state); Vertex vertexInSideArea = scenarioManager.getGraph().getVertex(4); boolean isSeed = vertexInSideArea.isSeed(); boolean isInArea = scenarioManager.getArea(1).getGeometry().contains(vertexInSideArea.getGeometry().getCenter()); assertTrue(isSeed && isInArea); }
@Override public void callPreProcessing(SimulationState simulationState) { Integer graphId = this.properties.getIntegerProperty(graphIdName); Double precisionSeed = this.properties.getDoubleProperty(precisionSeedName); Boolean insideAreaSeed = this.properties.getBooleanProperty(insideAreaSeedName); GraphScenarioConfiguration graphConfiguration = null; for(GraphScenarioConfiguration graphScenarioConfiguration : configurations.get(0).getGraphs()) { if(graphScenarioConfiguration.getId().intValue() == graphId) { graphConfiguration = graphScenarioConfiguration; } } HashSet<Area> alreadySeedAreas = new HashSet<>(); Graph graph = GraphTheoryFactory.createGraph(graphConfiguration.getName()); graph.setId(graphConfiguration.getId()); this.scenarioManager.getGraphs().add(graph); for(VertexConfiguration vertexConfiguration : graphConfiguration.getVertices()) { Vertex newVertex = null; Vector2D center = GeometryFactory.createVector(vertexConfiguration.getPoint().getX(), vertexConfiguration.getPoint().getY()); boolean isSeed = this.scenarioManager.getAreas() .stream() .filter(area -> { if(precisionSeed != null && FastMath.abs(area.getPointOfInterest().distance(center)) < precisionSeed) { return true; } else if (insideAreaSeed != null && insideAreaSeed && area.getGeometry().contains(center)) { return true; } return false; }) .count() > 0; if(isSeed) { Area area = this.scenarioManager.getAreas() .stream() .filter(existingArea -> { if(!alreadySeedAreas.contains(existingArea)) { if(precisionSeed != null && FastMath.abs(existingArea.getPointOfInterest().distance(center)) < precisionSeed) { return true; } else if (insideAreaSeed != null && insideAreaSeed && existingArea.getGeometry().contains(center)) { return true; } } return false; }) .findFirst() .orElse(null); if(area != null) { alreadySeedAreas.add(area); newVertex = GraphTheoryFactory.createVertex(area.getGeometry(), true, vertexConfiguration.getId()); } else { newVertex = GraphTheoryFactory.createVertexCyleBased(center, vertexConfiguration.getId()); } } else { newVertex = GraphTheoryFactory.createVertexCyleBased(center, vertexConfiguration.getId()); } graph.addVertex(newVertex); } for(EdgeConfiguration edgeConfiguration : graphConfiguration.getEdges()) { Vertex left = graph.getVertex(edgeConfiguration.getIdLeft()); Vertex right = graph.getVertex(edgeConfiguration.getIdRight()); graph.doublyConnectVertices(left, right); } }
FromConfigurationOperation extends GraphOperation { @Override public void callPreProcessing(SimulationState simulationState) { Integer graphId = this.properties.getIntegerProperty(graphIdName); Double precisionSeed = this.properties.getDoubleProperty(precisionSeedName); Boolean insideAreaSeed = this.properties.getBooleanProperty(insideAreaSeedName); GraphScenarioConfiguration graphConfiguration = null; for(GraphScenarioConfiguration graphScenarioConfiguration : configurations.get(0).getGraphs()) { if(graphScenarioConfiguration.getId().intValue() == graphId) { graphConfiguration = graphScenarioConfiguration; } } HashSet<Area> alreadySeedAreas = new HashSet<>(); Graph graph = GraphTheoryFactory.createGraph(graphConfiguration.getName()); graph.setId(graphConfiguration.getId()); this.scenarioManager.getGraphs().add(graph); for(VertexConfiguration vertexConfiguration : graphConfiguration.getVertices()) { Vertex newVertex = null; Vector2D center = GeometryFactory.createVector(vertexConfiguration.getPoint().getX(), vertexConfiguration.getPoint().getY()); boolean isSeed = this.scenarioManager.getAreas() .stream() .filter(area -> { if(precisionSeed != null && FastMath.abs(area.getPointOfInterest().distance(center)) < precisionSeed) { return true; } else if (insideAreaSeed != null && insideAreaSeed && area.getGeometry().contains(center)) { return true; } return false; }) .count() > 0; if(isSeed) { Area area = this.scenarioManager.getAreas() .stream() .filter(existingArea -> { if(!alreadySeedAreas.contains(existingArea)) { if(precisionSeed != null && FastMath.abs(existingArea.getPointOfInterest().distance(center)) < precisionSeed) { return true; } else if (insideAreaSeed != null && insideAreaSeed && existingArea.getGeometry().contains(center)) { return true; } } return false; }) .findFirst() .orElse(null); if(area != null) { alreadySeedAreas.add(area); newVertex = GraphTheoryFactory.createVertex(area.getGeometry(), true, vertexConfiguration.getId()); } else { newVertex = GraphTheoryFactory.createVertexCyleBased(center, vertexConfiguration.getId()); } } else { newVertex = GraphTheoryFactory.createVertexCyleBased(center, vertexConfiguration.getId()); } graph.addVertex(newVertex); } for(EdgeConfiguration edgeConfiguration : graphConfiguration.getEdges()) { Vertex left = graph.getVertex(edgeConfiguration.getIdLeft()); Vertex right = graph.getVertex(edgeConfiguration.getIdRight()); graph.doublyConnectVertices(left, right); } } }
FromConfigurationOperation extends GraphOperation { @Override public void callPreProcessing(SimulationState simulationState) { Integer graphId = this.properties.getIntegerProperty(graphIdName); Double precisionSeed = this.properties.getDoubleProperty(precisionSeedName); Boolean insideAreaSeed = this.properties.getBooleanProperty(insideAreaSeedName); GraphScenarioConfiguration graphConfiguration = null; for(GraphScenarioConfiguration graphScenarioConfiguration : configurations.get(0).getGraphs()) { if(graphScenarioConfiguration.getId().intValue() == graphId) { graphConfiguration = graphScenarioConfiguration; } } HashSet<Area> alreadySeedAreas = new HashSet<>(); Graph graph = GraphTheoryFactory.createGraph(graphConfiguration.getName()); graph.setId(graphConfiguration.getId()); this.scenarioManager.getGraphs().add(graph); for(VertexConfiguration vertexConfiguration : graphConfiguration.getVertices()) { Vertex newVertex = null; Vector2D center = GeometryFactory.createVector(vertexConfiguration.getPoint().getX(), vertexConfiguration.getPoint().getY()); boolean isSeed = this.scenarioManager.getAreas() .stream() .filter(area -> { if(precisionSeed != null && FastMath.abs(area.getPointOfInterest().distance(center)) < precisionSeed) { return true; } else if (insideAreaSeed != null && insideAreaSeed && area.getGeometry().contains(center)) { return true; } return false; }) .count() > 0; if(isSeed) { Area area = this.scenarioManager.getAreas() .stream() .filter(existingArea -> { if(!alreadySeedAreas.contains(existingArea)) { if(precisionSeed != null && FastMath.abs(existingArea.getPointOfInterest().distance(center)) < precisionSeed) { return true; } else if (insideAreaSeed != null && insideAreaSeed && existingArea.getGeometry().contains(center)) { return true; } } return false; }) .findFirst() .orElse(null); if(area != null) { alreadySeedAreas.add(area); newVertex = GraphTheoryFactory.createVertex(area.getGeometry(), true, vertexConfiguration.getId()); } else { newVertex = GraphTheoryFactory.createVertexCyleBased(center, vertexConfiguration.getId()); } } else { newVertex = GraphTheoryFactory.createVertexCyleBased(center, vertexConfiguration.getId()); } graph.addVertex(newVertex); } for(EdgeConfiguration edgeConfiguration : graphConfiguration.getEdges()) { Vertex left = graph.getVertex(edgeConfiguration.getIdLeft()); Vertex right = graph.getVertex(edgeConfiguration.getIdRight()); graph.doublyConnectVertices(left, right); } } FromConfigurationOperation(ArrayList<ScenarioConfiguration> scenarioConfigurations); }
FromConfigurationOperation extends GraphOperation { @Override public void callPreProcessing(SimulationState simulationState) { Integer graphId = this.properties.getIntegerProperty(graphIdName); Double precisionSeed = this.properties.getDoubleProperty(precisionSeedName); Boolean insideAreaSeed = this.properties.getBooleanProperty(insideAreaSeedName); GraphScenarioConfiguration graphConfiguration = null; for(GraphScenarioConfiguration graphScenarioConfiguration : configurations.get(0).getGraphs()) { if(graphScenarioConfiguration.getId().intValue() == graphId) { graphConfiguration = graphScenarioConfiguration; } } HashSet<Area> alreadySeedAreas = new HashSet<>(); Graph graph = GraphTheoryFactory.createGraph(graphConfiguration.getName()); graph.setId(graphConfiguration.getId()); this.scenarioManager.getGraphs().add(graph); for(VertexConfiguration vertexConfiguration : graphConfiguration.getVertices()) { Vertex newVertex = null; Vector2D center = GeometryFactory.createVector(vertexConfiguration.getPoint().getX(), vertexConfiguration.getPoint().getY()); boolean isSeed = this.scenarioManager.getAreas() .stream() .filter(area -> { if(precisionSeed != null && FastMath.abs(area.getPointOfInterest().distance(center)) < precisionSeed) { return true; } else if (insideAreaSeed != null && insideAreaSeed && area.getGeometry().contains(center)) { return true; } return false; }) .count() > 0; if(isSeed) { Area area = this.scenarioManager.getAreas() .stream() .filter(existingArea -> { if(!alreadySeedAreas.contains(existingArea)) { if(precisionSeed != null && FastMath.abs(existingArea.getPointOfInterest().distance(center)) < precisionSeed) { return true; } else if (insideAreaSeed != null && insideAreaSeed && existingArea.getGeometry().contains(center)) { return true; } } return false; }) .findFirst() .orElse(null); if(area != null) { alreadySeedAreas.add(area); newVertex = GraphTheoryFactory.createVertex(area.getGeometry(), true, vertexConfiguration.getId()); } else { newVertex = GraphTheoryFactory.createVertexCyleBased(center, vertexConfiguration.getId()); } } else { newVertex = GraphTheoryFactory.createVertexCyleBased(center, vertexConfiguration.getId()); } graph.addVertex(newVertex); } for(EdgeConfiguration edgeConfiguration : graphConfiguration.getEdges()) { Vertex left = graph.getVertex(edgeConfiguration.getIdLeft()); Vertex right = graph.getVertex(edgeConfiguration.getIdRight()); graph.doublyConnectVertices(left, right); } } FromConfigurationOperation(ArrayList<ScenarioConfiguration> scenarioConfigurations); @Override void callPreProcessing(SimulationState simulationState); @Override void callPostProcessing(SimulationState simulationState); }
FromConfigurationOperation extends GraphOperation { @Override public void callPreProcessing(SimulationState simulationState) { Integer graphId = this.properties.getIntegerProperty(graphIdName); Double precisionSeed = this.properties.getDoubleProperty(precisionSeedName); Boolean insideAreaSeed = this.properties.getBooleanProperty(insideAreaSeedName); GraphScenarioConfiguration graphConfiguration = null; for(GraphScenarioConfiguration graphScenarioConfiguration : configurations.get(0).getGraphs()) { if(graphScenarioConfiguration.getId().intValue() == graphId) { graphConfiguration = graphScenarioConfiguration; } } HashSet<Area> alreadySeedAreas = new HashSet<>(); Graph graph = GraphTheoryFactory.createGraph(graphConfiguration.getName()); graph.setId(graphConfiguration.getId()); this.scenarioManager.getGraphs().add(graph); for(VertexConfiguration vertexConfiguration : graphConfiguration.getVertices()) { Vertex newVertex = null; Vector2D center = GeometryFactory.createVector(vertexConfiguration.getPoint().getX(), vertexConfiguration.getPoint().getY()); boolean isSeed = this.scenarioManager.getAreas() .stream() .filter(area -> { if(precisionSeed != null && FastMath.abs(area.getPointOfInterest().distance(center)) < precisionSeed) { return true; } else if (insideAreaSeed != null && insideAreaSeed && area.getGeometry().contains(center)) { return true; } return false; }) .count() > 0; if(isSeed) { Area area = this.scenarioManager.getAreas() .stream() .filter(existingArea -> { if(!alreadySeedAreas.contains(existingArea)) { if(precisionSeed != null && FastMath.abs(existingArea.getPointOfInterest().distance(center)) < precisionSeed) { return true; } else if (insideAreaSeed != null && insideAreaSeed && existingArea.getGeometry().contains(center)) { return true; } } return false; }) .findFirst() .orElse(null); if(area != null) { alreadySeedAreas.add(area); newVertex = GraphTheoryFactory.createVertex(area.getGeometry(), true, vertexConfiguration.getId()); } else { newVertex = GraphTheoryFactory.createVertexCyleBased(center, vertexConfiguration.getId()); } } else { newVertex = GraphTheoryFactory.createVertexCyleBased(center, vertexConfiguration.getId()); } graph.addVertex(newVertex); } for(EdgeConfiguration edgeConfiguration : graphConfiguration.getEdges()) { Vertex left = graph.getVertex(edgeConfiguration.getIdLeft()); Vertex right = graph.getVertex(edgeConfiguration.getIdRight()); graph.doublyConnectVertices(left, right); } } FromConfigurationOperation(ArrayList<ScenarioConfiguration> scenarioConfigurations); @Override void callPreProcessing(SimulationState simulationState); @Override void callPostProcessing(SimulationState simulationState); }
@Test public void calculateTimeToConflictPoint() throws Exception { Vector2D curPosition, curVelocity, othPosition, othVelocity; curPosition = GeometryFactory.createVector(0, 0); curVelocity = GeometryFactory.createVector(0, 1); othPosition = GeometryFactory.createVector(2, 2); othVelocity = GeometryFactory.createVector(-1, 0); Assert.assertEquals(0.0, ZengAdditionalComputations.calculateTimeToConflictPoint(curPosition, curVelocity, othPosition, othVelocity), PRECISION); curPosition = GeometryFactory.createVector(0, 0); curVelocity = GeometryFactory.createVector(1, 1); othPosition = GeometryFactory.createVector(2, 0); othVelocity = GeometryFactory.createVector(-1, 1); Assert.assertEquals(0.0, ZengAdditionalComputations.calculateTimeToConflictPoint(curPosition, curVelocity, othPosition, othVelocity), PRECISION); curPosition = GeometryFactory.createVector(0, 0); curVelocity = GeometryFactory.createVector(0, 1); othPosition = GeometryFactory.createVector(1, 0); othVelocity = GeometryFactory.createVector(-1, -1); Assert.assertEquals(Double.POSITIVE_INFINITY, ZengAdditionalComputations.calculateTimeToConflictPoint(curPosition, curVelocity, othPosition, othVelocity), PRECISION); curPosition = GeometryFactory.createVector(0, 0); curVelocity = GeometryFactory.createVector(1, 0); othPosition = GeometryFactory.createVector(11, 1); othVelocity = GeometryFactory.createVector(0, -1); Assert.assertEquals(10.0, ZengAdditionalComputations.calculateTimeToConflictPoint(curPosition, curVelocity, othPosition, othVelocity), PRECISION); curPosition = GeometryFactory.createVector(0, 0); curVelocity = GeometryFactory.createVector(0, 1); othPosition = GeometryFactory.createVector(0, 10); othVelocity = GeometryFactory.createVector(0, -1); Assert.assertEquals(0.0, ZengAdditionalComputations.calculateTimeToConflictPoint(curPosition, curVelocity, othPosition, othVelocity), PRECISION); }
public static Double calculateTimeToConflictPoint(Vector2D currentPosition, Vector2D currentVelocity, Vector2D otherPosition, Vector2D otherVelocity) { if(currentVelocity.isZero() || otherVelocity.isZero()) { return Double.POSITIVE_INFINITY; } Ray2D currentRay = GeometryFactory.createRay2D(currentPosition, currentVelocity); Ray2D otherRay = GeometryFactory.createRay2D(otherPosition, otherVelocity); Vector2D conflictPoint = currentRay.intersectionPoint(otherRay); if(conflictPoint != null) { double curTimeToConflictPoint = (conflictPoint.subtract(currentPosition).getMagnitude() / currentVelocity.getMagnitude()); double othTimeToConflictPoint = (conflictPoint.subtract(otherPosition).getMagnitude() / otherVelocity.getMagnitude()); return Math.abs(curTimeToConflictPoint - othTimeToConflictPoint); } Segment2D conflictSegment = currentRay.intersectionSegment(otherRay); if(conflictSegment != null) { return 0.0; } Ray2D conflictRay = currentRay.intersectionRay(otherRay); if(conflictRay != null) { return 0.0; } return Double.POSITIVE_INFINITY; }
ZengAdditionalComputations { public static Double calculateTimeToConflictPoint(Vector2D currentPosition, Vector2D currentVelocity, Vector2D otherPosition, Vector2D otherVelocity) { if(currentVelocity.isZero() || otherVelocity.isZero()) { return Double.POSITIVE_INFINITY; } Ray2D currentRay = GeometryFactory.createRay2D(currentPosition, currentVelocity); Ray2D otherRay = GeometryFactory.createRay2D(otherPosition, otherVelocity); Vector2D conflictPoint = currentRay.intersectionPoint(otherRay); if(conflictPoint != null) { double curTimeToConflictPoint = (conflictPoint.subtract(currentPosition).getMagnitude() / currentVelocity.getMagnitude()); double othTimeToConflictPoint = (conflictPoint.subtract(otherPosition).getMagnitude() / otherVelocity.getMagnitude()); return Math.abs(curTimeToConflictPoint - othTimeToConflictPoint); } Segment2D conflictSegment = currentRay.intersectionSegment(otherRay); if(conflictSegment != null) { return 0.0; } Ray2D conflictRay = currentRay.intersectionRay(otherRay); if(conflictRay != null) { return 0.0; } return Double.POSITIVE_INFINITY; } }
ZengAdditionalComputations { public static Double calculateTimeToConflictPoint(Vector2D currentPosition, Vector2D currentVelocity, Vector2D otherPosition, Vector2D otherVelocity) { if(currentVelocity.isZero() || otherVelocity.isZero()) { return Double.POSITIVE_INFINITY; } Ray2D currentRay = GeometryFactory.createRay2D(currentPosition, currentVelocity); Ray2D otherRay = GeometryFactory.createRay2D(otherPosition, otherVelocity); Vector2D conflictPoint = currentRay.intersectionPoint(otherRay); if(conflictPoint != null) { double curTimeToConflictPoint = (conflictPoint.subtract(currentPosition).getMagnitude() / currentVelocity.getMagnitude()); double othTimeToConflictPoint = (conflictPoint.subtract(otherPosition).getMagnitude() / otherVelocity.getMagnitude()); return Math.abs(curTimeToConflictPoint - othTimeToConflictPoint); } Segment2D conflictSegment = currentRay.intersectionSegment(otherRay); if(conflictSegment != null) { return 0.0; } Ray2D conflictRay = currentRay.intersectionRay(otherRay); if(conflictRay != null) { return 0.0; } return Double.POSITIVE_INFINITY; } }
ZengAdditionalComputations { public static Double calculateTimeToConflictPoint(Vector2D currentPosition, Vector2D currentVelocity, Vector2D otherPosition, Vector2D otherVelocity) { if(currentVelocity.isZero() || otherVelocity.isZero()) { return Double.POSITIVE_INFINITY; } Ray2D currentRay = GeometryFactory.createRay2D(currentPosition, currentVelocity); Ray2D otherRay = GeometryFactory.createRay2D(otherPosition, otherVelocity); Vector2D conflictPoint = currentRay.intersectionPoint(otherRay); if(conflictPoint != null) { double curTimeToConflictPoint = (conflictPoint.subtract(currentPosition).getMagnitude() / currentVelocity.getMagnitude()); double othTimeToConflictPoint = (conflictPoint.subtract(otherPosition).getMagnitude() / otherVelocity.getMagnitude()); return Math.abs(curTimeToConflictPoint - othTimeToConflictPoint); } Segment2D conflictSegment = currentRay.intersectionSegment(otherRay); if(conflictSegment != null) { return 0.0; } Ray2D conflictRay = currentRay.intersectionRay(otherRay); if(conflictRay != null) { return 0.0; } return Double.POSITIVE_INFINITY; } static Vector2D computeRepulsiveForceConflictingPedestrians(IOperationalPedestrian pedestrian, Collection<IPedestrian> otherPedestrians, double timeStepDuration, double interaction_strength_for_repulsive_force_from_surrounding_pedestrians, double interaction_range_for_relative_distance, double range_for_relative_conflicting_time, double strength_of_forces_exerted_from_other_pedestrians); static Double calculateTimeToConflictPoint(Vector2D currentPosition, Vector2D currentVelocity, Vector2D otherPosition, Vector2D otherVelocity); static double calculateInteractionAngleFactor(Vector2D currentVelocity, Vector2D distance, double influenceStrength); static TaggedArea findCorrespondingCrosswalk(IOperationalPedestrian pedestrian, List<TaggedArea> crosswalkAreas); static Vector2D findNearestCrosswalkBoundaryPoint(IOperationalPedestrian pedestrian, TaggedArea nextCrosswalk, double epsilon); }
ZengAdditionalComputations { public static Double calculateTimeToConflictPoint(Vector2D currentPosition, Vector2D currentVelocity, Vector2D otherPosition, Vector2D otherVelocity) { if(currentVelocity.isZero() || otherVelocity.isZero()) { return Double.POSITIVE_INFINITY; } Ray2D currentRay = GeometryFactory.createRay2D(currentPosition, currentVelocity); Ray2D otherRay = GeometryFactory.createRay2D(otherPosition, otherVelocity); Vector2D conflictPoint = currentRay.intersectionPoint(otherRay); if(conflictPoint != null) { double curTimeToConflictPoint = (conflictPoint.subtract(currentPosition).getMagnitude() / currentVelocity.getMagnitude()); double othTimeToConflictPoint = (conflictPoint.subtract(otherPosition).getMagnitude() / otherVelocity.getMagnitude()); return Math.abs(curTimeToConflictPoint - othTimeToConflictPoint); } Segment2D conflictSegment = currentRay.intersectionSegment(otherRay); if(conflictSegment != null) { return 0.0; } Ray2D conflictRay = currentRay.intersectionRay(otherRay); if(conflictRay != null) { return 0.0; } return Double.POSITIVE_INFINITY; } static Vector2D computeRepulsiveForceConflictingPedestrians(IOperationalPedestrian pedestrian, Collection<IPedestrian> otherPedestrians, double timeStepDuration, double interaction_strength_for_repulsive_force_from_surrounding_pedestrians, double interaction_range_for_relative_distance, double range_for_relative_conflicting_time, double strength_of_forces_exerted_from_other_pedestrians); static Double calculateTimeToConflictPoint(Vector2D currentPosition, Vector2D currentVelocity, Vector2D otherPosition, Vector2D otherVelocity); static double calculateInteractionAngleFactor(Vector2D currentVelocity, Vector2D distance, double influenceStrength); static TaggedArea findCorrespondingCrosswalk(IOperationalPedestrian pedestrian, List<TaggedArea> crosswalkAreas); static Vector2D findNearestCrosswalkBoundaryPoint(IOperationalPedestrian pedestrian, TaggedArea nextCrosswalk, double epsilon); }
@Test public void isVisible() throws Exception { SightConePerceptionModel sightConePerceptionModelModel = new SightConePerceptionModel(); sightConePerceptionModelModel.setAngle(90); sightConePerceptionModelModel.setRadius(30); Vector2D curPedPos, curPedHead, otherPedPos, otherPedHead; curPedPos = GeometryFactory.createVector(0,0); curPedHead = GeometryFactory.createVector(1,0); otherPedPos = GeometryFactory.createVector(20,0); otherPedHead = GeometryFactory.createVector(1,0); currentPedestrian.setWalkingState(new WalkingState(curPedPos, curPedHead, curPedHead)); otherPedestrian.setWalkingState(new WalkingState(otherPedPos, otherPedHead, otherPedHead)); assertTrue(sightConePerceptionModelModel.isVisible(currentPedestrian, otherPedestrian)); otherPedPos.set(30.1, 0); assertFalse(sightConePerceptionModelModel.isVisible(currentPedestrian, otherPedestrian)); otherPedPos.set(20, 20); assertTrue(sightConePerceptionModelModel.isVisible(currentPedestrian, otherPedestrian)); otherPedPos.set(0, 20); assertFalse(sightConePerceptionModelModel.isVisible(currentPedestrian, otherPedestrian)); otherPedPos.set(Math.cos(Math.toRadians(-46)), Math.sin(Math.toRadians(-46))); assertFalse(sightConePerceptionModelModel.isVisible(currentPedestrian, otherPedestrian)); otherPedPos.set(Math.cos(Math.toRadians(-44)), Math.sin(Math.toRadians(-44))); assertTrue(sightConePerceptionModelModel.isVisible(currentPedestrian, otherPedestrian)); curPedPos.set(10,10); curPedHead.set(0,-1); otherPedPos.set(10, 11); assertFalse(sightConePerceptionModelModel.isVisible(currentPedestrian, otherPedestrian)); otherPedPos.set(10, 11); assertFalse(sightConePerceptionModelModel.isVisible(currentPedestrian, otherPedestrian)); otherPedPos.set(10, 9); assertTrue(sightConePerceptionModelModel.isVisible(currentPedestrian, otherPedestrian)); otherPedPos.set(10 + Math.cos(-46), 10 + Math.sin(-46)); assertTrue(sightConePerceptionModelModel.isVisible(currentPedestrian, otherPedestrian)); otherPedPos.set(10 + Math.cos(-44.5)*5, 10 + Math.sin(-44.5)*5); assertFalse(sightConePerceptionModelModel.isVisible(currentPedestrian, otherPedestrian)); }
@Override public boolean isVisible(IPedestrian currentPedestrian, IPedestrian otherPedestrian) { return isVisible(currentPedestrian, otherPedestrian.getPosition()); }
SightConePerceptionModel extends PerceptionalModel { @Override public boolean isVisible(IPedestrian currentPedestrian, IPedestrian otherPedestrian) { return isVisible(currentPedestrian, otherPedestrian.getPosition()); } }
SightConePerceptionModel extends PerceptionalModel { @Override public boolean isVisible(IPedestrian currentPedestrian, IPedestrian otherPedestrian) { return isVisible(currentPedestrian, otherPedestrian.getPosition()); } }
SightConePerceptionModel extends PerceptionalModel { @Override public boolean isVisible(IPedestrian currentPedestrian, IPedestrian otherPedestrian) { return isVisible(currentPedestrian, otherPedestrian.getPosition()); } void setRadius(double radius); void setAngle(double angle); @Override void callPreProcessing(SimulationState simulationState); @Override void callPostProcessing(SimulationState simulationState); @Override List<IPedestrian> getPerceptedPedestrians(IPedestrian currentPedestrian, SimulationState simulationState); @Override boolean isVisible(IPedestrian currentPedestrian, IPedestrian otherPedestrian); @Override boolean isVisible(IPedestrian pedestrian, Vector2D position); @Override boolean isVisible(IPedestrian pedestrian, Area area); @Override boolean isVisible(IPedestrian pedestrian, Vertex vertex); @Override boolean isVisible(IPedestrian pedestrian, Edge edge); @Override boolean isVisible(Vector2D viewPort, Vector2D position); @Override double getPerceptionDistance(); @Override List<Vector2D> getPerceptedObstaclePositions(IPedestrian pedestrian, SimulationState simulationState); @Override List<IPedestrian> getPerceptedPedestrianPositions(IPedestrian pedestrian, SimulationState simulationState); @Override List<Vector2D> getPerceptedFreePositions(IPedestrian pedestrian, SimulationState simulationState); }
SightConePerceptionModel extends PerceptionalModel { @Override public boolean isVisible(IPedestrian currentPedestrian, IPedestrian otherPedestrian) { return isVisible(currentPedestrian, otherPedestrian.getPosition()); } void setRadius(double radius); void setAngle(double angle); @Override void callPreProcessing(SimulationState simulationState); @Override void callPostProcessing(SimulationState simulationState); @Override List<IPedestrian> getPerceptedPedestrians(IPedestrian currentPedestrian, SimulationState simulationState); @Override boolean isVisible(IPedestrian currentPedestrian, IPedestrian otherPedestrian); @Override boolean isVisible(IPedestrian pedestrian, Vector2D position); @Override boolean isVisible(IPedestrian pedestrian, Area area); @Override boolean isVisible(IPedestrian pedestrian, Vertex vertex); @Override boolean isVisible(IPedestrian pedestrian, Edge edge); @Override boolean isVisible(Vector2D viewPort, Vector2D position); @Override double getPerceptionDistance(); @Override List<Vector2D> getPerceptedObstaclePositions(IPedestrian pedestrian, SimulationState simulationState); @Override List<IPedestrian> getPerceptedPedestrianPositions(IPedestrian pedestrian, SimulationState simulationState); @Override List<Vector2D> getPerceptedFreePositions(IPedestrian pedestrian, SimulationState simulationState); }
@Test public void closestPoint() throws Exception { F1 = GeometryFactory.createVector(0, 0); F2 = GeometryFactory.createVector(2, 0); minorAxis = 2; ellipse = GeometryFactory.createEllipse(F1, F2, minorAxis); point = GeometryFactory.createVector(1, 3); closestPoint = ellipse.closestPoint(point); Assert.assertEquals(1, closestPoint.getXComponent(), PRECISION); Assert.assertEquals(2, closestPoint.getYComponent(), PRECISION); ellipse = GeometryFactory.createEllipse(new Vector2D(10, 10), new Vector2D(1, 0), 1, 1); point = new Vector2D(12, 12); Assert.assertEquals(10+Math.sqrt(2)/2, ellipse.closestPoint(point).getXComponent(), PRECISION); Assert.assertEquals(10+Math.sqrt(2)/2, ellipse.closestPoint(point).getXComponent(), PRECISION); }
public Vector2D closestPoint(Vector2D point) { return null; }
Ellipse2D { public Vector2D closestPoint(Vector2D point) { return null; } }
Ellipse2D { public Vector2D closestPoint(Vector2D point) { return null; } Ellipse2D(Vector2D center, Vector2D direction, double majorAxis, double minorAxis); }
Ellipse2D { public Vector2D closestPoint(Vector2D point) { return null; } Ellipse2D(Vector2D center, Vector2D direction, double majorAxis, double minorAxis); Vector2D closestPoint(Vector2D point); Vector2D vectorBetween(Vector2D point); Vector2D normal(Vector2D point); Vector2D getCenter(); void setCenter(Vector2D center); double getOrientation(); double getMajorAxis(); double getMinorAxis(); void translate(double x, double y); void translate(Vector2D vector); }
Ellipse2D { public Vector2D closestPoint(Vector2D point) { return null; } Ellipse2D(Vector2D center, Vector2D direction, double majorAxis, double minorAxis); Vector2D closestPoint(Vector2D point); Vector2D vectorBetween(Vector2D point); Vector2D normal(Vector2D point); Vector2D getCenter(); void setCenter(Vector2D center); double getOrientation(); double getMajorAxis(); double getMinorAxis(); void translate(double x, double y); void translate(Vector2D vector); }
@Test public void vectorBetween() throws Exception { Vector2D vectorBetween; F1 = GeometryFactory.createVector(0, 0); F2 = GeometryFactory.createVector(2, 0); minorAxis = 2; ellipse = GeometryFactory.createEllipse(F1, F2, minorAxis); point = GeometryFactory.createVector(1, 3); vectorBetween = ellipse.vectorBetween(point); Assert.assertEquals(0, vectorBetween.getXComponent(), PRECISION); Assert.assertEquals(1, vectorBetween.getYComponent(), PRECISION); ellipse = GeometryFactory.createEllipse(new Vector2D(10, 10), new Vector2D(1, 0), 1, 1); Assert.assertEquals(0, ellipse.getOrientation(), PRECISION); point = new Vector2D(12,12); closestPoint = ellipse.closestPoint(point); vectorBetween = ellipse.vectorBetween(point); Assert.assertEquals(2 - Math.sqrt(2)/2, vectorBetween.getXComponent(), PRECISION); Assert.assertEquals(2 - Math.sqrt(2)/2, vectorBetween.getYComponent(), PRECISION); }
public Vector2D vectorBetween(Vector2D point) { Vector2D closestPoint = closestPoint(point); return point.subtract(closestPoint); }
Ellipse2D { public Vector2D vectorBetween(Vector2D point) { Vector2D closestPoint = closestPoint(point); return point.subtract(closestPoint); } }
Ellipse2D { public Vector2D vectorBetween(Vector2D point) { Vector2D closestPoint = closestPoint(point); return point.subtract(closestPoint); } Ellipse2D(Vector2D center, Vector2D direction, double majorAxis, double minorAxis); }
Ellipse2D { public Vector2D vectorBetween(Vector2D point) { Vector2D closestPoint = closestPoint(point); return point.subtract(closestPoint); } Ellipse2D(Vector2D center, Vector2D direction, double majorAxis, double minorAxis); Vector2D closestPoint(Vector2D point); Vector2D vectorBetween(Vector2D point); Vector2D normal(Vector2D point); Vector2D getCenter(); void setCenter(Vector2D center); double getOrientation(); double getMajorAxis(); double getMinorAxis(); void translate(double x, double y); void translate(Vector2D vector); }
Ellipse2D { public Vector2D vectorBetween(Vector2D point) { Vector2D closestPoint = closestPoint(point); return point.subtract(closestPoint); } Ellipse2D(Vector2D center, Vector2D direction, double majorAxis, double minorAxis); Vector2D closestPoint(Vector2D point); Vector2D vectorBetween(Vector2D point); Vector2D normal(Vector2D point); Vector2D getCenter(); void setCenter(Vector2D center); double getOrientation(); double getMajorAxis(); double getMinorAxis(); void translate(double x, double y); void translate(Vector2D vector); }
@Test public void normal() throws Exception { center = GeometryFactory.createVector(1, 1); direction = GeometryFactory.createVector(1, 1); minorAxis = 2; majorAxis = 5; ellipse = GeometryFactory.createEllipse(center, direction, majorAxis, minorAxis); point = GeometryFactory.createVector(1-1/Math.sqrt(2), 1+1/Math.sqrt(2)); normal = ellipse.normal(point); Assert.assertEquals(-1/Math.sqrt(2), normal.getXComponent(), PRECISION); Assert.assertEquals(1/Math.sqrt(2), normal.getYComponent(), PRECISION); F1 = GeometryFactory.createVector(0, 0); F2 = GeometryFactory.createVector(2, 0); minorAxis = 2; ellipse = GeometryFactory.createEllipse(F1, F2, minorAxis); point = GeometryFactory.createVector(1, 3); normal = ellipse.normal(point); Assert.assertEquals(0, normal.getXComponent(), PRECISION); Assert.assertEquals(1, normal.getYComponent(), PRECISION); F1 = GeometryFactory.createVector(0, 0); F2 = GeometryFactory.createVector(2, 2); minorAxis = 1; ellipse = GeometryFactory.createEllipse(F1, F2, minorAxis); Assert.assertEquals(Math.sqrt(3), ellipse.getMajorAxis(), PRECISION); point = GeometryFactory.createVector(2.5, 2.5); normal = ellipse.normal(point); Assert.assertEquals(Math.sqrt(2)/2, normal.getXComponent(), PRECISION); Assert.assertEquals(Math.sqrt(2)/2, normal.getYComponent(), PRECISION); F1 = GeometryFactory.createVector(0, 0); F2 = GeometryFactory.createVector(2, 2); minorAxis = 1; ellipse = GeometryFactory.createEllipse(F1, F2, minorAxis); point = GeometryFactory.createVector(-1, -1); normal = ellipse.normal(point); Assert.assertEquals(-Math.sqrt(2)/2, normal.getXComponent(), PRECISION); Assert.assertEquals(-Math.sqrt(2)/2, normal.getYComponent(), PRECISION); center = GeometryFactory.createVector(1, 0); direction = GeometryFactory.createVector(1, 0); minorAxis = 2; majorAxis = 5; ellipse = GeometryFactory.createEllipse(center, direction, majorAxis, minorAxis); point = GeometryFactory.createVector(1, 5); normal = ellipse.normal(point); Assert.assertEquals(0, normal.getXComponent(), PRECISION); Assert.assertEquals(1, normal.getYComponent(), PRECISION); }
public Vector2D normal(Vector2D point) { Vector2D pointOnEllipse = closestPoint(point); pointOnEllipse = pointOnEllipse.subtract(this.getCenter()).rotate(-this.getOrientation()); Vector2D normal = new Vector2D(pointOnEllipse.getXComponent() * getMinorAxis()/getMajorAxis(), pointOnEllipse.getYComponent() * getMajorAxis()/getMinorAxis()); return normal.rotate(this.getOrientation()).getNormalized(); }
Ellipse2D { public Vector2D normal(Vector2D point) { Vector2D pointOnEllipse = closestPoint(point); pointOnEllipse = pointOnEllipse.subtract(this.getCenter()).rotate(-this.getOrientation()); Vector2D normal = new Vector2D(pointOnEllipse.getXComponent() * getMinorAxis()/getMajorAxis(), pointOnEllipse.getYComponent() * getMajorAxis()/getMinorAxis()); return normal.rotate(this.getOrientation()).getNormalized(); } }
Ellipse2D { public Vector2D normal(Vector2D point) { Vector2D pointOnEllipse = closestPoint(point); pointOnEllipse = pointOnEllipse.subtract(this.getCenter()).rotate(-this.getOrientation()); Vector2D normal = new Vector2D(pointOnEllipse.getXComponent() * getMinorAxis()/getMajorAxis(), pointOnEllipse.getYComponent() * getMajorAxis()/getMinorAxis()); return normal.rotate(this.getOrientation()).getNormalized(); } Ellipse2D(Vector2D center, Vector2D direction, double majorAxis, double minorAxis); }
Ellipse2D { public Vector2D normal(Vector2D point) { Vector2D pointOnEllipse = closestPoint(point); pointOnEllipse = pointOnEllipse.subtract(this.getCenter()).rotate(-this.getOrientation()); Vector2D normal = new Vector2D(pointOnEllipse.getXComponent() * getMinorAxis()/getMajorAxis(), pointOnEllipse.getYComponent() * getMajorAxis()/getMinorAxis()); return normal.rotate(this.getOrientation()).getNormalized(); } Ellipse2D(Vector2D center, Vector2D direction, double majorAxis, double minorAxis); Vector2D closestPoint(Vector2D point); Vector2D vectorBetween(Vector2D point); Vector2D normal(Vector2D point); Vector2D getCenter(); void setCenter(Vector2D center); double getOrientation(); double getMajorAxis(); double getMinorAxis(); void translate(double x, double y); void translate(Vector2D vector); }
Ellipse2D { public Vector2D normal(Vector2D point) { Vector2D pointOnEllipse = closestPoint(point); pointOnEllipse = pointOnEllipse.subtract(this.getCenter()).rotate(-this.getOrientation()); Vector2D normal = new Vector2D(pointOnEllipse.getXComponent() * getMinorAxis()/getMajorAxis(), pointOnEllipse.getYComponent() * getMajorAxis()/getMinorAxis()); return normal.rotate(this.getOrientation()).getNormalized(); } Ellipse2D(Vector2D center, Vector2D direction, double majorAxis, double minorAxis); Vector2D closestPoint(Vector2D point); Vector2D vectorBetween(Vector2D point); Vector2D normal(Vector2D point); Vector2D getCenter(); void setCenter(Vector2D center); double getOrientation(); double getMajorAxis(); double getMinorAxis(); void translate(double x, double y); void translate(Vector2D vector); }
@Test public void vectorBetween() throws Exception { center = GeometryFactory.createVector(0, 0); direction = GeometryFactory.createVector(1, 0); width = 2; height = 6; rectangle = new Rectangle2D(center, direction, width, height); point = GeometryFactory.createVector(3, 2); Assert.assertEquals(1, rectangle.distanceBetween(point), PRECISION); point = GeometryFactory.createVector(-4, 2); Assert.assertEquals(Math.sqrt(2), rectangle.distanceBetween(point), PRECISION); point = GeometryFactory.createVector(3, 2); Vector2D between = rectangle.vectorBetween(point); Assert.assertEquals(0, between.getXComponent(), PRECISION); Assert.assertEquals(-1, between.getYComponent(), PRECISION); }
@Override public Vector2D vectorBetween(Vector2D point) { return this.rectangleAsSegments().vectorBetween(point); }
Rectangle2D extends Geometry2D { @Override public Vector2D vectorBetween(Vector2D point) { return this.rectangleAsSegments().vectorBetween(point); } }
Rectangle2D extends Geometry2D { @Override public Vector2D vectorBetween(Vector2D point) { return this.rectangleAsSegments().vectorBetween(point); } Rectangle2D(Vector2D center, Vector2D direction, double width, double height); }
Rectangle2D extends Geometry2D { @Override public Vector2D vectorBetween(Vector2D point) { return this.rectangleAsSegments().vectorBetween(point); } Rectangle2D(Vector2D center, Vector2D direction, double width, double height); @Override double distanceBetween(Vector2D point); @Override double minimalDistanceBetween(List<Vector2D> points); @Override Vector2D vectorBetween(Vector2D point); @Override ArrayList<Vector2D> getIntersection(Segment2D segment); @Override ArrayList<Vector2D> getIntersection(Polygon2D polygon); @Override ArrayList<Vector2D> getIntersection(Cycle2D segment); @Override boolean isOnCorners(Vector2D vector, double precision); @Override boolean isOnLines(Vector2D vector, double precision); @Override List<Vector2D> getVertices(); synchronized Segment2D rectangleAsSegments(); @Override List<Segment2D> getSegments(); @Override Vector2D getPointClosestToVector(Vector2D toVector); @Override double area(); @Override boolean contains(Vector2D point); @Override boolean contains(Vector2D point, Transform transform); @Override Mass createMass(double density); @Override double getRadius(); @Override double getRadius(Vector2D vector); @Override Vector2D getCenter(); @Override void rotate(double theta); @Override void rotate(double theta, double x, double y); @Override void rotate(double theta, Vector2D vector); @Override void translate(double x, double y); @Override void translate(Vector2D vector); }
Rectangle2D extends Geometry2D { @Override public Vector2D vectorBetween(Vector2D point) { return this.rectangleAsSegments().vectorBetween(point); } Rectangle2D(Vector2D center, Vector2D direction, double width, double height); @Override double distanceBetween(Vector2D point); @Override double minimalDistanceBetween(List<Vector2D> points); @Override Vector2D vectorBetween(Vector2D point); @Override ArrayList<Vector2D> getIntersection(Segment2D segment); @Override ArrayList<Vector2D> getIntersection(Polygon2D polygon); @Override ArrayList<Vector2D> getIntersection(Cycle2D segment); @Override boolean isOnCorners(Vector2D vector, double precision); @Override boolean isOnLines(Vector2D vector, double precision); @Override List<Vector2D> getVertices(); synchronized Segment2D rectangleAsSegments(); @Override List<Segment2D> getSegments(); @Override Vector2D getPointClosestToVector(Vector2D toVector); @Override double area(); @Override boolean contains(Vector2D point); @Override boolean contains(Vector2D point, Transform transform); @Override Mass createMass(double density); @Override double getRadius(); @Override double getRadius(Vector2D vector); @Override Vector2D getCenter(); @Override void rotate(double theta); @Override void rotate(double theta, double x, double y); @Override void rotate(double theta, Vector2D vector); @Override void translate(double x, double y); @Override void translate(Vector2D vector); }
@Test public void intersectionPoint() throws Exception { aStart = GeometryFactory.createVector(0,0); aDirection = GeometryFactory.createVector(1,0); a = GeometryFactory.createRay2D(aStart, aDirection); bStart = GeometryFactory.createVector(0,1); bDirection = GeometryFactory.createVector(1,0); b = GeometryFactory.createRay2D(bStart, bDirection); assertNull(a.intersectionPoint(b)); aStart = GeometryFactory.createVector(0,0); aDirection = GeometryFactory.createVector(1,0); a = GeometryFactory.createRay2D(aStart, aDirection); b = GeometryFactory.createRay2D(aStart, aDirection); assertNull(a.intersectionPoint(b)); aStart = GeometryFactory.createVector(1,1); aDirection = GeometryFactory.createVector(1,0); a = GeometryFactory.createRay2D(aStart, aDirection); bStart = GeometryFactory.createVector(2,1); bDirection = GeometryFactory.createVector(1,0); b = GeometryFactory.createRay2D(bStart, bDirection); assertNull(a.intersectionPoint(b)); aStart = GeometryFactory.createVector(5,0); aDirection = GeometryFactory.createVector(-1,0); bStart = GeometryFactory.createVector(0,5); bDirection = GeometryFactory.createVector(0,-1); a = GeometryFactory.createRay2D(aStart, aDirection); b = GeometryFactory.createRay2D(bStart, bDirection); intersection = a.intersectionPoint(b); Assert.assertEquals(0, intersection.getXComponent(), PRECISION); Assert.assertEquals(0, intersection.getXComponent(), PRECISION); aStart = GeometryFactory.createVector(2,0); aDirection = GeometryFactory.createVector(1,2); bStart = GeometryFactory.createVector(0,2); bDirection = GeometryFactory.createVector(2,1); a = GeometryFactory.createRay2D(aStart, aDirection); b = GeometryFactory.createRay2D(bStart, bDirection); intersection = a.intersectionPoint(b); Assert.assertEquals(4, intersection.getXComponent(), PRECISION); Assert.assertEquals(4, intersection.getXComponent(), PRECISION); }
public Vector2D intersectionPoint(Ray2D other) { double dx = other.getStart().getXComponent() - this.getStart().getXComponent(); double dy = other.getStart().getYComponent() - this.getStart().getYComponent(); double det = other.getDirection().getXComponent() * this.getDirection().getYComponent() - other.getDirection().getYComponent() * this.getDirection().getXComponent(); if(det == 0) { return null; } double u = (dy * other.getDirection().getXComponent() - dx * other.getDirection().getYComponent()) / det; double v = (dy * this.getDirection().getXComponent() - dx * this.getDirection().getYComponent()) / det; if(u >= 0 && v >= 0) { return this.getStart().sum(this.getDirection().multiply(u)); } else { return null; } }
Ray2D { public Vector2D intersectionPoint(Ray2D other) { double dx = other.getStart().getXComponent() - this.getStart().getXComponent(); double dy = other.getStart().getYComponent() - this.getStart().getYComponent(); double det = other.getDirection().getXComponent() * this.getDirection().getYComponent() - other.getDirection().getYComponent() * this.getDirection().getXComponent(); if(det == 0) { return null; } double u = (dy * other.getDirection().getXComponent() - dx * other.getDirection().getYComponent()) / det; double v = (dy * this.getDirection().getXComponent() - dx * this.getDirection().getYComponent()) / det; if(u >= 0 && v >= 0) { return this.getStart().sum(this.getDirection().multiply(u)); } else { return null; } } }
Ray2D { public Vector2D intersectionPoint(Ray2D other) { double dx = other.getStart().getXComponent() - this.getStart().getXComponent(); double dy = other.getStart().getYComponent() - this.getStart().getYComponent(); double det = other.getDirection().getXComponent() * this.getDirection().getYComponent() - other.getDirection().getYComponent() * this.getDirection().getXComponent(); if(det == 0) { return null; } double u = (dy * other.getDirection().getXComponent() - dx * other.getDirection().getYComponent()) / det; double v = (dy * this.getDirection().getXComponent() - dx * this.getDirection().getYComponent()) / det; if(u >= 0 && v >= 0) { return this.getStart().sum(this.getDirection().multiply(u)); } else { return null; } } Ray2D(Vector2D start, Vector2D direction); }
Ray2D { public Vector2D intersectionPoint(Ray2D other) { double dx = other.getStart().getXComponent() - this.getStart().getXComponent(); double dy = other.getStart().getYComponent() - this.getStart().getYComponent(); double det = other.getDirection().getXComponent() * this.getDirection().getYComponent() - other.getDirection().getYComponent() * this.getDirection().getXComponent(); if(det == 0) { return null; } double u = (dy * other.getDirection().getXComponent() - dx * other.getDirection().getYComponent()) / det; double v = (dy * this.getDirection().getXComponent() - dx * this.getDirection().getYComponent()) / det; if(u >= 0 && v >= 0) { return this.getStart().sum(this.getDirection().multiply(u)); } else { return null; } } Ray2D(Vector2D start, Vector2D direction); Vector2D getStart(); void setStart(Vector2D start); Vector2D getDirection(); void setDirection(Vector2D direction); Vector2D intersectionPoint(Ray2D other); Ray2D intersectionRay(Ray2D other); Segment2D intersectionSegment(Ray2D other); boolean contains(Vector2D point); boolean isParallel(Ray2D other); boolean equals(Ray2D other); String toString(); }
Ray2D { public Vector2D intersectionPoint(Ray2D other) { double dx = other.getStart().getXComponent() - this.getStart().getXComponent(); double dy = other.getStart().getYComponent() - this.getStart().getYComponent(); double det = other.getDirection().getXComponent() * this.getDirection().getYComponent() - other.getDirection().getYComponent() * this.getDirection().getXComponent(); if(det == 0) { return null; } double u = (dy * other.getDirection().getXComponent() - dx * other.getDirection().getYComponent()) / det; double v = (dy * this.getDirection().getXComponent() - dx * this.getDirection().getYComponent()) / det; if(u >= 0 && v >= 0) { return this.getStart().sum(this.getDirection().multiply(u)); } else { return null; } } Ray2D(Vector2D start, Vector2D direction); Vector2D getStart(); void setStart(Vector2D start); Vector2D getDirection(); void setDirection(Vector2D direction); Vector2D intersectionPoint(Ray2D other); Ray2D intersectionRay(Ray2D other); Segment2D intersectionSegment(Ray2D other); boolean contains(Vector2D point); boolean isParallel(Ray2D other); boolean equals(Ray2D other); String toString(); }
@Test public void isParallel() throws Exception { aStart = GeometryFactory.createVector(0,0); aDirection = GeometryFactory.createVector(1,0); a = GeometryFactory.createRay2D(aStart, aDirection); bStart = GeometryFactory.createVector(1,1); bDirection = GeometryFactory.createVector(1,0); b = GeometryFactory.createRay2D(bStart, bDirection); assertTrue(a.isParallel(b)); bStart = GeometryFactory.createVector(1,1); bDirection = GeometryFactory.createVector(1,1.0001); b = GeometryFactory.createRay2D(bStart, bDirection); assertFalse(a.isParallel(b)); bStart = GeometryFactory.createVector(0,0); bDirection = GeometryFactory.createVector(0,1); b = GeometryFactory.createRay2D(bStart, bDirection); assertFalse(a.isParallel(b)); }
public boolean isParallel(Ray2D other) { return this.getDirection().cross(other.getDirection()) == 0; }
Ray2D { public boolean isParallel(Ray2D other) { return this.getDirection().cross(other.getDirection()) == 0; } }
Ray2D { public boolean isParallel(Ray2D other) { return this.getDirection().cross(other.getDirection()) == 0; } Ray2D(Vector2D start, Vector2D direction); }
Ray2D { public boolean isParallel(Ray2D other) { return this.getDirection().cross(other.getDirection()) == 0; } Ray2D(Vector2D start, Vector2D direction); Vector2D getStart(); void setStart(Vector2D start); Vector2D getDirection(); void setDirection(Vector2D direction); Vector2D intersectionPoint(Ray2D other); Ray2D intersectionRay(Ray2D other); Segment2D intersectionSegment(Ray2D other); boolean contains(Vector2D point); boolean isParallel(Ray2D other); boolean equals(Ray2D other); String toString(); }
Ray2D { public boolean isParallel(Ray2D other) { return this.getDirection().cross(other.getDirection()) == 0; } Ray2D(Vector2D start, Vector2D direction); Vector2D getStart(); void setStart(Vector2D start); Vector2D getDirection(); void setDirection(Vector2D direction); Vector2D intersectionPoint(Ray2D other); Ray2D intersectionRay(Ray2D other); Segment2D intersectionSegment(Ray2D other); boolean contains(Vector2D point); boolean isParallel(Ray2D other); boolean equals(Ray2D other); String toString(); }
@Test public void equals() throws Exception { aStart = GeometryFactory.createVector(0,0); aDirection = GeometryFactory.createVector(1,0); a = GeometryFactory.createRay2D(aStart, aDirection); bStart = GeometryFactory.createVector(1,1); bDirection = GeometryFactory.createVector(1,0); b = GeometryFactory.createRay2D(bStart, bDirection); assertFalse(a.equals(b)); bStart = GeometryFactory.createVector(0,0); bDirection = GeometryFactory.createVector(2,0); b = GeometryFactory.createRay2D(bStart, bDirection); assertTrue(a.equals(b)); }
public boolean equals(Ray2D other) { return this.getStart().equals(other.getStart()) && this.getDirection().getNormalized().equals(other.getDirection().getNormalized()); }
Ray2D { public boolean equals(Ray2D other) { return this.getStart().equals(other.getStart()) && this.getDirection().getNormalized().equals(other.getDirection().getNormalized()); } }
Ray2D { public boolean equals(Ray2D other) { return this.getStart().equals(other.getStart()) && this.getDirection().getNormalized().equals(other.getDirection().getNormalized()); } Ray2D(Vector2D start, Vector2D direction); }
Ray2D { public boolean equals(Ray2D other) { return this.getStart().equals(other.getStart()) && this.getDirection().getNormalized().equals(other.getDirection().getNormalized()); } Ray2D(Vector2D start, Vector2D direction); Vector2D getStart(); void setStart(Vector2D start); Vector2D getDirection(); void setDirection(Vector2D direction); Vector2D intersectionPoint(Ray2D other); Ray2D intersectionRay(Ray2D other); Segment2D intersectionSegment(Ray2D other); boolean contains(Vector2D point); boolean isParallel(Ray2D other); boolean equals(Ray2D other); String toString(); }
Ray2D { public boolean equals(Ray2D other) { return this.getStart().equals(other.getStart()) && this.getDirection().getNormalized().equals(other.getDirection().getNormalized()); } Ray2D(Vector2D start, Vector2D direction); Vector2D getStart(); void setStart(Vector2D start); Vector2D getDirection(); void setDirection(Vector2D direction); Vector2D intersectionPoint(Ray2D other); Ray2D intersectionRay(Ray2D other); Segment2D intersectionSegment(Ray2D other); boolean contains(Vector2D point); boolean isParallel(Ray2D other); boolean equals(Ray2D other); String toString(); }
@Test public void contains() throws Exception { aStart = GeometryFactory.createVector(5,5); aDirection = GeometryFactory.createVector(1,0); a = GeometryFactory.createRay2D(aStart, aDirection); point = GeometryFactory.createVector(7,0); assertFalse(a.contains(point)); point = GeometryFactory.createVector(7,5); assertTrue(a.contains(point)); point = GeometryFactory.createVector(4,5); assertFalse(a.contains(point)); aStart = GeometryFactory.createVector(0,0); aDirection = GeometryFactory.createVector(0,1); a = GeometryFactory.createRay2D(aStart, aDirection); point = GeometryFactory.createVector(0,1); assertTrue(a.contains(point)); point = GeometryFactory.createVector(0,-2); assertFalse(a.contains(point)); aStart = GeometryFactory.createVector(1,0); aDirection = GeometryFactory.createVector(1,1); a = GeometryFactory.createRay2D(aStart, aDirection); point = GeometryFactory.createVector(3,2); assertTrue(a.contains(point)); point = GeometryFactory.createVector(0,-1); assertFalse(a.contains(point)); }
public boolean contains(Vector2D point) { Vector2D newNorm = point.subtract(this.getStart()).getNormalized(); double dotProduct = newNorm.dot(this.getDirection().getNormalized()); return Math.abs(1.0 - dotProduct) < EPSILON; }
Ray2D { public boolean contains(Vector2D point) { Vector2D newNorm = point.subtract(this.getStart()).getNormalized(); double dotProduct = newNorm.dot(this.getDirection().getNormalized()); return Math.abs(1.0 - dotProduct) < EPSILON; } }
Ray2D { public boolean contains(Vector2D point) { Vector2D newNorm = point.subtract(this.getStart()).getNormalized(); double dotProduct = newNorm.dot(this.getDirection().getNormalized()); return Math.abs(1.0 - dotProduct) < EPSILON; } Ray2D(Vector2D start, Vector2D direction); }
Ray2D { public boolean contains(Vector2D point) { Vector2D newNorm = point.subtract(this.getStart()).getNormalized(); double dotProduct = newNorm.dot(this.getDirection().getNormalized()); return Math.abs(1.0 - dotProduct) < EPSILON; } Ray2D(Vector2D start, Vector2D direction); Vector2D getStart(); void setStart(Vector2D start); Vector2D getDirection(); void setDirection(Vector2D direction); Vector2D intersectionPoint(Ray2D other); Ray2D intersectionRay(Ray2D other); Segment2D intersectionSegment(Ray2D other); boolean contains(Vector2D point); boolean isParallel(Ray2D other); boolean equals(Ray2D other); String toString(); }
Ray2D { public boolean contains(Vector2D point) { Vector2D newNorm = point.subtract(this.getStart()).getNormalized(); double dotProduct = newNorm.dot(this.getDirection().getNormalized()); return Math.abs(1.0 - dotProduct) < EPSILON; } Ray2D(Vector2D start, Vector2D direction); Vector2D getStart(); void setStart(Vector2D start); Vector2D getDirection(); void setDirection(Vector2D direction); Vector2D intersectionPoint(Ray2D other); Ray2D intersectionRay(Ray2D other); Segment2D intersectionSegment(Ray2D other); boolean contains(Vector2D point); boolean isParallel(Ray2D other); boolean equals(Ray2D other); String toString(); }
@Test public void intersectionRay() throws Exception { aStart = GeometryFactory.createVector(0,0); aDirection = GeometryFactory.createVector(1,0); a = GeometryFactory.createRay2D(aStart, aDirection); bStart = GeometryFactory.createVector(5,0); bDirection = GeometryFactory.createVector(1,0); b = GeometryFactory.createRay2D(bStart, bDirection); Ray2D intersectionRay = a.intersectionRay(b); assertTrue(intersectionRay.equals(b)); intersectionRay = b.intersectionRay(a); assertTrue(intersectionRay.equals(b)); aStart = GeometryFactory.createVector(0,0); aDirection = GeometryFactory.createVector(0,5); a = GeometryFactory.createRay2D(aStart, aDirection); bStart = GeometryFactory.createVector(0,3); bDirection = GeometryFactory.createVector(0,0.1); b = GeometryFactory.createRay2D(bStart, bDirection); intersectionRay = a.intersectionRay(b); assertTrue(intersectionRay.equals(b)); intersectionRay = b.intersectionRay(a); assertTrue(intersectionRay.equals(b)); aStart = GeometryFactory.createVector(0,0); aDirection = GeometryFactory.createVector(1,0); a = GeometryFactory.createRay2D(aStart, aDirection); bStart = GeometryFactory.createVector(5,0); bDirection = GeometryFactory.createVector(-1,0); b = GeometryFactory.createRay2D(bStart, bDirection); assertNull(a.intersectionRay(b)); aStart = GeometryFactory.createVector(0,0); aDirection = GeometryFactory.createVector(1,0); a = GeometryFactory.createRay2D(aStart, aDirection); bStart = GeometryFactory.createVector(0,5); bDirection = GeometryFactory.createVector(0,-1); b = GeometryFactory.createRay2D(bStart, bDirection); assertNull(a.intersectionRay(b)); }
public Ray2D intersectionRay(Ray2D other) { double dotProduct = this.getDirection().getNormalized().dot(other.getDirection().getNormalized()); if(this.contains(other.getStart()) && !other.contains(this.getStart()) && Math.abs(1.0 - dotProduct) < EPSILON) { return new Ray2D(other.getStart(), other.getDirection()); } else if(!this.contains(other.getStart()) && other.contains(this.getStart()) && Math.abs(1.0 - dotProduct) < EPSILON) { return new Ray2D(this.getStart(), this.getDirection()); } else { return null; } }
Ray2D { public Ray2D intersectionRay(Ray2D other) { double dotProduct = this.getDirection().getNormalized().dot(other.getDirection().getNormalized()); if(this.contains(other.getStart()) && !other.contains(this.getStart()) && Math.abs(1.0 - dotProduct) < EPSILON) { return new Ray2D(other.getStart(), other.getDirection()); } else if(!this.contains(other.getStart()) && other.contains(this.getStart()) && Math.abs(1.0 - dotProduct) < EPSILON) { return new Ray2D(this.getStart(), this.getDirection()); } else { return null; } } }
Ray2D { public Ray2D intersectionRay(Ray2D other) { double dotProduct = this.getDirection().getNormalized().dot(other.getDirection().getNormalized()); if(this.contains(other.getStart()) && !other.contains(this.getStart()) && Math.abs(1.0 - dotProduct) < EPSILON) { return new Ray2D(other.getStart(), other.getDirection()); } else if(!this.contains(other.getStart()) && other.contains(this.getStart()) && Math.abs(1.0 - dotProduct) < EPSILON) { return new Ray2D(this.getStart(), this.getDirection()); } else { return null; } } Ray2D(Vector2D start, Vector2D direction); }
Ray2D { public Ray2D intersectionRay(Ray2D other) { double dotProduct = this.getDirection().getNormalized().dot(other.getDirection().getNormalized()); if(this.contains(other.getStart()) && !other.contains(this.getStart()) && Math.abs(1.0 - dotProduct) < EPSILON) { return new Ray2D(other.getStart(), other.getDirection()); } else if(!this.contains(other.getStart()) && other.contains(this.getStart()) && Math.abs(1.0 - dotProduct) < EPSILON) { return new Ray2D(this.getStart(), this.getDirection()); } else { return null; } } Ray2D(Vector2D start, Vector2D direction); Vector2D getStart(); void setStart(Vector2D start); Vector2D getDirection(); void setDirection(Vector2D direction); Vector2D intersectionPoint(Ray2D other); Ray2D intersectionRay(Ray2D other); Segment2D intersectionSegment(Ray2D other); boolean contains(Vector2D point); boolean isParallel(Ray2D other); boolean equals(Ray2D other); String toString(); }
Ray2D { public Ray2D intersectionRay(Ray2D other) { double dotProduct = this.getDirection().getNormalized().dot(other.getDirection().getNormalized()); if(this.contains(other.getStart()) && !other.contains(this.getStart()) && Math.abs(1.0 - dotProduct) < EPSILON) { return new Ray2D(other.getStart(), other.getDirection()); } else if(!this.contains(other.getStart()) && other.contains(this.getStart()) && Math.abs(1.0 - dotProduct) < EPSILON) { return new Ray2D(this.getStart(), this.getDirection()); } else { return null; } } Ray2D(Vector2D start, Vector2D direction); Vector2D getStart(); void setStart(Vector2D start); Vector2D getDirection(); void setDirection(Vector2D direction); Vector2D intersectionPoint(Ray2D other); Ray2D intersectionRay(Ray2D other); Segment2D intersectionSegment(Ray2D other); boolean contains(Vector2D point); boolean isParallel(Ray2D other); boolean equals(Ray2D other); String toString(); }
@Test public void pluginRegistersATask() { Project project = ProjectBuilder.builder().build(); project.getPlugins().apply("org.openapitools.openapistylevalidator"); assertNotNull(project.getTasks().findByName("openAPIStyleValidator")); }
public void apply(Project project) { project.getTasks().register("openAPIStyleValidator", OpenAPIStyleValidatorTask.class); }
OpenAPIStyleValidatorGradlePlugin implements Plugin<Project> { public void apply(Project project) { project.getTasks().register("openAPIStyleValidator", OpenAPIStyleValidatorTask.class); } }
OpenAPIStyleValidatorGradlePlugin implements Plugin<Project> { public void apply(Project project) { project.getTasks().register("openAPIStyleValidator", OpenAPIStyleValidatorTask.class); } }
OpenAPIStyleValidatorGradlePlugin implements Plugin<Project> { public void apply(Project project) { project.getTasks().register("openAPIStyleValidator", OpenAPIStyleValidatorTask.class); } void apply(Project project); }
OpenAPIStyleValidatorGradlePlugin implements Plugin<Project> { public void apply(Project project) { project.getTasks().register("openAPIStyleValidator", OpenAPIStyleValidatorTask.class); } void apply(Project project); }
@Test void validateShouldReturnSixErrorsWithoutOptionFile() throws Exception { OptionManager optionManager = new OptionManager(); Options options = optionManager.getOptions(); CommandLine commandLine = parser.parse(options, new String[]{"-s", "src/test/resources/ping.yaml"}); List<StyleError> errorList = Main.validate(optionManager, commandLine); sixErrorsAssertions(errorList); }
static List<StyleError> validate(OptionManager optionManager, CommandLine commandLine) { OpenAPIParser openApiParser = new OpenAPIParser(); ParseOptions parseOptions = new ParseOptions(); parseOptions.setResolve(true); SwaggerParseResult parserResult = openApiParser.readLocation(optionManager.getSource(commandLine), null, parseOptions); io.swagger.v3.oas.models.OpenAPI swaggerOpenAPI = parserResult.getOpenAPI(); org.eclipse.microprofile.openapi.models.OpenAPI openAPI = SwAdapter.toOpenAPI(swaggerOpenAPI); OpenApiSpecStyleValidator openApiSpecStyleValidator = new OpenApiSpecStyleValidator(openAPI); ValidatorParameters parameters = optionManager.getOptionalValidatorParametersOrDefault(commandLine); return openApiSpecStyleValidator.validate(parameters); }
Main { static List<StyleError> validate(OptionManager optionManager, CommandLine commandLine) { OpenAPIParser openApiParser = new OpenAPIParser(); ParseOptions parseOptions = new ParseOptions(); parseOptions.setResolve(true); SwaggerParseResult parserResult = openApiParser.readLocation(optionManager.getSource(commandLine), null, parseOptions); io.swagger.v3.oas.models.OpenAPI swaggerOpenAPI = parserResult.getOpenAPI(); org.eclipse.microprofile.openapi.models.OpenAPI openAPI = SwAdapter.toOpenAPI(swaggerOpenAPI); OpenApiSpecStyleValidator openApiSpecStyleValidator = new OpenApiSpecStyleValidator(openAPI); ValidatorParameters parameters = optionManager.getOptionalValidatorParametersOrDefault(commandLine); return openApiSpecStyleValidator.validate(parameters); } }
Main { static List<StyleError> validate(OptionManager optionManager, CommandLine commandLine) { OpenAPIParser openApiParser = new OpenAPIParser(); ParseOptions parseOptions = new ParseOptions(); parseOptions.setResolve(true); SwaggerParseResult parserResult = openApiParser.readLocation(optionManager.getSource(commandLine), null, parseOptions); io.swagger.v3.oas.models.OpenAPI swaggerOpenAPI = parserResult.getOpenAPI(); org.eclipse.microprofile.openapi.models.OpenAPI openAPI = SwAdapter.toOpenAPI(swaggerOpenAPI); OpenApiSpecStyleValidator openApiSpecStyleValidator = new OpenApiSpecStyleValidator(openAPI); ValidatorParameters parameters = optionManager.getOptionalValidatorParametersOrDefault(commandLine); return openApiSpecStyleValidator.validate(parameters); } }
Main { static List<StyleError> validate(OptionManager optionManager, CommandLine commandLine) { OpenAPIParser openApiParser = new OpenAPIParser(); ParseOptions parseOptions = new ParseOptions(); parseOptions.setResolve(true); SwaggerParseResult parserResult = openApiParser.readLocation(optionManager.getSource(commandLine), null, parseOptions); io.swagger.v3.oas.models.OpenAPI swaggerOpenAPI = parserResult.getOpenAPI(); org.eclipse.microprofile.openapi.models.OpenAPI openAPI = SwAdapter.toOpenAPI(swaggerOpenAPI); OpenApiSpecStyleValidator openApiSpecStyleValidator = new OpenApiSpecStyleValidator(openAPI); ValidatorParameters parameters = optionManager.getOptionalValidatorParametersOrDefault(commandLine); return openApiSpecStyleValidator.validate(parameters); } static void main(String[] args); }
Main { static List<StyleError> validate(OptionManager optionManager, CommandLine commandLine) { OpenAPIParser openApiParser = new OpenAPIParser(); ParseOptions parseOptions = new ParseOptions(); parseOptions.setResolve(true); SwaggerParseResult parserResult = openApiParser.readLocation(optionManager.getSource(commandLine), null, parseOptions); io.swagger.v3.oas.models.OpenAPI swaggerOpenAPI = parserResult.getOpenAPI(); org.eclipse.microprofile.openapi.models.OpenAPI openAPI = SwAdapter.toOpenAPI(swaggerOpenAPI); OpenApiSpecStyleValidator openApiSpecStyleValidator = new OpenApiSpecStyleValidator(openAPI); ValidatorParameters parameters = optionManager.getOptionalValidatorParametersOrDefault(commandLine); return openApiSpecStyleValidator.validate(parameters); } static void main(String[] args); }
@Test void validateShouldReturnSixErrorsWithEmptyOptionFile() throws Exception { OptionManager optionManager = new OptionManager(); Options options = optionManager.getOptions(); CommandLine commandLine = parser.parse(options, new String[]{"-s", "src/test/resources/ping.yaml", "-o", "src/test/resources/empty.json"}); List<StyleError> errorList = Main.validate(optionManager, commandLine); sixErrorsAssertions(errorList); }
static List<StyleError> validate(OptionManager optionManager, CommandLine commandLine) { OpenAPIParser openApiParser = new OpenAPIParser(); ParseOptions parseOptions = new ParseOptions(); parseOptions.setResolve(true); SwaggerParseResult parserResult = openApiParser.readLocation(optionManager.getSource(commandLine), null, parseOptions); io.swagger.v3.oas.models.OpenAPI swaggerOpenAPI = parserResult.getOpenAPI(); org.eclipse.microprofile.openapi.models.OpenAPI openAPI = SwAdapter.toOpenAPI(swaggerOpenAPI); OpenApiSpecStyleValidator openApiSpecStyleValidator = new OpenApiSpecStyleValidator(openAPI); ValidatorParameters parameters = optionManager.getOptionalValidatorParametersOrDefault(commandLine); return openApiSpecStyleValidator.validate(parameters); }
Main { static List<StyleError> validate(OptionManager optionManager, CommandLine commandLine) { OpenAPIParser openApiParser = new OpenAPIParser(); ParseOptions parseOptions = new ParseOptions(); parseOptions.setResolve(true); SwaggerParseResult parserResult = openApiParser.readLocation(optionManager.getSource(commandLine), null, parseOptions); io.swagger.v3.oas.models.OpenAPI swaggerOpenAPI = parserResult.getOpenAPI(); org.eclipse.microprofile.openapi.models.OpenAPI openAPI = SwAdapter.toOpenAPI(swaggerOpenAPI); OpenApiSpecStyleValidator openApiSpecStyleValidator = new OpenApiSpecStyleValidator(openAPI); ValidatorParameters parameters = optionManager.getOptionalValidatorParametersOrDefault(commandLine); return openApiSpecStyleValidator.validate(parameters); } }
Main { static List<StyleError> validate(OptionManager optionManager, CommandLine commandLine) { OpenAPIParser openApiParser = new OpenAPIParser(); ParseOptions parseOptions = new ParseOptions(); parseOptions.setResolve(true); SwaggerParseResult parserResult = openApiParser.readLocation(optionManager.getSource(commandLine), null, parseOptions); io.swagger.v3.oas.models.OpenAPI swaggerOpenAPI = parserResult.getOpenAPI(); org.eclipse.microprofile.openapi.models.OpenAPI openAPI = SwAdapter.toOpenAPI(swaggerOpenAPI); OpenApiSpecStyleValidator openApiSpecStyleValidator = new OpenApiSpecStyleValidator(openAPI); ValidatorParameters parameters = optionManager.getOptionalValidatorParametersOrDefault(commandLine); return openApiSpecStyleValidator.validate(parameters); } }
Main { static List<StyleError> validate(OptionManager optionManager, CommandLine commandLine) { OpenAPIParser openApiParser = new OpenAPIParser(); ParseOptions parseOptions = new ParseOptions(); parseOptions.setResolve(true); SwaggerParseResult parserResult = openApiParser.readLocation(optionManager.getSource(commandLine), null, parseOptions); io.swagger.v3.oas.models.OpenAPI swaggerOpenAPI = parserResult.getOpenAPI(); org.eclipse.microprofile.openapi.models.OpenAPI openAPI = SwAdapter.toOpenAPI(swaggerOpenAPI); OpenApiSpecStyleValidator openApiSpecStyleValidator = new OpenApiSpecStyleValidator(openAPI); ValidatorParameters parameters = optionManager.getOptionalValidatorParametersOrDefault(commandLine); return openApiSpecStyleValidator.validate(parameters); } static void main(String[] args); }
Main { static List<StyleError> validate(OptionManager optionManager, CommandLine commandLine) { OpenAPIParser openApiParser = new OpenAPIParser(); ParseOptions parseOptions = new ParseOptions(); parseOptions.setResolve(true); SwaggerParseResult parserResult = openApiParser.readLocation(optionManager.getSource(commandLine), null, parseOptions); io.swagger.v3.oas.models.OpenAPI swaggerOpenAPI = parserResult.getOpenAPI(); org.eclipse.microprofile.openapi.models.OpenAPI openAPI = SwAdapter.toOpenAPI(swaggerOpenAPI); OpenApiSpecStyleValidator openApiSpecStyleValidator = new OpenApiSpecStyleValidator(openAPI); ValidatorParameters parameters = optionManager.getOptionalValidatorParametersOrDefault(commandLine); return openApiSpecStyleValidator.validate(parameters); } static void main(String[] args); }
@Test void validateShouldReturnSixErrorsWithDefaultOptionFile() throws Exception { OptionManager optionManager = new OptionManager(); Options options = optionManager.getOptions(); CommandLine commandLine = parser.parse(options, new String[]{"-s", "src/test/resources/ping.yaml", "-o", "src/test/resources/default.json"}); List<StyleError> errorList = Main.validate(optionManager, commandLine); sixErrorsAssertions(errorList); }
static List<StyleError> validate(OptionManager optionManager, CommandLine commandLine) { OpenAPIParser openApiParser = new OpenAPIParser(); ParseOptions parseOptions = new ParseOptions(); parseOptions.setResolve(true); SwaggerParseResult parserResult = openApiParser.readLocation(optionManager.getSource(commandLine), null, parseOptions); io.swagger.v3.oas.models.OpenAPI swaggerOpenAPI = parserResult.getOpenAPI(); org.eclipse.microprofile.openapi.models.OpenAPI openAPI = SwAdapter.toOpenAPI(swaggerOpenAPI); OpenApiSpecStyleValidator openApiSpecStyleValidator = new OpenApiSpecStyleValidator(openAPI); ValidatorParameters parameters = optionManager.getOptionalValidatorParametersOrDefault(commandLine); return openApiSpecStyleValidator.validate(parameters); }
Main { static List<StyleError> validate(OptionManager optionManager, CommandLine commandLine) { OpenAPIParser openApiParser = new OpenAPIParser(); ParseOptions parseOptions = new ParseOptions(); parseOptions.setResolve(true); SwaggerParseResult parserResult = openApiParser.readLocation(optionManager.getSource(commandLine), null, parseOptions); io.swagger.v3.oas.models.OpenAPI swaggerOpenAPI = parserResult.getOpenAPI(); org.eclipse.microprofile.openapi.models.OpenAPI openAPI = SwAdapter.toOpenAPI(swaggerOpenAPI); OpenApiSpecStyleValidator openApiSpecStyleValidator = new OpenApiSpecStyleValidator(openAPI); ValidatorParameters parameters = optionManager.getOptionalValidatorParametersOrDefault(commandLine); return openApiSpecStyleValidator.validate(parameters); } }
Main { static List<StyleError> validate(OptionManager optionManager, CommandLine commandLine) { OpenAPIParser openApiParser = new OpenAPIParser(); ParseOptions parseOptions = new ParseOptions(); parseOptions.setResolve(true); SwaggerParseResult parserResult = openApiParser.readLocation(optionManager.getSource(commandLine), null, parseOptions); io.swagger.v3.oas.models.OpenAPI swaggerOpenAPI = parserResult.getOpenAPI(); org.eclipse.microprofile.openapi.models.OpenAPI openAPI = SwAdapter.toOpenAPI(swaggerOpenAPI); OpenApiSpecStyleValidator openApiSpecStyleValidator = new OpenApiSpecStyleValidator(openAPI); ValidatorParameters parameters = optionManager.getOptionalValidatorParametersOrDefault(commandLine); return openApiSpecStyleValidator.validate(parameters); } }
Main { static List<StyleError> validate(OptionManager optionManager, CommandLine commandLine) { OpenAPIParser openApiParser = new OpenAPIParser(); ParseOptions parseOptions = new ParseOptions(); parseOptions.setResolve(true); SwaggerParseResult parserResult = openApiParser.readLocation(optionManager.getSource(commandLine), null, parseOptions); io.swagger.v3.oas.models.OpenAPI swaggerOpenAPI = parserResult.getOpenAPI(); org.eclipse.microprofile.openapi.models.OpenAPI openAPI = SwAdapter.toOpenAPI(swaggerOpenAPI); OpenApiSpecStyleValidator openApiSpecStyleValidator = new OpenApiSpecStyleValidator(openAPI); ValidatorParameters parameters = optionManager.getOptionalValidatorParametersOrDefault(commandLine); return openApiSpecStyleValidator.validate(parameters); } static void main(String[] args); }
Main { static List<StyleError> validate(OptionManager optionManager, CommandLine commandLine) { OpenAPIParser openApiParser = new OpenAPIParser(); ParseOptions parseOptions = new ParseOptions(); parseOptions.setResolve(true); SwaggerParseResult parserResult = openApiParser.readLocation(optionManager.getSource(commandLine), null, parseOptions); io.swagger.v3.oas.models.OpenAPI swaggerOpenAPI = parserResult.getOpenAPI(); org.eclipse.microprofile.openapi.models.OpenAPI openAPI = SwAdapter.toOpenAPI(swaggerOpenAPI); OpenApiSpecStyleValidator openApiSpecStyleValidator = new OpenApiSpecStyleValidator(openAPI); ValidatorParameters parameters = optionManager.getOptionalValidatorParametersOrDefault(commandLine); return openApiSpecStyleValidator.validate(parameters); } static void main(String[] args); }
@Test void validateShouldReturnNoErrorsWithCustomOptionFile() throws Exception { OptionManager optionManager = new OptionManager(); Options options = optionManager.getOptions(); CommandLine commandLine = parser.parse(options, new String[]{"-s", "src/test/resources/ping.yaml", "-o", "src/test/resources/custom.json"}); List<StyleError> errorList = Main.validate(optionManager, commandLine); assertEquals(0, errorList.size()); }
static List<StyleError> validate(OptionManager optionManager, CommandLine commandLine) { OpenAPIParser openApiParser = new OpenAPIParser(); ParseOptions parseOptions = new ParseOptions(); parseOptions.setResolve(true); SwaggerParseResult parserResult = openApiParser.readLocation(optionManager.getSource(commandLine), null, parseOptions); io.swagger.v3.oas.models.OpenAPI swaggerOpenAPI = parserResult.getOpenAPI(); org.eclipse.microprofile.openapi.models.OpenAPI openAPI = SwAdapter.toOpenAPI(swaggerOpenAPI); OpenApiSpecStyleValidator openApiSpecStyleValidator = new OpenApiSpecStyleValidator(openAPI); ValidatorParameters parameters = optionManager.getOptionalValidatorParametersOrDefault(commandLine); return openApiSpecStyleValidator.validate(parameters); }
Main { static List<StyleError> validate(OptionManager optionManager, CommandLine commandLine) { OpenAPIParser openApiParser = new OpenAPIParser(); ParseOptions parseOptions = new ParseOptions(); parseOptions.setResolve(true); SwaggerParseResult parserResult = openApiParser.readLocation(optionManager.getSource(commandLine), null, parseOptions); io.swagger.v3.oas.models.OpenAPI swaggerOpenAPI = parserResult.getOpenAPI(); org.eclipse.microprofile.openapi.models.OpenAPI openAPI = SwAdapter.toOpenAPI(swaggerOpenAPI); OpenApiSpecStyleValidator openApiSpecStyleValidator = new OpenApiSpecStyleValidator(openAPI); ValidatorParameters parameters = optionManager.getOptionalValidatorParametersOrDefault(commandLine); return openApiSpecStyleValidator.validate(parameters); } }
Main { static List<StyleError> validate(OptionManager optionManager, CommandLine commandLine) { OpenAPIParser openApiParser = new OpenAPIParser(); ParseOptions parseOptions = new ParseOptions(); parseOptions.setResolve(true); SwaggerParseResult parserResult = openApiParser.readLocation(optionManager.getSource(commandLine), null, parseOptions); io.swagger.v3.oas.models.OpenAPI swaggerOpenAPI = parserResult.getOpenAPI(); org.eclipse.microprofile.openapi.models.OpenAPI openAPI = SwAdapter.toOpenAPI(swaggerOpenAPI); OpenApiSpecStyleValidator openApiSpecStyleValidator = new OpenApiSpecStyleValidator(openAPI); ValidatorParameters parameters = optionManager.getOptionalValidatorParametersOrDefault(commandLine); return openApiSpecStyleValidator.validate(parameters); } }
Main { static List<StyleError> validate(OptionManager optionManager, CommandLine commandLine) { OpenAPIParser openApiParser = new OpenAPIParser(); ParseOptions parseOptions = new ParseOptions(); parseOptions.setResolve(true); SwaggerParseResult parserResult = openApiParser.readLocation(optionManager.getSource(commandLine), null, parseOptions); io.swagger.v3.oas.models.OpenAPI swaggerOpenAPI = parserResult.getOpenAPI(); org.eclipse.microprofile.openapi.models.OpenAPI openAPI = SwAdapter.toOpenAPI(swaggerOpenAPI); OpenApiSpecStyleValidator openApiSpecStyleValidator = new OpenApiSpecStyleValidator(openAPI); ValidatorParameters parameters = optionManager.getOptionalValidatorParametersOrDefault(commandLine); return openApiSpecStyleValidator.validate(parameters); } static void main(String[] args); }
Main { static List<StyleError> validate(OptionManager optionManager, CommandLine commandLine) { OpenAPIParser openApiParser = new OpenAPIParser(); ParseOptions parseOptions = new ParseOptions(); parseOptions.setResolve(true); SwaggerParseResult parserResult = openApiParser.readLocation(optionManager.getSource(commandLine), null, parseOptions); io.swagger.v3.oas.models.OpenAPI swaggerOpenAPI = parserResult.getOpenAPI(); org.eclipse.microprofile.openapi.models.OpenAPI openAPI = SwAdapter.toOpenAPI(swaggerOpenAPI); OpenApiSpecStyleValidator openApiSpecStyleValidator = new OpenApiSpecStyleValidator(openAPI); ValidatorParameters parameters = optionManager.getOptionalValidatorParametersOrDefault(commandLine); return openApiSpecStyleValidator.validate(parameters); } static void main(String[] args); }
@Test void validateWithoutOptionFileShouldReturnNamingErrors() throws Exception { OptionManager optionManager = new OptionManager(); Options options = optionManager.getOptions(); CommandLine commandLine = parser.parse(options, new String[]{"-s", "src/test/resources/some.yaml"}); List<StyleError> errorList = Main.validate(optionManager, commandLine); namingErrorsAssertions(errorList, "camelCase", "camelCase", "hyphen-case"); }
static List<StyleError> validate(OptionManager optionManager, CommandLine commandLine) { OpenAPIParser openApiParser = new OpenAPIParser(); ParseOptions parseOptions = new ParseOptions(); parseOptions.setResolve(true); SwaggerParseResult parserResult = openApiParser.readLocation(optionManager.getSource(commandLine), null, parseOptions); io.swagger.v3.oas.models.OpenAPI swaggerOpenAPI = parserResult.getOpenAPI(); org.eclipse.microprofile.openapi.models.OpenAPI openAPI = SwAdapter.toOpenAPI(swaggerOpenAPI); OpenApiSpecStyleValidator openApiSpecStyleValidator = new OpenApiSpecStyleValidator(openAPI); ValidatorParameters parameters = optionManager.getOptionalValidatorParametersOrDefault(commandLine); return openApiSpecStyleValidator.validate(parameters); }
Main { static List<StyleError> validate(OptionManager optionManager, CommandLine commandLine) { OpenAPIParser openApiParser = new OpenAPIParser(); ParseOptions parseOptions = new ParseOptions(); parseOptions.setResolve(true); SwaggerParseResult parserResult = openApiParser.readLocation(optionManager.getSource(commandLine), null, parseOptions); io.swagger.v3.oas.models.OpenAPI swaggerOpenAPI = parserResult.getOpenAPI(); org.eclipse.microprofile.openapi.models.OpenAPI openAPI = SwAdapter.toOpenAPI(swaggerOpenAPI); OpenApiSpecStyleValidator openApiSpecStyleValidator = new OpenApiSpecStyleValidator(openAPI); ValidatorParameters parameters = optionManager.getOptionalValidatorParametersOrDefault(commandLine); return openApiSpecStyleValidator.validate(parameters); } }
Main { static List<StyleError> validate(OptionManager optionManager, CommandLine commandLine) { OpenAPIParser openApiParser = new OpenAPIParser(); ParseOptions parseOptions = new ParseOptions(); parseOptions.setResolve(true); SwaggerParseResult parserResult = openApiParser.readLocation(optionManager.getSource(commandLine), null, parseOptions); io.swagger.v3.oas.models.OpenAPI swaggerOpenAPI = parserResult.getOpenAPI(); org.eclipse.microprofile.openapi.models.OpenAPI openAPI = SwAdapter.toOpenAPI(swaggerOpenAPI); OpenApiSpecStyleValidator openApiSpecStyleValidator = new OpenApiSpecStyleValidator(openAPI); ValidatorParameters parameters = optionManager.getOptionalValidatorParametersOrDefault(commandLine); return openApiSpecStyleValidator.validate(parameters); } }
Main { static List<StyleError> validate(OptionManager optionManager, CommandLine commandLine) { OpenAPIParser openApiParser = new OpenAPIParser(); ParseOptions parseOptions = new ParseOptions(); parseOptions.setResolve(true); SwaggerParseResult parserResult = openApiParser.readLocation(optionManager.getSource(commandLine), null, parseOptions); io.swagger.v3.oas.models.OpenAPI swaggerOpenAPI = parserResult.getOpenAPI(); org.eclipse.microprofile.openapi.models.OpenAPI openAPI = SwAdapter.toOpenAPI(swaggerOpenAPI); OpenApiSpecStyleValidator openApiSpecStyleValidator = new OpenApiSpecStyleValidator(openAPI); ValidatorParameters parameters = optionManager.getOptionalValidatorParametersOrDefault(commandLine); return openApiSpecStyleValidator.validate(parameters); } static void main(String[] args); }
Main { static List<StyleError> validate(OptionManager optionManager, CommandLine commandLine) { OpenAPIParser openApiParser = new OpenAPIParser(); ParseOptions parseOptions = new ParseOptions(); parseOptions.setResolve(true); SwaggerParseResult parserResult = openApiParser.readLocation(optionManager.getSource(commandLine), null, parseOptions); io.swagger.v3.oas.models.OpenAPI swaggerOpenAPI = parserResult.getOpenAPI(); org.eclipse.microprofile.openapi.models.OpenAPI openAPI = SwAdapter.toOpenAPI(swaggerOpenAPI); OpenApiSpecStyleValidator openApiSpecStyleValidator = new OpenApiSpecStyleValidator(openAPI); ValidatorParameters parameters = optionManager.getOptionalValidatorParametersOrDefault(commandLine); return openApiSpecStyleValidator.validate(parameters); } static void main(String[] args); }
@Test void validateWithAlternativeNamingOptionTestShouldReturnNamingErrors() throws Exception { OptionManager optionManager = new OptionManager(); Options options = optionManager.getOptions(); CommandLine commandLine = parser.parse(options, new String[]{"-s", "src/test/resources/some.yaml", "-o", "src/test/resources/alternative.json"}); List<StyleError> errorList = Main.validate(optionManager, commandLine); namingErrorsAssertions(errorList, "hyphen-case", "hyphen-case", "camelCase"); }
static List<StyleError> validate(OptionManager optionManager, CommandLine commandLine) { OpenAPIParser openApiParser = new OpenAPIParser(); ParseOptions parseOptions = new ParseOptions(); parseOptions.setResolve(true); SwaggerParseResult parserResult = openApiParser.readLocation(optionManager.getSource(commandLine), null, parseOptions); io.swagger.v3.oas.models.OpenAPI swaggerOpenAPI = parserResult.getOpenAPI(); org.eclipse.microprofile.openapi.models.OpenAPI openAPI = SwAdapter.toOpenAPI(swaggerOpenAPI); OpenApiSpecStyleValidator openApiSpecStyleValidator = new OpenApiSpecStyleValidator(openAPI); ValidatorParameters parameters = optionManager.getOptionalValidatorParametersOrDefault(commandLine); return openApiSpecStyleValidator.validate(parameters); }
Main { static List<StyleError> validate(OptionManager optionManager, CommandLine commandLine) { OpenAPIParser openApiParser = new OpenAPIParser(); ParseOptions parseOptions = new ParseOptions(); parseOptions.setResolve(true); SwaggerParseResult parserResult = openApiParser.readLocation(optionManager.getSource(commandLine), null, parseOptions); io.swagger.v3.oas.models.OpenAPI swaggerOpenAPI = parserResult.getOpenAPI(); org.eclipse.microprofile.openapi.models.OpenAPI openAPI = SwAdapter.toOpenAPI(swaggerOpenAPI); OpenApiSpecStyleValidator openApiSpecStyleValidator = new OpenApiSpecStyleValidator(openAPI); ValidatorParameters parameters = optionManager.getOptionalValidatorParametersOrDefault(commandLine); return openApiSpecStyleValidator.validate(parameters); } }
Main { static List<StyleError> validate(OptionManager optionManager, CommandLine commandLine) { OpenAPIParser openApiParser = new OpenAPIParser(); ParseOptions parseOptions = new ParseOptions(); parseOptions.setResolve(true); SwaggerParseResult parserResult = openApiParser.readLocation(optionManager.getSource(commandLine), null, parseOptions); io.swagger.v3.oas.models.OpenAPI swaggerOpenAPI = parserResult.getOpenAPI(); org.eclipse.microprofile.openapi.models.OpenAPI openAPI = SwAdapter.toOpenAPI(swaggerOpenAPI); OpenApiSpecStyleValidator openApiSpecStyleValidator = new OpenApiSpecStyleValidator(openAPI); ValidatorParameters parameters = optionManager.getOptionalValidatorParametersOrDefault(commandLine); return openApiSpecStyleValidator.validate(parameters); } }
Main { static List<StyleError> validate(OptionManager optionManager, CommandLine commandLine) { OpenAPIParser openApiParser = new OpenAPIParser(); ParseOptions parseOptions = new ParseOptions(); parseOptions.setResolve(true); SwaggerParseResult parserResult = openApiParser.readLocation(optionManager.getSource(commandLine), null, parseOptions); io.swagger.v3.oas.models.OpenAPI swaggerOpenAPI = parserResult.getOpenAPI(); org.eclipse.microprofile.openapi.models.OpenAPI openAPI = SwAdapter.toOpenAPI(swaggerOpenAPI); OpenApiSpecStyleValidator openApiSpecStyleValidator = new OpenApiSpecStyleValidator(openAPI); ValidatorParameters parameters = optionManager.getOptionalValidatorParametersOrDefault(commandLine); return openApiSpecStyleValidator.validate(parameters); } static void main(String[] args); }
Main { static List<StyleError> validate(OptionManager optionManager, CommandLine commandLine) { OpenAPIParser openApiParser = new OpenAPIParser(); ParseOptions parseOptions = new ParseOptions(); parseOptions.setResolve(true); SwaggerParseResult parserResult = openApiParser.readLocation(optionManager.getSource(commandLine), null, parseOptions); io.swagger.v3.oas.models.OpenAPI swaggerOpenAPI = parserResult.getOpenAPI(); org.eclipse.microprofile.openapi.models.OpenAPI openAPI = SwAdapter.toOpenAPI(swaggerOpenAPI); OpenApiSpecStyleValidator openApiSpecStyleValidator = new OpenApiSpecStyleValidator(openAPI); ValidatorParameters parameters = optionManager.getOptionalValidatorParametersOrDefault(commandLine); return openApiSpecStyleValidator.validate(parameters); } static void main(String[] args); }
@Test void validateWithUnderscoreNamingOptionTestShouldReturnNoError() throws Exception { OptionManager optionManager = new OptionManager(); Options options = optionManager.getOptions(); CommandLine commandLine = parser.parse(options, new String[]{"-s", "src/test/resources/some.yaml", "-o", "src/test/resources/underscore.json"}); List<StyleError> errorList = Main.validate(optionManager, commandLine); assertEquals(0, errorList.size()); }
static List<StyleError> validate(OptionManager optionManager, CommandLine commandLine) { OpenAPIParser openApiParser = new OpenAPIParser(); ParseOptions parseOptions = new ParseOptions(); parseOptions.setResolve(true); SwaggerParseResult parserResult = openApiParser.readLocation(optionManager.getSource(commandLine), null, parseOptions); io.swagger.v3.oas.models.OpenAPI swaggerOpenAPI = parserResult.getOpenAPI(); org.eclipse.microprofile.openapi.models.OpenAPI openAPI = SwAdapter.toOpenAPI(swaggerOpenAPI); OpenApiSpecStyleValidator openApiSpecStyleValidator = new OpenApiSpecStyleValidator(openAPI); ValidatorParameters parameters = optionManager.getOptionalValidatorParametersOrDefault(commandLine); return openApiSpecStyleValidator.validate(parameters); }
Main { static List<StyleError> validate(OptionManager optionManager, CommandLine commandLine) { OpenAPIParser openApiParser = new OpenAPIParser(); ParseOptions parseOptions = new ParseOptions(); parseOptions.setResolve(true); SwaggerParseResult parserResult = openApiParser.readLocation(optionManager.getSource(commandLine), null, parseOptions); io.swagger.v3.oas.models.OpenAPI swaggerOpenAPI = parserResult.getOpenAPI(); org.eclipse.microprofile.openapi.models.OpenAPI openAPI = SwAdapter.toOpenAPI(swaggerOpenAPI); OpenApiSpecStyleValidator openApiSpecStyleValidator = new OpenApiSpecStyleValidator(openAPI); ValidatorParameters parameters = optionManager.getOptionalValidatorParametersOrDefault(commandLine); return openApiSpecStyleValidator.validate(parameters); } }
Main { static List<StyleError> validate(OptionManager optionManager, CommandLine commandLine) { OpenAPIParser openApiParser = new OpenAPIParser(); ParseOptions parseOptions = new ParseOptions(); parseOptions.setResolve(true); SwaggerParseResult parserResult = openApiParser.readLocation(optionManager.getSource(commandLine), null, parseOptions); io.swagger.v3.oas.models.OpenAPI swaggerOpenAPI = parserResult.getOpenAPI(); org.eclipse.microprofile.openapi.models.OpenAPI openAPI = SwAdapter.toOpenAPI(swaggerOpenAPI); OpenApiSpecStyleValidator openApiSpecStyleValidator = new OpenApiSpecStyleValidator(openAPI); ValidatorParameters parameters = optionManager.getOptionalValidatorParametersOrDefault(commandLine); return openApiSpecStyleValidator.validate(parameters); } }
Main { static List<StyleError> validate(OptionManager optionManager, CommandLine commandLine) { OpenAPIParser openApiParser = new OpenAPIParser(); ParseOptions parseOptions = new ParseOptions(); parseOptions.setResolve(true); SwaggerParseResult parserResult = openApiParser.readLocation(optionManager.getSource(commandLine), null, parseOptions); io.swagger.v3.oas.models.OpenAPI swaggerOpenAPI = parserResult.getOpenAPI(); org.eclipse.microprofile.openapi.models.OpenAPI openAPI = SwAdapter.toOpenAPI(swaggerOpenAPI); OpenApiSpecStyleValidator openApiSpecStyleValidator = new OpenApiSpecStyleValidator(openAPI); ValidatorParameters parameters = optionManager.getOptionalValidatorParametersOrDefault(commandLine); return openApiSpecStyleValidator.validate(parameters); } static void main(String[] args); }
Main { static List<StyleError> validate(OptionManager optionManager, CommandLine commandLine) { OpenAPIParser openApiParser = new OpenAPIParser(); ParseOptions parseOptions = new ParseOptions(); parseOptions.setResolve(true); SwaggerParseResult parserResult = openApiParser.readLocation(optionManager.getSource(commandLine), null, parseOptions); io.swagger.v3.oas.models.OpenAPI swaggerOpenAPI = parserResult.getOpenAPI(); org.eclipse.microprofile.openapi.models.OpenAPI openAPI = SwAdapter.toOpenAPI(swaggerOpenAPI); OpenApiSpecStyleValidator openApiSpecStyleValidator = new OpenApiSpecStyleValidator(openAPI); ValidatorParameters parameters = optionManager.getOptionalValidatorParametersOrDefault(commandLine); return openApiSpecStyleValidator.validate(parameters); } static void main(String[] args); }
@Test void validateWithAlternativeLegacyNamingOptionTestShouldReturnNamingErrors() throws Exception { OptionManager optionManager = new OptionManager(); Options options = optionManager.getOptions(); CommandLine commandLine = parser.parse(options, new String[]{"-s", "src/test/resources/some.yaml", "-o", "src/test/resources/alternativeLegacy.json"}); List<StyleError> errorList = Main.validate(optionManager, commandLine); namingErrorsAssertions(errorList, "hyphen-case", "hyphen-case", "camelCase"); }
static List<StyleError> validate(OptionManager optionManager, CommandLine commandLine) { OpenAPIParser openApiParser = new OpenAPIParser(); ParseOptions parseOptions = new ParseOptions(); parseOptions.setResolve(true); SwaggerParseResult parserResult = openApiParser.readLocation(optionManager.getSource(commandLine), null, parseOptions); io.swagger.v3.oas.models.OpenAPI swaggerOpenAPI = parserResult.getOpenAPI(); org.eclipse.microprofile.openapi.models.OpenAPI openAPI = SwAdapter.toOpenAPI(swaggerOpenAPI); OpenApiSpecStyleValidator openApiSpecStyleValidator = new OpenApiSpecStyleValidator(openAPI); ValidatorParameters parameters = optionManager.getOptionalValidatorParametersOrDefault(commandLine); return openApiSpecStyleValidator.validate(parameters); }
Main { static List<StyleError> validate(OptionManager optionManager, CommandLine commandLine) { OpenAPIParser openApiParser = new OpenAPIParser(); ParseOptions parseOptions = new ParseOptions(); parseOptions.setResolve(true); SwaggerParseResult parserResult = openApiParser.readLocation(optionManager.getSource(commandLine), null, parseOptions); io.swagger.v3.oas.models.OpenAPI swaggerOpenAPI = parserResult.getOpenAPI(); org.eclipse.microprofile.openapi.models.OpenAPI openAPI = SwAdapter.toOpenAPI(swaggerOpenAPI); OpenApiSpecStyleValidator openApiSpecStyleValidator = new OpenApiSpecStyleValidator(openAPI); ValidatorParameters parameters = optionManager.getOptionalValidatorParametersOrDefault(commandLine); return openApiSpecStyleValidator.validate(parameters); } }
Main { static List<StyleError> validate(OptionManager optionManager, CommandLine commandLine) { OpenAPIParser openApiParser = new OpenAPIParser(); ParseOptions parseOptions = new ParseOptions(); parseOptions.setResolve(true); SwaggerParseResult parserResult = openApiParser.readLocation(optionManager.getSource(commandLine), null, parseOptions); io.swagger.v3.oas.models.OpenAPI swaggerOpenAPI = parserResult.getOpenAPI(); org.eclipse.microprofile.openapi.models.OpenAPI openAPI = SwAdapter.toOpenAPI(swaggerOpenAPI); OpenApiSpecStyleValidator openApiSpecStyleValidator = new OpenApiSpecStyleValidator(openAPI); ValidatorParameters parameters = optionManager.getOptionalValidatorParametersOrDefault(commandLine); return openApiSpecStyleValidator.validate(parameters); } }
Main { static List<StyleError> validate(OptionManager optionManager, CommandLine commandLine) { OpenAPIParser openApiParser = new OpenAPIParser(); ParseOptions parseOptions = new ParseOptions(); parseOptions.setResolve(true); SwaggerParseResult parserResult = openApiParser.readLocation(optionManager.getSource(commandLine), null, parseOptions); io.swagger.v3.oas.models.OpenAPI swaggerOpenAPI = parserResult.getOpenAPI(); org.eclipse.microprofile.openapi.models.OpenAPI openAPI = SwAdapter.toOpenAPI(swaggerOpenAPI); OpenApiSpecStyleValidator openApiSpecStyleValidator = new OpenApiSpecStyleValidator(openAPI); ValidatorParameters parameters = optionManager.getOptionalValidatorParametersOrDefault(commandLine); return openApiSpecStyleValidator.validate(parameters); } static void main(String[] args); }
Main { static List<StyleError> validate(OptionManager optionManager, CommandLine commandLine) { OpenAPIParser openApiParser = new OpenAPIParser(); ParseOptions parseOptions = new ParseOptions(); parseOptions.setResolve(true); SwaggerParseResult parserResult = openApiParser.readLocation(optionManager.getSource(commandLine), null, parseOptions); io.swagger.v3.oas.models.OpenAPI swaggerOpenAPI = parserResult.getOpenAPI(); org.eclipse.microprofile.openapi.models.OpenAPI openAPI = SwAdapter.toOpenAPI(swaggerOpenAPI); OpenApiSpecStyleValidator openApiSpecStyleValidator = new OpenApiSpecStyleValidator(openAPI); ValidatorParameters parameters = optionManager.getOptionalValidatorParametersOrDefault(commandLine); return openApiSpecStyleValidator.validate(parameters); } static void main(String[] args); }
@Test void validateWithAlternativeAndLegacyNamingOptionTestShouldReturnNamingErrors() throws Exception { OptionManager optionManager = new OptionManager(); Options options = optionManager.getOptions(); CommandLine commandLine = parser.parse(options, new String[]{"-s", "src/test/resources/some.yaml", "-o", "src/test/resources/alternativeAndLegacy.json"}); List<StyleError> errorList = Main.validate(optionManager, commandLine); namingErrorsAssertions(errorList, "hyphen-case", "hyphen-case", "camelCase"); }
static List<StyleError> validate(OptionManager optionManager, CommandLine commandLine) { OpenAPIParser openApiParser = new OpenAPIParser(); ParseOptions parseOptions = new ParseOptions(); parseOptions.setResolve(true); SwaggerParseResult parserResult = openApiParser.readLocation(optionManager.getSource(commandLine), null, parseOptions); io.swagger.v3.oas.models.OpenAPI swaggerOpenAPI = parserResult.getOpenAPI(); org.eclipse.microprofile.openapi.models.OpenAPI openAPI = SwAdapter.toOpenAPI(swaggerOpenAPI); OpenApiSpecStyleValidator openApiSpecStyleValidator = new OpenApiSpecStyleValidator(openAPI); ValidatorParameters parameters = optionManager.getOptionalValidatorParametersOrDefault(commandLine); return openApiSpecStyleValidator.validate(parameters); }
Main { static List<StyleError> validate(OptionManager optionManager, CommandLine commandLine) { OpenAPIParser openApiParser = new OpenAPIParser(); ParseOptions parseOptions = new ParseOptions(); parseOptions.setResolve(true); SwaggerParseResult parserResult = openApiParser.readLocation(optionManager.getSource(commandLine), null, parseOptions); io.swagger.v3.oas.models.OpenAPI swaggerOpenAPI = parserResult.getOpenAPI(); org.eclipse.microprofile.openapi.models.OpenAPI openAPI = SwAdapter.toOpenAPI(swaggerOpenAPI); OpenApiSpecStyleValidator openApiSpecStyleValidator = new OpenApiSpecStyleValidator(openAPI); ValidatorParameters parameters = optionManager.getOptionalValidatorParametersOrDefault(commandLine); return openApiSpecStyleValidator.validate(parameters); } }
Main { static List<StyleError> validate(OptionManager optionManager, CommandLine commandLine) { OpenAPIParser openApiParser = new OpenAPIParser(); ParseOptions parseOptions = new ParseOptions(); parseOptions.setResolve(true); SwaggerParseResult parserResult = openApiParser.readLocation(optionManager.getSource(commandLine), null, parseOptions); io.swagger.v3.oas.models.OpenAPI swaggerOpenAPI = parserResult.getOpenAPI(); org.eclipse.microprofile.openapi.models.OpenAPI openAPI = SwAdapter.toOpenAPI(swaggerOpenAPI); OpenApiSpecStyleValidator openApiSpecStyleValidator = new OpenApiSpecStyleValidator(openAPI); ValidatorParameters parameters = optionManager.getOptionalValidatorParametersOrDefault(commandLine); return openApiSpecStyleValidator.validate(parameters); } }
Main { static List<StyleError> validate(OptionManager optionManager, CommandLine commandLine) { OpenAPIParser openApiParser = new OpenAPIParser(); ParseOptions parseOptions = new ParseOptions(); parseOptions.setResolve(true); SwaggerParseResult parserResult = openApiParser.readLocation(optionManager.getSource(commandLine), null, parseOptions); io.swagger.v3.oas.models.OpenAPI swaggerOpenAPI = parserResult.getOpenAPI(); org.eclipse.microprofile.openapi.models.OpenAPI openAPI = SwAdapter.toOpenAPI(swaggerOpenAPI); OpenApiSpecStyleValidator openApiSpecStyleValidator = new OpenApiSpecStyleValidator(openAPI); ValidatorParameters parameters = optionManager.getOptionalValidatorParametersOrDefault(commandLine); return openApiSpecStyleValidator.validate(parameters); } static void main(String[] args); }
Main { static List<StyleError> validate(OptionManager optionManager, CommandLine commandLine) { OpenAPIParser openApiParser = new OpenAPIParser(); ParseOptions parseOptions = new ParseOptions(); parseOptions.setResolve(true); SwaggerParseResult parserResult = openApiParser.readLocation(optionManager.getSource(commandLine), null, parseOptions); io.swagger.v3.oas.models.OpenAPI swaggerOpenAPI = parserResult.getOpenAPI(); org.eclipse.microprofile.openapi.models.OpenAPI openAPI = SwAdapter.toOpenAPI(swaggerOpenAPI); OpenApiSpecStyleValidator openApiSpecStyleValidator = new OpenApiSpecStyleValidator(openAPI); ValidatorParameters parameters = optionManager.getOptionalValidatorParametersOrDefault(commandLine); return openApiSpecStyleValidator.validate(parameters); } static void main(String[] args); }
@Test void validateWithUnderscoreLegacyNamingOptionTestShouldReturnNoError() throws Exception { OptionManager optionManager = new OptionManager(); Options options = optionManager.getOptions(); CommandLine commandLine = parser.parse(options, new String[]{"-s", "src/test/resources/some.yaml", "-o", "src/test/resources/underscoreLegacy.json"}); List<StyleError> errorList = Main.validate(optionManager, commandLine); assertEquals(0, errorList.size()); }
static List<StyleError> validate(OptionManager optionManager, CommandLine commandLine) { OpenAPIParser openApiParser = new OpenAPIParser(); ParseOptions parseOptions = new ParseOptions(); parseOptions.setResolve(true); SwaggerParseResult parserResult = openApiParser.readLocation(optionManager.getSource(commandLine), null, parseOptions); io.swagger.v3.oas.models.OpenAPI swaggerOpenAPI = parserResult.getOpenAPI(); org.eclipse.microprofile.openapi.models.OpenAPI openAPI = SwAdapter.toOpenAPI(swaggerOpenAPI); OpenApiSpecStyleValidator openApiSpecStyleValidator = new OpenApiSpecStyleValidator(openAPI); ValidatorParameters parameters = optionManager.getOptionalValidatorParametersOrDefault(commandLine); return openApiSpecStyleValidator.validate(parameters); }
Main { static List<StyleError> validate(OptionManager optionManager, CommandLine commandLine) { OpenAPIParser openApiParser = new OpenAPIParser(); ParseOptions parseOptions = new ParseOptions(); parseOptions.setResolve(true); SwaggerParseResult parserResult = openApiParser.readLocation(optionManager.getSource(commandLine), null, parseOptions); io.swagger.v3.oas.models.OpenAPI swaggerOpenAPI = parserResult.getOpenAPI(); org.eclipse.microprofile.openapi.models.OpenAPI openAPI = SwAdapter.toOpenAPI(swaggerOpenAPI); OpenApiSpecStyleValidator openApiSpecStyleValidator = new OpenApiSpecStyleValidator(openAPI); ValidatorParameters parameters = optionManager.getOptionalValidatorParametersOrDefault(commandLine); return openApiSpecStyleValidator.validate(parameters); } }
Main { static List<StyleError> validate(OptionManager optionManager, CommandLine commandLine) { OpenAPIParser openApiParser = new OpenAPIParser(); ParseOptions parseOptions = new ParseOptions(); parseOptions.setResolve(true); SwaggerParseResult parserResult = openApiParser.readLocation(optionManager.getSource(commandLine), null, parseOptions); io.swagger.v3.oas.models.OpenAPI swaggerOpenAPI = parserResult.getOpenAPI(); org.eclipse.microprofile.openapi.models.OpenAPI openAPI = SwAdapter.toOpenAPI(swaggerOpenAPI); OpenApiSpecStyleValidator openApiSpecStyleValidator = new OpenApiSpecStyleValidator(openAPI); ValidatorParameters parameters = optionManager.getOptionalValidatorParametersOrDefault(commandLine); return openApiSpecStyleValidator.validate(parameters); } }
Main { static List<StyleError> validate(OptionManager optionManager, CommandLine commandLine) { OpenAPIParser openApiParser = new OpenAPIParser(); ParseOptions parseOptions = new ParseOptions(); parseOptions.setResolve(true); SwaggerParseResult parserResult = openApiParser.readLocation(optionManager.getSource(commandLine), null, parseOptions); io.swagger.v3.oas.models.OpenAPI swaggerOpenAPI = parserResult.getOpenAPI(); org.eclipse.microprofile.openapi.models.OpenAPI openAPI = SwAdapter.toOpenAPI(swaggerOpenAPI); OpenApiSpecStyleValidator openApiSpecStyleValidator = new OpenApiSpecStyleValidator(openAPI); ValidatorParameters parameters = optionManager.getOptionalValidatorParametersOrDefault(commandLine); return openApiSpecStyleValidator.validate(parameters); } static void main(String[] args); }
Main { static List<StyleError> validate(OptionManager optionManager, CommandLine commandLine) { OpenAPIParser openApiParser = new OpenAPIParser(); ParseOptions parseOptions = new ParseOptions(); parseOptions.setResolve(true); SwaggerParseResult parserResult = openApiParser.readLocation(optionManager.getSource(commandLine), null, parseOptions); io.swagger.v3.oas.models.OpenAPI swaggerOpenAPI = parserResult.getOpenAPI(); org.eclipse.microprofile.openapi.models.OpenAPI openAPI = SwAdapter.toOpenAPI(swaggerOpenAPI); OpenApiSpecStyleValidator openApiSpecStyleValidator = new OpenApiSpecStyleValidator(openAPI); ValidatorParameters parameters = optionManager.getOptionalValidatorParametersOrDefault(commandLine); return openApiSpecStyleValidator.validate(parameters); } static void main(String[] args); }
@Test void goodUnderscoreCaseShouldReturnTrue() { String goodUnderscoreCase1 = "my_variable"; String goodUnderscoreCase2 = "variable"; String goodUnderscoreCase3 = "my_super_variable"; boolean actual1 = validator.isNamingValid(goodUnderscoreCase1, ValidatorParameters.NamingConvention.UnderscoreCase); boolean actual2 = validator.isNamingValid(goodUnderscoreCase2, ValidatorParameters.NamingConvention.UnderscoreCase); boolean actual3 = validator.isNamingValid(goodUnderscoreCase3, ValidatorParameters.NamingConvention.UnderscoreCase); Assertions.assertAll( () -> assertTrue(actual1), () -> assertTrue(actual2), () -> assertTrue(actual3) ); }
boolean isNamingValid(String name, ValidatorParameters.NamingConvention namingStrategy) { switch (namingStrategy) { case UnderscoreCase: return isUnderscoreCase(name); case CamelCase: return isCamelCase(name); case HyphenCase: return isHyphenCase(name); } return false; }
NamingValidator { boolean isNamingValid(String name, ValidatorParameters.NamingConvention namingStrategy) { switch (namingStrategy) { case UnderscoreCase: return isUnderscoreCase(name); case CamelCase: return isCamelCase(name); case HyphenCase: return isHyphenCase(name); } return false; } }
NamingValidator { boolean isNamingValid(String name, ValidatorParameters.NamingConvention namingStrategy) { switch (namingStrategy) { case UnderscoreCase: return isUnderscoreCase(name); case CamelCase: return isCamelCase(name); case HyphenCase: return isHyphenCase(name); } return false; } }
NamingValidator { boolean isNamingValid(String name, ValidatorParameters.NamingConvention namingStrategy) { switch (namingStrategy) { case UnderscoreCase: return isUnderscoreCase(name); case CamelCase: return isCamelCase(name); case HyphenCase: return isHyphenCase(name); } return false; } }
NamingValidator { boolean isNamingValid(String name, ValidatorParameters.NamingConvention namingStrategy) { switch (namingStrategy) { case UnderscoreCase: return isUnderscoreCase(name); case CamelCase: return isCamelCase(name); case HyphenCase: return isHyphenCase(name); } return false; } }
@Test void badUnderscoreCaseShouldReturnFalse() { String badUnderscoreCase1 = "myVariable"; String badUnderscoreCase2 = "my-variable"; String badUnderscoreCase3 = "my-Variable"; String badUnderscoreCase4 = "my__variable_lol"; String badUnderscoreCase5 = "_my_variable"; String badUnderscoreCase6 = "my_variable_"; boolean actual1 = validator.isNamingValid(badUnderscoreCase1, ValidatorParameters.NamingConvention.UnderscoreCase); boolean actual2 = validator.isNamingValid(badUnderscoreCase2, ValidatorParameters.NamingConvention.UnderscoreCase); boolean actual3 = validator.isNamingValid(badUnderscoreCase3, ValidatorParameters.NamingConvention.UnderscoreCase); boolean actual4 = validator.isNamingValid(badUnderscoreCase4, ValidatorParameters.NamingConvention.UnderscoreCase); boolean actual5 = validator.isNamingValid(badUnderscoreCase5, ValidatorParameters.NamingConvention.UnderscoreCase); boolean actual6 = validator.isNamingValid(badUnderscoreCase6, ValidatorParameters.NamingConvention.UnderscoreCase); Assertions.assertAll( () -> assertFalse(actual1), () -> assertFalse(actual2), () -> assertFalse(actual3), () -> assertFalse(actual4), () -> assertFalse(actual5), () -> assertFalse(actual6) ); }
boolean isNamingValid(String name, ValidatorParameters.NamingConvention namingStrategy) { switch (namingStrategy) { case UnderscoreCase: return isUnderscoreCase(name); case CamelCase: return isCamelCase(name); case HyphenCase: return isHyphenCase(name); } return false; }
NamingValidator { boolean isNamingValid(String name, ValidatorParameters.NamingConvention namingStrategy) { switch (namingStrategy) { case UnderscoreCase: return isUnderscoreCase(name); case CamelCase: return isCamelCase(name); case HyphenCase: return isHyphenCase(name); } return false; } }
NamingValidator { boolean isNamingValid(String name, ValidatorParameters.NamingConvention namingStrategy) { switch (namingStrategy) { case UnderscoreCase: return isUnderscoreCase(name); case CamelCase: return isCamelCase(name); case HyphenCase: return isHyphenCase(name); } return false; } }
NamingValidator { boolean isNamingValid(String name, ValidatorParameters.NamingConvention namingStrategy) { switch (namingStrategy) { case UnderscoreCase: return isUnderscoreCase(name); case CamelCase: return isCamelCase(name); case HyphenCase: return isHyphenCase(name); } return false; } }
NamingValidator { boolean isNamingValid(String name, ValidatorParameters.NamingConvention namingStrategy) { switch (namingStrategy) { case UnderscoreCase: return isUnderscoreCase(name); case CamelCase: return isCamelCase(name); case HyphenCase: return isHyphenCase(name); } return false; } }
@Test void goodCamelCaseShouldReturnTrue() { String goodCamelCase1 = "myVariable"; String goodCamelCase2 = "variable"; String goodCamelCase3 = "mySuperVariable"; String goodCamelCase4 = "mySuperVariableIsAFunnyOne"; String goodCamelCase5 = "zone2Delete"; String goodCamelCase6 = "address1"; boolean actual1 = validator.isNamingValid(goodCamelCase1, ValidatorParameters.NamingConvention.CamelCase); boolean actual2 = validator.isNamingValid(goodCamelCase2, ValidatorParameters.NamingConvention.CamelCase); boolean actual3 = validator.isNamingValid(goodCamelCase3, ValidatorParameters.NamingConvention.CamelCase); boolean actual4 = validator.isNamingValid(goodCamelCase4, ValidatorParameters.NamingConvention.CamelCase); boolean actual5 = validator.isNamingValid(goodCamelCase5, ValidatorParameters.NamingConvention.CamelCase); boolean actual6 = validator.isNamingValid(goodCamelCase6, ValidatorParameters.NamingConvention.CamelCase); Assertions.assertAll( () -> assertTrue(actual1), () -> assertTrue(actual2), () -> assertTrue(actual3), () -> assertTrue(actual4), () -> assertTrue(actual5), () -> assertTrue(actual6) ); }
boolean isNamingValid(String name, ValidatorParameters.NamingConvention namingStrategy) { switch (namingStrategy) { case UnderscoreCase: return isUnderscoreCase(name); case CamelCase: return isCamelCase(name); case HyphenCase: return isHyphenCase(name); } return false; }
NamingValidator { boolean isNamingValid(String name, ValidatorParameters.NamingConvention namingStrategy) { switch (namingStrategy) { case UnderscoreCase: return isUnderscoreCase(name); case CamelCase: return isCamelCase(name); case HyphenCase: return isHyphenCase(name); } return false; } }
NamingValidator { boolean isNamingValid(String name, ValidatorParameters.NamingConvention namingStrategy) { switch (namingStrategy) { case UnderscoreCase: return isUnderscoreCase(name); case CamelCase: return isCamelCase(name); case HyphenCase: return isHyphenCase(name); } return false; } }
NamingValidator { boolean isNamingValid(String name, ValidatorParameters.NamingConvention namingStrategy) { switch (namingStrategy) { case UnderscoreCase: return isUnderscoreCase(name); case CamelCase: return isCamelCase(name); case HyphenCase: return isHyphenCase(name); } return false; } }
NamingValidator { boolean isNamingValid(String name, ValidatorParameters.NamingConvention namingStrategy) { switch (namingStrategy) { case UnderscoreCase: return isUnderscoreCase(name); case CamelCase: return isCamelCase(name); case HyphenCase: return isHyphenCase(name); } return false; } }
@Test void badCamelCaseShouldReturnFalse() { String badCamelCase1 = "my_variable"; String badCamelCase2 = "my-variable"; String badCamelCase3 = "my-Variable"; String badCamelCase4 = "Variable"; String badCamelCase5 = "my variable"; boolean actual1 = validator.isNamingValid(badCamelCase1, ValidatorParameters.NamingConvention.CamelCase); boolean actual2 = validator.isNamingValid(badCamelCase2, ValidatorParameters.NamingConvention.CamelCase); boolean actual3 = validator.isNamingValid(badCamelCase3, ValidatorParameters.NamingConvention.CamelCase); boolean actual4 = validator.isNamingValid(badCamelCase4, ValidatorParameters.NamingConvention.CamelCase); boolean actual5 = validator.isNamingValid(badCamelCase5, ValidatorParameters.NamingConvention.CamelCase); Assertions.assertAll( () -> assertFalse(actual1), () -> assertFalse(actual2), () -> assertFalse(actual3), () -> assertFalse(actual4), () -> assertFalse(actual5) ); }
boolean isNamingValid(String name, ValidatorParameters.NamingConvention namingStrategy) { switch (namingStrategy) { case UnderscoreCase: return isUnderscoreCase(name); case CamelCase: return isCamelCase(name); case HyphenCase: return isHyphenCase(name); } return false; }
NamingValidator { boolean isNamingValid(String name, ValidatorParameters.NamingConvention namingStrategy) { switch (namingStrategy) { case UnderscoreCase: return isUnderscoreCase(name); case CamelCase: return isCamelCase(name); case HyphenCase: return isHyphenCase(name); } return false; } }
NamingValidator { boolean isNamingValid(String name, ValidatorParameters.NamingConvention namingStrategy) { switch (namingStrategy) { case UnderscoreCase: return isUnderscoreCase(name); case CamelCase: return isCamelCase(name); case HyphenCase: return isHyphenCase(name); } return false; } }
NamingValidator { boolean isNamingValid(String name, ValidatorParameters.NamingConvention namingStrategy) { switch (namingStrategy) { case UnderscoreCase: return isUnderscoreCase(name); case CamelCase: return isCamelCase(name); case HyphenCase: return isHyphenCase(name); } return false; } }
NamingValidator { boolean isNamingValid(String name, ValidatorParameters.NamingConvention namingStrategy) { switch (namingStrategy) { case UnderscoreCase: return isUnderscoreCase(name); case CamelCase: return isCamelCase(name); case HyphenCase: return isHyphenCase(name); } return false; } }
@Test void goodHyphenCaseShouldReturnTrue() { String goodHyphenCase1 = "my-variable"; String goodHyphenCase2 = "variable"; String goodHyphenCase3 = "my-super-variable"; boolean actual1 = validator.isNamingValid(goodHyphenCase1, ValidatorParameters.NamingConvention.HyphenCase); boolean actual2 = validator.isNamingValid(goodHyphenCase2, ValidatorParameters.NamingConvention.HyphenCase); boolean actual3 = validator.isNamingValid(goodHyphenCase3, ValidatorParameters.NamingConvention.HyphenCase); Assertions.assertAll( () -> assertTrue(actual1), () -> assertTrue(actual2), () -> assertTrue(actual3) ); }
boolean isNamingValid(String name, ValidatorParameters.NamingConvention namingStrategy) { switch (namingStrategy) { case UnderscoreCase: return isUnderscoreCase(name); case CamelCase: return isCamelCase(name); case HyphenCase: return isHyphenCase(name); } return false; }
NamingValidator { boolean isNamingValid(String name, ValidatorParameters.NamingConvention namingStrategy) { switch (namingStrategy) { case UnderscoreCase: return isUnderscoreCase(name); case CamelCase: return isCamelCase(name); case HyphenCase: return isHyphenCase(name); } return false; } }
NamingValidator { boolean isNamingValid(String name, ValidatorParameters.NamingConvention namingStrategy) { switch (namingStrategy) { case UnderscoreCase: return isUnderscoreCase(name); case CamelCase: return isCamelCase(name); case HyphenCase: return isHyphenCase(name); } return false; } }
NamingValidator { boolean isNamingValid(String name, ValidatorParameters.NamingConvention namingStrategy) { switch (namingStrategy) { case UnderscoreCase: return isUnderscoreCase(name); case CamelCase: return isCamelCase(name); case HyphenCase: return isHyphenCase(name); } return false; } }
NamingValidator { boolean isNamingValid(String name, ValidatorParameters.NamingConvention namingStrategy) { switch (namingStrategy) { case UnderscoreCase: return isUnderscoreCase(name); case CamelCase: return isCamelCase(name); case HyphenCase: return isHyphenCase(name); } return false; } }
@Test void badHyphenCaseShouldReturnFalse() { String badHyphenCase1 = "my_variable"; String badHyphenCase2 = "myVariable"; String badHyphenCase3 = "my_Variable"; String badHyphenCase4 = "my__Variable_is_important"; String badHyphenCase5 = "_my_variable"; String badHyphenCase6 = "my_variable_"; boolean actual1 = validator.isNamingValid(badHyphenCase1, ValidatorParameters.NamingConvention.HyphenCase); boolean actual2 = validator.isNamingValid(badHyphenCase2, ValidatorParameters.NamingConvention.HyphenCase); boolean actual3 = validator.isNamingValid(badHyphenCase3, ValidatorParameters.NamingConvention.HyphenCase); boolean actual4 = validator.isNamingValid(badHyphenCase4, ValidatorParameters.NamingConvention.HyphenCase); boolean actual5 = validator.isNamingValid(badHyphenCase5, ValidatorParameters.NamingConvention.HyphenCase); boolean actual6 = validator.isNamingValid(badHyphenCase6, ValidatorParameters.NamingConvention.HyphenCase); Assertions.assertAll( () -> assertFalse(actual1), () -> assertFalse(actual2), () -> assertFalse(actual3), () -> assertFalse(actual4), () -> assertFalse(actual5), () -> assertFalse(actual6) ); }
boolean isNamingValid(String name, ValidatorParameters.NamingConvention namingStrategy) { switch (namingStrategy) { case UnderscoreCase: return isUnderscoreCase(name); case CamelCase: return isCamelCase(name); case HyphenCase: return isHyphenCase(name); } return false; }
NamingValidator { boolean isNamingValid(String name, ValidatorParameters.NamingConvention namingStrategy) { switch (namingStrategy) { case UnderscoreCase: return isUnderscoreCase(name); case CamelCase: return isCamelCase(name); case HyphenCase: return isHyphenCase(name); } return false; } }
NamingValidator { boolean isNamingValid(String name, ValidatorParameters.NamingConvention namingStrategy) { switch (namingStrategy) { case UnderscoreCase: return isUnderscoreCase(name); case CamelCase: return isCamelCase(name); case HyphenCase: return isHyphenCase(name); } return false; } }
NamingValidator { boolean isNamingValid(String name, ValidatorParameters.NamingConvention namingStrategy) { switch (namingStrategy) { case UnderscoreCase: return isUnderscoreCase(name); case CamelCase: return isCamelCase(name); case HyphenCase: return isHyphenCase(name); } return false; } }
NamingValidator { boolean isNamingValid(String name, ValidatorParameters.NamingConvention namingStrategy) { switch (namingStrategy) { case UnderscoreCase: return isUnderscoreCase(name); case CamelCase: return isCamelCase(name); case HyphenCase: return isHyphenCase(name); } return false; } }
@Test void validatePingOpenAPI() { OpenAPI openAPI = createPingOpenAPI(); OpenApiSpecStyleValidator validator = new OpenApiSpecStyleValidator(openAPI); ValidatorParameters parameters = new ValidatorParameters(); List<StyleError> errors = validator.validate(parameters); assertTrue(errors.size() == 1); assertEquals("*ERROR* in Model 'Myobject', property 'name', field 'example' -> This field should be present and not empty", errors.get(0).toString()); }
public List<StyleError> validate(ValidatorParameters parameters) { this.parameters = parameters; validateInfo(); validateOperations(); validateModels(); validateNaming(); return errorAggregator.getErrorList(); }
OpenApiSpecStyleValidator { public List<StyleError> validate(ValidatorParameters parameters) { this.parameters = parameters; validateInfo(); validateOperations(); validateModels(); validateNaming(); return errorAggregator.getErrorList(); } }
OpenApiSpecStyleValidator { public List<StyleError> validate(ValidatorParameters parameters) { this.parameters = parameters; validateInfo(); validateOperations(); validateModels(); validateNaming(); return errorAggregator.getErrorList(); } OpenApiSpecStyleValidator(OpenAPI openApi); }
OpenApiSpecStyleValidator { public List<StyleError> validate(ValidatorParameters parameters) { this.parameters = parameters; validateInfo(); validateOperations(); validateModels(); validateNaming(); return errorAggregator.getErrorList(); } OpenApiSpecStyleValidator(OpenAPI openApi); List<StyleError> validate(ValidatorParameters parameters); }
OpenApiSpecStyleValidator { public List<StyleError> validate(ValidatorParameters parameters) { this.parameters = parameters; validateInfo(); validateOperations(); validateModels(); validateNaming(); return errorAggregator.getErrorList(); } OpenApiSpecStyleValidator(OpenAPI openApi); List<StyleError> validate(ValidatorParameters parameters); static final String INPUT_FILE; }
@Test void validatePingOpenAPI_without_ValidateModelPropertiesExample() { OpenAPI openAPI = createPingOpenAPI(); OpenApiSpecStyleValidator validator = new OpenApiSpecStyleValidator(openAPI); ValidatorParameters parameters = new ValidatorParameters(); parameters.setValidateModelPropertiesExample(false); List<StyleError> errors = validator.validate(parameters); assertTrue(errors.size() == 0); }
public List<StyleError> validate(ValidatorParameters parameters) { this.parameters = parameters; validateInfo(); validateOperations(); validateModels(); validateNaming(); return errorAggregator.getErrorList(); }
OpenApiSpecStyleValidator { public List<StyleError> validate(ValidatorParameters parameters) { this.parameters = parameters; validateInfo(); validateOperations(); validateModels(); validateNaming(); return errorAggregator.getErrorList(); } }
OpenApiSpecStyleValidator { public List<StyleError> validate(ValidatorParameters parameters) { this.parameters = parameters; validateInfo(); validateOperations(); validateModels(); validateNaming(); return errorAggregator.getErrorList(); } OpenApiSpecStyleValidator(OpenAPI openApi); }
OpenApiSpecStyleValidator { public List<StyleError> validate(ValidatorParameters parameters) { this.parameters = parameters; validateInfo(); validateOperations(); validateModels(); validateNaming(); return errorAggregator.getErrorList(); } OpenApiSpecStyleValidator(OpenAPI openApi); List<StyleError> validate(ValidatorParameters parameters); }
OpenApiSpecStyleValidator { public List<StyleError> validate(ValidatorParameters parameters) { this.parameters = parameters; validateInfo(); validateOperations(); validateModels(); validateNaming(); return errorAggregator.getErrorList(); } OpenApiSpecStyleValidator(OpenAPI openApi); List<StyleError> validate(ValidatorParameters parameters); static final String INPUT_FILE; }
@Test void validatePingOpenAPI_WithoutSchema_and_components() { OpenAPI openAPI = createSimplePingOpenAPI(); OpenApiSpecStyleValidator validator = new OpenApiSpecStyleValidator(openAPI); ValidatorParameters parameters = new ValidatorParameters(); List<StyleError> errors = validator.validate(parameters); assertTrue(errors.size() == 0); }
public List<StyleError> validate(ValidatorParameters parameters) { this.parameters = parameters; validateInfo(); validateOperations(); validateModels(); validateNaming(); return errorAggregator.getErrorList(); }
OpenApiSpecStyleValidator { public List<StyleError> validate(ValidatorParameters parameters) { this.parameters = parameters; validateInfo(); validateOperations(); validateModels(); validateNaming(); return errorAggregator.getErrorList(); } }
OpenApiSpecStyleValidator { public List<StyleError> validate(ValidatorParameters parameters) { this.parameters = parameters; validateInfo(); validateOperations(); validateModels(); validateNaming(); return errorAggregator.getErrorList(); } OpenApiSpecStyleValidator(OpenAPI openApi); }
OpenApiSpecStyleValidator { public List<StyleError> validate(ValidatorParameters parameters) { this.parameters = parameters; validateInfo(); validateOperations(); validateModels(); validateNaming(); return errorAggregator.getErrorList(); } OpenApiSpecStyleValidator(OpenAPI openApi); List<StyleError> validate(ValidatorParameters parameters); }
OpenApiSpecStyleValidator { public List<StyleError> validate(ValidatorParameters parameters) { this.parameters = parameters; validateInfo(); validateOperations(); validateModels(); validateNaming(); return errorAggregator.getErrorList(); } OpenApiSpecStyleValidator(OpenAPI openApi); List<StyleError> validate(ValidatorParameters parameters); static final String INPUT_FILE; }
@Test public void testSubstituteProperties() { Map<String, String> properties = new HashMap<>(); properties.put("name", "Bruce Wayne"); properties.put("description", "Batman"); properties.put("Snippet", "I am the night"); KmlPlacemark placemark = new KmlPlacemark(null, null, null, properties); String result1 = KmlUtil.substituteProperties("$[name] is my name", placemark); assertEquals("Bruce Wayne is my name", result1); String result2 = KmlUtil.substituteProperties("Also known as $[description]", placemark); assertEquals("Also known as Batman", result2); String result3 = KmlUtil.substituteProperties("I say \"$[Snippet]\" often", placemark); assertEquals("I say \"I am the night\" often", result3); String result4 = KmlUtil.substituteProperties("My address is $[address]", placemark); assertEquals("When property doesn't exist, placeholder is left in place", "My address is $[address]", result4); }
public static String substituteProperties(String template, KmlPlacemark placemark) { StringBuffer sb = new StringBuffer(); Pattern pattern = Pattern.compile("\\$\\[(.+?)]"); Matcher matcher = pattern.matcher(template); while (matcher.find()) { String property = matcher.group(1); String value = placemark.getProperty(property); if (value != null) { matcher.appendReplacement(sb, value); } } matcher.appendTail(sb); return sb.toString(); }
KmlUtil { public static String substituteProperties(String template, KmlPlacemark placemark) { StringBuffer sb = new StringBuffer(); Pattern pattern = Pattern.compile("\\$\\[(.+?)]"); Matcher matcher = pattern.matcher(template); while (matcher.find()) { String property = matcher.group(1); String value = placemark.getProperty(property); if (value != null) { matcher.appendReplacement(sb, value); } } matcher.appendTail(sb); return sb.toString(); } }
KmlUtil { public static String substituteProperties(String template, KmlPlacemark placemark) { StringBuffer sb = new StringBuffer(); Pattern pattern = Pattern.compile("\\$\\[(.+?)]"); Matcher matcher = pattern.matcher(template); while (matcher.find()) { String property = matcher.group(1); String value = placemark.getProperty(property); if (value != null) { matcher.appendReplacement(sb, value); } } matcher.appendTail(sb); return sb.toString(); } }
KmlUtil { public static String substituteProperties(String template, KmlPlacemark placemark) { StringBuffer sb = new StringBuffer(); Pattern pattern = Pattern.compile("\\$\\[(.+?)]"); Matcher matcher = pattern.matcher(template); while (matcher.find()) { String property = matcher.group(1); String value = placemark.getProperty(property); if (value != null) { matcher.appendReplacement(sb, value); } } matcher.appendTail(sb); return sb.toString(); } static String substituteProperties(String template, KmlPlacemark placemark); }
KmlUtil { public static String substituteProperties(String template, KmlPlacemark placemark) { StringBuffer sb = new StringBuffer(); Pattern pattern = Pattern.compile("\\$\\[(.+?)]"); Matcher matcher = pattern.matcher(template); while (matcher.find()) { String property = matcher.group(1); String value = placemark.getProperty(property); if (value != null) { matcher.appendReplacement(sb, value); } } matcher.appendTail(sb); return sb.toString(); } static String substituteProperties(String template, KmlPlacemark placemark); }
@Test public void testCreateContainerProperty() throws Exception { XmlPullParser xmlPullParser = createParser("amu_basic_folder.kml"); KmlContainer kmlContainer = KmlContainerParser.createContainer(xmlPullParser); assertTrue(kmlContainer.hasProperties()); assertEquals("Basic Folder", kmlContainer.getProperty("name")); xmlPullParser = createParser("amu_unknown_folder.kml"); kmlContainer = KmlContainerParser.createContainer(xmlPullParser); assertTrue(kmlContainer.hasProperty("name")); }
static KmlContainer createContainer(XmlPullParser parser) throws XmlPullParserException, IOException { return assignPropertiesToContainer(parser); }
KmlContainerParser { static KmlContainer createContainer(XmlPullParser parser) throws XmlPullParserException, IOException { return assignPropertiesToContainer(parser); } }
KmlContainerParser { static KmlContainer createContainer(XmlPullParser parser) throws XmlPullParserException, IOException { return assignPropertiesToContainer(parser); } }
KmlContainerParser { static KmlContainer createContainer(XmlPullParser parser) throws XmlPullParserException, IOException { return assignPropertiesToContainer(parser); } }
KmlContainerParser { static KmlContainer createContainer(XmlPullParser parser) throws XmlPullParserException, IOException { return assignPropertiesToContainer(parser); } }
@Test public void testCreateContainerPlacemark() throws Exception { XmlPullParser xmlPullParser = createParser("amu_basic_folder.kml"); KmlContainer kmlContainer = KmlContainerParser.createContainer(xmlPullParser); assertTrue(kmlContainer.hasPlacemarks()); assertEquals(1, kmlContainer.getPlacemarksHashMap().size()); xmlPullParser = createParser("amu_multiple_placemarks.kml"); kmlContainer = KmlContainerParser.createContainer(xmlPullParser); assertTrue(kmlContainer.hasPlacemarks()); assertEquals(2, kmlContainer.getPlacemarksHashMap().size()); }
static KmlContainer createContainer(XmlPullParser parser) throws XmlPullParserException, IOException { return assignPropertiesToContainer(parser); }
KmlContainerParser { static KmlContainer createContainer(XmlPullParser parser) throws XmlPullParserException, IOException { return assignPropertiesToContainer(parser); } }
KmlContainerParser { static KmlContainer createContainer(XmlPullParser parser) throws XmlPullParserException, IOException { return assignPropertiesToContainer(parser); } }
KmlContainerParser { static KmlContainer createContainer(XmlPullParser parser) throws XmlPullParserException, IOException { return assignPropertiesToContainer(parser); } }
KmlContainerParser { static KmlContainer createContainer(XmlPullParser parser) throws XmlPullParserException, IOException { return assignPropertiesToContainer(parser); } }
@Test public void testCreateContainerGroundOverlay() throws Exception { XmlPullParser xmlPullParser = createParser("amu_ground_overlay.kml"); KmlContainer kmlContainer = KmlContainerParser.createContainer(xmlPullParser); assertEquals(2, kmlContainer.getGroundOverlayHashMap().size()); }
static KmlContainer createContainer(XmlPullParser parser) throws XmlPullParserException, IOException { return assignPropertiesToContainer(parser); }
KmlContainerParser { static KmlContainer createContainer(XmlPullParser parser) throws XmlPullParserException, IOException { return assignPropertiesToContainer(parser); } }
KmlContainerParser { static KmlContainer createContainer(XmlPullParser parser) throws XmlPullParserException, IOException { return assignPropertiesToContainer(parser); } }
KmlContainerParser { static KmlContainer createContainer(XmlPullParser parser) throws XmlPullParserException, IOException { return assignPropertiesToContainer(parser); } }
KmlContainerParser { static KmlContainer createContainer(XmlPullParser parser) throws XmlPullParserException, IOException { return assignPropertiesToContainer(parser); } }
@Test public void testCreateContainerObjects() throws Exception { XmlPullParser xmlPullParser = createParser("amu_nested_folders.kml"); KmlContainer kmlContainer = KmlContainerParser.createContainer(xmlPullParser); assertNotNull(kmlContainer.getContainers()); int numberOfNestedContainers = 0; for (KmlContainer container : kmlContainer.getContainers()) { numberOfNestedContainers++; } assertEquals(2, numberOfNestedContainers); }
static KmlContainer createContainer(XmlPullParser parser) throws XmlPullParserException, IOException { return assignPropertiesToContainer(parser); }
KmlContainerParser { static KmlContainer createContainer(XmlPullParser parser) throws XmlPullParserException, IOException { return assignPropertiesToContainer(parser); } }
KmlContainerParser { static KmlContainer createContainer(XmlPullParser parser) throws XmlPullParserException, IOException { return assignPropertiesToContainer(parser); } }
KmlContainerParser { static KmlContainer createContainer(XmlPullParser parser) throws XmlPullParserException, IOException { return assignPropertiesToContainer(parser); } }
KmlContainerParser { static KmlContainer createContainer(XmlPullParser parser) throws XmlPullParserException, IOException { return assignPropertiesToContainer(parser); } }
@Test public void testGetKmlGeometryObject() { KmlLineString kmlLineString = createSimpleLineString(); assertNotNull(kmlLineString); assertNotNull(kmlLineString.getGeometryObject()); assertEquals(3, kmlLineString.getGeometryObject().size()); assertEquals(0.0, kmlLineString.getGeometryObject().get(0).latitude, 0); assertEquals(50.0, kmlLineString.getGeometryObject().get(1).latitude, 0); assertEquals(90.0, kmlLineString.getGeometryObject().get(2).latitude, 0); kmlLineString = createLoopedLineString(); assertNotNull(kmlLineString); assertNotNull(kmlLineString.getGeometryObject()); assertEquals(3, kmlLineString.getGeometryObject().size()); assertEquals(0.0, kmlLineString.getGeometryObject().get(0).latitude, 0); assertEquals(50.0, kmlLineString.getGeometryObject().get(1).latitude, 0); assertEquals(0.0, kmlLineString.getGeometryObject().get(2).latitude, 0); }
public ArrayList<LatLng> getGeometryObject() { List<LatLng> coordinatesList = super.getGeometryObject(); return new ArrayList<>(coordinatesList); }
KmlLineString extends LineString { public ArrayList<LatLng> getGeometryObject() { List<LatLng> coordinatesList = super.getGeometryObject(); return new ArrayList<>(coordinatesList); } }
KmlLineString extends LineString { public ArrayList<LatLng> getGeometryObject() { List<LatLng> coordinatesList = super.getGeometryObject(); return new ArrayList<>(coordinatesList); } KmlLineString(ArrayList<LatLng> coordinates); KmlLineString(ArrayList<LatLng> coordinates, ArrayList<Double> altitudes); }
KmlLineString extends LineString { public ArrayList<LatLng> getGeometryObject() { List<LatLng> coordinatesList = super.getGeometryObject(); return new ArrayList<>(coordinatesList); } KmlLineString(ArrayList<LatLng> coordinates); KmlLineString(ArrayList<LatLng> coordinates, ArrayList<Double> altitudes); ArrayList<Double> getAltitudes(); ArrayList<LatLng> getGeometryObject(); }
KmlLineString extends LineString { public ArrayList<LatLng> getGeometryObject() { List<LatLng> coordinatesList = super.getGeometryObject(); return new ArrayList<>(coordinatesList); } KmlLineString(ArrayList<LatLng> coordinates); KmlLineString(ArrayList<LatLng> coordinates, ArrayList<Double> altitudes); ArrayList<Double> getAltitudes(); ArrayList<LatLng> getGeometryObject(); }
@Test public void testLineStringAltitudes() { KmlLineString kmlLineString = createSimpleLineString(); assertNotNull(kmlLineString); assertNull(kmlLineString.getAltitudes()); kmlLineString = createSimpleLineStringWithAltitudes(); assertNotNull(kmlLineString); assertNotNull(kmlLineString.getAltitudes()); assertEquals(100.0, kmlLineString.getAltitudes().get(0), 0); assertEquals(200.0, kmlLineString.getAltitudes().get(1), 0); assertEquals(300.0, kmlLineString.getAltitudes().get(2), 0); }
public ArrayList<Double> getAltitudes() { return mAltitudes; }
KmlLineString extends LineString { public ArrayList<Double> getAltitudes() { return mAltitudes; } }
KmlLineString extends LineString { public ArrayList<Double> getAltitudes() { return mAltitudes; } KmlLineString(ArrayList<LatLng> coordinates); KmlLineString(ArrayList<LatLng> coordinates, ArrayList<Double> altitudes); }
KmlLineString extends LineString { public ArrayList<Double> getAltitudes() { return mAltitudes; } KmlLineString(ArrayList<LatLng> coordinates); KmlLineString(ArrayList<LatLng> coordinates, ArrayList<Double> altitudes); ArrayList<Double> getAltitudes(); ArrayList<LatLng> getGeometryObject(); }
KmlLineString extends LineString { public ArrayList<Double> getAltitudes() { return mAltitudes; } KmlLineString(ArrayList<LatLng> coordinates); KmlLineString(ArrayList<LatLng> coordinates, ArrayList<Double> altitudes); ArrayList<Double> getAltitudes(); ArrayList<LatLng> getGeometryObject(); }
@Test public void testPolygon() throws Exception { XmlPullParser xmlPullParser = createParser("amu_basic_placemark.kml"); KmlPlacemark placemark = KmlFeatureParser.createPlacemark(xmlPullParser); assertNotNull(placemark); assertEquals(placemark.getGeometry().getGeometryType(), "Polygon"); KmlPolygon polygon = ((KmlPolygon) placemark.getGeometry()); assertEquals(polygon.getInnerBoundaryCoordinates().size(), 2); assertEquals(polygon.getOuterBoundaryCoordinates().size(), 5); }
static KmlPlacemark createPlacemark(XmlPullParser parser) throws IOException, XmlPullParserException { String styleId = null; KmlStyle inlineStyle = null; HashMap<String, String> properties = new HashMap<String, String>(); Geometry geometry = null; int eventType = parser.getEventType(); while (!(eventType == END_TAG && parser.getName().equals("Placemark"))) { if (eventType == START_TAG) { if (parser.getName().equals(STYLE_URL_TAG)) { styleId = parser.nextText(); } else if (parser.getName().matches(GEOMETRY_REGEX)) { geometry = createGeometry(parser, parser.getName()); } else if (parser.getName().matches(PROPERTY_REGEX)) { properties.put(parser.getName(), parser.nextText()); } else if (parser.getName().equals(EXTENDED_DATA)) { properties.putAll(setExtendedDataProperties(parser)); } else if (parser.getName().equals(STYLE_TAG)) { inlineStyle = KmlStyleParser.createStyle(parser); } } eventType = parser.next(); } return new KmlPlacemark(geometry, styleId, inlineStyle, properties); }
KmlFeatureParser { static KmlPlacemark createPlacemark(XmlPullParser parser) throws IOException, XmlPullParserException { String styleId = null; KmlStyle inlineStyle = null; HashMap<String, String> properties = new HashMap<String, String>(); Geometry geometry = null; int eventType = parser.getEventType(); while (!(eventType == END_TAG && parser.getName().equals("Placemark"))) { if (eventType == START_TAG) { if (parser.getName().equals(STYLE_URL_TAG)) { styleId = parser.nextText(); } else if (parser.getName().matches(GEOMETRY_REGEX)) { geometry = createGeometry(parser, parser.getName()); } else if (parser.getName().matches(PROPERTY_REGEX)) { properties.put(parser.getName(), parser.nextText()); } else if (parser.getName().equals(EXTENDED_DATA)) { properties.putAll(setExtendedDataProperties(parser)); } else if (parser.getName().equals(STYLE_TAG)) { inlineStyle = KmlStyleParser.createStyle(parser); } } eventType = parser.next(); } return new KmlPlacemark(geometry, styleId, inlineStyle, properties); } }
KmlFeatureParser { static KmlPlacemark createPlacemark(XmlPullParser parser) throws IOException, XmlPullParserException { String styleId = null; KmlStyle inlineStyle = null; HashMap<String, String> properties = new HashMap<String, String>(); Geometry geometry = null; int eventType = parser.getEventType(); while (!(eventType == END_TAG && parser.getName().equals("Placemark"))) { if (eventType == START_TAG) { if (parser.getName().equals(STYLE_URL_TAG)) { styleId = parser.nextText(); } else if (parser.getName().matches(GEOMETRY_REGEX)) { geometry = createGeometry(parser, parser.getName()); } else if (parser.getName().matches(PROPERTY_REGEX)) { properties.put(parser.getName(), parser.nextText()); } else if (parser.getName().equals(EXTENDED_DATA)) { properties.putAll(setExtendedDataProperties(parser)); } else if (parser.getName().equals(STYLE_TAG)) { inlineStyle = KmlStyleParser.createStyle(parser); } } eventType = parser.next(); } return new KmlPlacemark(geometry, styleId, inlineStyle, properties); } }
KmlFeatureParser { static KmlPlacemark createPlacemark(XmlPullParser parser) throws IOException, XmlPullParserException { String styleId = null; KmlStyle inlineStyle = null; HashMap<String, String> properties = new HashMap<String, String>(); Geometry geometry = null; int eventType = parser.getEventType(); while (!(eventType == END_TAG && parser.getName().equals("Placemark"))) { if (eventType == START_TAG) { if (parser.getName().equals(STYLE_URL_TAG)) { styleId = parser.nextText(); } else if (parser.getName().matches(GEOMETRY_REGEX)) { geometry = createGeometry(parser, parser.getName()); } else if (parser.getName().matches(PROPERTY_REGEX)) { properties.put(parser.getName(), parser.nextText()); } else if (parser.getName().equals(EXTENDED_DATA)) { properties.putAll(setExtendedDataProperties(parser)); } else if (parser.getName().equals(STYLE_TAG)) { inlineStyle = KmlStyleParser.createStyle(parser); } } eventType = parser.next(); } return new KmlPlacemark(geometry, styleId, inlineStyle, properties); } }
KmlFeatureParser { static KmlPlacemark createPlacemark(XmlPullParser parser) throws IOException, XmlPullParserException { String styleId = null; KmlStyle inlineStyle = null; HashMap<String, String> properties = new HashMap<String, String>(); Geometry geometry = null; int eventType = parser.getEventType(); while (!(eventType == END_TAG && parser.getName().equals("Placemark"))) { if (eventType == START_TAG) { if (parser.getName().equals(STYLE_URL_TAG)) { styleId = parser.nextText(); } else if (parser.getName().matches(GEOMETRY_REGEX)) { geometry = createGeometry(parser, parser.getName()); } else if (parser.getName().matches(PROPERTY_REGEX)) { properties.put(parser.getName(), parser.nextText()); } else if (parser.getName().equals(EXTENDED_DATA)) { properties.putAll(setExtendedDataProperties(parser)); } else if (parser.getName().equals(STYLE_TAG)) { inlineStyle = KmlStyleParser.createStyle(parser); } } eventType = parser.next(); } return new KmlPlacemark(geometry, styleId, inlineStyle, properties); } }
@Test public void testMultiGeometry() throws Exception { XmlPullParser xmlPullParser = createParser("amu_multigeometry_placemarks.kml"); KmlPlacemark placemark = KmlFeatureParser.createPlacemark(xmlPullParser); assertNotNull(placemark); assertEquals(placemark.getGeometry().getGeometryType(), "MultiGeometry"); KmlMultiGeometry multiGeometry = ((KmlMultiGeometry) placemark.getGeometry()); assertEquals(multiGeometry.getGeometryObject().size(), 3); }
static KmlPlacemark createPlacemark(XmlPullParser parser) throws IOException, XmlPullParserException { String styleId = null; KmlStyle inlineStyle = null; HashMap<String, String> properties = new HashMap<String, String>(); Geometry geometry = null; int eventType = parser.getEventType(); while (!(eventType == END_TAG && parser.getName().equals("Placemark"))) { if (eventType == START_TAG) { if (parser.getName().equals(STYLE_URL_TAG)) { styleId = parser.nextText(); } else if (parser.getName().matches(GEOMETRY_REGEX)) { geometry = createGeometry(parser, parser.getName()); } else if (parser.getName().matches(PROPERTY_REGEX)) { properties.put(parser.getName(), parser.nextText()); } else if (parser.getName().equals(EXTENDED_DATA)) { properties.putAll(setExtendedDataProperties(parser)); } else if (parser.getName().equals(STYLE_TAG)) { inlineStyle = KmlStyleParser.createStyle(parser); } } eventType = parser.next(); } return new KmlPlacemark(geometry, styleId, inlineStyle, properties); }
KmlFeatureParser { static KmlPlacemark createPlacemark(XmlPullParser parser) throws IOException, XmlPullParserException { String styleId = null; KmlStyle inlineStyle = null; HashMap<String, String> properties = new HashMap<String, String>(); Geometry geometry = null; int eventType = parser.getEventType(); while (!(eventType == END_TAG && parser.getName().equals("Placemark"))) { if (eventType == START_TAG) { if (parser.getName().equals(STYLE_URL_TAG)) { styleId = parser.nextText(); } else if (parser.getName().matches(GEOMETRY_REGEX)) { geometry = createGeometry(parser, parser.getName()); } else if (parser.getName().matches(PROPERTY_REGEX)) { properties.put(parser.getName(), parser.nextText()); } else if (parser.getName().equals(EXTENDED_DATA)) { properties.putAll(setExtendedDataProperties(parser)); } else if (parser.getName().equals(STYLE_TAG)) { inlineStyle = KmlStyleParser.createStyle(parser); } } eventType = parser.next(); } return new KmlPlacemark(geometry, styleId, inlineStyle, properties); } }
KmlFeatureParser { static KmlPlacemark createPlacemark(XmlPullParser parser) throws IOException, XmlPullParserException { String styleId = null; KmlStyle inlineStyle = null; HashMap<String, String> properties = new HashMap<String, String>(); Geometry geometry = null; int eventType = parser.getEventType(); while (!(eventType == END_TAG && parser.getName().equals("Placemark"))) { if (eventType == START_TAG) { if (parser.getName().equals(STYLE_URL_TAG)) { styleId = parser.nextText(); } else if (parser.getName().matches(GEOMETRY_REGEX)) { geometry = createGeometry(parser, parser.getName()); } else if (parser.getName().matches(PROPERTY_REGEX)) { properties.put(parser.getName(), parser.nextText()); } else if (parser.getName().equals(EXTENDED_DATA)) { properties.putAll(setExtendedDataProperties(parser)); } else if (parser.getName().equals(STYLE_TAG)) { inlineStyle = KmlStyleParser.createStyle(parser); } } eventType = parser.next(); } return new KmlPlacemark(geometry, styleId, inlineStyle, properties); } }
KmlFeatureParser { static KmlPlacemark createPlacemark(XmlPullParser parser) throws IOException, XmlPullParserException { String styleId = null; KmlStyle inlineStyle = null; HashMap<String, String> properties = new HashMap<String, String>(); Geometry geometry = null; int eventType = parser.getEventType(); while (!(eventType == END_TAG && parser.getName().equals("Placemark"))) { if (eventType == START_TAG) { if (parser.getName().equals(STYLE_URL_TAG)) { styleId = parser.nextText(); } else if (parser.getName().matches(GEOMETRY_REGEX)) { geometry = createGeometry(parser, parser.getName()); } else if (parser.getName().matches(PROPERTY_REGEX)) { properties.put(parser.getName(), parser.nextText()); } else if (parser.getName().equals(EXTENDED_DATA)) { properties.putAll(setExtendedDataProperties(parser)); } else if (parser.getName().equals(STYLE_TAG)) { inlineStyle = KmlStyleParser.createStyle(parser); } } eventType = parser.next(); } return new KmlPlacemark(geometry, styleId, inlineStyle, properties); } }
KmlFeatureParser { static KmlPlacemark createPlacemark(XmlPullParser parser) throws IOException, XmlPullParserException { String styleId = null; KmlStyle inlineStyle = null; HashMap<String, String> properties = new HashMap<String, String>(); Geometry geometry = null; int eventType = parser.getEventType(); while (!(eventType == END_TAG && parser.getName().equals("Placemark"))) { if (eventType == START_TAG) { if (parser.getName().equals(STYLE_URL_TAG)) { styleId = parser.nextText(); } else if (parser.getName().matches(GEOMETRY_REGEX)) { geometry = createGeometry(parser, parser.getName()); } else if (parser.getName().matches(PROPERTY_REGEX)) { properties.put(parser.getName(), parser.nextText()); } else if (parser.getName().equals(EXTENDED_DATA)) { properties.putAll(setExtendedDataProperties(parser)); } else if (parser.getName().equals(STYLE_TAG)) { inlineStyle = KmlStyleParser.createStyle(parser); } } eventType = parser.next(); } return new KmlPlacemark(geometry, styleId, inlineStyle, properties); } }
@Test public void testProperties() throws Exception { XmlPullParser xmlPullParser = createParser("amu_multigeometry_placemarks.kml"); KmlPlacemark placemark = KmlFeatureParser.createPlacemark(xmlPullParser); assertTrue(placemark.hasProperties()); assertEquals(placemark.getProperty("name"), "Placemark Test"); assertNull(placemark.getProperty("description")); }
static KmlPlacemark createPlacemark(XmlPullParser parser) throws IOException, XmlPullParserException { String styleId = null; KmlStyle inlineStyle = null; HashMap<String, String> properties = new HashMap<String, String>(); Geometry geometry = null; int eventType = parser.getEventType(); while (!(eventType == END_TAG && parser.getName().equals("Placemark"))) { if (eventType == START_TAG) { if (parser.getName().equals(STYLE_URL_TAG)) { styleId = parser.nextText(); } else if (parser.getName().matches(GEOMETRY_REGEX)) { geometry = createGeometry(parser, parser.getName()); } else if (parser.getName().matches(PROPERTY_REGEX)) { properties.put(parser.getName(), parser.nextText()); } else if (parser.getName().equals(EXTENDED_DATA)) { properties.putAll(setExtendedDataProperties(parser)); } else if (parser.getName().equals(STYLE_TAG)) { inlineStyle = KmlStyleParser.createStyle(parser); } } eventType = parser.next(); } return new KmlPlacemark(geometry, styleId, inlineStyle, properties); }
KmlFeatureParser { static KmlPlacemark createPlacemark(XmlPullParser parser) throws IOException, XmlPullParserException { String styleId = null; KmlStyle inlineStyle = null; HashMap<String, String> properties = new HashMap<String, String>(); Geometry geometry = null; int eventType = parser.getEventType(); while (!(eventType == END_TAG && parser.getName().equals("Placemark"))) { if (eventType == START_TAG) { if (parser.getName().equals(STYLE_URL_TAG)) { styleId = parser.nextText(); } else if (parser.getName().matches(GEOMETRY_REGEX)) { geometry = createGeometry(parser, parser.getName()); } else if (parser.getName().matches(PROPERTY_REGEX)) { properties.put(parser.getName(), parser.nextText()); } else if (parser.getName().equals(EXTENDED_DATA)) { properties.putAll(setExtendedDataProperties(parser)); } else if (parser.getName().equals(STYLE_TAG)) { inlineStyle = KmlStyleParser.createStyle(parser); } } eventType = parser.next(); } return new KmlPlacemark(geometry, styleId, inlineStyle, properties); } }
KmlFeatureParser { static KmlPlacemark createPlacemark(XmlPullParser parser) throws IOException, XmlPullParserException { String styleId = null; KmlStyle inlineStyle = null; HashMap<String, String> properties = new HashMap<String, String>(); Geometry geometry = null; int eventType = parser.getEventType(); while (!(eventType == END_TAG && parser.getName().equals("Placemark"))) { if (eventType == START_TAG) { if (parser.getName().equals(STYLE_URL_TAG)) { styleId = parser.nextText(); } else if (parser.getName().matches(GEOMETRY_REGEX)) { geometry = createGeometry(parser, parser.getName()); } else if (parser.getName().matches(PROPERTY_REGEX)) { properties.put(parser.getName(), parser.nextText()); } else if (parser.getName().equals(EXTENDED_DATA)) { properties.putAll(setExtendedDataProperties(parser)); } else if (parser.getName().equals(STYLE_TAG)) { inlineStyle = KmlStyleParser.createStyle(parser); } } eventType = parser.next(); } return new KmlPlacemark(geometry, styleId, inlineStyle, properties); } }
KmlFeatureParser { static KmlPlacemark createPlacemark(XmlPullParser parser) throws IOException, XmlPullParserException { String styleId = null; KmlStyle inlineStyle = null; HashMap<String, String> properties = new HashMap<String, String>(); Geometry geometry = null; int eventType = parser.getEventType(); while (!(eventType == END_TAG && parser.getName().equals("Placemark"))) { if (eventType == START_TAG) { if (parser.getName().equals(STYLE_URL_TAG)) { styleId = parser.nextText(); } else if (parser.getName().matches(GEOMETRY_REGEX)) { geometry = createGeometry(parser, parser.getName()); } else if (parser.getName().matches(PROPERTY_REGEX)) { properties.put(parser.getName(), parser.nextText()); } else if (parser.getName().equals(EXTENDED_DATA)) { properties.putAll(setExtendedDataProperties(parser)); } else if (parser.getName().equals(STYLE_TAG)) { inlineStyle = KmlStyleParser.createStyle(parser); } } eventType = parser.next(); } return new KmlPlacemark(geometry, styleId, inlineStyle, properties); } }
KmlFeatureParser { static KmlPlacemark createPlacemark(XmlPullParser parser) throws IOException, XmlPullParserException { String styleId = null; KmlStyle inlineStyle = null; HashMap<String, String> properties = new HashMap<String, String>(); Geometry geometry = null; int eventType = parser.getEventType(); while (!(eventType == END_TAG && parser.getName().equals("Placemark"))) { if (eventType == START_TAG) { if (parser.getName().equals(STYLE_URL_TAG)) { styleId = parser.nextText(); } else if (parser.getName().matches(GEOMETRY_REGEX)) { geometry = createGeometry(parser, parser.getName()); } else if (parser.getName().matches(PROPERTY_REGEX)) { properties.put(parser.getName(), parser.nextText()); } else if (parser.getName().equals(EXTENDED_DATA)) { properties.putAll(setExtendedDataProperties(parser)); } else if (parser.getName().equals(STYLE_TAG)) { inlineStyle = KmlStyleParser.createStyle(parser); } } eventType = parser.next(); } return new KmlPlacemark(geometry, styleId, inlineStyle, properties); } }
@Test public void testExtendedData() throws Exception { XmlPullParser xmlPullParser = createParser("amu_multiple_placemarks.kml"); KmlPlacemark placemark = KmlFeatureParser.createPlacemark(xmlPullParser); assertNotNull(placemark.getProperty("holeNumber")); }
static KmlPlacemark createPlacemark(XmlPullParser parser) throws IOException, XmlPullParserException { String styleId = null; KmlStyle inlineStyle = null; HashMap<String, String> properties = new HashMap<String, String>(); Geometry geometry = null; int eventType = parser.getEventType(); while (!(eventType == END_TAG && parser.getName().equals("Placemark"))) { if (eventType == START_TAG) { if (parser.getName().equals(STYLE_URL_TAG)) { styleId = parser.nextText(); } else if (parser.getName().matches(GEOMETRY_REGEX)) { geometry = createGeometry(parser, parser.getName()); } else if (parser.getName().matches(PROPERTY_REGEX)) { properties.put(parser.getName(), parser.nextText()); } else if (parser.getName().equals(EXTENDED_DATA)) { properties.putAll(setExtendedDataProperties(parser)); } else if (parser.getName().equals(STYLE_TAG)) { inlineStyle = KmlStyleParser.createStyle(parser); } } eventType = parser.next(); } return new KmlPlacemark(geometry, styleId, inlineStyle, properties); }
KmlFeatureParser { static KmlPlacemark createPlacemark(XmlPullParser parser) throws IOException, XmlPullParserException { String styleId = null; KmlStyle inlineStyle = null; HashMap<String, String> properties = new HashMap<String, String>(); Geometry geometry = null; int eventType = parser.getEventType(); while (!(eventType == END_TAG && parser.getName().equals("Placemark"))) { if (eventType == START_TAG) { if (parser.getName().equals(STYLE_URL_TAG)) { styleId = parser.nextText(); } else if (parser.getName().matches(GEOMETRY_REGEX)) { geometry = createGeometry(parser, parser.getName()); } else if (parser.getName().matches(PROPERTY_REGEX)) { properties.put(parser.getName(), parser.nextText()); } else if (parser.getName().equals(EXTENDED_DATA)) { properties.putAll(setExtendedDataProperties(parser)); } else if (parser.getName().equals(STYLE_TAG)) { inlineStyle = KmlStyleParser.createStyle(parser); } } eventType = parser.next(); } return new KmlPlacemark(geometry, styleId, inlineStyle, properties); } }
KmlFeatureParser { static KmlPlacemark createPlacemark(XmlPullParser parser) throws IOException, XmlPullParserException { String styleId = null; KmlStyle inlineStyle = null; HashMap<String, String> properties = new HashMap<String, String>(); Geometry geometry = null; int eventType = parser.getEventType(); while (!(eventType == END_TAG && parser.getName().equals("Placemark"))) { if (eventType == START_TAG) { if (parser.getName().equals(STYLE_URL_TAG)) { styleId = parser.nextText(); } else if (parser.getName().matches(GEOMETRY_REGEX)) { geometry = createGeometry(parser, parser.getName()); } else if (parser.getName().matches(PROPERTY_REGEX)) { properties.put(parser.getName(), parser.nextText()); } else if (parser.getName().equals(EXTENDED_DATA)) { properties.putAll(setExtendedDataProperties(parser)); } else if (parser.getName().equals(STYLE_TAG)) { inlineStyle = KmlStyleParser.createStyle(parser); } } eventType = parser.next(); } return new KmlPlacemark(geometry, styleId, inlineStyle, properties); } }
KmlFeatureParser { static KmlPlacemark createPlacemark(XmlPullParser parser) throws IOException, XmlPullParserException { String styleId = null; KmlStyle inlineStyle = null; HashMap<String, String> properties = new HashMap<String, String>(); Geometry geometry = null; int eventType = parser.getEventType(); while (!(eventType == END_TAG && parser.getName().equals("Placemark"))) { if (eventType == START_TAG) { if (parser.getName().equals(STYLE_URL_TAG)) { styleId = parser.nextText(); } else if (parser.getName().matches(GEOMETRY_REGEX)) { geometry = createGeometry(parser, parser.getName()); } else if (parser.getName().matches(PROPERTY_REGEX)) { properties.put(parser.getName(), parser.nextText()); } else if (parser.getName().equals(EXTENDED_DATA)) { properties.putAll(setExtendedDataProperties(parser)); } else if (parser.getName().equals(STYLE_TAG)) { inlineStyle = KmlStyleParser.createStyle(parser); } } eventType = parser.next(); } return new KmlPlacemark(geometry, styleId, inlineStyle, properties); } }
KmlFeatureParser { static KmlPlacemark createPlacemark(XmlPullParser parser) throws IOException, XmlPullParserException { String styleId = null; KmlStyle inlineStyle = null; HashMap<String, String> properties = new HashMap<String, String>(); Geometry geometry = null; int eventType = parser.getEventType(); while (!(eventType == END_TAG && parser.getName().equals("Placemark"))) { if (eventType == START_TAG) { if (parser.getName().equals(STYLE_URL_TAG)) { styleId = parser.nextText(); } else if (parser.getName().matches(GEOMETRY_REGEX)) { geometry = createGeometry(parser, parser.getName()); } else if (parser.getName().matches(PROPERTY_REGEX)) { properties.put(parser.getName(), parser.nextText()); } else if (parser.getName().equals(EXTENDED_DATA)) { properties.putAll(setExtendedDataProperties(parser)); } else if (parser.getName().equals(STYLE_TAG)) { inlineStyle = KmlStyleParser.createStyle(parser); } } eventType = parser.next(); } return new KmlPlacemark(geometry, styleId, inlineStyle, properties); } }
@Test public void testTimestamps() { KmlTrack kmlTrack = createSimpleTrack(); assertNotNull(kmlTrack); assertNotNull(kmlTrack.getTimestamps()); assertEquals(kmlTrack.getTimestamps().size(), 3); assertEquals(kmlTrack.getTimestamps().get(0), Long.valueOf(1000L)); assertEquals(kmlTrack.getTimestamps().get(1), Long.valueOf(2000L)); assertEquals(kmlTrack.getTimestamps().get(2), Long.valueOf(3000L)); }
public ArrayList<Long> getTimestamps() { return mTimestamps; }
KmlTrack extends KmlLineString { public ArrayList<Long> getTimestamps() { return mTimestamps; } }
KmlTrack extends KmlLineString { public ArrayList<Long> getTimestamps() { return mTimestamps; } KmlTrack(ArrayList<LatLng> coordinates, ArrayList<Double> altitudes, ArrayList<Long> timestamps, HashMap<String, String> properties); }
KmlTrack extends KmlLineString { public ArrayList<Long> getTimestamps() { return mTimestamps; } KmlTrack(ArrayList<LatLng> coordinates, ArrayList<Double> altitudes, ArrayList<Long> timestamps, HashMap<String, String> properties); ArrayList<Long> getTimestamps(); HashMap<String, String> getProperties(); }
KmlTrack extends KmlLineString { public ArrayList<Long> getTimestamps() { return mTimestamps; } KmlTrack(ArrayList<LatLng> coordinates, ArrayList<Double> altitudes, ArrayList<Long> timestamps, HashMap<String, String> properties); ArrayList<Long> getTimestamps(); HashMap<String, String> getProperties(); }
@Test public void testMultiGeometries() throws Exception { XmlPullParser xmlPullParser = createParser("amu_nested_multigeometry.kml"); KmlPlacemark feature = KmlFeatureParser.createPlacemark(xmlPullParser); assertEquals(feature.getProperty("name"), "multiPointLine"); assertEquals(feature.getProperty("description"), "Nested MultiGeometry structure"); assertEquals(feature.getGeometry().getGeometryType(), "MultiGeometry"); List<Geometry> objects = (ArrayList<Geometry>) feature.getGeometry().getGeometryObject(); assertEquals(objects.get(0).getGeometryType(), "Point"); assertEquals(objects.get(1).getGeometryType(), "LineString"); assertEquals(objects.get(2).getGeometryType(), "MultiGeometry"); List<Geometry> subObjects = (ArrayList<Geometry>) objects.get(2).getGeometryObject(); assertEquals(subObjects.get(0).getGeometryType(), "Point"); assertEquals(subObjects.get(1).getGeometryType(), "LineString"); }
static KmlPlacemark createPlacemark(XmlPullParser parser) throws IOException, XmlPullParserException { String styleId = null; KmlStyle inlineStyle = null; HashMap<String, String> properties = new HashMap<String, String>(); Geometry geometry = null; int eventType = parser.getEventType(); while (!(eventType == END_TAG && parser.getName().equals("Placemark"))) { if (eventType == START_TAG) { if (parser.getName().equals(STYLE_URL_TAG)) { styleId = parser.nextText(); } else if (parser.getName().matches(GEOMETRY_REGEX)) { geometry = createGeometry(parser, parser.getName()); } else if (parser.getName().matches(PROPERTY_REGEX)) { properties.put(parser.getName(), parser.nextText()); } else if (parser.getName().equals(EXTENDED_DATA)) { properties.putAll(setExtendedDataProperties(parser)); } else if (parser.getName().equals(STYLE_TAG)) { inlineStyle = KmlStyleParser.createStyle(parser); } } eventType = parser.next(); } return new KmlPlacemark(geometry, styleId, inlineStyle, properties); }
KmlFeatureParser { static KmlPlacemark createPlacemark(XmlPullParser parser) throws IOException, XmlPullParserException { String styleId = null; KmlStyle inlineStyle = null; HashMap<String, String> properties = new HashMap<String, String>(); Geometry geometry = null; int eventType = parser.getEventType(); while (!(eventType == END_TAG && parser.getName().equals("Placemark"))) { if (eventType == START_TAG) { if (parser.getName().equals(STYLE_URL_TAG)) { styleId = parser.nextText(); } else if (parser.getName().matches(GEOMETRY_REGEX)) { geometry = createGeometry(parser, parser.getName()); } else if (parser.getName().matches(PROPERTY_REGEX)) { properties.put(parser.getName(), parser.nextText()); } else if (parser.getName().equals(EXTENDED_DATA)) { properties.putAll(setExtendedDataProperties(parser)); } else if (parser.getName().equals(STYLE_TAG)) { inlineStyle = KmlStyleParser.createStyle(parser); } } eventType = parser.next(); } return new KmlPlacemark(geometry, styleId, inlineStyle, properties); } }
KmlFeatureParser { static KmlPlacemark createPlacemark(XmlPullParser parser) throws IOException, XmlPullParserException { String styleId = null; KmlStyle inlineStyle = null; HashMap<String, String> properties = new HashMap<String, String>(); Geometry geometry = null; int eventType = parser.getEventType(); while (!(eventType == END_TAG && parser.getName().equals("Placemark"))) { if (eventType == START_TAG) { if (parser.getName().equals(STYLE_URL_TAG)) { styleId = parser.nextText(); } else if (parser.getName().matches(GEOMETRY_REGEX)) { geometry = createGeometry(parser, parser.getName()); } else if (parser.getName().matches(PROPERTY_REGEX)) { properties.put(parser.getName(), parser.nextText()); } else if (parser.getName().equals(EXTENDED_DATA)) { properties.putAll(setExtendedDataProperties(parser)); } else if (parser.getName().equals(STYLE_TAG)) { inlineStyle = KmlStyleParser.createStyle(parser); } } eventType = parser.next(); } return new KmlPlacemark(geometry, styleId, inlineStyle, properties); } }
KmlFeatureParser { static KmlPlacemark createPlacemark(XmlPullParser parser) throws IOException, XmlPullParserException { String styleId = null; KmlStyle inlineStyle = null; HashMap<String, String> properties = new HashMap<String, String>(); Geometry geometry = null; int eventType = parser.getEventType(); while (!(eventType == END_TAG && parser.getName().equals("Placemark"))) { if (eventType == START_TAG) { if (parser.getName().equals(STYLE_URL_TAG)) { styleId = parser.nextText(); } else if (parser.getName().matches(GEOMETRY_REGEX)) { geometry = createGeometry(parser, parser.getName()); } else if (parser.getName().matches(PROPERTY_REGEX)) { properties.put(parser.getName(), parser.nextText()); } else if (parser.getName().equals(EXTENDED_DATA)) { properties.putAll(setExtendedDataProperties(parser)); } else if (parser.getName().equals(STYLE_TAG)) { inlineStyle = KmlStyleParser.createStyle(parser); } } eventType = parser.next(); } return new KmlPlacemark(geometry, styleId, inlineStyle, properties); } }
KmlFeatureParser { static KmlPlacemark createPlacemark(XmlPullParser parser) throws IOException, XmlPullParserException { String styleId = null; KmlStyle inlineStyle = null; HashMap<String, String> properties = new HashMap<String, String>(); Geometry geometry = null; int eventType = parser.getEventType(); while (!(eventType == END_TAG && parser.getName().equals("Placemark"))) { if (eventType == START_TAG) { if (parser.getName().equals(STYLE_URL_TAG)) { styleId = parser.nextText(); } else if (parser.getName().matches(GEOMETRY_REGEX)) { geometry = createGeometry(parser, parser.getName()); } else if (parser.getName().matches(PROPERTY_REGEX)) { properties.put(parser.getName(), parser.nextText()); } else if (parser.getName().equals(EXTENDED_DATA)) { properties.putAll(setExtendedDataProperties(parser)); } else if (parser.getName().equals(STYLE_TAG)) { inlineStyle = KmlStyleParser.createStyle(parser); } } eventType = parser.next(); } return new KmlPlacemark(geometry, styleId, inlineStyle, properties); } }
@Test public void testGetGeometryType() { List<LineString> lineStrings = new ArrayList<>(); lineStrings.add( new LineString( new ArrayList<>(Arrays.asList(new LatLng(0, 0), new LatLng(50, 50))))); lineStrings.add( new LineString( new ArrayList<>(Arrays.asList(new LatLng(56, 65), new LatLng(23, 23))))); mg = new MultiGeometry(lineStrings); assertEquals("MultiGeometry", mg.getGeometryType()); List<GeoJsonPolygon> polygons = new ArrayList<>(); List<ArrayList<LatLng>> polygon = new ArrayList<>(); polygon.add( new ArrayList<>( Arrays.asList( new LatLng(0, 0), new LatLng(20, 20), new LatLng(60, 60), new LatLng(0, 0)))); polygons.add(new GeoJsonPolygon(polygon)); polygon = new ArrayList<>(); polygon.add( new ArrayList<>( Arrays.asList( new LatLng(0, 0), new LatLng(50, 80), new LatLng(10, 15), new LatLng(0, 0)))); polygon.add( new ArrayList<>( Arrays.asList( new LatLng(0, 0), new LatLng(20, 20), new LatLng(60, 60), new LatLng(0, 0)))); polygons.add(new GeoJsonPolygon(polygon)); mg = new MultiGeometry(polygons); assertEquals("MultiGeometry", mg.getGeometryType()); }
public String getGeometryType() { return geometryType; }
MultiGeometry implements Geometry { public String getGeometryType() { return geometryType; } }
MultiGeometry implements Geometry { public String getGeometryType() { return geometryType; } MultiGeometry(List<? extends Geometry> geometries); }
MultiGeometry implements Geometry { public String getGeometryType() { return geometryType; } MultiGeometry(List<? extends Geometry> geometries); String getGeometryType(); List<Geometry> getGeometryObject(); void setGeometryType(String type); @Override String toString(); }
MultiGeometry implements Geometry { public String getGeometryType() { return geometryType; } MultiGeometry(List<? extends Geometry> geometries); String getGeometryType(); List<Geometry> getGeometryObject(); void setGeometryType(String type); @Override String toString(); }
@Test public void testSetGeometryType() { List<LineString> lineStrings = new ArrayList<>(); lineStrings.add( new LineString( new ArrayList<>(Arrays.asList(new LatLng(0, 0), new LatLng(50, 50))))); lineStrings.add( new LineString( new ArrayList<>(Arrays.asList(new LatLng(56, 65), new LatLng(23, 23))))); mg = new MultiGeometry(lineStrings); assertEquals("MultiGeometry", mg.getGeometryType()); mg.setGeometryType("MultiLineString"); assertEquals("MultiLineString", mg.getGeometryType()); }
public void setGeometryType(String type) { geometryType = type; }
MultiGeometry implements Geometry { public void setGeometryType(String type) { geometryType = type; } }
MultiGeometry implements Geometry { public void setGeometryType(String type) { geometryType = type; } MultiGeometry(List<? extends Geometry> geometries); }
MultiGeometry implements Geometry { public void setGeometryType(String type) { geometryType = type; } MultiGeometry(List<? extends Geometry> geometries); String getGeometryType(); List<Geometry> getGeometryObject(); void setGeometryType(String type); @Override String toString(); }
MultiGeometry implements Geometry { public void setGeometryType(String type) { geometryType = type; } MultiGeometry(List<? extends Geometry> geometries); String getGeometryType(); List<Geometry> getGeometryObject(); void setGeometryType(String type); @Override String toString(); }
@Test public void testGetGeometryObject() { List<Point> points = new ArrayList<>(); points.add(new Point(new LatLng(0, 0))); points.add(new Point(new LatLng(5, 5))); points.add(new Point(new LatLng(10, 10))); mg = new MultiGeometry(points); assertEquals(points, mg.getGeometryObject()); points = new ArrayList<>(); mg = new MultiGeometry(points); assertEquals(new ArrayList<Point>(), mg.getGeometryObject()); try { mg = new MultiGeometry(null); fail(); } catch (IllegalArgumentException e) { assertEquals("Geometries cannot be null", e.getMessage()); } }
public List<Geometry> getGeometryObject() { return mGeometries; }
MultiGeometry implements Geometry { public List<Geometry> getGeometryObject() { return mGeometries; } }
MultiGeometry implements Geometry { public List<Geometry> getGeometryObject() { return mGeometries; } MultiGeometry(List<? extends Geometry> geometries); }
MultiGeometry implements Geometry { public List<Geometry> getGeometryObject() { return mGeometries; } MultiGeometry(List<? extends Geometry> geometries); String getGeometryType(); List<Geometry> getGeometryObject(); void setGeometryType(String type); @Override String toString(); }
MultiGeometry implements Geometry { public List<Geometry> getGeometryObject() { return mGeometries; } MultiGeometry(List<? extends Geometry> geometries); String getGeometryType(); List<Geometry> getGeometryObject(); void setGeometryType(String type); @Override String toString(); }
@Test public void testGetType() { LineString lineString = createSimpleLineString(); assertNotNull(lineString); assertNotNull(lineString.getGeometryType()); assertEquals("LineString", lineString.getGeometryType()); lineString = createLoopedLineString(); assertNotNull(lineString); assertNotNull(lineString.getGeometryType()); assertEquals("LineString", lineString.getGeometryType()); }
public String getGeometryType() { return GEOMETRY_TYPE; }
LineString implements Geometry<List<LatLng>> { public String getGeometryType() { return GEOMETRY_TYPE; } }
LineString implements Geometry<List<LatLng>> { public String getGeometryType() { return GEOMETRY_TYPE; } LineString(List<LatLng> coordinates); }
LineString implements Geometry<List<LatLng>> { public String getGeometryType() { return GEOMETRY_TYPE; } LineString(List<LatLng> coordinates); String getGeometryType(); List<LatLng> getGeometryObject(); @Override String toString(); }
LineString implements Geometry<List<LatLng>> { public String getGeometryType() { return GEOMETRY_TYPE; } LineString(List<LatLng> coordinates); String getGeometryType(); List<LatLng> getGeometryObject(); @Override String toString(); }
@Test public void testGetGeometryObject() { LineString lineString = createSimpleLineString(); assertNotNull(lineString); assertNotNull(lineString.getGeometryObject()); assertEquals(lineString.getGeometryObject().size(), 6); assertEquals(lineString.getGeometryObject().get(0).latitude, 90.0, 0); assertEquals(lineString.getGeometryObject().get(1).latitude, 90.0, 0); assertEquals(lineString.getGeometryObject().get(2).latitude, 90.0, 0); assertEquals(lineString.getGeometryObject().get(3).longitude, 53.0, 0); assertEquals(lineString.getGeometryObject().get(4).longitude, 54.0, 0); lineString = createLoopedLineString(); assertNotNull(lineString); assertNotNull(lineString.getGeometryObject()); assertEquals(lineString.getGeometryObject().size(), 4); assertEquals(lineString.getGeometryObject().get(0).latitude, 90.0, 0); assertEquals(lineString.getGeometryObject().get(1).latitude, 89.0, 0); assertEquals(lineString.getGeometryObject().get(2).longitude, 62.0, 0); assertEquals(lineString.getGeometryObject().get(3).longitude, 66.0, 0); }
public List<LatLng> getGeometryObject() { return mCoordinates; }
LineString implements Geometry<List<LatLng>> { public List<LatLng> getGeometryObject() { return mCoordinates; } }
LineString implements Geometry<List<LatLng>> { public List<LatLng> getGeometryObject() { return mCoordinates; } LineString(List<LatLng> coordinates); }
LineString implements Geometry<List<LatLng>> { public List<LatLng> getGeometryObject() { return mCoordinates; } LineString(List<LatLng> coordinates); String getGeometryType(); List<LatLng> getGeometryObject(); @Override String toString(); }
LineString implements Geometry<List<LatLng>> { public List<LatLng> getGeometryObject() { return mCoordinates; } LineString(List<LatLng> coordinates); String getGeometryType(); List<LatLng> getGeometryObject(); @Override String toString(); }
@Test public void testGetGeometryType() { assertTrue(Arrays.asList(pointStyle.getGeometryType()).contains("Point")); assertTrue(Arrays.asList(pointStyle.getGeometryType()).contains("MultiPoint")); assertTrue(Arrays.asList(pointStyle.getGeometryType()).contains("GeometryCollection")); assertEquals(3, pointStyle.getGeometryType().length); }
@Override public String[] getGeometryType() { return GEOMETRY_TYPE; }
GeoJsonPointStyle extends Style implements GeoJsonStyle { @Override public String[] getGeometryType() { return GEOMETRY_TYPE; } }
GeoJsonPointStyle extends Style implements GeoJsonStyle { @Override public String[] getGeometryType() { return GEOMETRY_TYPE; } GeoJsonPointStyle(); }
GeoJsonPointStyle extends Style implements GeoJsonStyle { @Override public String[] getGeometryType() { return GEOMETRY_TYPE; } GeoJsonPointStyle(); @Override String[] getGeometryType(); float getAlpha(); void setAlpha(float alpha); float getAnchorU(); float getAnchorV(); void setAnchor(float anchorU, float anchorV); boolean isDraggable(); void setDraggable(boolean draggable); boolean isFlat(); void setFlat(boolean flat); BitmapDescriptor getIcon(); void setIcon(BitmapDescriptor bitmap); float getInfoWindowAnchorU(); float getInfoWindowAnchorV(); void setInfoWindowAnchor(float infoWindowAnchorU, float infoWindowAnchorV); float getRotation(); void setRotation(float rotation); String getSnippet(); void setSnippet(String snippet); String getTitle(); void setTitle(String title); @Override boolean isVisible(); @Override void setVisible(boolean visible); MarkerOptions toMarkerOptions(); @Override String toString(); float getZIndex(); void setZIndex(float zIndex); }
GeoJsonPointStyle extends Style implements GeoJsonStyle { @Override public String[] getGeometryType() { return GEOMETRY_TYPE; } GeoJsonPointStyle(); @Override String[] getGeometryType(); float getAlpha(); void setAlpha(float alpha); float getAnchorU(); float getAnchorV(); void setAnchor(float anchorU, float anchorV); boolean isDraggable(); void setDraggable(boolean draggable); boolean isFlat(); void setFlat(boolean flat); BitmapDescriptor getIcon(); void setIcon(BitmapDescriptor bitmap); float getInfoWindowAnchorU(); float getInfoWindowAnchorV(); void setInfoWindowAnchor(float infoWindowAnchorU, float infoWindowAnchorV); float getRotation(); void setRotation(float rotation); String getSnippet(); void setSnippet(String snippet); String getTitle(); void setTitle(String title); @Override boolean isVisible(); @Override void setVisible(boolean visible); MarkerOptions toMarkerOptions(); @Override String toString(); float getZIndex(); void setZIndex(float zIndex); }
@Test public void testGetFeatures() { int featureCount = 0; for (Feature ignored : mLayer.getFeatures()) { featureCount++; } assertEquals(3, featureCount); }
public Iterable<GeoJsonFeature> getFeatures() { return (Iterable<GeoJsonFeature>) super.getFeatures(); }
GeoJsonLayer extends Layer { public Iterable<GeoJsonFeature> getFeatures() { return (Iterable<GeoJsonFeature>) super.getFeatures(); } }
GeoJsonLayer extends Layer { public Iterable<GeoJsonFeature> getFeatures() { return (Iterable<GeoJsonFeature>) super.getFeatures(); } GeoJsonLayer(GoogleMap map, JSONObject geoJsonFile, MarkerManager markerManager, PolygonManager polygonManager, PolylineManager polylineManager, GroundOverlayManager groundOverlayManager); GeoJsonLayer(GoogleMap map, int resourceId, Context context, MarkerManager markerManager, PolygonManager polygonManager, PolylineManager polylineManager, GroundOverlayManager groundOverlayManager); GeoJsonLayer(GoogleMap map, JSONObject geoJsonFile); GeoJsonLayer(GoogleMap map, int resourceId, Context context); }
GeoJsonLayer extends Layer { public Iterable<GeoJsonFeature> getFeatures() { return (Iterable<GeoJsonFeature>) super.getFeatures(); } GeoJsonLayer(GoogleMap map, JSONObject geoJsonFile, MarkerManager markerManager, PolygonManager polygonManager, PolylineManager polylineManager, GroundOverlayManager groundOverlayManager); GeoJsonLayer(GoogleMap map, int resourceId, Context context, MarkerManager markerManager, PolygonManager polygonManager, PolylineManager polylineManager, GroundOverlayManager groundOverlayManager); GeoJsonLayer(GoogleMap map, JSONObject geoJsonFile); GeoJsonLayer(GoogleMap map, int resourceId, Context context); @Override void addLayerToMap(); Iterable<GeoJsonFeature> getFeatures(); void addFeature(GeoJsonFeature feature); void removeFeature(GeoJsonFeature feature); LatLngBounds getBoundingBox(); @Override String toString(); }
GeoJsonLayer extends Layer { public Iterable<GeoJsonFeature> getFeatures() { return (Iterable<GeoJsonFeature>) super.getFeatures(); } GeoJsonLayer(GoogleMap map, JSONObject geoJsonFile, MarkerManager markerManager, PolygonManager polygonManager, PolylineManager polylineManager, GroundOverlayManager groundOverlayManager); GeoJsonLayer(GoogleMap map, int resourceId, Context context, MarkerManager markerManager, PolygonManager polygonManager, PolylineManager polylineManager, GroundOverlayManager groundOverlayManager); GeoJsonLayer(GoogleMap map, JSONObject geoJsonFile); GeoJsonLayer(GoogleMap map, int resourceId, Context context); @Override void addLayerToMap(); Iterable<GeoJsonFeature> getFeatures(); void addFeature(GeoJsonFeature feature); void removeFeature(GeoJsonFeature feature); LatLngBounds getBoundingBox(); @Override String toString(); }
@Test public void testAddFeature() { int featureCount = 0; mLayer.addFeature(new GeoJsonFeature(null, null, null, null)); for (Feature ignored : mLayer.getFeatures()) { featureCount++; } assertEquals(4, featureCount); }
public void addFeature(GeoJsonFeature feature) { if (feature == null) { throw new IllegalArgumentException("Feature cannot be null"); } super.addFeature(feature); }
GeoJsonLayer extends Layer { public void addFeature(GeoJsonFeature feature) { if (feature == null) { throw new IllegalArgumentException("Feature cannot be null"); } super.addFeature(feature); } }
GeoJsonLayer extends Layer { public void addFeature(GeoJsonFeature feature) { if (feature == null) { throw new IllegalArgumentException("Feature cannot be null"); } super.addFeature(feature); } GeoJsonLayer(GoogleMap map, JSONObject geoJsonFile, MarkerManager markerManager, PolygonManager polygonManager, PolylineManager polylineManager, GroundOverlayManager groundOverlayManager); GeoJsonLayer(GoogleMap map, int resourceId, Context context, MarkerManager markerManager, PolygonManager polygonManager, PolylineManager polylineManager, GroundOverlayManager groundOverlayManager); GeoJsonLayer(GoogleMap map, JSONObject geoJsonFile); GeoJsonLayer(GoogleMap map, int resourceId, Context context); }
GeoJsonLayer extends Layer { public void addFeature(GeoJsonFeature feature) { if (feature == null) { throw new IllegalArgumentException("Feature cannot be null"); } super.addFeature(feature); } GeoJsonLayer(GoogleMap map, JSONObject geoJsonFile, MarkerManager markerManager, PolygonManager polygonManager, PolylineManager polylineManager, GroundOverlayManager groundOverlayManager); GeoJsonLayer(GoogleMap map, int resourceId, Context context, MarkerManager markerManager, PolygonManager polygonManager, PolylineManager polylineManager, GroundOverlayManager groundOverlayManager); GeoJsonLayer(GoogleMap map, JSONObject geoJsonFile); GeoJsonLayer(GoogleMap map, int resourceId, Context context); @Override void addLayerToMap(); Iterable<GeoJsonFeature> getFeatures(); void addFeature(GeoJsonFeature feature); void removeFeature(GeoJsonFeature feature); LatLngBounds getBoundingBox(); @Override String toString(); }
GeoJsonLayer extends Layer { public void addFeature(GeoJsonFeature feature) { if (feature == null) { throw new IllegalArgumentException("Feature cannot be null"); } super.addFeature(feature); } GeoJsonLayer(GoogleMap map, JSONObject geoJsonFile, MarkerManager markerManager, PolygonManager polygonManager, PolylineManager polylineManager, GroundOverlayManager groundOverlayManager); GeoJsonLayer(GoogleMap map, int resourceId, Context context, MarkerManager markerManager, PolygonManager polygonManager, PolylineManager polylineManager, GroundOverlayManager groundOverlayManager); GeoJsonLayer(GoogleMap map, JSONObject geoJsonFile); GeoJsonLayer(GoogleMap map, int resourceId, Context context); @Override void addLayerToMap(); Iterable<GeoJsonFeature> getFeatures(); void addFeature(GeoJsonFeature feature); void removeFeature(GeoJsonFeature feature); LatLngBounds getBoundingBox(); @Override String toString(); }
@Test public void testRemoveFeature() { int featureCount = 0; for (Feature ignored : mLayer.getFeatures()) { featureCount++; } assertEquals(3, featureCount); }
public void removeFeature(GeoJsonFeature feature) { if (feature == null) { throw new IllegalArgumentException("Feature cannot be null"); } super.removeFeature(feature); }
GeoJsonLayer extends Layer { public void removeFeature(GeoJsonFeature feature) { if (feature == null) { throw new IllegalArgumentException("Feature cannot be null"); } super.removeFeature(feature); } }
GeoJsonLayer extends Layer { public void removeFeature(GeoJsonFeature feature) { if (feature == null) { throw new IllegalArgumentException("Feature cannot be null"); } super.removeFeature(feature); } GeoJsonLayer(GoogleMap map, JSONObject geoJsonFile, MarkerManager markerManager, PolygonManager polygonManager, PolylineManager polylineManager, GroundOverlayManager groundOverlayManager); GeoJsonLayer(GoogleMap map, int resourceId, Context context, MarkerManager markerManager, PolygonManager polygonManager, PolylineManager polylineManager, GroundOverlayManager groundOverlayManager); GeoJsonLayer(GoogleMap map, JSONObject geoJsonFile); GeoJsonLayer(GoogleMap map, int resourceId, Context context); }
GeoJsonLayer extends Layer { public void removeFeature(GeoJsonFeature feature) { if (feature == null) { throw new IllegalArgumentException("Feature cannot be null"); } super.removeFeature(feature); } GeoJsonLayer(GoogleMap map, JSONObject geoJsonFile, MarkerManager markerManager, PolygonManager polygonManager, PolylineManager polylineManager, GroundOverlayManager groundOverlayManager); GeoJsonLayer(GoogleMap map, int resourceId, Context context, MarkerManager markerManager, PolygonManager polygonManager, PolylineManager polylineManager, GroundOverlayManager groundOverlayManager); GeoJsonLayer(GoogleMap map, JSONObject geoJsonFile); GeoJsonLayer(GoogleMap map, int resourceId, Context context); @Override void addLayerToMap(); Iterable<GeoJsonFeature> getFeatures(); void addFeature(GeoJsonFeature feature); void removeFeature(GeoJsonFeature feature); LatLngBounds getBoundingBox(); @Override String toString(); }
GeoJsonLayer extends Layer { public void removeFeature(GeoJsonFeature feature) { if (feature == null) { throw new IllegalArgumentException("Feature cannot be null"); } super.removeFeature(feature); } GeoJsonLayer(GoogleMap map, JSONObject geoJsonFile, MarkerManager markerManager, PolygonManager polygonManager, PolylineManager polylineManager, GroundOverlayManager groundOverlayManager); GeoJsonLayer(GoogleMap map, int resourceId, Context context, MarkerManager markerManager, PolygonManager polygonManager, PolylineManager polylineManager, GroundOverlayManager groundOverlayManager); GeoJsonLayer(GoogleMap map, JSONObject geoJsonFile); GeoJsonLayer(GoogleMap map, int resourceId, Context context); @Override void addLayerToMap(); Iterable<GeoJsonFeature> getFeatures(); void addFeature(GeoJsonFeature feature); void removeFeature(GeoJsonFeature feature); LatLngBounds getBoundingBox(); @Override String toString(); }
@Test public void testProperties() { KmlTrack kmlTrack = createSimpleTrack(); assertNotNull(kmlTrack); assertNotNull(kmlTrack.getProperties()); assertEquals(kmlTrack.getProperties().size(), 1); assertEquals(kmlTrack.getProperties().get("key"), "value"); assertNull(kmlTrack.getProperties().get("missingKey")); }
public HashMap<String, String> getProperties() { return mProperties; }
KmlTrack extends KmlLineString { public HashMap<String, String> getProperties() { return mProperties; } }
KmlTrack extends KmlLineString { public HashMap<String, String> getProperties() { return mProperties; } KmlTrack(ArrayList<LatLng> coordinates, ArrayList<Double> altitudes, ArrayList<Long> timestamps, HashMap<String, String> properties); }
KmlTrack extends KmlLineString { public HashMap<String, String> getProperties() { return mProperties; } KmlTrack(ArrayList<LatLng> coordinates, ArrayList<Double> altitudes, ArrayList<Long> timestamps, HashMap<String, String> properties); ArrayList<Long> getTimestamps(); HashMap<String, String> getProperties(); }
KmlTrack extends KmlLineString { public HashMap<String, String> getProperties() { return mProperties; } KmlTrack(ArrayList<LatLng> coordinates, ArrayList<Double> altitudes, ArrayList<Long> timestamps, HashMap<String, String> properties); ArrayList<Long> getTimestamps(); HashMap<String, String> getProperties(); }
@Test public void testGetBoundingBox() { assertEquals( new LatLngBounds(new LatLng(-80, -150), new LatLng(80, 150)), mLayer.getBoundingBox()); }
public LatLngBounds getBoundingBox() { return mBoundingBox; }
GeoJsonLayer extends Layer { public LatLngBounds getBoundingBox() { return mBoundingBox; } }
GeoJsonLayer extends Layer { public LatLngBounds getBoundingBox() { return mBoundingBox; } GeoJsonLayer(GoogleMap map, JSONObject geoJsonFile, MarkerManager markerManager, PolygonManager polygonManager, PolylineManager polylineManager, GroundOverlayManager groundOverlayManager); GeoJsonLayer(GoogleMap map, int resourceId, Context context, MarkerManager markerManager, PolygonManager polygonManager, PolylineManager polylineManager, GroundOverlayManager groundOverlayManager); GeoJsonLayer(GoogleMap map, JSONObject geoJsonFile); GeoJsonLayer(GoogleMap map, int resourceId, Context context); }
GeoJsonLayer extends Layer { public LatLngBounds getBoundingBox() { return mBoundingBox; } GeoJsonLayer(GoogleMap map, JSONObject geoJsonFile, MarkerManager markerManager, PolygonManager polygonManager, PolylineManager polylineManager, GroundOverlayManager groundOverlayManager); GeoJsonLayer(GoogleMap map, int resourceId, Context context, MarkerManager markerManager, PolygonManager polygonManager, PolylineManager polylineManager, GroundOverlayManager groundOverlayManager); GeoJsonLayer(GoogleMap map, JSONObject geoJsonFile); GeoJsonLayer(GoogleMap map, int resourceId, Context context); @Override void addLayerToMap(); Iterable<GeoJsonFeature> getFeatures(); void addFeature(GeoJsonFeature feature); void removeFeature(GeoJsonFeature feature); LatLngBounds getBoundingBox(); @Override String toString(); }
GeoJsonLayer extends Layer { public LatLngBounds getBoundingBox() { return mBoundingBox; } GeoJsonLayer(GoogleMap map, JSONObject geoJsonFile, MarkerManager markerManager, PolygonManager polygonManager, PolylineManager polylineManager, GroundOverlayManager groundOverlayManager); GeoJsonLayer(GoogleMap map, int resourceId, Context context, MarkerManager markerManager, PolygonManager polygonManager, PolylineManager polylineManager, GroundOverlayManager groundOverlayManager); GeoJsonLayer(GoogleMap map, JSONObject geoJsonFile); GeoJsonLayer(GoogleMap map, int resourceId, Context context); @Override void addLayerToMap(); Iterable<GeoJsonFeature> getFeatures(); void addFeature(GeoJsonFeature feature); void removeFeature(GeoJsonFeature feature); LatLngBounds getBoundingBox(); @Override String toString(); }
@Test public void testGetGeometryType() { assertTrue(Arrays.asList(lineStringStyle.getGeometryType()).contains("LineString")); assertTrue(Arrays.asList(lineStringStyle.getGeometryType()).contains("MultiLineString")); assertTrue(Arrays.asList(lineStringStyle.getGeometryType()).contains("GeometryCollection")); assertEquals(3, lineStringStyle.getGeometryType().length); }
@Override public String[] getGeometryType() { return GEOMETRY_TYPE; }
GeoJsonLineStringStyle extends Style implements GeoJsonStyle { @Override public String[] getGeometryType() { return GEOMETRY_TYPE; } }
GeoJsonLineStringStyle extends Style implements GeoJsonStyle { @Override public String[] getGeometryType() { return GEOMETRY_TYPE; } GeoJsonLineStringStyle(); }
GeoJsonLineStringStyle extends Style implements GeoJsonStyle { @Override public String[] getGeometryType() { return GEOMETRY_TYPE; } GeoJsonLineStringStyle(); @Override String[] getGeometryType(); int getColor(); void setColor(int color); boolean isClickable(); void setClickable(boolean clickable); boolean isGeodesic(); void setGeodesic(boolean geodesic); float getWidth(); void setWidth(float width); float getZIndex(); void setZIndex(float zIndex); @Override boolean isVisible(); @Override void setVisible(boolean visible); PolylineOptions toPolylineOptions(); @Override String toString(); List<PatternItem> getPattern(); void setPattern(List<PatternItem> pattern); }
GeoJsonLineStringStyle extends Style implements GeoJsonStyle { @Override public String[] getGeometryType() { return GEOMETRY_TYPE; } GeoJsonLineStringStyle(); @Override String[] getGeometryType(); int getColor(); void setColor(int color); boolean isClickable(); void setClickable(boolean clickable); boolean isGeodesic(); void setGeodesic(boolean geodesic); float getWidth(); void setWidth(float width); float getZIndex(); void setZIndex(float zIndex); @Override boolean isVisible(); @Override void setVisible(boolean visible); PolylineOptions toPolylineOptions(); @Override String toString(); List<PatternItem> getPattern(); void setPattern(List<PatternItem> pattern); }
@Test public void testParseGeoJson() throws Exception { JSONObject validGeoJsonObject = new JSONObject( "{ \"type\": \"MultiLineString\",\n" + " \"coordinates\": [\n" + " [ [100.0, 0.0], [101.0, 1.0] ],\n" + " [ [102.0, 2.0], [103.0, 3.0] ]\n" + " ]\n" + " }"); GeoJsonParser parser = new GeoJsonParser(validGeoJsonObject); GeoJsonLineString ls1 = new GeoJsonLineString( new ArrayList<>(Arrays.asList(new LatLng(0, 100), new LatLng(1, 101)))); GeoJsonLineString ls2 = new GeoJsonLineString( new ArrayList<>(Arrays.asList(new LatLng(2, 102), new LatLng(3, 103)))); GeoJsonMultiLineString geoJsonMultiLineString = new GeoJsonMultiLineString(new ArrayList<>(Arrays.asList(ls1, ls2))); GeoJsonFeature geoJsonFeature = new GeoJsonFeature(geoJsonMultiLineString, null, null, null); List<GeoJsonFeature> geoJsonFeatures = new ArrayList<>(Arrays.asList(geoJsonFeature)); assertEquals(geoJsonFeatures.get(0).getId(), parser.getFeatures().get(0).getId()); }
private void parseGeoJson() { try { GeoJsonFeature feature; String type = mGeoJsonFile.getString("type"); if (type.equals(FEATURE)) { feature = parseFeature(mGeoJsonFile); if (feature != null) { mGeoJsonFeatures.add(feature); } } else if (type.equals(FEATURE_COLLECTION)) { mGeoJsonFeatures.addAll(parseFeatureCollection(mGeoJsonFile)); } else if (isGeometry(type)) { feature = parseGeometryToFeature(mGeoJsonFile); if (feature != null) { mGeoJsonFeatures.add(feature); } } else { Log.w(LOG_TAG, "GeoJSON file could not be parsed."); } } catch (JSONException e) { Log.w(LOG_TAG, "GeoJSON file could not be parsed."); } }
GeoJsonParser { private void parseGeoJson() { try { GeoJsonFeature feature; String type = mGeoJsonFile.getString("type"); if (type.equals(FEATURE)) { feature = parseFeature(mGeoJsonFile); if (feature != null) { mGeoJsonFeatures.add(feature); } } else if (type.equals(FEATURE_COLLECTION)) { mGeoJsonFeatures.addAll(parseFeatureCollection(mGeoJsonFile)); } else if (isGeometry(type)) { feature = parseGeometryToFeature(mGeoJsonFile); if (feature != null) { mGeoJsonFeatures.add(feature); } } else { Log.w(LOG_TAG, "GeoJSON file could not be parsed."); } } catch (JSONException e) { Log.w(LOG_TAG, "GeoJSON file could not be parsed."); } } }
GeoJsonParser { private void parseGeoJson() { try { GeoJsonFeature feature; String type = mGeoJsonFile.getString("type"); if (type.equals(FEATURE)) { feature = parseFeature(mGeoJsonFile); if (feature != null) { mGeoJsonFeatures.add(feature); } } else if (type.equals(FEATURE_COLLECTION)) { mGeoJsonFeatures.addAll(parseFeatureCollection(mGeoJsonFile)); } else if (isGeometry(type)) { feature = parseGeometryToFeature(mGeoJsonFile); if (feature != null) { mGeoJsonFeatures.add(feature); } } else { Log.w(LOG_TAG, "GeoJSON file could not be parsed."); } } catch (JSONException e) { Log.w(LOG_TAG, "GeoJSON file could not be parsed."); } } GeoJsonParser(JSONObject geoJsonFile); }
GeoJsonParser { private void parseGeoJson() { try { GeoJsonFeature feature; String type = mGeoJsonFile.getString("type"); if (type.equals(FEATURE)) { feature = parseFeature(mGeoJsonFile); if (feature != null) { mGeoJsonFeatures.add(feature); } } else if (type.equals(FEATURE_COLLECTION)) { mGeoJsonFeatures.addAll(parseFeatureCollection(mGeoJsonFile)); } else if (isGeometry(type)) { feature = parseGeometryToFeature(mGeoJsonFile); if (feature != null) { mGeoJsonFeatures.add(feature); } } else { Log.w(LOG_TAG, "GeoJSON file could not be parsed."); } } catch (JSONException e) { Log.w(LOG_TAG, "GeoJSON file could not be parsed."); } } GeoJsonParser(JSONObject geoJsonFile); static Geometry parseGeometry(JSONObject geoJsonGeometry); }
GeoJsonParser { private void parseGeoJson() { try { GeoJsonFeature feature; String type = mGeoJsonFile.getString("type"); if (type.equals(FEATURE)) { feature = parseFeature(mGeoJsonFile); if (feature != null) { mGeoJsonFeatures.add(feature); } } else if (type.equals(FEATURE_COLLECTION)) { mGeoJsonFeatures.addAll(parseFeatureCollection(mGeoJsonFile)); } else if (isGeometry(type)) { feature = parseGeometryToFeature(mGeoJsonFile); if (feature != null) { mGeoJsonFeatures.add(feature); } } else { Log.w(LOG_TAG, "GeoJSON file could not be parsed."); } } catch (JSONException e) { Log.w(LOG_TAG, "GeoJSON file could not be parsed."); } } GeoJsonParser(JSONObject geoJsonFile); static Geometry parseGeometry(JSONObject geoJsonGeometry); }
@Test public void testParseGeometryCollection() throws Exception { GeoJsonParser parser = new GeoJsonParser(validGeometryCollection()); assertEquals(1, parser.getFeatures().size()); for (GeoJsonFeature feature : parser.getFeatures()) { assertEquals("GeometryCollection", feature.getGeometry().getGeometryType()); int size = 0; for (String property : feature.getPropertyKeys()) { size++; } assertEquals(2, size); assertEquals("Popsicles", feature.getId()); GeoJsonGeometryCollection geometry = ((GeoJsonGeometryCollection) feature.getGeometry()); assertEquals(1, geometry.getGeometries().size()); for (Geometry geoJsonGeometry : geometry.getGeometries()) { assertEquals("GeometryCollection", geoJsonGeometry.getGeometryType()); } } }
ArrayList<GeoJsonFeature> getFeatures() { return mGeoJsonFeatures; }
GeoJsonParser { ArrayList<GeoJsonFeature> getFeatures() { return mGeoJsonFeatures; } }
GeoJsonParser { ArrayList<GeoJsonFeature> getFeatures() { return mGeoJsonFeatures; } GeoJsonParser(JSONObject geoJsonFile); }
GeoJsonParser { ArrayList<GeoJsonFeature> getFeatures() { return mGeoJsonFeatures; } GeoJsonParser(JSONObject geoJsonFile); static Geometry parseGeometry(JSONObject geoJsonGeometry); }
GeoJsonParser { ArrayList<GeoJsonFeature> getFeatures() { return mGeoJsonFeatures; } GeoJsonParser(JSONObject geoJsonFile); static Geometry parseGeometry(JSONObject geoJsonGeometry); }
@Test public void testParseMultiPolygon() throws Exception { GeoJsonParser parser = new GeoJsonParser(validMultiPolygon()); assertEquals(1, parser.getFeatures().size()); GeoJsonFeature feature = parser.getFeatures().get(0); GeoJsonMultiPolygon polygon = ((GeoJsonMultiPolygon) feature.getGeometry()); assertEquals(2, polygon.getPolygons().size()); assertEquals(1, polygon.getPolygons().get(0).getCoordinates().size()); List<List<LatLng>> p1 = new ArrayList<>(); p1.add( new ArrayList<>( Arrays.asList( new LatLng(2, 102), new LatLng(2, 103), new LatLng(3, 103), new LatLng(3, 102), new LatLng(2, 102)))); assertEquals(p1, polygon.getPolygons().get(0).getCoordinates()); assertEquals(2, polygon.getPolygons().get(1).getCoordinates().size()); List<List<LatLng>> p2 = new ArrayList<>(); p2.add( new ArrayList<>( Arrays.asList( new LatLng(0, 100), new LatLng(0, 101), new LatLng(1, 101), new LatLng(1, 100), new LatLng(0, 100)))); p2.add( new ArrayList<>( Arrays.asList( new LatLng(0.2, 100.2), new LatLng(0.2, 100.8), new LatLng(0.8, 100.8), new LatLng(0.8, 100.2), new LatLng(0.2, 100.2)))); assertEquals(p2, polygon.getPolygons().get(1).getCoordinates()); }
ArrayList<GeoJsonFeature> getFeatures() { return mGeoJsonFeatures; }
GeoJsonParser { ArrayList<GeoJsonFeature> getFeatures() { return mGeoJsonFeatures; } }
GeoJsonParser { ArrayList<GeoJsonFeature> getFeatures() { return mGeoJsonFeatures; } GeoJsonParser(JSONObject geoJsonFile); }
GeoJsonParser { ArrayList<GeoJsonFeature> getFeatures() { return mGeoJsonFeatures; } GeoJsonParser(JSONObject geoJsonFile); static Geometry parseGeometry(JSONObject geoJsonGeometry); }
GeoJsonParser { ArrayList<GeoJsonFeature> getFeatures() { return mGeoJsonFeatures; } GeoJsonParser(JSONObject geoJsonFile); static Geometry parseGeometry(JSONObject geoJsonGeometry); }
@Test public void testGetType() { List<GeoJsonLineString> lineStrings = new ArrayList<>(); lineStrings.add( new GeoJsonLineString( new ArrayList<>(Arrays.asList(new LatLng(0, 0), new LatLng(50, 50))))); lineStrings.add( new GeoJsonLineString( new ArrayList<>(Arrays.asList(new LatLng(80, 10), new LatLng(-54, 12.7))))); mls = new GeoJsonMultiLineString(lineStrings); assertEquals("MultiLineString", mls.getType()); }
public String getType() { return getGeometryType(); }
GeoJsonMultiLineString extends MultiGeometry { public String getType() { return getGeometryType(); } }
GeoJsonMultiLineString extends MultiGeometry { public String getType() { return getGeometryType(); } GeoJsonMultiLineString(List<GeoJsonLineString> geoJsonLineStrings); }
GeoJsonMultiLineString extends MultiGeometry { public String getType() { return getGeometryType(); } GeoJsonMultiLineString(List<GeoJsonLineString> geoJsonLineStrings); String getType(); List<GeoJsonLineString> getLineStrings(); }
GeoJsonMultiLineString extends MultiGeometry { public String getType() { return getGeometryType(); } GeoJsonMultiLineString(List<GeoJsonLineString> geoJsonLineStrings); String getType(); List<GeoJsonLineString> getLineStrings(); }
@Test public void testGetLineStrings() { List<GeoJsonLineString> lineStrings = new ArrayList<>(); lineStrings.add( new GeoJsonLineString( new ArrayList<>(Arrays.asList(new LatLng(0, 0), new LatLng(50, 50))))); lineStrings.add( new GeoJsonLineString( new ArrayList<>(Arrays.asList(new LatLng(80, 10), new LatLng(-54, 12.7))))); mls = new GeoJsonMultiLineString(lineStrings); assertEquals(lineStrings, mls.getLineStrings()); lineStrings = new ArrayList<>(); mls = new GeoJsonMultiLineString(lineStrings); assertEquals(new ArrayList<GeoJsonLineString>(), mls.getLineStrings()); try { mls = new GeoJsonMultiLineString(null); fail(); } catch (IllegalArgumentException e) { assertEquals("Geometries cannot be null", e.getMessage()); } }
public List<GeoJsonLineString> getLineStrings() { List<Geometry> geometryList = getGeometryObject(); ArrayList<GeoJsonLineString> geoJsonLineStrings = new ArrayList<GeoJsonLineString>(); for (Geometry geometry : geometryList) { GeoJsonLineString lineString = (GeoJsonLineString) geometry; geoJsonLineStrings.add(lineString); } return geoJsonLineStrings; }
GeoJsonMultiLineString extends MultiGeometry { public List<GeoJsonLineString> getLineStrings() { List<Geometry> geometryList = getGeometryObject(); ArrayList<GeoJsonLineString> geoJsonLineStrings = new ArrayList<GeoJsonLineString>(); for (Geometry geometry : geometryList) { GeoJsonLineString lineString = (GeoJsonLineString) geometry; geoJsonLineStrings.add(lineString); } return geoJsonLineStrings; } }
GeoJsonMultiLineString extends MultiGeometry { public List<GeoJsonLineString> getLineStrings() { List<Geometry> geometryList = getGeometryObject(); ArrayList<GeoJsonLineString> geoJsonLineStrings = new ArrayList<GeoJsonLineString>(); for (Geometry geometry : geometryList) { GeoJsonLineString lineString = (GeoJsonLineString) geometry; geoJsonLineStrings.add(lineString); } return geoJsonLineStrings; } GeoJsonMultiLineString(List<GeoJsonLineString> geoJsonLineStrings); }
GeoJsonMultiLineString extends MultiGeometry { public List<GeoJsonLineString> getLineStrings() { List<Geometry> geometryList = getGeometryObject(); ArrayList<GeoJsonLineString> geoJsonLineStrings = new ArrayList<GeoJsonLineString>(); for (Geometry geometry : geometryList) { GeoJsonLineString lineString = (GeoJsonLineString) geometry; geoJsonLineStrings.add(lineString); } return geoJsonLineStrings; } GeoJsonMultiLineString(List<GeoJsonLineString> geoJsonLineStrings); String getType(); List<GeoJsonLineString> getLineStrings(); }
GeoJsonMultiLineString extends MultiGeometry { public List<GeoJsonLineString> getLineStrings() { List<Geometry> geometryList = getGeometryObject(); ArrayList<GeoJsonLineString> geoJsonLineStrings = new ArrayList<GeoJsonLineString>(); for (Geometry geometry : geometryList) { GeoJsonLineString lineString = (GeoJsonLineString) geometry; geoJsonLineStrings.add(lineString); } return geoJsonLineStrings; } GeoJsonMultiLineString(List<GeoJsonLineString> geoJsonLineStrings); String getType(); List<GeoJsonLineString> getLineStrings(); }
@Test public void testGeometry() { GeoJsonFeature feature = new GeoJsonFeature(null, null, null, null); assertNull(feature.getGeometry()); GeoJsonPoint point = new GeoJsonPoint(new LatLng(0, 0)); feature.setGeometry(point); assertEquals(point, feature.getGeometry()); feature.setGeometry(null); assertNull(feature.getGeometry()); GeoJsonLineString lineString = new GeoJsonLineString( new ArrayList<>(Arrays.asList(new LatLng(0, 0), new LatLng(50, 50)))); feature = new GeoJsonFeature(lineString, null, null, null); assertEquals(lineString, feature.getGeometry()); feature.setGeometry(point); assertEquals(point, feature.getGeometry()); feature.setGeometry(null); assertNull(feature.getGeometry()); feature.setGeometry(lineString); assertEquals(lineString, feature.getGeometry()); }
public void setGeometry(Geometry geometry) { super.setGeometry(geometry); setChanged(); notifyObservers(); }
GeoJsonFeature extends Feature implements Observer { public void setGeometry(Geometry geometry) { super.setGeometry(geometry); setChanged(); notifyObservers(); } }
GeoJsonFeature extends Feature implements Observer { public void setGeometry(Geometry geometry) { super.setGeometry(geometry); setChanged(); notifyObservers(); } GeoJsonFeature(Geometry geometry, String id, HashMap<String, String> properties, LatLngBounds boundingBox); }
GeoJsonFeature extends Feature implements Observer { public void setGeometry(Geometry geometry) { super.setGeometry(geometry); setChanged(); notifyObservers(); } GeoJsonFeature(Geometry geometry, String id, HashMap<String, String> properties, LatLngBounds boundingBox); String setProperty(String property, String propertyValue); String removeProperty(String property); GeoJsonPointStyle getPointStyle(); void setPointStyle(GeoJsonPointStyle pointStyle); GeoJsonLineStringStyle getLineStringStyle(); void setLineStringStyle(GeoJsonLineStringStyle lineStringStyle); GeoJsonPolygonStyle getPolygonStyle(); void setPolygonStyle(GeoJsonPolygonStyle polygonStyle); PolygonOptions getPolygonOptions(); MarkerOptions getMarkerOptions(); PolylineOptions getPolylineOptions(); void setGeometry(Geometry geometry); LatLngBounds getBoundingBox(); @Override String toString(); @Override void update(Observable observable, Object data); }
GeoJsonFeature extends Feature implements Observer { public void setGeometry(Geometry geometry) { super.setGeometry(geometry); setChanged(); notifyObservers(); } GeoJsonFeature(Geometry geometry, String id, HashMap<String, String> properties, LatLngBounds boundingBox); String setProperty(String property, String propertyValue); String removeProperty(String property); GeoJsonPointStyle getPointStyle(); void setPointStyle(GeoJsonPointStyle pointStyle); GeoJsonLineStringStyle getLineStringStyle(); void setLineStringStyle(GeoJsonLineStringStyle lineStringStyle); GeoJsonPolygonStyle getPolygonStyle(); void setPolygonStyle(GeoJsonPolygonStyle polygonStyle); PolygonOptions getPolygonOptions(); MarkerOptions getMarkerOptions(); PolylineOptions getPolylineOptions(); void setGeometry(Geometry geometry); LatLngBounds getBoundingBox(); @Override String toString(); @Override void update(Observable observable, Object data); }
@Test public void testGetBoundingBox() { GeoJsonFeature feature = new GeoJsonFeature(null, null, null, null); assertNull(feature.getBoundingBox()); LatLngBounds boundingBox = new LatLngBounds(new LatLng(-20, -20), new LatLng(50, 50)); feature = new GeoJsonFeature(null, null, null, boundingBox); assertEquals(boundingBox, feature.getBoundingBox()); }
public LatLngBounds getBoundingBox() { return mBoundingBox; }
GeoJsonFeature extends Feature implements Observer { public LatLngBounds getBoundingBox() { return mBoundingBox; } }
GeoJsonFeature extends Feature implements Observer { public LatLngBounds getBoundingBox() { return mBoundingBox; } GeoJsonFeature(Geometry geometry, String id, HashMap<String, String> properties, LatLngBounds boundingBox); }
GeoJsonFeature extends Feature implements Observer { public LatLngBounds getBoundingBox() { return mBoundingBox; } GeoJsonFeature(Geometry geometry, String id, HashMap<String, String> properties, LatLngBounds boundingBox); String setProperty(String property, String propertyValue); String removeProperty(String property); GeoJsonPointStyle getPointStyle(); void setPointStyle(GeoJsonPointStyle pointStyle); GeoJsonLineStringStyle getLineStringStyle(); void setLineStringStyle(GeoJsonLineStringStyle lineStringStyle); GeoJsonPolygonStyle getPolygonStyle(); void setPolygonStyle(GeoJsonPolygonStyle polygonStyle); PolygonOptions getPolygonOptions(); MarkerOptions getMarkerOptions(); PolylineOptions getPolylineOptions(); void setGeometry(Geometry geometry); LatLngBounds getBoundingBox(); @Override String toString(); @Override void update(Observable observable, Object data); }
GeoJsonFeature extends Feature implements Observer { public LatLngBounds getBoundingBox() { return mBoundingBox; } GeoJsonFeature(Geometry geometry, String id, HashMap<String, String> properties, LatLngBounds boundingBox); String setProperty(String property, String propertyValue); String removeProperty(String property); GeoJsonPointStyle getPointStyle(); void setPointStyle(GeoJsonPointStyle pointStyle); GeoJsonLineStringStyle getLineStringStyle(); void setLineStringStyle(GeoJsonLineStringStyle lineStringStyle); GeoJsonPolygonStyle getPolygonStyle(); void setPolygonStyle(GeoJsonPolygonStyle polygonStyle); PolygonOptions getPolygonOptions(); MarkerOptions getMarkerOptions(); PolylineOptions getPolylineOptions(); void setGeometry(Geometry geometry); LatLngBounds getBoundingBox(); @Override String toString(); @Override void update(Observable observable, Object data); }
@Test public void testGetType() { List<LatLng> coordinates = new ArrayList<>(); coordinates.add(new LatLng(0, 0)); coordinates.add(new LatLng(50, 50)); coordinates.add(new LatLng(100, 100)); ls = new GeoJsonLineString(coordinates); assertEquals("LineString", ls.getType()); }
public String getType() { return getGeometryType(); }
GeoJsonLineString extends LineString { public String getType() { return getGeometryType(); } }
GeoJsonLineString extends LineString { public String getType() { return getGeometryType(); } GeoJsonLineString(List<LatLng> coordinates); GeoJsonLineString(List<LatLng> coordinates, List<Double> altitudes); }
GeoJsonLineString extends LineString { public String getType() { return getGeometryType(); } GeoJsonLineString(List<LatLng> coordinates); GeoJsonLineString(List<LatLng> coordinates, List<Double> altitudes); String getType(); List<LatLng> getCoordinates(); List<Double> getAltitudes(); }
GeoJsonLineString extends LineString { public String getType() { return getGeometryType(); } GeoJsonLineString(List<LatLng> coordinates); GeoJsonLineString(List<LatLng> coordinates, List<Double> altitudes); String getType(); List<LatLng> getCoordinates(); List<Double> getAltitudes(); }
@Test public void testGetGeometry() { KmlMultiGeometry kmlMultiGeometry = createMultiGeometry(); Assert.assertNotNull(kmlMultiGeometry); Assert.assertEquals(1, kmlMultiGeometry.getGeometryObject().size()); KmlLineString lineString = ((KmlLineString) kmlMultiGeometry.getGeometryObject().get(0)); Assert.assertNotNull(lineString); }
public ArrayList<Geometry> getGeometryObject() { List<Geometry> geometriesList = super.getGeometryObject(); return new ArrayList<>(geometriesList); }
KmlMultiGeometry extends MultiGeometry { public ArrayList<Geometry> getGeometryObject() { List<Geometry> geometriesList = super.getGeometryObject(); return new ArrayList<>(geometriesList); } }
KmlMultiGeometry extends MultiGeometry { public ArrayList<Geometry> getGeometryObject() { List<Geometry> geometriesList = super.getGeometryObject(); return new ArrayList<>(geometriesList); } KmlMultiGeometry(ArrayList<Geometry> geometries); }
KmlMultiGeometry extends MultiGeometry { public ArrayList<Geometry> getGeometryObject() { List<Geometry> geometriesList = super.getGeometryObject(); return new ArrayList<>(geometriesList); } KmlMultiGeometry(ArrayList<Geometry> geometries); ArrayList<Geometry> getGeometryObject(); @Override String toString(); }
KmlMultiGeometry extends MultiGeometry { public ArrayList<Geometry> getGeometryObject() { List<Geometry> geometriesList = super.getGeometryObject(); return new ArrayList<>(geometriesList); } KmlMultiGeometry(ArrayList<Geometry> geometries); ArrayList<Geometry> getGeometryObject(); @Override String toString(); }