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 testGenerateJavaCode() { DataValueGenerator dvg = new DataValueGenerator(); JavaBeanInterface jbi = dvg.heapInstance(JavaBeanInterface.class); jbi.setByte((byte) 1); jbi.setChar('2'); jbi.setShort((short) 3); jbi.setInt(4); jbi.setFloat(5); jbi.setLong(6); jbi.setDouble(7); jbi.setFlag(true); assertEquals(1, jbi.getByte()); assertEquals('2', jbi.getChar()); assertEquals(3, jbi.getShort()); assertEquals(4, jbi.getInt()); assertEquals(5.0, jbi.getFloat(), 0); assertEquals(6, jbi.getLong()); assertEquals(7.0, jbi.getDouble(), 0.0); assertTrue(jbi.getFlag()); }
|
public <T> T heapInstance(Class<T> tClass) { try { return (T) acquireHeapClass(tClass).newInstance(); } catch (Exception e) { throw new AssertionError(e); } }
|
DataValueGenerator { public <T> T heapInstance(Class<T> tClass) { try { return (T) acquireHeapClass(tClass).newInstance(); } catch (Exception e) { throw new AssertionError(e); } } }
|
DataValueGenerator { public <T> T heapInstance(Class<T> tClass) { try { return (T) acquireHeapClass(tClass).newInstance(); } catch (Exception e) { throw new AssertionError(e); } } }
|
DataValueGenerator { public <T> T heapInstance(Class<T> tClass) { try { return (T) acquireHeapClass(tClass).newInstance(); } catch (Exception e) { throw new AssertionError(e); } } static Class firstPrimitiveFieldType(Class valueClass); static String bytesType(Class type); static String simpleName(Class<?> type); static CharSequence normalize(Class aClass); static Method getGetter(FieldModel model); static Method getVolatileGetter(FieldModel model); static Method getSetter(FieldModel model); static Method getOrderedSetter(FieldModel model); static void appendImported(SortedSet<Class> imported, StringBuilder sb); static void appendPackage(DataValueModel<?> dvmodel, StringBuilder sb); static String getPackage(DataValueModel<?> dvmodel); static int fieldSize(FieldModel model); static TreeSet<Class> newImported(); static boolean shouldImport(Class type); static Map.Entry<String, FieldModel>[] heapSizeOrderedFieldsGrouped(DataValueModel<?> dvmodel); static int computeOffset(int offset, FieldModel model); static int computeNonScalarOffset(DataValueModel dvmodel, Class type); T heapInstance(Class<T> tClass); Class acquireHeapClass(Class<T> tClass); T nativeInstance(Class<T> tClass); Class acquireNativeClass(Class<T> tClass); String generateNativeObject(Class<?> tClass); String generateNativeObject(DataValueModel<?> dvmodel); boolean isDumpCode(); void setDumpCode(boolean dumpCode); }
|
DataValueGenerator { public <T> T heapInstance(Class<T> tClass) { try { return (T) acquireHeapClass(tClass).newInstance(); } catch (Exception e) { throw new AssertionError(e); } } static Class firstPrimitiveFieldType(Class valueClass); static String bytesType(Class type); static String simpleName(Class<?> type); static CharSequence normalize(Class aClass); static Method getGetter(FieldModel model); static Method getVolatileGetter(FieldModel model); static Method getSetter(FieldModel model); static Method getOrderedSetter(FieldModel model); static void appendImported(SortedSet<Class> imported, StringBuilder sb); static void appendPackage(DataValueModel<?> dvmodel, StringBuilder sb); static String getPackage(DataValueModel<?> dvmodel); static int fieldSize(FieldModel model); static TreeSet<Class> newImported(); static boolean shouldImport(Class type); static Map.Entry<String, FieldModel>[] heapSizeOrderedFieldsGrouped(DataValueModel<?> dvmodel); static int computeOffset(int offset, FieldModel model); static int computeNonScalarOffset(DataValueModel dvmodel, Class type); T heapInstance(Class<T> tClass); Class acquireHeapClass(Class<T> tClass); T nativeInstance(Class<T> tClass); Class acquireNativeClass(Class<T> tClass); String generateNativeObject(Class<?> tClass); String generateNativeObject(DataValueModel<?> dvmodel); boolean isDumpCode(); void setDumpCode(boolean dumpCode); }
|
@Test public void testGenerateJavaCode2() { DataValueGenerator dvg = new DataValueGenerator(); MinimalInterface mi = dvg.heapInstance(MinimalInterface.class); mi.byte$((byte) 1); mi.char$('2'); mi.short$((short) 3); mi.int$(4); mi.float$(5); mi.long$(6); mi.double$(7); mi.flag(true); assertEquals(1, mi.byte$()); assertEquals('2', mi.char$()); assertEquals(3, mi.short$()); assertEquals(4, mi.int$()); assertEquals(5.0, mi.float$(), 0); assertEquals(6, mi.long$()); assertEquals(7.0, mi.double$(), 0.0); assertTrue(mi.flag()); Bytes bbb = ByteBufferBytes.wrap(ByteBuffer.allocate(64)); mi.writeMarshallable(bbb); System.out.println("size: " + bbb.position()); MinimalInterface mi2 = dvg.heapInstance(MinimalInterface.class); bbb.position(0); mi2.readMarshallable(bbb); assertEquals(1, mi2.byte$()); assertEquals('2', mi2.char$()); assertEquals(3, mi2.short$()); assertEquals(4, mi2.int$()); assertEquals(5.0, mi2.float$(), 0); assertEquals(6, mi2.long$()); assertEquals(7.0, mi2.double$(), 0.0); assertTrue(mi2.flag()); }
|
public <T> T heapInstance(Class<T> tClass) { try { return (T) acquireHeapClass(tClass).newInstance(); } catch (Exception e) { throw new AssertionError(e); } }
|
DataValueGenerator { public <T> T heapInstance(Class<T> tClass) { try { return (T) acquireHeapClass(tClass).newInstance(); } catch (Exception e) { throw new AssertionError(e); } } }
|
DataValueGenerator { public <T> T heapInstance(Class<T> tClass) { try { return (T) acquireHeapClass(tClass).newInstance(); } catch (Exception e) { throw new AssertionError(e); } } }
|
DataValueGenerator { public <T> T heapInstance(Class<T> tClass) { try { return (T) acquireHeapClass(tClass).newInstance(); } catch (Exception e) { throw new AssertionError(e); } } static Class firstPrimitiveFieldType(Class valueClass); static String bytesType(Class type); static String simpleName(Class<?> type); static CharSequence normalize(Class aClass); static Method getGetter(FieldModel model); static Method getVolatileGetter(FieldModel model); static Method getSetter(FieldModel model); static Method getOrderedSetter(FieldModel model); static void appendImported(SortedSet<Class> imported, StringBuilder sb); static void appendPackage(DataValueModel<?> dvmodel, StringBuilder sb); static String getPackage(DataValueModel<?> dvmodel); static int fieldSize(FieldModel model); static TreeSet<Class> newImported(); static boolean shouldImport(Class type); static Map.Entry<String, FieldModel>[] heapSizeOrderedFieldsGrouped(DataValueModel<?> dvmodel); static int computeOffset(int offset, FieldModel model); static int computeNonScalarOffset(DataValueModel dvmodel, Class type); T heapInstance(Class<T> tClass); Class acquireHeapClass(Class<T> tClass); T nativeInstance(Class<T> tClass); Class acquireNativeClass(Class<T> tClass); String generateNativeObject(Class<?> tClass); String generateNativeObject(DataValueModel<?> dvmodel); boolean isDumpCode(); void setDumpCode(boolean dumpCode); }
|
DataValueGenerator { public <T> T heapInstance(Class<T> tClass) { try { return (T) acquireHeapClass(tClass).newInstance(); } catch (Exception e) { throw new AssertionError(e); } } static Class firstPrimitiveFieldType(Class valueClass); static String bytesType(Class type); static String simpleName(Class<?> type); static CharSequence normalize(Class aClass); static Method getGetter(FieldModel model); static Method getVolatileGetter(FieldModel model); static Method getSetter(FieldModel model); static Method getOrderedSetter(FieldModel model); static void appendImported(SortedSet<Class> imported, StringBuilder sb); static void appendPackage(DataValueModel<?> dvmodel, StringBuilder sb); static String getPackage(DataValueModel<?> dvmodel); static int fieldSize(FieldModel model); static TreeSet<Class> newImported(); static boolean shouldImport(Class type); static Map.Entry<String, FieldModel>[] heapSizeOrderedFieldsGrouped(DataValueModel<?> dvmodel); static int computeOffset(int offset, FieldModel model); static int computeNonScalarOffset(DataValueModel dvmodel, Class type); T heapInstance(Class<T> tClass); Class acquireHeapClass(Class<T> tClass); T nativeInstance(Class<T> tClass); Class acquireNativeClass(Class<T> tClass); String generateNativeObject(Class<?> tClass); String generateNativeObject(DataValueModel<?> dvmodel); boolean isDumpCode(); void setDumpCode(boolean dumpCode); }
|
@Test public void testGenerateNativeWithGetUsing() throws ClassNotFoundException, IllegalAccessException, InstantiationException { String actual = new DataValueGenerator().generateNativeObject(JavaBeanInterfaceGetUsing.class); System.out.println(actual); CachedCompiler cc = new CachedCompiler(null, null); Class aClass = cc.loadFromJava(JavaBeanInterfaceGetUsing.class.getName() + "$$Native", actual); JavaBeanInterfaceGetUsing jbi = (JavaBeanInterfaceGetUsing) aClass.asSubclass(JavaBeanInterfaceGetUsing.class).newInstance(); Bytes bytes = ByteBufferBytes.wrap(ByteBuffer.allocate(64)); ((Byteable) jbi).bytes(bytes, 0L); jbi.setString("G'day"); assertEquals("G'day", jbi.getUsingString(new StringBuilder()).toString()); }
|
public String generateNativeObject(Class<?> tClass) { return generateNativeObject(DataValueModels.acquireModel(tClass)); }
|
DataValueGenerator { public String generateNativeObject(Class<?> tClass) { return generateNativeObject(DataValueModels.acquireModel(tClass)); } }
|
DataValueGenerator { public String generateNativeObject(Class<?> tClass) { return generateNativeObject(DataValueModels.acquireModel(tClass)); } }
|
DataValueGenerator { public String generateNativeObject(Class<?> tClass) { return generateNativeObject(DataValueModels.acquireModel(tClass)); } static Class firstPrimitiveFieldType(Class valueClass); static String bytesType(Class type); static String simpleName(Class<?> type); static CharSequence normalize(Class aClass); static Method getGetter(FieldModel model); static Method getVolatileGetter(FieldModel model); static Method getSetter(FieldModel model); static Method getOrderedSetter(FieldModel model); static void appendImported(SortedSet<Class> imported, StringBuilder sb); static void appendPackage(DataValueModel<?> dvmodel, StringBuilder sb); static String getPackage(DataValueModel<?> dvmodel); static int fieldSize(FieldModel model); static TreeSet<Class> newImported(); static boolean shouldImport(Class type); static Map.Entry<String, FieldModel>[] heapSizeOrderedFieldsGrouped(DataValueModel<?> dvmodel); static int computeOffset(int offset, FieldModel model); static int computeNonScalarOffset(DataValueModel dvmodel, Class type); T heapInstance(Class<T> tClass); Class acquireHeapClass(Class<T> tClass); T nativeInstance(Class<T> tClass); Class acquireNativeClass(Class<T> tClass); String generateNativeObject(Class<?> tClass); String generateNativeObject(DataValueModel<?> dvmodel); boolean isDumpCode(); void setDumpCode(boolean dumpCode); }
|
DataValueGenerator { public String generateNativeObject(Class<?> tClass) { return generateNativeObject(DataValueModels.acquireModel(tClass)); } static Class firstPrimitiveFieldType(Class valueClass); static String bytesType(Class type); static String simpleName(Class<?> type); static CharSequence normalize(Class aClass); static Method getGetter(FieldModel model); static Method getVolatileGetter(FieldModel model); static Method getSetter(FieldModel model); static Method getOrderedSetter(FieldModel model); static void appendImported(SortedSet<Class> imported, StringBuilder sb); static void appendPackage(DataValueModel<?> dvmodel, StringBuilder sb); static String getPackage(DataValueModel<?> dvmodel); static int fieldSize(FieldModel model); static TreeSet<Class> newImported(); static boolean shouldImport(Class type); static Map.Entry<String, FieldModel>[] heapSizeOrderedFieldsGrouped(DataValueModel<?> dvmodel); static int computeOffset(int offset, FieldModel model); static int computeNonScalarOffset(DataValueModel dvmodel, Class type); T heapInstance(Class<T> tClass); Class acquireHeapClass(Class<T> tClass); T nativeInstance(Class<T> tClass); Class acquireNativeClass(Class<T> tClass); String generateNativeObject(Class<?> tClass); String generateNativeObject(DataValueModel<?> dvmodel); boolean isDumpCode(); void setDumpCode(boolean dumpCode); }
|
@Test public void testGenerateNativeWithHasArrays() throws ClassNotFoundException, IllegalAccessException, InstantiationException { String actual = new DataValueGenerator().generateNativeObject(HasArraysInterface.class); System.out.println(actual); CachedCompiler cc = new CachedCompiler(null, null); Class aClass = cc.loadFromJava(HasArraysInterface.class.getName() + "$$Native", actual); HasArraysInterface hai = (HasArraysInterface) aClass.asSubclass(HasArraysInterface.class).newInstance(); Bytes bytes = ByteBufferBytes.wrap(ByteBuffer.allocate(152)); ((Byteable) hai).bytes(bytes, 0L); hai.setStringAt(0, "G'day"); assertEquals("G'day", hai.getStringAt(0)); }
|
public String generateNativeObject(Class<?> tClass) { return generateNativeObject(DataValueModels.acquireModel(tClass)); }
|
DataValueGenerator { public String generateNativeObject(Class<?> tClass) { return generateNativeObject(DataValueModels.acquireModel(tClass)); } }
|
DataValueGenerator { public String generateNativeObject(Class<?> tClass) { return generateNativeObject(DataValueModels.acquireModel(tClass)); } }
|
DataValueGenerator { public String generateNativeObject(Class<?> tClass) { return generateNativeObject(DataValueModels.acquireModel(tClass)); } static Class firstPrimitiveFieldType(Class valueClass); static String bytesType(Class type); static String simpleName(Class<?> type); static CharSequence normalize(Class aClass); static Method getGetter(FieldModel model); static Method getVolatileGetter(FieldModel model); static Method getSetter(FieldModel model); static Method getOrderedSetter(FieldModel model); static void appendImported(SortedSet<Class> imported, StringBuilder sb); static void appendPackage(DataValueModel<?> dvmodel, StringBuilder sb); static String getPackage(DataValueModel<?> dvmodel); static int fieldSize(FieldModel model); static TreeSet<Class> newImported(); static boolean shouldImport(Class type); static Map.Entry<String, FieldModel>[] heapSizeOrderedFieldsGrouped(DataValueModel<?> dvmodel); static int computeOffset(int offset, FieldModel model); static int computeNonScalarOffset(DataValueModel dvmodel, Class type); T heapInstance(Class<T> tClass); Class acquireHeapClass(Class<T> tClass); T nativeInstance(Class<T> tClass); Class acquireNativeClass(Class<T> tClass); String generateNativeObject(Class<?> tClass); String generateNativeObject(DataValueModel<?> dvmodel); boolean isDumpCode(); void setDumpCode(boolean dumpCode); }
|
DataValueGenerator { public String generateNativeObject(Class<?> tClass) { return generateNativeObject(DataValueModels.acquireModel(tClass)); } static Class firstPrimitiveFieldType(Class valueClass); static String bytesType(Class type); static String simpleName(Class<?> type); static CharSequence normalize(Class aClass); static Method getGetter(FieldModel model); static Method getVolatileGetter(FieldModel model); static Method getSetter(FieldModel model); static Method getOrderedSetter(FieldModel model); static void appendImported(SortedSet<Class> imported, StringBuilder sb); static void appendPackage(DataValueModel<?> dvmodel, StringBuilder sb); static String getPackage(DataValueModel<?> dvmodel); static int fieldSize(FieldModel model); static TreeSet<Class> newImported(); static boolean shouldImport(Class type); static Map.Entry<String, FieldModel>[] heapSizeOrderedFieldsGrouped(DataValueModel<?> dvmodel); static int computeOffset(int offset, FieldModel model); static int computeNonScalarOffset(DataValueModel dvmodel, Class type); T heapInstance(Class<T> tClass); Class acquireHeapClass(Class<T> tClass); T nativeInstance(Class<T> tClass); Class acquireNativeClass(Class<T> tClass); String generateNativeObject(Class<?> tClass); String generateNativeObject(DataValueModel<?> dvmodel); boolean isDumpCode(); void setDumpCode(boolean dumpCode); }
|
@Test public void testGenerateNativeWithGetUsingHeapInstance() { DataValueGenerator dvg = new DataValueGenerator(); JavaBeanInterfaceGetUsingHeap si = dvg.heapInstance(JavaBeanInterfaceGetUsingHeap.class); si.setString("G'day"); assertEquals("G'day", si.getUsingString(new StringBuilder()).toString()); }
|
public <T> T heapInstance(Class<T> tClass) { try { return (T) acquireHeapClass(tClass).newInstance(); } catch (Exception e) { throw new AssertionError(e); } }
|
DataValueGenerator { public <T> T heapInstance(Class<T> tClass) { try { return (T) acquireHeapClass(tClass).newInstance(); } catch (Exception e) { throw new AssertionError(e); } } }
|
DataValueGenerator { public <T> T heapInstance(Class<T> tClass) { try { return (T) acquireHeapClass(tClass).newInstance(); } catch (Exception e) { throw new AssertionError(e); } } }
|
DataValueGenerator { public <T> T heapInstance(Class<T> tClass) { try { return (T) acquireHeapClass(tClass).newInstance(); } catch (Exception e) { throw new AssertionError(e); } } static Class firstPrimitiveFieldType(Class valueClass); static String bytesType(Class type); static String simpleName(Class<?> type); static CharSequence normalize(Class aClass); static Method getGetter(FieldModel model); static Method getVolatileGetter(FieldModel model); static Method getSetter(FieldModel model); static Method getOrderedSetter(FieldModel model); static void appendImported(SortedSet<Class> imported, StringBuilder sb); static void appendPackage(DataValueModel<?> dvmodel, StringBuilder sb); static String getPackage(DataValueModel<?> dvmodel); static int fieldSize(FieldModel model); static TreeSet<Class> newImported(); static boolean shouldImport(Class type); static Map.Entry<String, FieldModel>[] heapSizeOrderedFieldsGrouped(DataValueModel<?> dvmodel); static int computeOffset(int offset, FieldModel model); static int computeNonScalarOffset(DataValueModel dvmodel, Class type); T heapInstance(Class<T> tClass); Class acquireHeapClass(Class<T> tClass); T nativeInstance(Class<T> tClass); Class acquireNativeClass(Class<T> tClass); String generateNativeObject(Class<?> tClass); String generateNativeObject(DataValueModel<?> dvmodel); boolean isDumpCode(); void setDumpCode(boolean dumpCode); }
|
DataValueGenerator { public <T> T heapInstance(Class<T> tClass) { try { return (T) acquireHeapClass(tClass).newInstance(); } catch (Exception e) { throw new AssertionError(e); } } static Class firstPrimitiveFieldType(Class valueClass); static String bytesType(Class type); static String simpleName(Class<?> type); static CharSequence normalize(Class aClass); static Method getGetter(FieldModel model); static Method getVolatileGetter(FieldModel model); static Method getSetter(FieldModel model); static Method getOrderedSetter(FieldModel model); static void appendImported(SortedSet<Class> imported, StringBuilder sb); static void appendPackage(DataValueModel<?> dvmodel, StringBuilder sb); static String getPackage(DataValueModel<?> dvmodel); static int fieldSize(FieldModel model); static TreeSet<Class> newImported(); static boolean shouldImport(Class type); static Map.Entry<String, FieldModel>[] heapSizeOrderedFieldsGrouped(DataValueModel<?> dvmodel); static int computeOffset(int offset, FieldModel model); static int computeNonScalarOffset(DataValueModel dvmodel, Class type); T heapInstance(Class<T> tClass); Class acquireHeapClass(Class<T> tClass); T nativeInstance(Class<T> tClass); Class acquireNativeClass(Class<T> tClass); String generateNativeObject(Class<?> tClass); String generateNativeObject(DataValueModel<?> dvmodel); boolean isDumpCode(); void setDumpCode(boolean dumpCode); }
|
@Test public void testGetUsingStringFieldsWithStringBuilderHeapInstance() { DataValueGenerator dvg = new DataValueGenerator(); GetUsingStringInterface si = dvg.heapInstance(GetUsingStringInterface.class); si.setSomeStringField("Hello world"); si.setAnotherStringField("Hello world 2"); assertEquals("Hello world", si.getSomeStringField()); { StringBuilder builder = new StringBuilder(); si.getUsingSomeStringField(builder); assertEquals("Hello world", builder.toString()); } { StringBuilder builder = new StringBuilder(); si.getUsingAnotherStringField(builder); assertEquals("Hello world 2", builder.toString()); } }
|
public <T> T heapInstance(Class<T> tClass) { try { return (T) acquireHeapClass(tClass).newInstance(); } catch (Exception e) { throw new AssertionError(e); } }
|
DataValueGenerator { public <T> T heapInstance(Class<T> tClass) { try { return (T) acquireHeapClass(tClass).newInstance(); } catch (Exception e) { throw new AssertionError(e); } } }
|
DataValueGenerator { public <T> T heapInstance(Class<T> tClass) { try { return (T) acquireHeapClass(tClass).newInstance(); } catch (Exception e) { throw new AssertionError(e); } } }
|
DataValueGenerator { public <T> T heapInstance(Class<T> tClass) { try { return (T) acquireHeapClass(tClass).newInstance(); } catch (Exception e) { throw new AssertionError(e); } } static Class firstPrimitiveFieldType(Class valueClass); static String bytesType(Class type); static String simpleName(Class<?> type); static CharSequence normalize(Class aClass); static Method getGetter(FieldModel model); static Method getVolatileGetter(FieldModel model); static Method getSetter(FieldModel model); static Method getOrderedSetter(FieldModel model); static void appendImported(SortedSet<Class> imported, StringBuilder sb); static void appendPackage(DataValueModel<?> dvmodel, StringBuilder sb); static String getPackage(DataValueModel<?> dvmodel); static int fieldSize(FieldModel model); static TreeSet<Class> newImported(); static boolean shouldImport(Class type); static Map.Entry<String, FieldModel>[] heapSizeOrderedFieldsGrouped(DataValueModel<?> dvmodel); static int computeOffset(int offset, FieldModel model); static int computeNonScalarOffset(DataValueModel dvmodel, Class type); T heapInstance(Class<T> tClass); Class acquireHeapClass(Class<T> tClass); T nativeInstance(Class<T> tClass); Class acquireNativeClass(Class<T> tClass); String generateNativeObject(Class<?> tClass); String generateNativeObject(DataValueModel<?> dvmodel); boolean isDumpCode(); void setDumpCode(boolean dumpCode); }
|
DataValueGenerator { public <T> T heapInstance(Class<T> tClass) { try { return (T) acquireHeapClass(tClass).newInstance(); } catch (Exception e) { throw new AssertionError(e); } } static Class firstPrimitiveFieldType(Class valueClass); static String bytesType(Class type); static String simpleName(Class<?> type); static CharSequence normalize(Class aClass); static Method getGetter(FieldModel model); static Method getVolatileGetter(FieldModel model); static Method getSetter(FieldModel model); static Method getOrderedSetter(FieldModel model); static void appendImported(SortedSet<Class> imported, StringBuilder sb); static void appendPackage(DataValueModel<?> dvmodel, StringBuilder sb); static String getPackage(DataValueModel<?> dvmodel); static int fieldSize(FieldModel model); static TreeSet<Class> newImported(); static boolean shouldImport(Class type); static Map.Entry<String, FieldModel>[] heapSizeOrderedFieldsGrouped(DataValueModel<?> dvmodel); static int computeOffset(int offset, FieldModel model); static int computeNonScalarOffset(DataValueModel dvmodel, Class type); T heapInstance(Class<T> tClass); Class acquireHeapClass(Class<T> tClass); T nativeInstance(Class<T> tClass); Class acquireNativeClass(Class<T> tClass); String generateNativeObject(Class<?> tClass); String generateNativeObject(DataValueModel<?> dvmodel); boolean isDumpCode(); void setDumpCode(boolean dumpCode); }
|
@Test public void testGenerateInterfaceWithEnumOnHeap() { DataValueGenerator dvg = new DataValueGenerator(); JavaBeanInterfaceGetMyEnum jbie = dvg.heapInstance(JavaBeanInterfaceGetMyEnum.class); jbie.setMyEnum(MyEnum.B); }
|
public <T> T heapInstance(Class<T> tClass) { try { return (T) acquireHeapClass(tClass).newInstance(); } catch (Exception e) { throw new AssertionError(e); } }
|
DataValueGenerator { public <T> T heapInstance(Class<T> tClass) { try { return (T) acquireHeapClass(tClass).newInstance(); } catch (Exception e) { throw new AssertionError(e); } } }
|
DataValueGenerator { public <T> T heapInstance(Class<T> tClass) { try { return (T) acquireHeapClass(tClass).newInstance(); } catch (Exception e) { throw new AssertionError(e); } } }
|
DataValueGenerator { public <T> T heapInstance(Class<T> tClass) { try { return (T) acquireHeapClass(tClass).newInstance(); } catch (Exception e) { throw new AssertionError(e); } } static Class firstPrimitiveFieldType(Class valueClass); static String bytesType(Class type); static String simpleName(Class<?> type); static CharSequence normalize(Class aClass); static Method getGetter(FieldModel model); static Method getVolatileGetter(FieldModel model); static Method getSetter(FieldModel model); static Method getOrderedSetter(FieldModel model); static void appendImported(SortedSet<Class> imported, StringBuilder sb); static void appendPackage(DataValueModel<?> dvmodel, StringBuilder sb); static String getPackage(DataValueModel<?> dvmodel); static int fieldSize(FieldModel model); static TreeSet<Class> newImported(); static boolean shouldImport(Class type); static Map.Entry<String, FieldModel>[] heapSizeOrderedFieldsGrouped(DataValueModel<?> dvmodel); static int computeOffset(int offset, FieldModel model); static int computeNonScalarOffset(DataValueModel dvmodel, Class type); T heapInstance(Class<T> tClass); Class acquireHeapClass(Class<T> tClass); T nativeInstance(Class<T> tClass); Class acquireNativeClass(Class<T> tClass); String generateNativeObject(Class<?> tClass); String generateNativeObject(DataValueModel<?> dvmodel); boolean isDumpCode(); void setDumpCode(boolean dumpCode); }
|
DataValueGenerator { public <T> T heapInstance(Class<T> tClass) { try { return (T) acquireHeapClass(tClass).newInstance(); } catch (Exception e) { throw new AssertionError(e); } } static Class firstPrimitiveFieldType(Class valueClass); static String bytesType(Class type); static String simpleName(Class<?> type); static CharSequence normalize(Class aClass); static Method getGetter(FieldModel model); static Method getVolatileGetter(FieldModel model); static Method getSetter(FieldModel model); static Method getOrderedSetter(FieldModel model); static void appendImported(SortedSet<Class> imported, StringBuilder sb); static void appendPackage(DataValueModel<?> dvmodel, StringBuilder sb); static String getPackage(DataValueModel<?> dvmodel); static int fieldSize(FieldModel model); static TreeSet<Class> newImported(); static boolean shouldImport(Class type); static Map.Entry<String, FieldModel>[] heapSizeOrderedFieldsGrouped(DataValueModel<?> dvmodel); static int computeOffset(int offset, FieldModel model); static int computeNonScalarOffset(DataValueModel dvmodel, Class type); T heapInstance(Class<T> tClass); Class acquireHeapClass(Class<T> tClass); T nativeInstance(Class<T> tClass); Class acquireNativeClass(Class<T> tClass); String generateNativeObject(Class<?> tClass); String generateNativeObject(DataValueModel<?> dvmodel); boolean isDumpCode(); void setDumpCode(boolean dumpCode); }
|
@Test public void testGenerateInterfaceWithEnumNativeInstance() { DataValueGenerator dvg = new DataValueGenerator(); JavaBeanInterfaceGetMyEnum jbie = dvg.nativeInstance(JavaBeanInterfaceGetMyEnum.class); Bytes bytes = ByteBufferBytes.wrap(ByteBuffer.allocate(64)); ((Byteable) jbie).bytes(bytes, 0L); jbie.setMyEnum(MyEnum.C); }
|
public <T> T nativeInstance(Class<T> tClass) { try { return (T) acquireNativeClass(tClass).newInstance(); } catch (Exception e) { throw new AssertionError(e); } }
|
DataValueGenerator { public <T> T nativeInstance(Class<T> tClass) { try { return (T) acquireNativeClass(tClass).newInstance(); } catch (Exception e) { throw new AssertionError(e); } } }
|
DataValueGenerator { public <T> T nativeInstance(Class<T> tClass) { try { return (T) acquireNativeClass(tClass).newInstance(); } catch (Exception e) { throw new AssertionError(e); } } }
|
DataValueGenerator { public <T> T nativeInstance(Class<T> tClass) { try { return (T) acquireNativeClass(tClass).newInstance(); } catch (Exception e) { throw new AssertionError(e); } } static Class firstPrimitiveFieldType(Class valueClass); static String bytesType(Class type); static String simpleName(Class<?> type); static CharSequence normalize(Class aClass); static Method getGetter(FieldModel model); static Method getVolatileGetter(FieldModel model); static Method getSetter(FieldModel model); static Method getOrderedSetter(FieldModel model); static void appendImported(SortedSet<Class> imported, StringBuilder sb); static void appendPackage(DataValueModel<?> dvmodel, StringBuilder sb); static String getPackage(DataValueModel<?> dvmodel); static int fieldSize(FieldModel model); static TreeSet<Class> newImported(); static boolean shouldImport(Class type); static Map.Entry<String, FieldModel>[] heapSizeOrderedFieldsGrouped(DataValueModel<?> dvmodel); static int computeOffset(int offset, FieldModel model); static int computeNonScalarOffset(DataValueModel dvmodel, Class type); T heapInstance(Class<T> tClass); Class acquireHeapClass(Class<T> tClass); T nativeInstance(Class<T> tClass); Class acquireNativeClass(Class<T> tClass); String generateNativeObject(Class<?> tClass); String generateNativeObject(DataValueModel<?> dvmodel); boolean isDumpCode(); void setDumpCode(boolean dumpCode); }
|
DataValueGenerator { public <T> T nativeInstance(Class<T> tClass) { try { return (T) acquireNativeClass(tClass).newInstance(); } catch (Exception e) { throw new AssertionError(e); } } static Class firstPrimitiveFieldType(Class valueClass); static String bytesType(Class type); static String simpleName(Class<?> type); static CharSequence normalize(Class aClass); static Method getGetter(FieldModel model); static Method getVolatileGetter(FieldModel model); static Method getSetter(FieldModel model); static Method getOrderedSetter(FieldModel model); static void appendImported(SortedSet<Class> imported, StringBuilder sb); static void appendPackage(DataValueModel<?> dvmodel, StringBuilder sb); static String getPackage(DataValueModel<?> dvmodel); static int fieldSize(FieldModel model); static TreeSet<Class> newImported(); static boolean shouldImport(Class type); static Map.Entry<String, FieldModel>[] heapSizeOrderedFieldsGrouped(DataValueModel<?> dvmodel); static int computeOffset(int offset, FieldModel model); static int computeNonScalarOffset(DataValueModel dvmodel, Class type); T heapInstance(Class<T> tClass); Class acquireHeapClass(Class<T> tClass); T nativeInstance(Class<T> tClass); Class acquireNativeClass(Class<T> tClass); String generateNativeObject(Class<?> tClass); String generateNativeObject(DataValueModel<?> dvmodel); boolean isDumpCode(); void setDumpCode(boolean dumpCode); }
|
@Test public void testGenerateInterfaceWithDateOnHeap() { DataValueGenerator dvg = new DataValueGenerator(); JavaBeanInterfaceGetDate jbid = dvg.heapInstance(JavaBeanInterfaceGetDate.class); jbid.setDate(new Date()); }
|
public <T> T heapInstance(Class<T> tClass) { try { return (T) acquireHeapClass(tClass).newInstance(); } catch (Exception e) { throw new AssertionError(e); } }
|
DataValueGenerator { public <T> T heapInstance(Class<T> tClass) { try { return (T) acquireHeapClass(tClass).newInstance(); } catch (Exception e) { throw new AssertionError(e); } } }
|
DataValueGenerator { public <T> T heapInstance(Class<T> tClass) { try { return (T) acquireHeapClass(tClass).newInstance(); } catch (Exception e) { throw new AssertionError(e); } } }
|
DataValueGenerator { public <T> T heapInstance(Class<T> tClass) { try { return (T) acquireHeapClass(tClass).newInstance(); } catch (Exception e) { throw new AssertionError(e); } } static Class firstPrimitiveFieldType(Class valueClass); static String bytesType(Class type); static String simpleName(Class<?> type); static CharSequence normalize(Class aClass); static Method getGetter(FieldModel model); static Method getVolatileGetter(FieldModel model); static Method getSetter(FieldModel model); static Method getOrderedSetter(FieldModel model); static void appendImported(SortedSet<Class> imported, StringBuilder sb); static void appendPackage(DataValueModel<?> dvmodel, StringBuilder sb); static String getPackage(DataValueModel<?> dvmodel); static int fieldSize(FieldModel model); static TreeSet<Class> newImported(); static boolean shouldImport(Class type); static Map.Entry<String, FieldModel>[] heapSizeOrderedFieldsGrouped(DataValueModel<?> dvmodel); static int computeOffset(int offset, FieldModel model); static int computeNonScalarOffset(DataValueModel dvmodel, Class type); T heapInstance(Class<T> tClass); Class acquireHeapClass(Class<T> tClass); T nativeInstance(Class<T> tClass); Class acquireNativeClass(Class<T> tClass); String generateNativeObject(Class<?> tClass); String generateNativeObject(DataValueModel<?> dvmodel); boolean isDumpCode(); void setDumpCode(boolean dumpCode); }
|
DataValueGenerator { public <T> T heapInstance(Class<T> tClass) { try { return (T) acquireHeapClass(tClass).newInstance(); } catch (Exception e) { throw new AssertionError(e); } } static Class firstPrimitiveFieldType(Class valueClass); static String bytesType(Class type); static String simpleName(Class<?> type); static CharSequence normalize(Class aClass); static Method getGetter(FieldModel model); static Method getVolatileGetter(FieldModel model); static Method getSetter(FieldModel model); static Method getOrderedSetter(FieldModel model); static void appendImported(SortedSet<Class> imported, StringBuilder sb); static void appendPackage(DataValueModel<?> dvmodel, StringBuilder sb); static String getPackage(DataValueModel<?> dvmodel); static int fieldSize(FieldModel model); static TreeSet<Class> newImported(); static boolean shouldImport(Class type); static Map.Entry<String, FieldModel>[] heapSizeOrderedFieldsGrouped(DataValueModel<?> dvmodel); static int computeOffset(int offset, FieldModel model); static int computeNonScalarOffset(DataValueModel dvmodel, Class type); T heapInstance(Class<T> tClass); Class acquireHeapClass(Class<T> tClass); T nativeInstance(Class<T> tClass); Class acquireNativeClass(Class<T> tClass); String generateNativeObject(Class<?> tClass); String generateNativeObject(DataValueModel<?> dvmodel); boolean isDumpCode(); void setDumpCode(boolean dumpCode); }
|
@Test public void primitives3Metadata() { unsafeClassHeaderSize64BitCompressedOops(new Primitives3()); SerializationMetadata serializationMetadata = extractMetadata(Introspect.fields(Primitives3.class)); assertEquals(OBJECT_HEADER_SIZE, serializationMetadata.start); assertEquals(12, serializationMetadata.length); }
|
public static SerializationMetadata extractMetadata(List<Field> fields) { if (fields.isEmpty()) return EmptyObjectMetadata; Offsets offsets = minMaxOffsets(fields); long totalSize = OBJECT_HEADER_SIZE + offsets.max - offsets.min + 1; return new SerializationMetadata(offsets.min, padToObjectAlignment(totalSize) - OBJECT_HEADER_SIZE); }
|
DirectSerializationMetadata { public static SerializationMetadata extractMetadata(List<Field> fields) { if (fields.isEmpty()) return EmptyObjectMetadata; Offsets offsets = minMaxOffsets(fields); long totalSize = OBJECT_HEADER_SIZE + offsets.max - offsets.min + 1; return new SerializationMetadata(offsets.min, padToObjectAlignment(totalSize) - OBJECT_HEADER_SIZE); } }
|
DirectSerializationMetadata { public static SerializationMetadata extractMetadata(List<Field> fields) { if (fields.isEmpty()) return EmptyObjectMetadata; Offsets offsets = minMaxOffsets(fields); long totalSize = OBJECT_HEADER_SIZE + offsets.max - offsets.min + 1; return new SerializationMetadata(offsets.min, padToObjectAlignment(totalSize) - OBJECT_HEADER_SIZE); } }
|
DirectSerializationMetadata { public static SerializationMetadata extractMetadata(List<Field> fields) { if (fields.isEmpty()) return EmptyObjectMetadata; Offsets offsets = minMaxOffsets(fields); long totalSize = OBJECT_HEADER_SIZE + offsets.max - offsets.min + 1; return new SerializationMetadata(offsets.min, padToObjectAlignment(totalSize) - OBJECT_HEADER_SIZE); } static SerializationMetadata extractMetadata(List<Field> fields); static SerializationMetadata extractMetadataForPartialCopy(List<Field> fields); }
|
DirectSerializationMetadata { public static SerializationMetadata extractMetadata(List<Field> fields) { if (fields.isEmpty()) return EmptyObjectMetadata; Offsets offsets = minMaxOffsets(fields); long totalSize = OBJECT_HEADER_SIZE + offsets.max - offsets.min + 1; return new SerializationMetadata(offsets.min, padToObjectAlignment(totalSize) - OBJECT_HEADER_SIZE); } static SerializationMetadata extractMetadata(List<Field> fields); static SerializationMetadata extractMetadataForPartialCopy(List<Field> fields); }
|
@Test public void testGenerateInterfaceWithDateNativeInstace() { DataValueGenerator dvg = new DataValueGenerator(); JavaBeanInterfaceGetDate jbid = dvg.nativeInstance(JavaBeanInterfaceGetDate.class); Bytes bytes = ByteBufferBytes.wrap(ByteBuffer.allocate(64)); ((Byteable) jbid).bytes(bytes, 0L); jbid.setDate(new Date()); assertEquals(new Date(), jbid.getDate()); }
|
public <T> T nativeInstance(Class<T> tClass) { try { return (T) acquireNativeClass(tClass).newInstance(); } catch (Exception e) { throw new AssertionError(e); } }
|
DataValueGenerator { public <T> T nativeInstance(Class<T> tClass) { try { return (T) acquireNativeClass(tClass).newInstance(); } catch (Exception e) { throw new AssertionError(e); } } }
|
DataValueGenerator { public <T> T nativeInstance(Class<T> tClass) { try { return (T) acquireNativeClass(tClass).newInstance(); } catch (Exception e) { throw new AssertionError(e); } } }
|
DataValueGenerator { public <T> T nativeInstance(Class<T> tClass) { try { return (T) acquireNativeClass(tClass).newInstance(); } catch (Exception e) { throw new AssertionError(e); } } static Class firstPrimitiveFieldType(Class valueClass); static String bytesType(Class type); static String simpleName(Class<?> type); static CharSequence normalize(Class aClass); static Method getGetter(FieldModel model); static Method getVolatileGetter(FieldModel model); static Method getSetter(FieldModel model); static Method getOrderedSetter(FieldModel model); static void appendImported(SortedSet<Class> imported, StringBuilder sb); static void appendPackage(DataValueModel<?> dvmodel, StringBuilder sb); static String getPackage(DataValueModel<?> dvmodel); static int fieldSize(FieldModel model); static TreeSet<Class> newImported(); static boolean shouldImport(Class type); static Map.Entry<String, FieldModel>[] heapSizeOrderedFieldsGrouped(DataValueModel<?> dvmodel); static int computeOffset(int offset, FieldModel model); static int computeNonScalarOffset(DataValueModel dvmodel, Class type); T heapInstance(Class<T> tClass); Class acquireHeapClass(Class<T> tClass); T nativeInstance(Class<T> tClass); Class acquireNativeClass(Class<T> tClass); String generateNativeObject(Class<?> tClass); String generateNativeObject(DataValueModel<?> dvmodel); boolean isDumpCode(); void setDumpCode(boolean dumpCode); }
|
DataValueGenerator { public <T> T nativeInstance(Class<T> tClass) { try { return (T) acquireNativeClass(tClass).newInstance(); } catch (Exception e) { throw new AssertionError(e); } } static Class firstPrimitiveFieldType(Class valueClass); static String bytesType(Class type); static String simpleName(Class<?> type); static CharSequence normalize(Class aClass); static Method getGetter(FieldModel model); static Method getVolatileGetter(FieldModel model); static Method getSetter(FieldModel model); static Method getOrderedSetter(FieldModel model); static void appendImported(SortedSet<Class> imported, StringBuilder sb); static void appendPackage(DataValueModel<?> dvmodel, StringBuilder sb); static String getPackage(DataValueModel<?> dvmodel); static int fieldSize(FieldModel model); static TreeSet<Class> newImported(); static boolean shouldImport(Class type); static Map.Entry<String, FieldModel>[] heapSizeOrderedFieldsGrouped(DataValueModel<?> dvmodel); static int computeOffset(int offset, FieldModel model); static int computeNonScalarOffset(DataValueModel dvmodel, Class type); T heapInstance(Class<T> tClass); Class acquireHeapClass(Class<T> tClass); T nativeInstance(Class<T> tClass); Class acquireNativeClass(Class<T> tClass); String generateNativeObject(Class<?> tClass); String generateNativeObject(DataValueModel<?> dvmodel); boolean isDumpCode(); void setDumpCode(boolean dumpCode); }
|
@Test public void testLightPauser() throws InterruptedException { final LightPauser pauser = new LightPauser(100 * 1000, 100 * 1000); Thread thread = new Thread() { @Override public void run() { while (!Thread.interrupted()) pauser.pause(); } }; thread.start(); for (int t = 0; t < 3; t++) { long start = System.nanoTime(); int runs = 10000000; for (int i = 0; i < runs; i++) pauser.unpause(); long time = System.nanoTime() - start; System.out.printf("Average time to unpark was %,d ns%n", time / runs); Thread.sleep(20); } thread.interrupt(); }
|
public LightPauser(long busyPeriodNS, long parkPeriodNS) { this.busyPeriodNS = busyPeriodNS; this.parkPeriodNS = parkPeriodNS; }
|
LightPauser implements Pauser { public LightPauser(long busyPeriodNS, long parkPeriodNS) { this.busyPeriodNS = busyPeriodNS; this.parkPeriodNS = parkPeriodNS; } }
|
LightPauser implements Pauser { public LightPauser(long busyPeriodNS, long parkPeriodNS) { this.busyPeriodNS = busyPeriodNS; this.parkPeriodNS = parkPeriodNS; } LightPauser(long busyPeriodNS, long parkPeriodNS); }
|
LightPauser implements Pauser { public LightPauser(long busyPeriodNS, long parkPeriodNS) { this.busyPeriodNS = busyPeriodNS; this.parkPeriodNS = parkPeriodNS; } LightPauser(long busyPeriodNS, long parkPeriodNS); @Override void reset(); @Override void pause(); void pause(long maxPauseNS); @Override void unpause(); }
|
LightPauser implements Pauser { public LightPauser(long busyPeriodNS, long parkPeriodNS) { this.busyPeriodNS = busyPeriodNS; this.parkPeriodNS = parkPeriodNS; } LightPauser(long busyPeriodNS, long parkPeriodNS); @Override void reset(); @Override void pause(); void pause(long maxPauseNS); @Override void unpause(); static final long NO_BUSY_PERIOD; static final long NO_PAUSE_PERIOD; }
|
@Test public void testIntLog2() { for (int i = 0; i < 63; i++) { long l = 1L << i; assertEquals(i, Maths.intLog2(l)); } }
|
public static int intLog2(long num) { long l = Double.doubleToRawLongBits(num); return (int) ((l >> 52) - 1023); }
|
Maths { public static int intLog2(long num) { long l = Double.doubleToRawLongBits(num); return (int) ((l >> 52) - 1023); } }
|
Maths { public static int intLog2(long num) { long l = Double.doubleToRawLongBits(num); return (int) ((l >> 52) - 1023); } }
|
Maths { public static int intLog2(long num) { long l = Double.doubleToRawLongBits(num); return (int) ((l >> 52) - 1023); } static double round2(double d); static double round4(double d); static double round6(double d); static double round8(double d); static long power10(int n); static int nextPower2(int n, int min); static long nextPower2(long n, long min); static boolean isPowerOf2(int n); static boolean isPowerOf2(long n); static int hash(int n); static long hash(long n); static long hash(CharSequence cs); static int compare(long x, long y); static int intLog2(long num); static int toInt(long l, String error); static long agitate(long l); }
|
Maths { public static int intLog2(long num) { long l = Double.doubleToRawLongBits(num); return (int) ((l >> 52) - 1023); } static double round2(double d); static double round4(double d); static double round6(double d); static double round8(double d); static long power10(int n); static int nextPower2(int n, int min); static long nextPower2(long n, long min); static boolean isPowerOf2(int n); static boolean isPowerOf2(long n); static int hash(int n); static long hash(long n); static long hash(CharSequence cs); static int compare(long x, long y); static int intLog2(long num); static int toInt(long l, String error); static long agitate(long l); }
|
@Test public void primitives4Metadata() { unsafeClassHeaderSize64BitCompressedOops(new Primitives4()); SerializationMetadata serializationMetadata = extractMetadata(Introspect.fields(Primitives4.class)); assertEquals(OBJECT_HEADER_SIZE, serializationMetadata.start); assertEquals(4, serializationMetadata.length); }
|
public static SerializationMetadata extractMetadata(List<Field> fields) { if (fields.isEmpty()) return EmptyObjectMetadata; Offsets offsets = minMaxOffsets(fields); long totalSize = OBJECT_HEADER_SIZE + offsets.max - offsets.min + 1; return new SerializationMetadata(offsets.min, padToObjectAlignment(totalSize) - OBJECT_HEADER_SIZE); }
|
DirectSerializationMetadata { public static SerializationMetadata extractMetadata(List<Field> fields) { if (fields.isEmpty()) return EmptyObjectMetadata; Offsets offsets = minMaxOffsets(fields); long totalSize = OBJECT_HEADER_SIZE + offsets.max - offsets.min + 1; return new SerializationMetadata(offsets.min, padToObjectAlignment(totalSize) - OBJECT_HEADER_SIZE); } }
|
DirectSerializationMetadata { public static SerializationMetadata extractMetadata(List<Field> fields) { if (fields.isEmpty()) return EmptyObjectMetadata; Offsets offsets = minMaxOffsets(fields); long totalSize = OBJECT_HEADER_SIZE + offsets.max - offsets.min + 1; return new SerializationMetadata(offsets.min, padToObjectAlignment(totalSize) - OBJECT_HEADER_SIZE); } }
|
DirectSerializationMetadata { public static SerializationMetadata extractMetadata(List<Field> fields) { if (fields.isEmpty()) return EmptyObjectMetadata; Offsets offsets = minMaxOffsets(fields); long totalSize = OBJECT_HEADER_SIZE + offsets.max - offsets.min + 1; return new SerializationMetadata(offsets.min, padToObjectAlignment(totalSize) - OBJECT_HEADER_SIZE); } static SerializationMetadata extractMetadata(List<Field> fields); static SerializationMetadata extractMetadataForPartialCopy(List<Field> fields); }
|
DirectSerializationMetadata { public static SerializationMetadata extractMetadata(List<Field> fields) { if (fields.isEmpty()) return EmptyObjectMetadata; Offsets offsets = minMaxOffsets(fields); long totalSize = OBJECT_HEADER_SIZE + offsets.max - offsets.min + 1; return new SerializationMetadata(offsets.min, padToObjectAlignment(totalSize) - OBJECT_HEADER_SIZE); } static SerializationMetadata extractMetadata(List<Field> fields); static SerializationMetadata extractMetadataForPartialCopy(List<Field> fields); }
|
@Test public void primitives5Metadata() { unsafeClassHeaderSize64BitCompressedOops(new Primitives5()); SerializationMetadata serializationMetadata = extractMetadata(Introspect.fields(Primitives5.class)); assertEquals(OBJECT_HEADER_SIZE, serializationMetadata.start); assertEquals(12, serializationMetadata.length); }
|
public static SerializationMetadata extractMetadata(List<Field> fields) { if (fields.isEmpty()) return EmptyObjectMetadata; Offsets offsets = minMaxOffsets(fields); long totalSize = OBJECT_HEADER_SIZE + offsets.max - offsets.min + 1; return new SerializationMetadata(offsets.min, padToObjectAlignment(totalSize) - OBJECT_HEADER_SIZE); }
|
DirectSerializationMetadata { public static SerializationMetadata extractMetadata(List<Field> fields) { if (fields.isEmpty()) return EmptyObjectMetadata; Offsets offsets = minMaxOffsets(fields); long totalSize = OBJECT_HEADER_SIZE + offsets.max - offsets.min + 1; return new SerializationMetadata(offsets.min, padToObjectAlignment(totalSize) - OBJECT_HEADER_SIZE); } }
|
DirectSerializationMetadata { public static SerializationMetadata extractMetadata(List<Field> fields) { if (fields.isEmpty()) return EmptyObjectMetadata; Offsets offsets = minMaxOffsets(fields); long totalSize = OBJECT_HEADER_SIZE + offsets.max - offsets.min + 1; return new SerializationMetadata(offsets.min, padToObjectAlignment(totalSize) - OBJECT_HEADER_SIZE); } }
|
DirectSerializationMetadata { public static SerializationMetadata extractMetadata(List<Field> fields) { if (fields.isEmpty()) return EmptyObjectMetadata; Offsets offsets = minMaxOffsets(fields); long totalSize = OBJECT_HEADER_SIZE + offsets.max - offsets.min + 1; return new SerializationMetadata(offsets.min, padToObjectAlignment(totalSize) - OBJECT_HEADER_SIZE); } static SerializationMetadata extractMetadata(List<Field> fields); static SerializationMetadata extractMetadataForPartialCopy(List<Field> fields); }
|
DirectSerializationMetadata { public static SerializationMetadata extractMetadata(List<Field> fields) { if (fields.isEmpty()) return EmptyObjectMetadata; Offsets offsets = minMaxOffsets(fields); long totalSize = OBJECT_HEADER_SIZE + offsets.max - offsets.min + 1; return new SerializationMetadata(offsets.min, padToObjectAlignment(totalSize) - OBJECT_HEADER_SIZE); } static SerializationMetadata extractMetadata(List<Field> fields); static SerializationMetadata extractMetadataForPartialCopy(List<Field> fields); }
|
@Test public void primitives6Metadata() { unsafeClassHeaderSize64BitCompressedOops(new Primitives6()); SerializationMetadata serializationMetadata = extractMetadata(Introspect.fields(Primitives6.class)); assertEquals(OBJECT_HEADER_SIZE, serializationMetadata.start); assertEquals(28, serializationMetadata.length); }
|
public static SerializationMetadata extractMetadata(List<Field> fields) { if (fields.isEmpty()) return EmptyObjectMetadata; Offsets offsets = minMaxOffsets(fields); long totalSize = OBJECT_HEADER_SIZE + offsets.max - offsets.min + 1; return new SerializationMetadata(offsets.min, padToObjectAlignment(totalSize) - OBJECT_HEADER_SIZE); }
|
DirectSerializationMetadata { public static SerializationMetadata extractMetadata(List<Field> fields) { if (fields.isEmpty()) return EmptyObjectMetadata; Offsets offsets = minMaxOffsets(fields); long totalSize = OBJECT_HEADER_SIZE + offsets.max - offsets.min + 1; return new SerializationMetadata(offsets.min, padToObjectAlignment(totalSize) - OBJECT_HEADER_SIZE); } }
|
DirectSerializationMetadata { public static SerializationMetadata extractMetadata(List<Field> fields) { if (fields.isEmpty()) return EmptyObjectMetadata; Offsets offsets = minMaxOffsets(fields); long totalSize = OBJECT_HEADER_SIZE + offsets.max - offsets.min + 1; return new SerializationMetadata(offsets.min, padToObjectAlignment(totalSize) - OBJECT_HEADER_SIZE); } }
|
DirectSerializationMetadata { public static SerializationMetadata extractMetadata(List<Field> fields) { if (fields.isEmpty()) return EmptyObjectMetadata; Offsets offsets = minMaxOffsets(fields); long totalSize = OBJECT_HEADER_SIZE + offsets.max - offsets.min + 1; return new SerializationMetadata(offsets.min, padToObjectAlignment(totalSize) - OBJECT_HEADER_SIZE); } static SerializationMetadata extractMetadata(List<Field> fields); static SerializationMetadata extractMetadataForPartialCopy(List<Field> fields); }
|
DirectSerializationMetadata { public static SerializationMetadata extractMetadata(List<Field> fields) { if (fields.isEmpty()) return EmptyObjectMetadata; Offsets offsets = minMaxOffsets(fields); long totalSize = OBJECT_HEADER_SIZE + offsets.max - offsets.min + 1; return new SerializationMetadata(offsets.min, padToObjectAlignment(totalSize) - OBJECT_HEADER_SIZE); } static SerializationMetadata extractMetadata(List<Field> fields); static SerializationMetadata extractMetadataForPartialCopy(List<Field> fields); }
|
@Test public void instancePrimitivesAreEligible() { List<Field> field = fieldsNamed("intField"); assertEquals(field, stopAtFirstIneligibleField(field)); }
|
public static List<Field> stopAtFirstIneligibleField(List<Field> fields) { ArrayList<Field> eligibleFields = new ArrayList<Field>(); for (Field f : fields) { if (checkEligible(f)) { eligibleFields.add(f); } else { break; } } return eligibleFields.isEmpty() ? Collections.<Field>emptyList() : eligibleFields; }
|
DirectSerializationFilter { public static List<Field> stopAtFirstIneligibleField(List<Field> fields) { ArrayList<Field> eligibleFields = new ArrayList<Field>(); for (Field f : fields) { if (checkEligible(f)) { eligibleFields.add(f); } else { break; } } return eligibleFields.isEmpty() ? Collections.<Field>emptyList() : eligibleFields; } }
|
DirectSerializationFilter { public static List<Field> stopAtFirstIneligibleField(List<Field> fields) { ArrayList<Field> eligibleFields = new ArrayList<Field>(); for (Field f : fields) { if (checkEligible(f)) { eligibleFields.add(f); } else { break; } } return eligibleFields.isEmpty() ? Collections.<Field>emptyList() : eligibleFields; } }
|
DirectSerializationFilter { public static List<Field> stopAtFirstIneligibleField(List<Field> fields) { ArrayList<Field> eligibleFields = new ArrayList<Field>(); for (Field f : fields) { if (checkEligible(f)) { eligibleFields.add(f); } else { break; } } return eligibleFields.isEmpty() ? Collections.<Field>emptyList() : eligibleFields; } static List<Field> stopAtFirstIneligibleField(List<Field> fields); }
|
DirectSerializationFilter { public static List<Field> stopAtFirstIneligibleField(List<Field> fields) { ArrayList<Field> eligibleFields = new ArrayList<Field>(); for (Field f : fields) { if (checkEligible(f)) { eligibleFields.add(f); } else { break; } } return eligibleFields.isEmpty() ? Collections.<Field>emptyList() : eligibleFields; } static List<Field> stopAtFirstIneligibleField(List<Field> fields); }
|
@Test public void instancePrimitiveArraysAreNotEligible() { List<Field> field = fieldsNamed("doubleArray"); assertTrue(stopAtFirstIneligibleField(field).isEmpty()); }
|
public static List<Field> stopAtFirstIneligibleField(List<Field> fields) { ArrayList<Field> eligibleFields = new ArrayList<Field>(); for (Field f : fields) { if (checkEligible(f)) { eligibleFields.add(f); } else { break; } } return eligibleFields.isEmpty() ? Collections.<Field>emptyList() : eligibleFields; }
|
DirectSerializationFilter { public static List<Field> stopAtFirstIneligibleField(List<Field> fields) { ArrayList<Field> eligibleFields = new ArrayList<Field>(); for (Field f : fields) { if (checkEligible(f)) { eligibleFields.add(f); } else { break; } } return eligibleFields.isEmpty() ? Collections.<Field>emptyList() : eligibleFields; } }
|
DirectSerializationFilter { public static List<Field> stopAtFirstIneligibleField(List<Field> fields) { ArrayList<Field> eligibleFields = new ArrayList<Field>(); for (Field f : fields) { if (checkEligible(f)) { eligibleFields.add(f); } else { break; } } return eligibleFields.isEmpty() ? Collections.<Field>emptyList() : eligibleFields; } }
|
DirectSerializationFilter { public static List<Field> stopAtFirstIneligibleField(List<Field> fields) { ArrayList<Field> eligibleFields = new ArrayList<Field>(); for (Field f : fields) { if (checkEligible(f)) { eligibleFields.add(f); } else { break; } } return eligibleFields.isEmpty() ? Collections.<Field>emptyList() : eligibleFields; } static List<Field> stopAtFirstIneligibleField(List<Field> fields); }
|
DirectSerializationFilter { public static List<Field> stopAtFirstIneligibleField(List<Field> fields) { ArrayList<Field> eligibleFields = new ArrayList<Field>(); for (Field f : fields) { if (checkEligible(f)) { eligibleFields.add(f); } else { break; } } return eligibleFields.isEmpty() ? Collections.<Field>emptyList() : eligibleFields; } static List<Field> stopAtFirstIneligibleField(List<Field> fields); }
|
@Test public void instanceReferencesAreNotEligible() { List<Field> field = fieldsNamed("stringList"); assertTrue(stopAtFirstIneligibleField(field).isEmpty()); }
|
public static List<Field> stopAtFirstIneligibleField(List<Field> fields) { ArrayList<Field> eligibleFields = new ArrayList<Field>(); for (Field f : fields) { if (checkEligible(f)) { eligibleFields.add(f); } else { break; } } return eligibleFields.isEmpty() ? Collections.<Field>emptyList() : eligibleFields; }
|
DirectSerializationFilter { public static List<Field> stopAtFirstIneligibleField(List<Field> fields) { ArrayList<Field> eligibleFields = new ArrayList<Field>(); for (Field f : fields) { if (checkEligible(f)) { eligibleFields.add(f); } else { break; } } return eligibleFields.isEmpty() ? Collections.<Field>emptyList() : eligibleFields; } }
|
DirectSerializationFilter { public static List<Field> stopAtFirstIneligibleField(List<Field> fields) { ArrayList<Field> eligibleFields = new ArrayList<Field>(); for (Field f : fields) { if (checkEligible(f)) { eligibleFields.add(f); } else { break; } } return eligibleFields.isEmpty() ? Collections.<Field>emptyList() : eligibleFields; } }
|
DirectSerializationFilter { public static List<Field> stopAtFirstIneligibleField(List<Field> fields) { ArrayList<Field> eligibleFields = new ArrayList<Field>(); for (Field f : fields) { if (checkEligible(f)) { eligibleFields.add(f); } else { break; } } return eligibleFields.isEmpty() ? Collections.<Field>emptyList() : eligibleFields; } static List<Field> stopAtFirstIneligibleField(List<Field> fields); }
|
DirectSerializationFilter { public static List<Field> stopAtFirstIneligibleField(List<Field> fields) { ArrayList<Field> eligibleFields = new ArrayList<Field>(); for (Field f : fields) { if (checkEligible(f)) { eligibleFields.add(f); } else { break; } } return eligibleFields.isEmpty() ? Collections.<Field>emptyList() : eligibleFields; } static List<Field> stopAtFirstIneligibleField(List<Field> fields); }
|
@Test public void instanceReferenceArraysAreNotEligible() { List<Field> field = fieldsNamed("objectArray"); assertTrue(stopAtFirstIneligibleField(field).isEmpty()); }
|
public static List<Field> stopAtFirstIneligibleField(List<Field> fields) { ArrayList<Field> eligibleFields = new ArrayList<Field>(); for (Field f : fields) { if (checkEligible(f)) { eligibleFields.add(f); } else { break; } } return eligibleFields.isEmpty() ? Collections.<Field>emptyList() : eligibleFields; }
|
DirectSerializationFilter { public static List<Field> stopAtFirstIneligibleField(List<Field> fields) { ArrayList<Field> eligibleFields = new ArrayList<Field>(); for (Field f : fields) { if (checkEligible(f)) { eligibleFields.add(f); } else { break; } } return eligibleFields.isEmpty() ? Collections.<Field>emptyList() : eligibleFields; } }
|
DirectSerializationFilter { public static List<Field> stopAtFirstIneligibleField(List<Field> fields) { ArrayList<Field> eligibleFields = new ArrayList<Field>(); for (Field f : fields) { if (checkEligible(f)) { eligibleFields.add(f); } else { break; } } return eligibleFields.isEmpty() ? Collections.<Field>emptyList() : eligibleFields; } }
|
DirectSerializationFilter { public static List<Field> stopAtFirstIneligibleField(List<Field> fields) { ArrayList<Field> eligibleFields = new ArrayList<Field>(); for (Field f : fields) { if (checkEligible(f)) { eligibleFields.add(f); } else { break; } } return eligibleFields.isEmpty() ? Collections.<Field>emptyList() : eligibleFields; } static List<Field> stopAtFirstIneligibleField(List<Field> fields); }
|
DirectSerializationFilter { public static List<Field> stopAtFirstIneligibleField(List<Field> fields) { ArrayList<Field> eligibleFields = new ArrayList<Field>(); for (Field f : fields) { if (checkEligible(f)) { eligibleFields.add(f); } else { break; } } return eligibleFields.isEmpty() ? Collections.<Field>emptyList() : eligibleFields; } static List<Field> stopAtFirstIneligibleField(List<Field> fields); }
|
@Test public void testSayHello() { assertEquals("Hello,World!",new HelloWorldController().sayHello()); }
|
@RequestMapping("/") public String sayHello() { return "Hello,World!"; }
|
HelloWorldController { @RequestMapping("/") public String sayHello() { return "Hello,World!"; } }
|
HelloWorldController { @RequestMapping("/") public String sayHello() { return "Hello,World!"; } }
|
HelloWorldController { @RequestMapping("/") public String sayHello() { return "Hello,World!"; } @RequestMapping("/") String sayHello(); @PostMapping(value = "/request_param") String requestParam(@RequestParam(value = "name") String name); @PostMapping(value = "/request_body") UserInfo requestBody(@RequestParam(value = "name") String name, @RequestBody UserInfo info); @PostMapping(value = "/request_body1") UserInfo requestBody1(@RequestBody UserInfo info); }
|
HelloWorldController { @RequestMapping("/") public String sayHello() { return "Hello,World!"; } @RequestMapping("/") String sayHello(); @PostMapping(value = "/request_param") String requestParam(@RequestParam(value = "name") String name); @PostMapping(value = "/request_body") UserInfo requestBody(@RequestParam(value = "name") String name, @RequestBody UserInfo info); @PostMapping(value = "/request_body1") UserInfo requestBody1(@RequestBody UserInfo info); }
|
@Test public void testBuildUrl() { OpenhabSseConnection c = new OpenhabSseConnection(); c.setServerUrl("URL"); c.setItemNames("cmdName"); assertEquals("URL/rest/events?topics=smarthome/items/cmdName/command", c.buildUrl()); c.setItemNames("cmdName","item1", "item2"); assertEquals("URL/rest/events?topics=smarthome/items/item1/statechanged,smarthome/items/item2/statechanged,smarthome/items/cmdName/command", c.buildUrl()); }
|
@Override protected String buildUrl() { return mUrl + "/rest/events?topics=" + buildTopic(); }
|
OpenhabSseConnection extends SseConnection implements SseConnection.ISseDataListener { @Override protected String buildUrl() { return mUrl + "/rest/events?topics=" + buildTopic(); } }
|
OpenhabSseConnection extends SseConnection implements SseConnection.ISseDataListener { @Override protected String buildUrl() { return mUrl + "/rest/events?topics=" + buildTopic(); } OpenhabSseConnection(); }
|
OpenhabSseConnection extends SseConnection implements SseConnection.ISseDataListener { @Override protected String buildUrl() { return mUrl + "/rest/events?topics=" + buildTopic(); } OpenhabSseConnection(); void removeItemValueListener(IStateUpdateListener l); @Override void data(String data); }
|
OpenhabSseConnection extends SseConnection implements SseConnection.ISseDataListener { @Override protected String buildUrl() { return mUrl + "/rest/events?topics=" + buildTopic(); } OpenhabSseConnection(); void removeItemValueListener(IStateUpdateListener l); @Override void data(String data); }
|
@Test public void backAndForth() { LocalizedFieldNames.Lookup lookup = localizedFieldNames.createLookup(Arrays.asList("dc.title")); final Locale english = new Locale("en"); String title = lookup.toLocalizedName("dc_title", english); Assert.assertEquals("Title", title); String fieldName = lookup.toFieldName(title, english); Assert.assertEquals("dc_title", fieldName); }
|
public Lookup createLookup(List<String> keys) { return new LookupImpl(keys); }
|
LocalizedFieldNames { public Lookup createLookup(List<String> keys) { return new LookupImpl(keys); } }
|
LocalizedFieldNames { public Lookup createLookup(List<String> keys) { return new LookupImpl(keys); } }
|
LocalizedFieldNames { public Lookup createLookup(List<String> keys) { return new LookupImpl(keys); } void setMessageSource(MessageSource messageSource); Lookup createLookup(List<String> keys); }
|
LocalizedFieldNames { public Lookup createLookup(List<String> keys) { return new LookupImpl(keys); } void setMessageSource(MessageSource messageSource); Lookup createLookup(List<String> keys); }
|
@Test public void multiWord() { LocalizedFieldNames.Lookup lookup = localizedFieldNames.createLookup(Arrays.asList("dcterms.isReferencedBy")); final Locale english = new Locale("en"); String fieldName = lookup.toFieldName("isreferENCedby", english); Assert.assertEquals("dcterms_isReferencedBy", fieldName); }
|
public Lookup createLookup(List<String> keys) { return new LookupImpl(keys); }
|
LocalizedFieldNames { public Lookup createLookup(List<String> keys) { return new LookupImpl(keys); } }
|
LocalizedFieldNames { public Lookup createLookup(List<String> keys) { return new LookupImpl(keys); } }
|
LocalizedFieldNames { public Lookup createLookup(List<String> keys) { return new LookupImpl(keys); } void setMessageSource(MessageSource messageSource); Lookup createLookup(List<String> keys); }
|
LocalizedFieldNames { public Lookup createLookup(List<String> keys) { return new LookupImpl(keys); } void setMessageSource(MessageSource messageSource); Lookup createLookup(List<String> keys); }
|
@Test public void TestDetectAnyBorder() { VirtualEdgeIteratorState ve1 = generateEdge(1); VirtualEdgeIteratorState ve2 = generateEdge(2); VirtualEdgeIteratorState ve3 = generateEdge(3); BordersExtractor be = new BordersExtractor(_graphstorage, new int[0]); assertEquals(true, be.isBorder(1)); assertEquals(true, be.isBorder(2)); assertEquals(false, be.isBorder(3)); }
|
public boolean isBorder(int edgeId) { int type = storage.getEdgeValue(edgeId, BordersGraphStorage.Property.TYPE); return (type == BordersGraphStorage.OPEN_BORDER || type == BordersGraphStorage.CONTROLLED_BORDER); }
|
BordersExtractor { public boolean isBorder(int edgeId) { int type = storage.getEdgeValue(edgeId, BordersGraphStorage.Property.TYPE); return (type == BordersGraphStorage.OPEN_BORDER || type == BordersGraphStorage.CONTROLLED_BORDER); } }
|
BordersExtractor { public boolean isBorder(int edgeId) { int type = storage.getEdgeValue(edgeId, BordersGraphStorage.Property.TYPE); return (type == BordersGraphStorage.OPEN_BORDER || type == BordersGraphStorage.CONTROLLED_BORDER); } BordersExtractor(BordersGraphStorage storage, int[] avoidCountries); }
|
BordersExtractor { public boolean isBorder(int edgeId) { int type = storage.getEdgeValue(edgeId, BordersGraphStorage.Property.TYPE); return (type == BordersGraphStorage.OPEN_BORDER || type == BordersGraphStorage.CONTROLLED_BORDER); } BordersExtractor(BordersGraphStorage storage, int[] avoidCountries); int getValue(int edgeId); boolean isBorder(int edgeId); boolean isControlledBorder(int edgeId); boolean isOpenBorder(int edgeId); boolean restrictedCountry(int edgeId); boolean isSameCountry(List<Integer> edgeIds); }
|
BordersExtractor { public boolean isBorder(int edgeId) { int type = storage.getEdgeValue(edgeId, BordersGraphStorage.Property.TYPE); return (type == BordersGraphStorage.OPEN_BORDER || type == BordersGraphStorage.CONTROLLED_BORDER); } BordersExtractor(BordersGraphStorage storage, int[] avoidCountries); int getValue(int edgeId); boolean isBorder(int edgeId); boolean isControlledBorder(int edgeId); boolean isOpenBorder(int edgeId); boolean restrictedCountry(int edgeId); boolean isSameCountry(List<Integer> edgeIds); }
|
@Test public void getBbox() { }
|
public BoundingBox getBbox() { return bbox; }
|
IsochronesResponse { public BoundingBox getBbox() { return bbox; } }
|
IsochronesResponse { public BoundingBox getBbox() { return bbox; } IsochronesResponse(IsochronesRequest request); }
|
IsochronesResponse { public BoundingBox getBbox() { return bbox; } IsochronesResponse(IsochronesRequest request); IsochronesResponseInfo getResponseInformation(); BoundingBox getBbox(); }
|
IsochronesResponse { public BoundingBox getBbox() { return bbox; } IsochronesResponse(IsochronesRequest request); IsochronesResponseInfo getResponseInformation(); BoundingBox getBbox(); }
|
@Test public void getIsochrones() { }
|
@JsonProperty("features") public List<GeoJSONIsochroneBase> getIsochrones() { return isochroneResults; }
|
GeoJSONIsochronesResponse extends IsochronesResponse { @JsonProperty("features") public List<GeoJSONIsochroneBase> getIsochrones() { return isochroneResults; } }
|
GeoJSONIsochronesResponse extends IsochronesResponse { @JsonProperty("features") public List<GeoJSONIsochroneBase> getIsochrones() { return isochroneResults; } GeoJSONIsochronesResponse(IsochronesRequest request, IsochroneMapCollection isoMaps); }
|
GeoJSONIsochronesResponse extends IsochronesResponse { @JsonProperty("features") public List<GeoJSONIsochroneBase> getIsochrones() { return isochroneResults; } GeoJSONIsochronesResponse(IsochronesRequest request, IsochroneMapCollection isoMaps); @JsonProperty("bbox") @JsonInclude(JsonInclude.Include.NON_NULL) @ApiModelProperty(value = "Bounding box that covers all returned isochrones", example = "[49.414057, 8.680894, 49.420514, 8.690123]") double[] getBBoxAsArray(); @JsonProperty("features") List<GeoJSONIsochroneBase> getIsochrones(); @JsonProperty("metadata") IsochronesResponseInfo getProperties(); }
|
GeoJSONIsochronesResponse extends IsochronesResponse { @JsonProperty("features") public List<GeoJSONIsochroneBase> getIsochrones() { return isochroneResults; } GeoJSONIsochronesResponse(IsochronesRequest request, IsochroneMapCollection isoMaps); @JsonProperty("bbox") @JsonInclude(JsonInclude.Include.NON_NULL) @ApiModelProperty(value = "Bounding box that covers all returned isochrones", example = "[49.414057, 8.680894, 49.420514, 8.690123]") double[] getBBoxAsArray(); @JsonProperty("features") List<GeoJSONIsochroneBase> getIsochrones(); @JsonProperty("metadata") IsochronesResponseInfo getProperties(); @JsonProperty("type")
final String type; }
|
@Test public void getProperties() { }
|
@JsonProperty("metadata") public IsochronesResponseInfo getProperties() { return this.responseInformation; }
|
GeoJSONIsochronesResponse extends IsochronesResponse { @JsonProperty("metadata") public IsochronesResponseInfo getProperties() { return this.responseInformation; } }
|
GeoJSONIsochronesResponse extends IsochronesResponse { @JsonProperty("metadata") public IsochronesResponseInfo getProperties() { return this.responseInformation; } GeoJSONIsochronesResponse(IsochronesRequest request, IsochroneMapCollection isoMaps); }
|
GeoJSONIsochronesResponse extends IsochronesResponse { @JsonProperty("metadata") public IsochronesResponseInfo getProperties() { return this.responseInformation; } GeoJSONIsochronesResponse(IsochronesRequest request, IsochroneMapCollection isoMaps); @JsonProperty("bbox") @JsonInclude(JsonInclude.Include.NON_NULL) @ApiModelProperty(value = "Bounding box that covers all returned isochrones", example = "[49.414057, 8.680894, 49.420514, 8.690123]") double[] getBBoxAsArray(); @JsonProperty("features") List<GeoJSONIsochroneBase> getIsochrones(); @JsonProperty("metadata") IsochronesResponseInfo getProperties(); }
|
GeoJSONIsochronesResponse extends IsochronesResponse { @JsonProperty("metadata") public IsochronesResponseInfo getProperties() { return this.responseInformation; } GeoJSONIsochronesResponse(IsochronesRequest request, IsochroneMapCollection isoMaps); @JsonProperty("bbox") @JsonInclude(JsonInclude.Include.NON_NULL) @ApiModelProperty(value = "Bounding box that covers all returned isochrones", example = "[49.414057, 8.680894, 49.420514, 8.690123]") double[] getBBoxAsArray(); @JsonProperty("features") List<GeoJSONIsochroneBase> getIsochrones(); @JsonProperty("metadata") IsochronesResponseInfo getProperties(); @JsonProperty("type")
final String type; }
|
@Test public void getValue() { }
|
public Double getValue() { return value; }
|
GeoJSONIsochroneProperties { public Double getValue() { return value; } }
|
GeoJSONIsochroneProperties { public Double getValue() { return value; } GeoJSONIsochroneProperties(Isochrone isochrone, Coordinate center, int groupIndex); }
|
GeoJSONIsochroneProperties { public Double getValue() { return value; } GeoJSONIsochroneProperties(Isochrone isochrone, Coordinate center, int groupIndex); int getGroupIndex(); Double getValue(); Double[] getCenter(); Double getArea(); Double getReachfactor(); Double getTotalPop(); }
|
GeoJSONIsochroneProperties { public Double getValue() { return value; } GeoJSONIsochroneProperties(Isochrone isochrone, Coordinate center, int groupIndex); int getGroupIndex(); Double getValue(); Double[] getCenter(); Double getArea(); Double getReachfactor(); Double getTotalPop(); }
|
@Test public void getCenter() { }
|
public Double[] getCenter() { return center; }
|
GeoJSONIsochroneProperties { public Double[] getCenter() { return center; } }
|
GeoJSONIsochroneProperties { public Double[] getCenter() { return center; } GeoJSONIsochroneProperties(Isochrone isochrone, Coordinate center, int groupIndex); }
|
GeoJSONIsochroneProperties { public Double[] getCenter() { return center; } GeoJSONIsochroneProperties(Isochrone isochrone, Coordinate center, int groupIndex); int getGroupIndex(); Double getValue(); Double[] getCenter(); Double getArea(); Double getReachfactor(); Double getTotalPop(); }
|
GeoJSONIsochroneProperties { public Double[] getCenter() { return center; } GeoJSONIsochroneProperties(Isochrone isochrone, Coordinate center, int groupIndex); int getGroupIndex(); Double getValue(); Double[] getCenter(); Double getArea(); Double getReachfactor(); Double getTotalPop(); }
|
@Test public void getArea() { }
|
public Double getArea() { return area; }
|
GeoJSONIsochroneProperties { public Double getArea() { return area; } }
|
GeoJSONIsochroneProperties { public Double getArea() { return area; } GeoJSONIsochroneProperties(Isochrone isochrone, Coordinate center, int groupIndex); }
|
GeoJSONIsochroneProperties { public Double getArea() { return area; } GeoJSONIsochroneProperties(Isochrone isochrone, Coordinate center, int groupIndex); int getGroupIndex(); Double getValue(); Double[] getCenter(); Double getArea(); Double getReachfactor(); Double getTotalPop(); }
|
GeoJSONIsochroneProperties { public Double getArea() { return area; } GeoJSONIsochroneProperties(Isochrone isochrone, Coordinate center, int groupIndex); int getGroupIndex(); Double getValue(); Double[] getCenter(); Double getArea(); Double getReachfactor(); Double getTotalPop(); }
|
@Test public void getReachfactor() { }
|
public Double getReachfactor() { return reachfactor; }
|
GeoJSONIsochroneProperties { public Double getReachfactor() { return reachfactor; } }
|
GeoJSONIsochroneProperties { public Double getReachfactor() { return reachfactor; } GeoJSONIsochroneProperties(Isochrone isochrone, Coordinate center, int groupIndex); }
|
GeoJSONIsochroneProperties { public Double getReachfactor() { return reachfactor; } GeoJSONIsochroneProperties(Isochrone isochrone, Coordinate center, int groupIndex); int getGroupIndex(); Double getValue(); Double[] getCenter(); Double getArea(); Double getReachfactor(); Double getTotalPop(); }
|
GeoJSONIsochroneProperties { public Double getReachfactor() { return reachfactor; } GeoJSONIsochroneProperties(Isochrone isochrone, Coordinate center, int groupIndex); int getGroupIndex(); Double getValue(); Double[] getCenter(); Double getArea(); Double getReachfactor(); Double getTotalPop(); }
|
@Test public void convertMatrixRequestTest() throws StatusCodeException { org.heigit.ors.api.requests.matrix.MatrixRequest springMatrixRequest = new org.heigit.ors.api.requests.matrix.MatrixRequest(bareCoordinates); springMatrixRequest.setProfile(APIEnums.Profile.DRIVING_CAR); springMatrixRequest.setSources(new String[]{"all"}); springMatrixRequest.setDestinations(new String[]{"all"}); MatrixRequest matrixRequest = MatrixRequestHandler.convertMatrixRequest(springMatrixRequest); Assert.assertEquals(1, matrixRequest.getProfileType()); Assert.assertEquals(3, matrixRequest.getSources().length); Assert.assertEquals(3, matrixRequest.getDestinations().length); Assert.assertEquals(1, matrixRequest.getMetrics()); Assert.assertEquals(WeightingMethod.UNKNOWN, matrixRequest.getWeightingMethod()); Assert.assertEquals(DistanceUnit.METERS, matrixRequest.getUnits()); Assert.assertFalse(matrixRequest.getResolveLocations()); Assert.assertFalse(matrixRequest.getFlexibleMode()); Assert.assertNull(matrixRequest.getId()); springMatrixRequest = new org.heigit.ors.api.requests.matrix.MatrixRequest(bareCoordinates); springMatrixRequest.setProfile(APIEnums.Profile.DRIVING_CAR); springMatrixRequest.setSources(new String[]{"all"}); springMatrixRequest.setDestinations(new String[]{"all"}); MatrixRequestEnums.Metrics[] metrics = new MatrixRequestEnums.Metrics[2]; metrics[0] = MatrixRequestEnums.Metrics.DURATION; metrics[1] = MatrixRequestEnums.Metrics.DISTANCE; springMatrixRequest.setMetrics(metrics); matrixRequest = MatrixRequestHandler.convertMatrixRequest(springMatrixRequest); Assert.assertEquals(3, matrixRequest.getMetrics()); }
|
public static org.heigit.ors.matrix.MatrixRequest convertMatrixRequest(MatrixRequest request) throws StatusCodeException { org.heigit.ors.matrix.MatrixRequest coreRequest = new org.heigit.ors.matrix.MatrixRequest(); int sources = request.getSources() == null ? request.getLocations().size() : request.getSources().length; int destinations = request.getDestinations() == null ? request.getLocations().size() : request.getDestinations().length; Coordinate[] locations = convertLocations(request.getLocations(), sources * destinations); coreRequest.setProfileType(convertToMatrixProfileType(request.getProfile())); if (request.hasMetrics()) coreRequest.setMetrics(convertMetrics(request.getMetrics())); if (request.hasDestinations()) coreRequest.setDestinations(convertDestinations(request.getDestinations(), locations)); else { coreRequest.setDestinations(convertDestinations(new String[]{"all"}, locations)); } if (request.hasSources()) coreRequest.setSources(convertSources(request.getSources(), locations)); else { coreRequest.setSources(convertSources(new String[]{"all"}, locations)); } if (request.hasId()) coreRequest.setId(request.getId()); if (request.hasOptimized()) coreRequest.setFlexibleMode(!request.getOptimized()); if (request.hasResolveLocations()) coreRequest.setResolveLocations(request.getResolveLocations()); if (request.hasUnits()) coreRequest.setUnits(convertUnits(request.getUnits())); return coreRequest; }
|
MatrixRequestHandler { public static org.heigit.ors.matrix.MatrixRequest convertMatrixRequest(MatrixRequest request) throws StatusCodeException { org.heigit.ors.matrix.MatrixRequest coreRequest = new org.heigit.ors.matrix.MatrixRequest(); int sources = request.getSources() == null ? request.getLocations().size() : request.getSources().length; int destinations = request.getDestinations() == null ? request.getLocations().size() : request.getDestinations().length; Coordinate[] locations = convertLocations(request.getLocations(), sources * destinations); coreRequest.setProfileType(convertToMatrixProfileType(request.getProfile())); if (request.hasMetrics()) coreRequest.setMetrics(convertMetrics(request.getMetrics())); if (request.hasDestinations()) coreRequest.setDestinations(convertDestinations(request.getDestinations(), locations)); else { coreRequest.setDestinations(convertDestinations(new String[]{"all"}, locations)); } if (request.hasSources()) coreRequest.setSources(convertSources(request.getSources(), locations)); else { coreRequest.setSources(convertSources(new String[]{"all"}, locations)); } if (request.hasId()) coreRequest.setId(request.getId()); if (request.hasOptimized()) coreRequest.setFlexibleMode(!request.getOptimized()); if (request.hasResolveLocations()) coreRequest.setResolveLocations(request.getResolveLocations()); if (request.hasUnits()) coreRequest.setUnits(convertUnits(request.getUnits())); return coreRequest; } }
|
MatrixRequestHandler { public static org.heigit.ors.matrix.MatrixRequest convertMatrixRequest(MatrixRequest request) throws StatusCodeException { org.heigit.ors.matrix.MatrixRequest coreRequest = new org.heigit.ors.matrix.MatrixRequest(); int sources = request.getSources() == null ? request.getLocations().size() : request.getSources().length; int destinations = request.getDestinations() == null ? request.getLocations().size() : request.getDestinations().length; Coordinate[] locations = convertLocations(request.getLocations(), sources * destinations); coreRequest.setProfileType(convertToMatrixProfileType(request.getProfile())); if (request.hasMetrics()) coreRequest.setMetrics(convertMetrics(request.getMetrics())); if (request.hasDestinations()) coreRequest.setDestinations(convertDestinations(request.getDestinations(), locations)); else { coreRequest.setDestinations(convertDestinations(new String[]{"all"}, locations)); } if (request.hasSources()) coreRequest.setSources(convertSources(request.getSources(), locations)); else { coreRequest.setSources(convertSources(new String[]{"all"}, locations)); } if (request.hasId()) coreRequest.setId(request.getId()); if (request.hasOptimized()) coreRequest.setFlexibleMode(!request.getOptimized()); if (request.hasResolveLocations()) coreRequest.setResolveLocations(request.getResolveLocations()); if (request.hasUnits()) coreRequest.setUnits(convertUnits(request.getUnits())); return coreRequest; } private MatrixRequestHandler(); }
|
MatrixRequestHandler { public static org.heigit.ors.matrix.MatrixRequest convertMatrixRequest(MatrixRequest request) throws StatusCodeException { org.heigit.ors.matrix.MatrixRequest coreRequest = new org.heigit.ors.matrix.MatrixRequest(); int sources = request.getSources() == null ? request.getLocations().size() : request.getSources().length; int destinations = request.getDestinations() == null ? request.getLocations().size() : request.getDestinations().length; Coordinate[] locations = convertLocations(request.getLocations(), sources * destinations); coreRequest.setProfileType(convertToMatrixProfileType(request.getProfile())); if (request.hasMetrics()) coreRequest.setMetrics(convertMetrics(request.getMetrics())); if (request.hasDestinations()) coreRequest.setDestinations(convertDestinations(request.getDestinations(), locations)); else { coreRequest.setDestinations(convertDestinations(new String[]{"all"}, locations)); } if (request.hasSources()) coreRequest.setSources(convertSources(request.getSources(), locations)); else { coreRequest.setSources(convertSources(new String[]{"all"}, locations)); } if (request.hasId()) coreRequest.setId(request.getId()); if (request.hasOptimized()) coreRequest.setFlexibleMode(!request.getOptimized()); if (request.hasResolveLocations()) coreRequest.setResolveLocations(request.getResolveLocations()); if (request.hasUnits()) coreRequest.setUnits(convertUnits(request.getUnits())); return coreRequest; } private MatrixRequestHandler(); static MatrixResult generateMatrixFromRequest(MatrixRequest request); static org.heigit.ors.matrix.MatrixRequest convertMatrixRequest(MatrixRequest request); static int convertMetrics(MatrixRequestEnums.Metrics[] metrics); }
|
MatrixRequestHandler { public static org.heigit.ors.matrix.MatrixRequest convertMatrixRequest(MatrixRequest request) throws StatusCodeException { org.heigit.ors.matrix.MatrixRequest coreRequest = new org.heigit.ors.matrix.MatrixRequest(); int sources = request.getSources() == null ? request.getLocations().size() : request.getSources().length; int destinations = request.getDestinations() == null ? request.getLocations().size() : request.getDestinations().length; Coordinate[] locations = convertLocations(request.getLocations(), sources * destinations); coreRequest.setProfileType(convertToMatrixProfileType(request.getProfile())); if (request.hasMetrics()) coreRequest.setMetrics(convertMetrics(request.getMetrics())); if (request.hasDestinations()) coreRequest.setDestinations(convertDestinations(request.getDestinations(), locations)); else { coreRequest.setDestinations(convertDestinations(new String[]{"all"}, locations)); } if (request.hasSources()) coreRequest.setSources(convertSources(request.getSources(), locations)); else { coreRequest.setSources(convertSources(new String[]{"all"}, locations)); } if (request.hasId()) coreRequest.setId(request.getId()); if (request.hasOptimized()) coreRequest.setFlexibleMode(!request.getOptimized()); if (request.hasResolveLocations()) coreRequest.setResolveLocations(request.getResolveLocations()); if (request.hasUnits()) coreRequest.setUnits(convertUnits(request.getUnits())); return coreRequest; } private MatrixRequestHandler(); static MatrixResult generateMatrixFromRequest(MatrixRequest request); static org.heigit.ors.matrix.MatrixRequest convertMatrixRequest(MatrixRequest request); static int convertMetrics(MatrixRequestEnums.Metrics[] metrics); }
|
@Test(expected = ParameterValueException.class) public void invalidLocationsTest() throws StatusCodeException { org.heigit.ors.api.requests.matrix.MatrixRequest springMatrixRequest = new org.heigit.ors.api.requests.matrix.MatrixRequest(new ArrayList<>()); springMatrixRequest.setProfile(APIEnums.Profile.DRIVING_CAR); springMatrixRequest.setSources(new String[]{"foo"}); springMatrixRequest.setDestinations(new String[]{"bar"}); MatrixRequestHandler.convertMatrixRequest(springMatrixRequest); }
|
public static org.heigit.ors.matrix.MatrixRequest convertMatrixRequest(MatrixRequest request) throws StatusCodeException { org.heigit.ors.matrix.MatrixRequest coreRequest = new org.heigit.ors.matrix.MatrixRequest(); int sources = request.getSources() == null ? request.getLocations().size() : request.getSources().length; int destinations = request.getDestinations() == null ? request.getLocations().size() : request.getDestinations().length; Coordinate[] locations = convertLocations(request.getLocations(), sources * destinations); coreRequest.setProfileType(convertToMatrixProfileType(request.getProfile())); if (request.hasMetrics()) coreRequest.setMetrics(convertMetrics(request.getMetrics())); if (request.hasDestinations()) coreRequest.setDestinations(convertDestinations(request.getDestinations(), locations)); else { coreRequest.setDestinations(convertDestinations(new String[]{"all"}, locations)); } if (request.hasSources()) coreRequest.setSources(convertSources(request.getSources(), locations)); else { coreRequest.setSources(convertSources(new String[]{"all"}, locations)); } if (request.hasId()) coreRequest.setId(request.getId()); if (request.hasOptimized()) coreRequest.setFlexibleMode(!request.getOptimized()); if (request.hasResolveLocations()) coreRequest.setResolveLocations(request.getResolveLocations()); if (request.hasUnits()) coreRequest.setUnits(convertUnits(request.getUnits())); return coreRequest; }
|
MatrixRequestHandler { public static org.heigit.ors.matrix.MatrixRequest convertMatrixRequest(MatrixRequest request) throws StatusCodeException { org.heigit.ors.matrix.MatrixRequest coreRequest = new org.heigit.ors.matrix.MatrixRequest(); int sources = request.getSources() == null ? request.getLocations().size() : request.getSources().length; int destinations = request.getDestinations() == null ? request.getLocations().size() : request.getDestinations().length; Coordinate[] locations = convertLocations(request.getLocations(), sources * destinations); coreRequest.setProfileType(convertToMatrixProfileType(request.getProfile())); if (request.hasMetrics()) coreRequest.setMetrics(convertMetrics(request.getMetrics())); if (request.hasDestinations()) coreRequest.setDestinations(convertDestinations(request.getDestinations(), locations)); else { coreRequest.setDestinations(convertDestinations(new String[]{"all"}, locations)); } if (request.hasSources()) coreRequest.setSources(convertSources(request.getSources(), locations)); else { coreRequest.setSources(convertSources(new String[]{"all"}, locations)); } if (request.hasId()) coreRequest.setId(request.getId()); if (request.hasOptimized()) coreRequest.setFlexibleMode(!request.getOptimized()); if (request.hasResolveLocations()) coreRequest.setResolveLocations(request.getResolveLocations()); if (request.hasUnits()) coreRequest.setUnits(convertUnits(request.getUnits())); return coreRequest; } }
|
MatrixRequestHandler { public static org.heigit.ors.matrix.MatrixRequest convertMatrixRequest(MatrixRequest request) throws StatusCodeException { org.heigit.ors.matrix.MatrixRequest coreRequest = new org.heigit.ors.matrix.MatrixRequest(); int sources = request.getSources() == null ? request.getLocations().size() : request.getSources().length; int destinations = request.getDestinations() == null ? request.getLocations().size() : request.getDestinations().length; Coordinate[] locations = convertLocations(request.getLocations(), sources * destinations); coreRequest.setProfileType(convertToMatrixProfileType(request.getProfile())); if (request.hasMetrics()) coreRequest.setMetrics(convertMetrics(request.getMetrics())); if (request.hasDestinations()) coreRequest.setDestinations(convertDestinations(request.getDestinations(), locations)); else { coreRequest.setDestinations(convertDestinations(new String[]{"all"}, locations)); } if (request.hasSources()) coreRequest.setSources(convertSources(request.getSources(), locations)); else { coreRequest.setSources(convertSources(new String[]{"all"}, locations)); } if (request.hasId()) coreRequest.setId(request.getId()); if (request.hasOptimized()) coreRequest.setFlexibleMode(!request.getOptimized()); if (request.hasResolveLocations()) coreRequest.setResolveLocations(request.getResolveLocations()); if (request.hasUnits()) coreRequest.setUnits(convertUnits(request.getUnits())); return coreRequest; } private MatrixRequestHandler(); }
|
MatrixRequestHandler { public static org.heigit.ors.matrix.MatrixRequest convertMatrixRequest(MatrixRequest request) throws StatusCodeException { org.heigit.ors.matrix.MatrixRequest coreRequest = new org.heigit.ors.matrix.MatrixRequest(); int sources = request.getSources() == null ? request.getLocations().size() : request.getSources().length; int destinations = request.getDestinations() == null ? request.getLocations().size() : request.getDestinations().length; Coordinate[] locations = convertLocations(request.getLocations(), sources * destinations); coreRequest.setProfileType(convertToMatrixProfileType(request.getProfile())); if (request.hasMetrics()) coreRequest.setMetrics(convertMetrics(request.getMetrics())); if (request.hasDestinations()) coreRequest.setDestinations(convertDestinations(request.getDestinations(), locations)); else { coreRequest.setDestinations(convertDestinations(new String[]{"all"}, locations)); } if (request.hasSources()) coreRequest.setSources(convertSources(request.getSources(), locations)); else { coreRequest.setSources(convertSources(new String[]{"all"}, locations)); } if (request.hasId()) coreRequest.setId(request.getId()); if (request.hasOptimized()) coreRequest.setFlexibleMode(!request.getOptimized()); if (request.hasResolveLocations()) coreRequest.setResolveLocations(request.getResolveLocations()); if (request.hasUnits()) coreRequest.setUnits(convertUnits(request.getUnits())); return coreRequest; } private MatrixRequestHandler(); static MatrixResult generateMatrixFromRequest(MatrixRequest request); static org.heigit.ors.matrix.MatrixRequest convertMatrixRequest(MatrixRequest request); static int convertMetrics(MatrixRequestEnums.Metrics[] metrics); }
|
MatrixRequestHandler { public static org.heigit.ors.matrix.MatrixRequest convertMatrixRequest(MatrixRequest request) throws StatusCodeException { org.heigit.ors.matrix.MatrixRequest coreRequest = new org.heigit.ors.matrix.MatrixRequest(); int sources = request.getSources() == null ? request.getLocations().size() : request.getSources().length; int destinations = request.getDestinations() == null ? request.getLocations().size() : request.getDestinations().length; Coordinate[] locations = convertLocations(request.getLocations(), sources * destinations); coreRequest.setProfileType(convertToMatrixProfileType(request.getProfile())); if (request.hasMetrics()) coreRequest.setMetrics(convertMetrics(request.getMetrics())); if (request.hasDestinations()) coreRequest.setDestinations(convertDestinations(request.getDestinations(), locations)); else { coreRequest.setDestinations(convertDestinations(new String[]{"all"}, locations)); } if (request.hasSources()) coreRequest.setSources(convertSources(request.getSources(), locations)); else { coreRequest.setSources(convertSources(new String[]{"all"}, locations)); } if (request.hasId()) coreRequest.setId(request.getId()); if (request.hasOptimized()) coreRequest.setFlexibleMode(!request.getOptimized()); if (request.hasResolveLocations()) coreRequest.setResolveLocations(request.getResolveLocations()); if (request.hasUnits()) coreRequest.setUnits(convertUnits(request.getUnits())); return coreRequest; } private MatrixRequestHandler(); static MatrixResult generateMatrixFromRequest(MatrixRequest request); static org.heigit.ors.matrix.MatrixRequest convertMatrixRequest(MatrixRequest request); static int convertMetrics(MatrixRequestEnums.Metrics[] metrics); }
|
@Test(expected = ParameterValueException.class) public void invalidMetricsTest() throws StatusCodeException { org.heigit.ors.api.requests.matrix.MatrixRequest springMatrixRequest = new org.heigit.ors.api.requests.matrix.MatrixRequest(new ArrayList<>()); springMatrixRequest.setProfile(APIEnums.Profile.DRIVING_CAR); springMatrixRequest.setLocations(listOfBareCoordinatesList); springMatrixRequest.setMetrics(new MatrixRequestEnums.Metrics[0]); springMatrixRequest.setSources(new String[]{"foo"}); springMatrixRequest.setDestinations(new String[]{"bar"}); MatrixRequestHandler.convertMatrixRequest(springMatrixRequest); }
|
public static org.heigit.ors.matrix.MatrixRequest convertMatrixRequest(MatrixRequest request) throws StatusCodeException { org.heigit.ors.matrix.MatrixRequest coreRequest = new org.heigit.ors.matrix.MatrixRequest(); int sources = request.getSources() == null ? request.getLocations().size() : request.getSources().length; int destinations = request.getDestinations() == null ? request.getLocations().size() : request.getDestinations().length; Coordinate[] locations = convertLocations(request.getLocations(), sources * destinations); coreRequest.setProfileType(convertToMatrixProfileType(request.getProfile())); if (request.hasMetrics()) coreRequest.setMetrics(convertMetrics(request.getMetrics())); if (request.hasDestinations()) coreRequest.setDestinations(convertDestinations(request.getDestinations(), locations)); else { coreRequest.setDestinations(convertDestinations(new String[]{"all"}, locations)); } if (request.hasSources()) coreRequest.setSources(convertSources(request.getSources(), locations)); else { coreRequest.setSources(convertSources(new String[]{"all"}, locations)); } if (request.hasId()) coreRequest.setId(request.getId()); if (request.hasOptimized()) coreRequest.setFlexibleMode(!request.getOptimized()); if (request.hasResolveLocations()) coreRequest.setResolveLocations(request.getResolveLocations()); if (request.hasUnits()) coreRequest.setUnits(convertUnits(request.getUnits())); return coreRequest; }
|
MatrixRequestHandler { public static org.heigit.ors.matrix.MatrixRequest convertMatrixRequest(MatrixRequest request) throws StatusCodeException { org.heigit.ors.matrix.MatrixRequest coreRequest = new org.heigit.ors.matrix.MatrixRequest(); int sources = request.getSources() == null ? request.getLocations().size() : request.getSources().length; int destinations = request.getDestinations() == null ? request.getLocations().size() : request.getDestinations().length; Coordinate[] locations = convertLocations(request.getLocations(), sources * destinations); coreRequest.setProfileType(convertToMatrixProfileType(request.getProfile())); if (request.hasMetrics()) coreRequest.setMetrics(convertMetrics(request.getMetrics())); if (request.hasDestinations()) coreRequest.setDestinations(convertDestinations(request.getDestinations(), locations)); else { coreRequest.setDestinations(convertDestinations(new String[]{"all"}, locations)); } if (request.hasSources()) coreRequest.setSources(convertSources(request.getSources(), locations)); else { coreRequest.setSources(convertSources(new String[]{"all"}, locations)); } if (request.hasId()) coreRequest.setId(request.getId()); if (request.hasOptimized()) coreRequest.setFlexibleMode(!request.getOptimized()); if (request.hasResolveLocations()) coreRequest.setResolveLocations(request.getResolveLocations()); if (request.hasUnits()) coreRequest.setUnits(convertUnits(request.getUnits())); return coreRequest; } }
|
MatrixRequestHandler { public static org.heigit.ors.matrix.MatrixRequest convertMatrixRequest(MatrixRequest request) throws StatusCodeException { org.heigit.ors.matrix.MatrixRequest coreRequest = new org.heigit.ors.matrix.MatrixRequest(); int sources = request.getSources() == null ? request.getLocations().size() : request.getSources().length; int destinations = request.getDestinations() == null ? request.getLocations().size() : request.getDestinations().length; Coordinate[] locations = convertLocations(request.getLocations(), sources * destinations); coreRequest.setProfileType(convertToMatrixProfileType(request.getProfile())); if (request.hasMetrics()) coreRequest.setMetrics(convertMetrics(request.getMetrics())); if (request.hasDestinations()) coreRequest.setDestinations(convertDestinations(request.getDestinations(), locations)); else { coreRequest.setDestinations(convertDestinations(new String[]{"all"}, locations)); } if (request.hasSources()) coreRequest.setSources(convertSources(request.getSources(), locations)); else { coreRequest.setSources(convertSources(new String[]{"all"}, locations)); } if (request.hasId()) coreRequest.setId(request.getId()); if (request.hasOptimized()) coreRequest.setFlexibleMode(!request.getOptimized()); if (request.hasResolveLocations()) coreRequest.setResolveLocations(request.getResolveLocations()); if (request.hasUnits()) coreRequest.setUnits(convertUnits(request.getUnits())); return coreRequest; } private MatrixRequestHandler(); }
|
MatrixRequestHandler { public static org.heigit.ors.matrix.MatrixRequest convertMatrixRequest(MatrixRequest request) throws StatusCodeException { org.heigit.ors.matrix.MatrixRequest coreRequest = new org.heigit.ors.matrix.MatrixRequest(); int sources = request.getSources() == null ? request.getLocations().size() : request.getSources().length; int destinations = request.getDestinations() == null ? request.getLocations().size() : request.getDestinations().length; Coordinate[] locations = convertLocations(request.getLocations(), sources * destinations); coreRequest.setProfileType(convertToMatrixProfileType(request.getProfile())); if (request.hasMetrics()) coreRequest.setMetrics(convertMetrics(request.getMetrics())); if (request.hasDestinations()) coreRequest.setDestinations(convertDestinations(request.getDestinations(), locations)); else { coreRequest.setDestinations(convertDestinations(new String[]{"all"}, locations)); } if (request.hasSources()) coreRequest.setSources(convertSources(request.getSources(), locations)); else { coreRequest.setSources(convertSources(new String[]{"all"}, locations)); } if (request.hasId()) coreRequest.setId(request.getId()); if (request.hasOptimized()) coreRequest.setFlexibleMode(!request.getOptimized()); if (request.hasResolveLocations()) coreRequest.setResolveLocations(request.getResolveLocations()); if (request.hasUnits()) coreRequest.setUnits(convertUnits(request.getUnits())); return coreRequest; } private MatrixRequestHandler(); static MatrixResult generateMatrixFromRequest(MatrixRequest request); static org.heigit.ors.matrix.MatrixRequest convertMatrixRequest(MatrixRequest request); static int convertMetrics(MatrixRequestEnums.Metrics[] metrics); }
|
MatrixRequestHandler { public static org.heigit.ors.matrix.MatrixRequest convertMatrixRequest(MatrixRequest request) throws StatusCodeException { org.heigit.ors.matrix.MatrixRequest coreRequest = new org.heigit.ors.matrix.MatrixRequest(); int sources = request.getSources() == null ? request.getLocations().size() : request.getSources().length; int destinations = request.getDestinations() == null ? request.getLocations().size() : request.getDestinations().length; Coordinate[] locations = convertLocations(request.getLocations(), sources * destinations); coreRequest.setProfileType(convertToMatrixProfileType(request.getProfile())); if (request.hasMetrics()) coreRequest.setMetrics(convertMetrics(request.getMetrics())); if (request.hasDestinations()) coreRequest.setDestinations(convertDestinations(request.getDestinations(), locations)); else { coreRequest.setDestinations(convertDestinations(new String[]{"all"}, locations)); } if (request.hasSources()) coreRequest.setSources(convertSources(request.getSources(), locations)); else { coreRequest.setSources(convertSources(new String[]{"all"}, locations)); } if (request.hasId()) coreRequest.setId(request.getId()); if (request.hasOptimized()) coreRequest.setFlexibleMode(!request.getOptimized()); if (request.hasResolveLocations()) coreRequest.setResolveLocations(request.getResolveLocations()); if (request.hasUnits()) coreRequest.setUnits(convertUnits(request.getUnits())); return coreRequest; } private MatrixRequestHandler(); static MatrixResult generateMatrixFromRequest(MatrixRequest request); static org.heigit.ors.matrix.MatrixRequest convertMatrixRequest(MatrixRequest request); static int convertMetrics(MatrixRequestEnums.Metrics[] metrics); }
|
@Test public void TestAvoidSpecificBorders() { _searchParams.setAvoidBorders(BordersExtractor.Avoid.NONE); _searchParams.setAvoidCountries(new int[] {1, 5}); AvoidBordersEdgeFilter filter = new AvoidBordersEdgeFilter(_searchParams, _graphStorage); VirtualEdgeIteratorState ve1 = generateEdge(1); VirtualEdgeIteratorState ve2 = generateEdge(2); VirtualEdgeIteratorState ve3 = generateEdge(3); assertFalse(filter.accept(ve1)); assertTrue(filter.accept(ve2)); assertFalse(filter.accept(ve3)); }
|
@Override public final boolean accept(EdgeIteratorState iter) { if (!isStorageBuilt) return true; if (avoidBorders != BordersExtractor.Avoid.NONE) { switch(avoidBorders) { case ALL: if(bordersExtractor.isBorder(iter.getEdge())) { return false; } break; case CONTROLLED: if(bordersExtractor.isControlledBorder(iter.getEdge())) { return false; } break; default: break; } } return !avoidCountries || !bordersExtractor.restrictedCountry(iter.getEdge()); }
|
AvoidBordersEdgeFilter implements EdgeFilter { @Override public final boolean accept(EdgeIteratorState iter) { if (!isStorageBuilt) return true; if (avoidBorders != BordersExtractor.Avoid.NONE) { switch(avoidBorders) { case ALL: if(bordersExtractor.isBorder(iter.getEdge())) { return false; } break; case CONTROLLED: if(bordersExtractor.isControlledBorder(iter.getEdge())) { return false; } break; default: break; } } return !avoidCountries || !bordersExtractor.restrictedCountry(iter.getEdge()); } }
|
AvoidBordersEdgeFilter implements EdgeFilter { @Override public final boolean accept(EdgeIteratorState iter) { if (!isStorageBuilt) return true; if (avoidBorders != BordersExtractor.Avoid.NONE) { switch(avoidBorders) { case ALL: if(bordersExtractor.isBorder(iter.getEdge())) { return false; } break; case CONTROLLED: if(bordersExtractor.isControlledBorder(iter.getEdge())) { return false; } break; default: break; } } return !avoidCountries || !bordersExtractor.restrictedCountry(iter.getEdge()); } AvoidBordersEdgeFilter(RouteSearchParameters searchParams, BordersGraphStorage extBorders); AvoidBordersEdgeFilter(RouteSearchParameters searchParams, GraphStorage graphStorage); }
|
AvoidBordersEdgeFilter implements EdgeFilter { @Override public final boolean accept(EdgeIteratorState iter) { if (!isStorageBuilt) return true; if (avoidBorders != BordersExtractor.Avoid.NONE) { switch(avoidBorders) { case ALL: if(bordersExtractor.isBorder(iter.getEdge())) { return false; } break; case CONTROLLED: if(bordersExtractor.isControlledBorder(iter.getEdge())) { return false; } break; default: break; } } return !avoidCountries || !bordersExtractor.restrictedCountry(iter.getEdge()); } AvoidBordersEdgeFilter(RouteSearchParameters searchParams, BordersGraphStorage extBorders); AvoidBordersEdgeFilter(RouteSearchParameters searchParams, GraphStorage graphStorage); @Override final boolean accept(EdgeIteratorState iter); }
|
AvoidBordersEdgeFilter implements EdgeFilter { @Override public final boolean accept(EdgeIteratorState iter) { if (!isStorageBuilt) return true; if (avoidBorders != BordersExtractor.Avoid.NONE) { switch(avoidBorders) { case ALL: if(bordersExtractor.isBorder(iter.getEdge())) { return false; } break; case CONTROLLED: if(bordersExtractor.isControlledBorder(iter.getEdge())) { return false; } break; default: break; } } return !avoidCountries || !bordersExtractor.restrictedCountry(iter.getEdge()); } AvoidBordersEdgeFilter(RouteSearchParameters searchParams, BordersGraphStorage extBorders); AvoidBordersEdgeFilter(RouteSearchParameters searchParams, GraphStorage graphStorage); @Override final boolean accept(EdgeIteratorState iter); }
|
@Test(expected = ParameterValueException.class) public void invalidSourceIndexTest() throws StatusCodeException { org.heigit.ors.api.requests.matrix.MatrixRequest springMatrixRequest = new org.heigit.ors.api.requests.matrix.MatrixRequest(new ArrayList<>()); springMatrixRequest.setProfile(APIEnums.Profile.DRIVING_CAR); springMatrixRequest.setLocations(listOfBareCoordinatesList); springMatrixRequest.setSources(new String[]{"foo"}); springMatrixRequest.setDestinations(new String[]{"bar"}); MatrixRequestHandler.convertMatrixRequest(springMatrixRequest); }
|
public static org.heigit.ors.matrix.MatrixRequest convertMatrixRequest(MatrixRequest request) throws StatusCodeException { org.heigit.ors.matrix.MatrixRequest coreRequest = new org.heigit.ors.matrix.MatrixRequest(); int sources = request.getSources() == null ? request.getLocations().size() : request.getSources().length; int destinations = request.getDestinations() == null ? request.getLocations().size() : request.getDestinations().length; Coordinate[] locations = convertLocations(request.getLocations(), sources * destinations); coreRequest.setProfileType(convertToMatrixProfileType(request.getProfile())); if (request.hasMetrics()) coreRequest.setMetrics(convertMetrics(request.getMetrics())); if (request.hasDestinations()) coreRequest.setDestinations(convertDestinations(request.getDestinations(), locations)); else { coreRequest.setDestinations(convertDestinations(new String[]{"all"}, locations)); } if (request.hasSources()) coreRequest.setSources(convertSources(request.getSources(), locations)); else { coreRequest.setSources(convertSources(new String[]{"all"}, locations)); } if (request.hasId()) coreRequest.setId(request.getId()); if (request.hasOptimized()) coreRequest.setFlexibleMode(!request.getOptimized()); if (request.hasResolveLocations()) coreRequest.setResolveLocations(request.getResolveLocations()); if (request.hasUnits()) coreRequest.setUnits(convertUnits(request.getUnits())); return coreRequest; }
|
MatrixRequestHandler { public static org.heigit.ors.matrix.MatrixRequest convertMatrixRequest(MatrixRequest request) throws StatusCodeException { org.heigit.ors.matrix.MatrixRequest coreRequest = new org.heigit.ors.matrix.MatrixRequest(); int sources = request.getSources() == null ? request.getLocations().size() : request.getSources().length; int destinations = request.getDestinations() == null ? request.getLocations().size() : request.getDestinations().length; Coordinate[] locations = convertLocations(request.getLocations(), sources * destinations); coreRequest.setProfileType(convertToMatrixProfileType(request.getProfile())); if (request.hasMetrics()) coreRequest.setMetrics(convertMetrics(request.getMetrics())); if (request.hasDestinations()) coreRequest.setDestinations(convertDestinations(request.getDestinations(), locations)); else { coreRequest.setDestinations(convertDestinations(new String[]{"all"}, locations)); } if (request.hasSources()) coreRequest.setSources(convertSources(request.getSources(), locations)); else { coreRequest.setSources(convertSources(new String[]{"all"}, locations)); } if (request.hasId()) coreRequest.setId(request.getId()); if (request.hasOptimized()) coreRequest.setFlexibleMode(!request.getOptimized()); if (request.hasResolveLocations()) coreRequest.setResolveLocations(request.getResolveLocations()); if (request.hasUnits()) coreRequest.setUnits(convertUnits(request.getUnits())); return coreRequest; } }
|
MatrixRequestHandler { public static org.heigit.ors.matrix.MatrixRequest convertMatrixRequest(MatrixRequest request) throws StatusCodeException { org.heigit.ors.matrix.MatrixRequest coreRequest = new org.heigit.ors.matrix.MatrixRequest(); int sources = request.getSources() == null ? request.getLocations().size() : request.getSources().length; int destinations = request.getDestinations() == null ? request.getLocations().size() : request.getDestinations().length; Coordinate[] locations = convertLocations(request.getLocations(), sources * destinations); coreRequest.setProfileType(convertToMatrixProfileType(request.getProfile())); if (request.hasMetrics()) coreRequest.setMetrics(convertMetrics(request.getMetrics())); if (request.hasDestinations()) coreRequest.setDestinations(convertDestinations(request.getDestinations(), locations)); else { coreRequest.setDestinations(convertDestinations(new String[]{"all"}, locations)); } if (request.hasSources()) coreRequest.setSources(convertSources(request.getSources(), locations)); else { coreRequest.setSources(convertSources(new String[]{"all"}, locations)); } if (request.hasId()) coreRequest.setId(request.getId()); if (request.hasOptimized()) coreRequest.setFlexibleMode(!request.getOptimized()); if (request.hasResolveLocations()) coreRequest.setResolveLocations(request.getResolveLocations()); if (request.hasUnits()) coreRequest.setUnits(convertUnits(request.getUnits())); return coreRequest; } private MatrixRequestHandler(); }
|
MatrixRequestHandler { public static org.heigit.ors.matrix.MatrixRequest convertMatrixRequest(MatrixRequest request) throws StatusCodeException { org.heigit.ors.matrix.MatrixRequest coreRequest = new org.heigit.ors.matrix.MatrixRequest(); int sources = request.getSources() == null ? request.getLocations().size() : request.getSources().length; int destinations = request.getDestinations() == null ? request.getLocations().size() : request.getDestinations().length; Coordinate[] locations = convertLocations(request.getLocations(), sources * destinations); coreRequest.setProfileType(convertToMatrixProfileType(request.getProfile())); if (request.hasMetrics()) coreRequest.setMetrics(convertMetrics(request.getMetrics())); if (request.hasDestinations()) coreRequest.setDestinations(convertDestinations(request.getDestinations(), locations)); else { coreRequest.setDestinations(convertDestinations(new String[]{"all"}, locations)); } if (request.hasSources()) coreRequest.setSources(convertSources(request.getSources(), locations)); else { coreRequest.setSources(convertSources(new String[]{"all"}, locations)); } if (request.hasId()) coreRequest.setId(request.getId()); if (request.hasOptimized()) coreRequest.setFlexibleMode(!request.getOptimized()); if (request.hasResolveLocations()) coreRequest.setResolveLocations(request.getResolveLocations()); if (request.hasUnits()) coreRequest.setUnits(convertUnits(request.getUnits())); return coreRequest; } private MatrixRequestHandler(); static MatrixResult generateMatrixFromRequest(MatrixRequest request); static org.heigit.ors.matrix.MatrixRequest convertMatrixRequest(MatrixRequest request); static int convertMetrics(MatrixRequestEnums.Metrics[] metrics); }
|
MatrixRequestHandler { public static org.heigit.ors.matrix.MatrixRequest convertMatrixRequest(MatrixRequest request) throws StatusCodeException { org.heigit.ors.matrix.MatrixRequest coreRequest = new org.heigit.ors.matrix.MatrixRequest(); int sources = request.getSources() == null ? request.getLocations().size() : request.getSources().length; int destinations = request.getDestinations() == null ? request.getLocations().size() : request.getDestinations().length; Coordinate[] locations = convertLocations(request.getLocations(), sources * destinations); coreRequest.setProfileType(convertToMatrixProfileType(request.getProfile())); if (request.hasMetrics()) coreRequest.setMetrics(convertMetrics(request.getMetrics())); if (request.hasDestinations()) coreRequest.setDestinations(convertDestinations(request.getDestinations(), locations)); else { coreRequest.setDestinations(convertDestinations(new String[]{"all"}, locations)); } if (request.hasSources()) coreRequest.setSources(convertSources(request.getSources(), locations)); else { coreRequest.setSources(convertSources(new String[]{"all"}, locations)); } if (request.hasId()) coreRequest.setId(request.getId()); if (request.hasOptimized()) coreRequest.setFlexibleMode(!request.getOptimized()); if (request.hasResolveLocations()) coreRequest.setResolveLocations(request.getResolveLocations()); if (request.hasUnits()) coreRequest.setUnits(convertUnits(request.getUnits())); return coreRequest; } private MatrixRequestHandler(); static MatrixResult generateMatrixFromRequest(MatrixRequest request); static org.heigit.ors.matrix.MatrixRequest convertMatrixRequest(MatrixRequest request); static int convertMetrics(MatrixRequestEnums.Metrics[] metrics); }
|
@Test(expected = ParameterValueException.class) public void invalidDestinationIndexTest() throws StatusCodeException { org.heigit.ors.api.requests.matrix.MatrixRequest springMatrixRequest = new org.heigit.ors.api.requests.matrix.MatrixRequest(new ArrayList<>()); springMatrixRequest.setProfile(APIEnums.Profile.DRIVING_CAR); springMatrixRequest.setLocations(listOfBareCoordinatesList); springMatrixRequest.setSources(new String[]{"all"}); springMatrixRequest.setDestinations(new String[]{"foo"}); MatrixRequestHandler.convertMatrixRequest(springMatrixRequest); }
|
public static org.heigit.ors.matrix.MatrixRequest convertMatrixRequest(MatrixRequest request) throws StatusCodeException { org.heigit.ors.matrix.MatrixRequest coreRequest = new org.heigit.ors.matrix.MatrixRequest(); int sources = request.getSources() == null ? request.getLocations().size() : request.getSources().length; int destinations = request.getDestinations() == null ? request.getLocations().size() : request.getDestinations().length; Coordinate[] locations = convertLocations(request.getLocations(), sources * destinations); coreRequest.setProfileType(convertToMatrixProfileType(request.getProfile())); if (request.hasMetrics()) coreRequest.setMetrics(convertMetrics(request.getMetrics())); if (request.hasDestinations()) coreRequest.setDestinations(convertDestinations(request.getDestinations(), locations)); else { coreRequest.setDestinations(convertDestinations(new String[]{"all"}, locations)); } if (request.hasSources()) coreRequest.setSources(convertSources(request.getSources(), locations)); else { coreRequest.setSources(convertSources(new String[]{"all"}, locations)); } if (request.hasId()) coreRequest.setId(request.getId()); if (request.hasOptimized()) coreRequest.setFlexibleMode(!request.getOptimized()); if (request.hasResolveLocations()) coreRequest.setResolveLocations(request.getResolveLocations()); if (request.hasUnits()) coreRequest.setUnits(convertUnits(request.getUnits())); return coreRequest; }
|
MatrixRequestHandler { public static org.heigit.ors.matrix.MatrixRequest convertMatrixRequest(MatrixRequest request) throws StatusCodeException { org.heigit.ors.matrix.MatrixRequest coreRequest = new org.heigit.ors.matrix.MatrixRequest(); int sources = request.getSources() == null ? request.getLocations().size() : request.getSources().length; int destinations = request.getDestinations() == null ? request.getLocations().size() : request.getDestinations().length; Coordinate[] locations = convertLocations(request.getLocations(), sources * destinations); coreRequest.setProfileType(convertToMatrixProfileType(request.getProfile())); if (request.hasMetrics()) coreRequest.setMetrics(convertMetrics(request.getMetrics())); if (request.hasDestinations()) coreRequest.setDestinations(convertDestinations(request.getDestinations(), locations)); else { coreRequest.setDestinations(convertDestinations(new String[]{"all"}, locations)); } if (request.hasSources()) coreRequest.setSources(convertSources(request.getSources(), locations)); else { coreRequest.setSources(convertSources(new String[]{"all"}, locations)); } if (request.hasId()) coreRequest.setId(request.getId()); if (request.hasOptimized()) coreRequest.setFlexibleMode(!request.getOptimized()); if (request.hasResolveLocations()) coreRequest.setResolveLocations(request.getResolveLocations()); if (request.hasUnits()) coreRequest.setUnits(convertUnits(request.getUnits())); return coreRequest; } }
|
MatrixRequestHandler { public static org.heigit.ors.matrix.MatrixRequest convertMatrixRequest(MatrixRequest request) throws StatusCodeException { org.heigit.ors.matrix.MatrixRequest coreRequest = new org.heigit.ors.matrix.MatrixRequest(); int sources = request.getSources() == null ? request.getLocations().size() : request.getSources().length; int destinations = request.getDestinations() == null ? request.getLocations().size() : request.getDestinations().length; Coordinate[] locations = convertLocations(request.getLocations(), sources * destinations); coreRequest.setProfileType(convertToMatrixProfileType(request.getProfile())); if (request.hasMetrics()) coreRequest.setMetrics(convertMetrics(request.getMetrics())); if (request.hasDestinations()) coreRequest.setDestinations(convertDestinations(request.getDestinations(), locations)); else { coreRequest.setDestinations(convertDestinations(new String[]{"all"}, locations)); } if (request.hasSources()) coreRequest.setSources(convertSources(request.getSources(), locations)); else { coreRequest.setSources(convertSources(new String[]{"all"}, locations)); } if (request.hasId()) coreRequest.setId(request.getId()); if (request.hasOptimized()) coreRequest.setFlexibleMode(!request.getOptimized()); if (request.hasResolveLocations()) coreRequest.setResolveLocations(request.getResolveLocations()); if (request.hasUnits()) coreRequest.setUnits(convertUnits(request.getUnits())); return coreRequest; } private MatrixRequestHandler(); }
|
MatrixRequestHandler { public static org.heigit.ors.matrix.MatrixRequest convertMatrixRequest(MatrixRequest request) throws StatusCodeException { org.heigit.ors.matrix.MatrixRequest coreRequest = new org.heigit.ors.matrix.MatrixRequest(); int sources = request.getSources() == null ? request.getLocations().size() : request.getSources().length; int destinations = request.getDestinations() == null ? request.getLocations().size() : request.getDestinations().length; Coordinate[] locations = convertLocations(request.getLocations(), sources * destinations); coreRequest.setProfileType(convertToMatrixProfileType(request.getProfile())); if (request.hasMetrics()) coreRequest.setMetrics(convertMetrics(request.getMetrics())); if (request.hasDestinations()) coreRequest.setDestinations(convertDestinations(request.getDestinations(), locations)); else { coreRequest.setDestinations(convertDestinations(new String[]{"all"}, locations)); } if (request.hasSources()) coreRequest.setSources(convertSources(request.getSources(), locations)); else { coreRequest.setSources(convertSources(new String[]{"all"}, locations)); } if (request.hasId()) coreRequest.setId(request.getId()); if (request.hasOptimized()) coreRequest.setFlexibleMode(!request.getOptimized()); if (request.hasResolveLocations()) coreRequest.setResolveLocations(request.getResolveLocations()); if (request.hasUnits()) coreRequest.setUnits(convertUnits(request.getUnits())); return coreRequest; } private MatrixRequestHandler(); static MatrixResult generateMatrixFromRequest(MatrixRequest request); static org.heigit.ors.matrix.MatrixRequest convertMatrixRequest(MatrixRequest request); static int convertMetrics(MatrixRequestEnums.Metrics[] metrics); }
|
MatrixRequestHandler { public static org.heigit.ors.matrix.MatrixRequest convertMatrixRequest(MatrixRequest request) throws StatusCodeException { org.heigit.ors.matrix.MatrixRequest coreRequest = new org.heigit.ors.matrix.MatrixRequest(); int sources = request.getSources() == null ? request.getLocations().size() : request.getSources().length; int destinations = request.getDestinations() == null ? request.getLocations().size() : request.getDestinations().length; Coordinate[] locations = convertLocations(request.getLocations(), sources * destinations); coreRequest.setProfileType(convertToMatrixProfileType(request.getProfile())); if (request.hasMetrics()) coreRequest.setMetrics(convertMetrics(request.getMetrics())); if (request.hasDestinations()) coreRequest.setDestinations(convertDestinations(request.getDestinations(), locations)); else { coreRequest.setDestinations(convertDestinations(new String[]{"all"}, locations)); } if (request.hasSources()) coreRequest.setSources(convertSources(request.getSources(), locations)); else { coreRequest.setSources(convertSources(new String[]{"all"}, locations)); } if (request.hasId()) coreRequest.setId(request.getId()); if (request.hasOptimized()) coreRequest.setFlexibleMode(!request.getOptimized()); if (request.hasResolveLocations()) coreRequest.setResolveLocations(request.getResolveLocations()); if (request.hasUnits()) coreRequest.setUnits(convertUnits(request.getUnits())); return coreRequest; } private MatrixRequestHandler(); static MatrixResult generateMatrixFromRequest(MatrixRequest request); static org.heigit.ors.matrix.MatrixRequest convertMatrixRequest(MatrixRequest request); static int convertMetrics(MatrixRequestEnums.Metrics[] metrics); }
|
@Test public void convertMetricsTest() throws ParameterValueException { Assert.assertEquals(1, MatrixRequestHandler.convertMetrics(new MatrixRequestEnums.Metrics[] {MatrixRequestEnums.Metrics.DURATION})); Assert.assertEquals(2, MatrixRequestHandler.convertMetrics(new MatrixRequestEnums.Metrics[] {MatrixRequestEnums.Metrics.DISTANCE})); Assert.assertEquals(3, MatrixRequestHandler.convertMetrics(new MatrixRequestEnums.Metrics[] {MatrixRequestEnums.Metrics.DURATION, MatrixRequestEnums.Metrics.DISTANCE})); }
|
public static int convertMetrics(MatrixRequestEnums.Metrics[] metrics) throws ParameterValueException { List<String> metricsAsStrings = new ArrayList<>(); for (int i=0; i<metrics.length; i++) { metricsAsStrings.add(metrics[i].toString()); } String concatMetrics = String.join("|", metricsAsStrings); int combined = MatrixMetricsType.getFromString(concatMetrics); if (combined == MatrixMetricsType.UNKNOWN) throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_METRICS); return combined; }
|
MatrixRequestHandler { public static int convertMetrics(MatrixRequestEnums.Metrics[] metrics) throws ParameterValueException { List<String> metricsAsStrings = new ArrayList<>(); for (int i=0; i<metrics.length; i++) { metricsAsStrings.add(metrics[i].toString()); } String concatMetrics = String.join("|", metricsAsStrings); int combined = MatrixMetricsType.getFromString(concatMetrics); if (combined == MatrixMetricsType.UNKNOWN) throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_METRICS); return combined; } }
|
MatrixRequestHandler { public static int convertMetrics(MatrixRequestEnums.Metrics[] metrics) throws ParameterValueException { List<String> metricsAsStrings = new ArrayList<>(); for (int i=0; i<metrics.length; i++) { metricsAsStrings.add(metrics[i].toString()); } String concatMetrics = String.join("|", metricsAsStrings); int combined = MatrixMetricsType.getFromString(concatMetrics); if (combined == MatrixMetricsType.UNKNOWN) throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_METRICS); return combined; } private MatrixRequestHandler(); }
|
MatrixRequestHandler { public static int convertMetrics(MatrixRequestEnums.Metrics[] metrics) throws ParameterValueException { List<String> metricsAsStrings = new ArrayList<>(); for (int i=0; i<metrics.length; i++) { metricsAsStrings.add(metrics[i].toString()); } String concatMetrics = String.join("|", metricsAsStrings); int combined = MatrixMetricsType.getFromString(concatMetrics); if (combined == MatrixMetricsType.UNKNOWN) throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_METRICS); return combined; } private MatrixRequestHandler(); static MatrixResult generateMatrixFromRequest(MatrixRequest request); static org.heigit.ors.matrix.MatrixRequest convertMatrixRequest(MatrixRequest request); static int convertMetrics(MatrixRequestEnums.Metrics[] metrics); }
|
MatrixRequestHandler { public static int convertMetrics(MatrixRequestEnums.Metrics[] metrics) throws ParameterValueException { List<String> metricsAsStrings = new ArrayList<>(); for (int i=0; i<metrics.length; i++) { metricsAsStrings.add(metrics[i].toString()); } String concatMetrics = String.join("|", metricsAsStrings); int combined = MatrixMetricsType.getFromString(concatMetrics); if (combined == MatrixMetricsType.UNKNOWN) throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_METRICS); return combined; } private MatrixRequestHandler(); static MatrixResult generateMatrixFromRequest(MatrixRequest request); static org.heigit.ors.matrix.MatrixRequest convertMatrixRequest(MatrixRequest request); static int convertMetrics(MatrixRequestEnums.Metrics[] metrics); }
|
@Test(expected = ParameterValueException.class) public void notEnoughLocationsTest() throws ParameterValueException, ServerLimitExceededException { MatrixRequestHandler.convertLocations(minimalLocations, 5); }
|
protected static Coordinate[] convertLocations(List<List<Double>> locations, int numberOfRoutes) throws ParameterValueException, ServerLimitExceededException { if (locations == null || locations.size() < 2) throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_LOCATIONS); int maximumNumberOfRoutes = MatrixServiceSettings.getMaximumRoutes(false); if (numberOfRoutes > maximumNumberOfRoutes) throw new ServerLimitExceededException(MatrixErrorCodes.PARAMETER_VALUE_EXCEEDS_MAXIMUM, "Only a total of " + maximumNumberOfRoutes + " routes are allowed."); ArrayList<Coordinate> locationCoordinates = new ArrayList<>(); for (List<Double> coordinate : locations) { locationCoordinates.add(convertSingleLocationCoordinate(coordinate)); } try { return locationCoordinates.toArray(new Coordinate[locations.size()]); } catch (NumberFormatException | ArrayStoreException | NullPointerException ex) { throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_LOCATIONS); } }
|
MatrixRequestHandler { protected static Coordinate[] convertLocations(List<List<Double>> locations, int numberOfRoutes) throws ParameterValueException, ServerLimitExceededException { if (locations == null || locations.size() < 2) throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_LOCATIONS); int maximumNumberOfRoutes = MatrixServiceSettings.getMaximumRoutes(false); if (numberOfRoutes > maximumNumberOfRoutes) throw new ServerLimitExceededException(MatrixErrorCodes.PARAMETER_VALUE_EXCEEDS_MAXIMUM, "Only a total of " + maximumNumberOfRoutes + " routes are allowed."); ArrayList<Coordinate> locationCoordinates = new ArrayList<>(); for (List<Double> coordinate : locations) { locationCoordinates.add(convertSingleLocationCoordinate(coordinate)); } try { return locationCoordinates.toArray(new Coordinate[locations.size()]); } catch (NumberFormatException | ArrayStoreException | NullPointerException ex) { throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_LOCATIONS); } } }
|
MatrixRequestHandler { protected static Coordinate[] convertLocations(List<List<Double>> locations, int numberOfRoutes) throws ParameterValueException, ServerLimitExceededException { if (locations == null || locations.size() < 2) throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_LOCATIONS); int maximumNumberOfRoutes = MatrixServiceSettings.getMaximumRoutes(false); if (numberOfRoutes > maximumNumberOfRoutes) throw new ServerLimitExceededException(MatrixErrorCodes.PARAMETER_VALUE_EXCEEDS_MAXIMUM, "Only a total of " + maximumNumberOfRoutes + " routes are allowed."); ArrayList<Coordinate> locationCoordinates = new ArrayList<>(); for (List<Double> coordinate : locations) { locationCoordinates.add(convertSingleLocationCoordinate(coordinate)); } try { return locationCoordinates.toArray(new Coordinate[locations.size()]); } catch (NumberFormatException | ArrayStoreException | NullPointerException ex) { throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_LOCATIONS); } } private MatrixRequestHandler(); }
|
MatrixRequestHandler { protected static Coordinate[] convertLocations(List<List<Double>> locations, int numberOfRoutes) throws ParameterValueException, ServerLimitExceededException { if (locations == null || locations.size() < 2) throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_LOCATIONS); int maximumNumberOfRoutes = MatrixServiceSettings.getMaximumRoutes(false); if (numberOfRoutes > maximumNumberOfRoutes) throw new ServerLimitExceededException(MatrixErrorCodes.PARAMETER_VALUE_EXCEEDS_MAXIMUM, "Only a total of " + maximumNumberOfRoutes + " routes are allowed."); ArrayList<Coordinate> locationCoordinates = new ArrayList<>(); for (List<Double> coordinate : locations) { locationCoordinates.add(convertSingleLocationCoordinate(coordinate)); } try { return locationCoordinates.toArray(new Coordinate[locations.size()]); } catch (NumberFormatException | ArrayStoreException | NullPointerException ex) { throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_LOCATIONS); } } private MatrixRequestHandler(); static MatrixResult generateMatrixFromRequest(MatrixRequest request); static org.heigit.ors.matrix.MatrixRequest convertMatrixRequest(MatrixRequest request); static int convertMetrics(MatrixRequestEnums.Metrics[] metrics); }
|
MatrixRequestHandler { protected static Coordinate[] convertLocations(List<List<Double>> locations, int numberOfRoutes) throws ParameterValueException, ServerLimitExceededException { if (locations == null || locations.size() < 2) throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_LOCATIONS); int maximumNumberOfRoutes = MatrixServiceSettings.getMaximumRoutes(false); if (numberOfRoutes > maximumNumberOfRoutes) throw new ServerLimitExceededException(MatrixErrorCodes.PARAMETER_VALUE_EXCEEDS_MAXIMUM, "Only a total of " + maximumNumberOfRoutes + " routes are allowed."); ArrayList<Coordinate> locationCoordinates = new ArrayList<>(); for (List<Double> coordinate : locations) { locationCoordinates.add(convertSingleLocationCoordinate(coordinate)); } try { return locationCoordinates.toArray(new Coordinate[locations.size()]); } catch (NumberFormatException | ArrayStoreException | NullPointerException ex) { throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_LOCATIONS); } } private MatrixRequestHandler(); static MatrixResult generateMatrixFromRequest(MatrixRequest request); static org.heigit.ors.matrix.MatrixRequest convertMatrixRequest(MatrixRequest request); static int convertMetrics(MatrixRequestEnums.Metrics[] metrics); }
|
@Test(expected = ServerLimitExceededException.class) public void maximumExceedingLocationsTest() throws ParameterValueException, ServerLimitExceededException { MatrixRequestHandler.convertLocations(listOfBareCoordinatesList, maximumRoutes); }
|
protected static Coordinate[] convertLocations(List<List<Double>> locations, int numberOfRoutes) throws ParameterValueException, ServerLimitExceededException { if (locations == null || locations.size() < 2) throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_LOCATIONS); int maximumNumberOfRoutes = MatrixServiceSettings.getMaximumRoutes(false); if (numberOfRoutes > maximumNumberOfRoutes) throw new ServerLimitExceededException(MatrixErrorCodes.PARAMETER_VALUE_EXCEEDS_MAXIMUM, "Only a total of " + maximumNumberOfRoutes + " routes are allowed."); ArrayList<Coordinate> locationCoordinates = new ArrayList<>(); for (List<Double> coordinate : locations) { locationCoordinates.add(convertSingleLocationCoordinate(coordinate)); } try { return locationCoordinates.toArray(new Coordinate[locations.size()]); } catch (NumberFormatException | ArrayStoreException | NullPointerException ex) { throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_LOCATIONS); } }
|
MatrixRequestHandler { protected static Coordinate[] convertLocations(List<List<Double>> locations, int numberOfRoutes) throws ParameterValueException, ServerLimitExceededException { if (locations == null || locations.size() < 2) throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_LOCATIONS); int maximumNumberOfRoutes = MatrixServiceSettings.getMaximumRoutes(false); if (numberOfRoutes > maximumNumberOfRoutes) throw new ServerLimitExceededException(MatrixErrorCodes.PARAMETER_VALUE_EXCEEDS_MAXIMUM, "Only a total of " + maximumNumberOfRoutes + " routes are allowed."); ArrayList<Coordinate> locationCoordinates = new ArrayList<>(); for (List<Double> coordinate : locations) { locationCoordinates.add(convertSingleLocationCoordinate(coordinate)); } try { return locationCoordinates.toArray(new Coordinate[locations.size()]); } catch (NumberFormatException | ArrayStoreException | NullPointerException ex) { throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_LOCATIONS); } } }
|
MatrixRequestHandler { protected static Coordinate[] convertLocations(List<List<Double>> locations, int numberOfRoutes) throws ParameterValueException, ServerLimitExceededException { if (locations == null || locations.size() < 2) throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_LOCATIONS); int maximumNumberOfRoutes = MatrixServiceSettings.getMaximumRoutes(false); if (numberOfRoutes > maximumNumberOfRoutes) throw new ServerLimitExceededException(MatrixErrorCodes.PARAMETER_VALUE_EXCEEDS_MAXIMUM, "Only a total of " + maximumNumberOfRoutes + " routes are allowed."); ArrayList<Coordinate> locationCoordinates = new ArrayList<>(); for (List<Double> coordinate : locations) { locationCoordinates.add(convertSingleLocationCoordinate(coordinate)); } try { return locationCoordinates.toArray(new Coordinate[locations.size()]); } catch (NumberFormatException | ArrayStoreException | NullPointerException ex) { throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_LOCATIONS); } } private MatrixRequestHandler(); }
|
MatrixRequestHandler { protected static Coordinate[] convertLocations(List<List<Double>> locations, int numberOfRoutes) throws ParameterValueException, ServerLimitExceededException { if (locations == null || locations.size() < 2) throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_LOCATIONS); int maximumNumberOfRoutes = MatrixServiceSettings.getMaximumRoutes(false); if (numberOfRoutes > maximumNumberOfRoutes) throw new ServerLimitExceededException(MatrixErrorCodes.PARAMETER_VALUE_EXCEEDS_MAXIMUM, "Only a total of " + maximumNumberOfRoutes + " routes are allowed."); ArrayList<Coordinate> locationCoordinates = new ArrayList<>(); for (List<Double> coordinate : locations) { locationCoordinates.add(convertSingleLocationCoordinate(coordinate)); } try { return locationCoordinates.toArray(new Coordinate[locations.size()]); } catch (NumberFormatException | ArrayStoreException | NullPointerException ex) { throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_LOCATIONS); } } private MatrixRequestHandler(); static MatrixResult generateMatrixFromRequest(MatrixRequest request); static org.heigit.ors.matrix.MatrixRequest convertMatrixRequest(MatrixRequest request); static int convertMetrics(MatrixRequestEnums.Metrics[] metrics); }
|
MatrixRequestHandler { protected static Coordinate[] convertLocations(List<List<Double>> locations, int numberOfRoutes) throws ParameterValueException, ServerLimitExceededException { if (locations == null || locations.size() < 2) throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_LOCATIONS); int maximumNumberOfRoutes = MatrixServiceSettings.getMaximumRoutes(false); if (numberOfRoutes > maximumNumberOfRoutes) throw new ServerLimitExceededException(MatrixErrorCodes.PARAMETER_VALUE_EXCEEDS_MAXIMUM, "Only a total of " + maximumNumberOfRoutes + " routes are allowed."); ArrayList<Coordinate> locationCoordinates = new ArrayList<>(); for (List<Double> coordinate : locations) { locationCoordinates.add(convertSingleLocationCoordinate(coordinate)); } try { return locationCoordinates.toArray(new Coordinate[locations.size()]); } catch (NumberFormatException | ArrayStoreException | NullPointerException ex) { throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_LOCATIONS); } } private MatrixRequestHandler(); static MatrixResult generateMatrixFromRequest(MatrixRequest request); static org.heigit.ors.matrix.MatrixRequest convertMatrixRequest(MatrixRequest request); static int convertMetrics(MatrixRequestEnums.Metrics[] metrics); }
|
@Test public void convertLocationsTest() throws ParameterValueException, ServerLimitExceededException { Coordinate[] coordinates = MatrixRequestHandler.convertLocations(listOfBareCoordinatesList, 3); Assert.assertEquals(8.681495, coordinates[0].x, 0); Assert.assertEquals(49.41461, coordinates[0].y, 0); Assert.assertEquals(Double.NaN, coordinates[0].z, 0); Assert.assertEquals(8.686507, coordinates[1].x, 0); Assert.assertEquals(49.41943, coordinates[1].y, 0); Assert.assertEquals(Double.NaN, coordinates[1].z, 0); Assert.assertEquals(8.687872, coordinates[2].x, 0); Assert.assertEquals(49.420318, coordinates[2].y, 0); Assert.assertEquals(Double.NaN, coordinates[2].z, 0); }
|
protected static Coordinate[] convertLocations(List<List<Double>> locations, int numberOfRoutes) throws ParameterValueException, ServerLimitExceededException { if (locations == null || locations.size() < 2) throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_LOCATIONS); int maximumNumberOfRoutes = MatrixServiceSettings.getMaximumRoutes(false); if (numberOfRoutes > maximumNumberOfRoutes) throw new ServerLimitExceededException(MatrixErrorCodes.PARAMETER_VALUE_EXCEEDS_MAXIMUM, "Only a total of " + maximumNumberOfRoutes + " routes are allowed."); ArrayList<Coordinate> locationCoordinates = new ArrayList<>(); for (List<Double> coordinate : locations) { locationCoordinates.add(convertSingleLocationCoordinate(coordinate)); } try { return locationCoordinates.toArray(new Coordinate[locations.size()]); } catch (NumberFormatException | ArrayStoreException | NullPointerException ex) { throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_LOCATIONS); } }
|
MatrixRequestHandler { protected static Coordinate[] convertLocations(List<List<Double>> locations, int numberOfRoutes) throws ParameterValueException, ServerLimitExceededException { if (locations == null || locations.size() < 2) throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_LOCATIONS); int maximumNumberOfRoutes = MatrixServiceSettings.getMaximumRoutes(false); if (numberOfRoutes > maximumNumberOfRoutes) throw new ServerLimitExceededException(MatrixErrorCodes.PARAMETER_VALUE_EXCEEDS_MAXIMUM, "Only a total of " + maximumNumberOfRoutes + " routes are allowed."); ArrayList<Coordinate> locationCoordinates = new ArrayList<>(); for (List<Double> coordinate : locations) { locationCoordinates.add(convertSingleLocationCoordinate(coordinate)); } try { return locationCoordinates.toArray(new Coordinate[locations.size()]); } catch (NumberFormatException | ArrayStoreException | NullPointerException ex) { throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_LOCATIONS); } } }
|
MatrixRequestHandler { protected static Coordinate[] convertLocations(List<List<Double>> locations, int numberOfRoutes) throws ParameterValueException, ServerLimitExceededException { if (locations == null || locations.size() < 2) throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_LOCATIONS); int maximumNumberOfRoutes = MatrixServiceSettings.getMaximumRoutes(false); if (numberOfRoutes > maximumNumberOfRoutes) throw new ServerLimitExceededException(MatrixErrorCodes.PARAMETER_VALUE_EXCEEDS_MAXIMUM, "Only a total of " + maximumNumberOfRoutes + " routes are allowed."); ArrayList<Coordinate> locationCoordinates = new ArrayList<>(); for (List<Double> coordinate : locations) { locationCoordinates.add(convertSingleLocationCoordinate(coordinate)); } try { return locationCoordinates.toArray(new Coordinate[locations.size()]); } catch (NumberFormatException | ArrayStoreException | NullPointerException ex) { throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_LOCATIONS); } } private MatrixRequestHandler(); }
|
MatrixRequestHandler { protected static Coordinate[] convertLocations(List<List<Double>> locations, int numberOfRoutes) throws ParameterValueException, ServerLimitExceededException { if (locations == null || locations.size() < 2) throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_LOCATIONS); int maximumNumberOfRoutes = MatrixServiceSettings.getMaximumRoutes(false); if (numberOfRoutes > maximumNumberOfRoutes) throw new ServerLimitExceededException(MatrixErrorCodes.PARAMETER_VALUE_EXCEEDS_MAXIMUM, "Only a total of " + maximumNumberOfRoutes + " routes are allowed."); ArrayList<Coordinate> locationCoordinates = new ArrayList<>(); for (List<Double> coordinate : locations) { locationCoordinates.add(convertSingleLocationCoordinate(coordinate)); } try { return locationCoordinates.toArray(new Coordinate[locations.size()]); } catch (NumberFormatException | ArrayStoreException | NullPointerException ex) { throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_LOCATIONS); } } private MatrixRequestHandler(); static MatrixResult generateMatrixFromRequest(MatrixRequest request); static org.heigit.ors.matrix.MatrixRequest convertMatrixRequest(MatrixRequest request); static int convertMetrics(MatrixRequestEnums.Metrics[] metrics); }
|
MatrixRequestHandler { protected static Coordinate[] convertLocations(List<List<Double>> locations, int numberOfRoutes) throws ParameterValueException, ServerLimitExceededException { if (locations == null || locations.size() < 2) throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_LOCATIONS); int maximumNumberOfRoutes = MatrixServiceSettings.getMaximumRoutes(false); if (numberOfRoutes > maximumNumberOfRoutes) throw new ServerLimitExceededException(MatrixErrorCodes.PARAMETER_VALUE_EXCEEDS_MAXIMUM, "Only a total of " + maximumNumberOfRoutes + " routes are allowed."); ArrayList<Coordinate> locationCoordinates = new ArrayList<>(); for (List<Double> coordinate : locations) { locationCoordinates.add(convertSingleLocationCoordinate(coordinate)); } try { return locationCoordinates.toArray(new Coordinate[locations.size()]); } catch (NumberFormatException | ArrayStoreException | NullPointerException ex) { throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_LOCATIONS); } } private MatrixRequestHandler(); static MatrixResult generateMatrixFromRequest(MatrixRequest request); static org.heigit.ors.matrix.MatrixRequest convertMatrixRequest(MatrixRequest request); static int convertMetrics(MatrixRequestEnums.Metrics[] metrics); }
|
@Test public void convertSingleLocationCoordinateTest() throws ParameterValueException { List<Double> locationsList = new ArrayList<>(); locationsList.add(8.681495); locationsList.add(49.41461); Coordinate coordinates = MatrixRequestHandler.convertSingleLocationCoordinate(locationsList); Assert.assertEquals(8.681495, coordinates.x, 0); Assert.assertEquals(49.41461, coordinates.y, 0); Assert.assertEquals(Double.NaN, coordinates.z, 0); }
|
protected static Coordinate convertSingleLocationCoordinate(List<Double> coordinate) throws ParameterValueException { if (coordinate.size() != 2) throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_LOCATIONS); return new Coordinate(coordinate.get(0), coordinate.get(1)); }
|
MatrixRequestHandler { protected static Coordinate convertSingleLocationCoordinate(List<Double> coordinate) throws ParameterValueException { if (coordinate.size() != 2) throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_LOCATIONS); return new Coordinate(coordinate.get(0), coordinate.get(1)); } }
|
MatrixRequestHandler { protected static Coordinate convertSingleLocationCoordinate(List<Double> coordinate) throws ParameterValueException { if (coordinate.size() != 2) throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_LOCATIONS); return new Coordinate(coordinate.get(0), coordinate.get(1)); } private MatrixRequestHandler(); }
|
MatrixRequestHandler { protected static Coordinate convertSingleLocationCoordinate(List<Double> coordinate) throws ParameterValueException { if (coordinate.size() != 2) throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_LOCATIONS); return new Coordinate(coordinate.get(0), coordinate.get(1)); } private MatrixRequestHandler(); static MatrixResult generateMatrixFromRequest(MatrixRequest request); static org.heigit.ors.matrix.MatrixRequest convertMatrixRequest(MatrixRequest request); static int convertMetrics(MatrixRequestEnums.Metrics[] metrics); }
|
MatrixRequestHandler { protected static Coordinate convertSingleLocationCoordinate(List<Double> coordinate) throws ParameterValueException { if (coordinate.size() != 2) throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_LOCATIONS); return new Coordinate(coordinate.get(0), coordinate.get(1)); } private MatrixRequestHandler(); static MatrixResult generateMatrixFromRequest(MatrixRequest request); static org.heigit.ors.matrix.MatrixRequest convertMatrixRequest(MatrixRequest request); static int convertMetrics(MatrixRequestEnums.Metrics[] metrics); }
|
@Test(expected = ParameterValueException.class) public void convertWrongSingleLocationCoordinateTest() throws ParameterValueException { List<Double> locationsList = new ArrayList<>(); locationsList.add(8.681495); locationsList.add(49.41461); locationsList.add(123.0); MatrixRequestHandler.convertSingleLocationCoordinate(locationsList); }
|
protected static Coordinate convertSingleLocationCoordinate(List<Double> coordinate) throws ParameterValueException { if (coordinate.size() != 2) throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_LOCATIONS); return new Coordinate(coordinate.get(0), coordinate.get(1)); }
|
MatrixRequestHandler { protected static Coordinate convertSingleLocationCoordinate(List<Double> coordinate) throws ParameterValueException { if (coordinate.size() != 2) throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_LOCATIONS); return new Coordinate(coordinate.get(0), coordinate.get(1)); } }
|
MatrixRequestHandler { protected static Coordinate convertSingleLocationCoordinate(List<Double> coordinate) throws ParameterValueException { if (coordinate.size() != 2) throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_LOCATIONS); return new Coordinate(coordinate.get(0), coordinate.get(1)); } private MatrixRequestHandler(); }
|
MatrixRequestHandler { protected static Coordinate convertSingleLocationCoordinate(List<Double> coordinate) throws ParameterValueException { if (coordinate.size() != 2) throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_LOCATIONS); return new Coordinate(coordinate.get(0), coordinate.get(1)); } private MatrixRequestHandler(); static MatrixResult generateMatrixFromRequest(MatrixRequest request); static org.heigit.ors.matrix.MatrixRequest convertMatrixRequest(MatrixRequest request); static int convertMetrics(MatrixRequestEnums.Metrics[] metrics); }
|
MatrixRequestHandler { protected static Coordinate convertSingleLocationCoordinate(List<Double> coordinate) throws ParameterValueException { if (coordinate.size() != 2) throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_LOCATIONS); return new Coordinate(coordinate.get(0), coordinate.get(1)); } private MatrixRequestHandler(); static MatrixResult generateMatrixFromRequest(MatrixRequest request); static org.heigit.ors.matrix.MatrixRequest convertMatrixRequest(MatrixRequest request); static int convertMetrics(MatrixRequestEnums.Metrics[] metrics); }
|
@Test public void convertSourcesTest() throws ParameterValueException { String[] emptySources = new String[0]; Coordinate[] convertedSources = MatrixRequestHandler.convertSources(emptySources, this.coordinates); Assert.assertEquals(8.681495, convertedSources[0].x, 0); Assert.assertEquals(49.41461, convertedSources[0].y, 0); Assert.assertEquals(Double.NaN, convertedSources[0].z, 0); Assert.assertEquals(8.686507, convertedSources[1].x, 0); Assert.assertEquals(49.41943, convertedSources[1].y, 0); Assert.assertEquals(Double.NaN, convertedSources[1].z, 0); Assert.assertEquals(8.687872, convertedSources[2].x, 0); Assert.assertEquals(49.420318, convertedSources[2].y, 0); Assert.assertEquals(Double.NaN, convertedSources[2].z, 0); String[] allSources = new String[]{"all"}; convertedSources = MatrixRequestHandler.convertSources(allSources, this.coordinates); Assert.assertEquals(8.681495, convertedSources[0].x, 0); Assert.assertEquals(49.41461, convertedSources[0].y, 0); Assert.assertEquals(Double.NaN, convertedSources[0].z, 0); Assert.assertEquals(8.686507, convertedSources[1].x, 0); Assert.assertEquals(49.41943, convertedSources[1].y, 0); Assert.assertEquals(Double.NaN, convertedSources[1].z, 0); Assert.assertEquals(8.687872, convertedSources[2].x, 0); Assert.assertEquals(49.420318, convertedSources[2].y, 0); Assert.assertEquals(Double.NaN, convertedSources[2].z, 0); String[] secondSource = new String[]{"1"}; convertedSources = MatrixRequestHandler.convertSources(secondSource, this.coordinates); Assert.assertEquals(8.686507, convertedSources[0].x, 0); Assert.assertEquals(49.41943, convertedSources[0].y, 0); Assert.assertEquals(Double.NaN, convertedSources[0].z, 0); }
|
protected static Coordinate[] convertSources(String[] sourcesIndex, Coordinate[] locations) throws ParameterValueException { int length = sourcesIndex.length; if (length == 0) return locations; if (length == 1 && "all".equalsIgnoreCase(sourcesIndex[0])) return locations; try { ArrayList<Coordinate> indexCoordinateArray = convertIndexToLocations(sourcesIndex, locations); return indexCoordinateArray.toArray(new Coordinate[0]); } catch (Exception ex) { throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_SOURCES); } }
|
MatrixRequestHandler { protected static Coordinate[] convertSources(String[] sourcesIndex, Coordinate[] locations) throws ParameterValueException { int length = sourcesIndex.length; if (length == 0) return locations; if (length == 1 && "all".equalsIgnoreCase(sourcesIndex[0])) return locations; try { ArrayList<Coordinate> indexCoordinateArray = convertIndexToLocations(sourcesIndex, locations); return indexCoordinateArray.toArray(new Coordinate[0]); } catch (Exception ex) { throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_SOURCES); } } }
|
MatrixRequestHandler { protected static Coordinate[] convertSources(String[] sourcesIndex, Coordinate[] locations) throws ParameterValueException { int length = sourcesIndex.length; if (length == 0) return locations; if (length == 1 && "all".equalsIgnoreCase(sourcesIndex[0])) return locations; try { ArrayList<Coordinate> indexCoordinateArray = convertIndexToLocations(sourcesIndex, locations); return indexCoordinateArray.toArray(new Coordinate[0]); } catch (Exception ex) { throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_SOURCES); } } private MatrixRequestHandler(); }
|
MatrixRequestHandler { protected static Coordinate[] convertSources(String[] sourcesIndex, Coordinate[] locations) throws ParameterValueException { int length = sourcesIndex.length; if (length == 0) return locations; if (length == 1 && "all".equalsIgnoreCase(sourcesIndex[0])) return locations; try { ArrayList<Coordinate> indexCoordinateArray = convertIndexToLocations(sourcesIndex, locations); return indexCoordinateArray.toArray(new Coordinate[0]); } catch (Exception ex) { throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_SOURCES); } } private MatrixRequestHandler(); static MatrixResult generateMatrixFromRequest(MatrixRequest request); static org.heigit.ors.matrix.MatrixRequest convertMatrixRequest(MatrixRequest request); static int convertMetrics(MatrixRequestEnums.Metrics[] metrics); }
|
MatrixRequestHandler { protected static Coordinate[] convertSources(String[] sourcesIndex, Coordinate[] locations) throws ParameterValueException { int length = sourcesIndex.length; if (length == 0) return locations; if (length == 1 && "all".equalsIgnoreCase(sourcesIndex[0])) return locations; try { ArrayList<Coordinate> indexCoordinateArray = convertIndexToLocations(sourcesIndex, locations); return indexCoordinateArray.toArray(new Coordinate[0]); } catch (Exception ex) { throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_SOURCES); } } private MatrixRequestHandler(); static MatrixResult generateMatrixFromRequest(MatrixRequest request); static org.heigit.ors.matrix.MatrixRequest convertMatrixRequest(MatrixRequest request); static int convertMetrics(MatrixRequestEnums.Metrics[] metrics); }
|
@Test(expected = ParameterValueException.class) public void convertWrongSourcesTest() throws ParameterValueException { String[] wrongSource = new String[]{"foo"}; MatrixRequestHandler.convertSources(wrongSource, this.coordinates); }
|
protected static Coordinate[] convertSources(String[] sourcesIndex, Coordinate[] locations) throws ParameterValueException { int length = sourcesIndex.length; if (length == 0) return locations; if (length == 1 && "all".equalsIgnoreCase(sourcesIndex[0])) return locations; try { ArrayList<Coordinate> indexCoordinateArray = convertIndexToLocations(sourcesIndex, locations); return indexCoordinateArray.toArray(new Coordinate[0]); } catch (Exception ex) { throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_SOURCES); } }
|
MatrixRequestHandler { protected static Coordinate[] convertSources(String[] sourcesIndex, Coordinate[] locations) throws ParameterValueException { int length = sourcesIndex.length; if (length == 0) return locations; if (length == 1 && "all".equalsIgnoreCase(sourcesIndex[0])) return locations; try { ArrayList<Coordinate> indexCoordinateArray = convertIndexToLocations(sourcesIndex, locations); return indexCoordinateArray.toArray(new Coordinate[0]); } catch (Exception ex) { throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_SOURCES); } } }
|
MatrixRequestHandler { protected static Coordinate[] convertSources(String[] sourcesIndex, Coordinate[] locations) throws ParameterValueException { int length = sourcesIndex.length; if (length == 0) return locations; if (length == 1 && "all".equalsIgnoreCase(sourcesIndex[0])) return locations; try { ArrayList<Coordinate> indexCoordinateArray = convertIndexToLocations(sourcesIndex, locations); return indexCoordinateArray.toArray(new Coordinate[0]); } catch (Exception ex) { throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_SOURCES); } } private MatrixRequestHandler(); }
|
MatrixRequestHandler { protected static Coordinate[] convertSources(String[] sourcesIndex, Coordinate[] locations) throws ParameterValueException { int length = sourcesIndex.length; if (length == 0) return locations; if (length == 1 && "all".equalsIgnoreCase(sourcesIndex[0])) return locations; try { ArrayList<Coordinate> indexCoordinateArray = convertIndexToLocations(sourcesIndex, locations); return indexCoordinateArray.toArray(new Coordinate[0]); } catch (Exception ex) { throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_SOURCES); } } private MatrixRequestHandler(); static MatrixResult generateMatrixFromRequest(MatrixRequest request); static org.heigit.ors.matrix.MatrixRequest convertMatrixRequest(MatrixRequest request); static int convertMetrics(MatrixRequestEnums.Metrics[] metrics); }
|
MatrixRequestHandler { protected static Coordinate[] convertSources(String[] sourcesIndex, Coordinate[] locations) throws ParameterValueException { int length = sourcesIndex.length; if (length == 0) return locations; if (length == 1 && "all".equalsIgnoreCase(sourcesIndex[0])) return locations; try { ArrayList<Coordinate> indexCoordinateArray = convertIndexToLocations(sourcesIndex, locations); return indexCoordinateArray.toArray(new Coordinate[0]); } catch (Exception ex) { throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_SOURCES); } } private MatrixRequestHandler(); static MatrixResult generateMatrixFromRequest(MatrixRequest request); static org.heigit.ors.matrix.MatrixRequest convertMatrixRequest(MatrixRequest request); static int convertMetrics(MatrixRequestEnums.Metrics[] metrics); }
|
@Test public void TestAvoidSpecificAndControlledBorders() { _searchParams.setAvoidBorders(BordersExtractor.Avoid.CONTROLLED); _searchParams.setAvoidCountries(new int[] {3}); AvoidBordersEdgeFilter filter = new AvoidBordersEdgeFilter(_searchParams, _graphStorage); VirtualEdgeIteratorState ve1 = generateEdge(1); VirtualEdgeIteratorState ve2 = generateEdge(2); VirtualEdgeIteratorState ve3 = generateEdge(3); assertFalse(filter.accept(ve1)); assertFalse(filter.accept(ve2)); assertTrue(filter.accept(ve3)); }
|
@Override public final boolean accept(EdgeIteratorState iter) { if (!isStorageBuilt) return true; if (avoidBorders != BordersExtractor.Avoid.NONE) { switch(avoidBorders) { case ALL: if(bordersExtractor.isBorder(iter.getEdge())) { return false; } break; case CONTROLLED: if(bordersExtractor.isControlledBorder(iter.getEdge())) { return false; } break; default: break; } } return !avoidCountries || !bordersExtractor.restrictedCountry(iter.getEdge()); }
|
AvoidBordersEdgeFilter implements EdgeFilter { @Override public final boolean accept(EdgeIteratorState iter) { if (!isStorageBuilt) return true; if (avoidBorders != BordersExtractor.Avoid.NONE) { switch(avoidBorders) { case ALL: if(bordersExtractor.isBorder(iter.getEdge())) { return false; } break; case CONTROLLED: if(bordersExtractor.isControlledBorder(iter.getEdge())) { return false; } break; default: break; } } return !avoidCountries || !bordersExtractor.restrictedCountry(iter.getEdge()); } }
|
AvoidBordersEdgeFilter implements EdgeFilter { @Override public final boolean accept(EdgeIteratorState iter) { if (!isStorageBuilt) return true; if (avoidBorders != BordersExtractor.Avoid.NONE) { switch(avoidBorders) { case ALL: if(bordersExtractor.isBorder(iter.getEdge())) { return false; } break; case CONTROLLED: if(bordersExtractor.isControlledBorder(iter.getEdge())) { return false; } break; default: break; } } return !avoidCountries || !bordersExtractor.restrictedCountry(iter.getEdge()); } AvoidBordersEdgeFilter(RouteSearchParameters searchParams, BordersGraphStorage extBorders); AvoidBordersEdgeFilter(RouteSearchParameters searchParams, GraphStorage graphStorage); }
|
AvoidBordersEdgeFilter implements EdgeFilter { @Override public final boolean accept(EdgeIteratorState iter) { if (!isStorageBuilt) return true; if (avoidBorders != BordersExtractor.Avoid.NONE) { switch(avoidBorders) { case ALL: if(bordersExtractor.isBorder(iter.getEdge())) { return false; } break; case CONTROLLED: if(bordersExtractor.isControlledBorder(iter.getEdge())) { return false; } break; default: break; } } return !avoidCountries || !bordersExtractor.restrictedCountry(iter.getEdge()); } AvoidBordersEdgeFilter(RouteSearchParameters searchParams, BordersGraphStorage extBorders); AvoidBordersEdgeFilter(RouteSearchParameters searchParams, GraphStorage graphStorage); @Override final boolean accept(EdgeIteratorState iter); }
|
AvoidBordersEdgeFilter implements EdgeFilter { @Override public final boolean accept(EdgeIteratorState iter) { if (!isStorageBuilt) return true; if (avoidBorders != BordersExtractor.Avoid.NONE) { switch(avoidBorders) { case ALL: if(bordersExtractor.isBorder(iter.getEdge())) { return false; } break; case CONTROLLED: if(bordersExtractor.isControlledBorder(iter.getEdge())) { return false; } break; default: break; } } return !avoidCountries || !bordersExtractor.restrictedCountry(iter.getEdge()); } AvoidBordersEdgeFilter(RouteSearchParameters searchParams, BordersGraphStorage extBorders); AvoidBordersEdgeFilter(RouteSearchParameters searchParams, GraphStorage graphStorage); @Override final boolean accept(EdgeIteratorState iter); }
|
@Test public void convertDestinationsTest() throws ParameterValueException { String[] emptyDestinations = new String[0]; Coordinate[] convertedDestinations = MatrixRequestHandler.convertDestinations(emptyDestinations, this.coordinates); Assert.assertEquals(8.681495, convertedDestinations[0].x, 0); Assert.assertEquals(49.41461, convertedDestinations[0].y, 0); Assert.assertEquals(Double.NaN, convertedDestinations[0].z, 0); Assert.assertEquals(8.686507, convertedDestinations[1].x, 0); Assert.assertEquals(49.41943, convertedDestinations[1].y, 0); Assert.assertEquals(Double.NaN, convertedDestinations[1].z, 0); Assert.assertEquals(8.687872, convertedDestinations[2].x, 0); Assert.assertEquals(49.420318, convertedDestinations[2].y, 0); Assert.assertEquals(Double.NaN, convertedDestinations[2].z, 0); String[] allDestinations = new String[]{"all"}; convertedDestinations = MatrixRequestHandler.convertDestinations(allDestinations, this.coordinates); Assert.assertEquals(8.681495, convertedDestinations[0].x, 0); Assert.assertEquals(49.41461, convertedDestinations[0].y, 0); Assert.assertEquals(Double.NaN, convertedDestinations[0].z, 0); Assert.assertEquals(8.686507, convertedDestinations[1].x, 0); Assert.assertEquals(49.41943, convertedDestinations[1].y, 0); Assert.assertEquals(Double.NaN, convertedDestinations[1].z, 0); Assert.assertEquals(8.687872, convertedDestinations[2].x, 0); Assert.assertEquals(49.420318, convertedDestinations[2].y, 0); Assert.assertEquals(Double.NaN, convertedDestinations[2].z, 0); String[] secondDestination = new String[]{"1"}; convertedDestinations = MatrixRequestHandler.convertDestinations(secondDestination, this.coordinates); Assert.assertEquals(8.686507, convertedDestinations[0].x, 0); Assert.assertEquals(49.41943, convertedDestinations[0].y, 0); Assert.assertEquals(Double.NaN, convertedDestinations[0].z, 0); }
|
protected static Coordinate[] convertDestinations(String[] destinationsIndex, Coordinate[] locations) throws ParameterValueException { int length = destinationsIndex.length; if (length == 0) return locations; if (length == 1 && "all".equalsIgnoreCase(destinationsIndex[0])) return locations; try { ArrayList<Coordinate> indexCoordinateArray = convertIndexToLocations(destinationsIndex, locations); return indexCoordinateArray.toArray(new Coordinate[0]); } catch (Exception ex) { throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_DESTINATIONS); } }
|
MatrixRequestHandler { protected static Coordinate[] convertDestinations(String[] destinationsIndex, Coordinate[] locations) throws ParameterValueException { int length = destinationsIndex.length; if (length == 0) return locations; if (length == 1 && "all".equalsIgnoreCase(destinationsIndex[0])) return locations; try { ArrayList<Coordinate> indexCoordinateArray = convertIndexToLocations(destinationsIndex, locations); return indexCoordinateArray.toArray(new Coordinate[0]); } catch (Exception ex) { throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_DESTINATIONS); } } }
|
MatrixRequestHandler { protected static Coordinate[] convertDestinations(String[] destinationsIndex, Coordinate[] locations) throws ParameterValueException { int length = destinationsIndex.length; if (length == 0) return locations; if (length == 1 && "all".equalsIgnoreCase(destinationsIndex[0])) return locations; try { ArrayList<Coordinate> indexCoordinateArray = convertIndexToLocations(destinationsIndex, locations); return indexCoordinateArray.toArray(new Coordinate[0]); } catch (Exception ex) { throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_DESTINATIONS); } } private MatrixRequestHandler(); }
|
MatrixRequestHandler { protected static Coordinate[] convertDestinations(String[] destinationsIndex, Coordinate[] locations) throws ParameterValueException { int length = destinationsIndex.length; if (length == 0) return locations; if (length == 1 && "all".equalsIgnoreCase(destinationsIndex[0])) return locations; try { ArrayList<Coordinate> indexCoordinateArray = convertIndexToLocations(destinationsIndex, locations); return indexCoordinateArray.toArray(new Coordinate[0]); } catch (Exception ex) { throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_DESTINATIONS); } } private MatrixRequestHandler(); static MatrixResult generateMatrixFromRequest(MatrixRequest request); static org.heigit.ors.matrix.MatrixRequest convertMatrixRequest(MatrixRequest request); static int convertMetrics(MatrixRequestEnums.Metrics[] metrics); }
|
MatrixRequestHandler { protected static Coordinate[] convertDestinations(String[] destinationsIndex, Coordinate[] locations) throws ParameterValueException { int length = destinationsIndex.length; if (length == 0) return locations; if (length == 1 && "all".equalsIgnoreCase(destinationsIndex[0])) return locations; try { ArrayList<Coordinate> indexCoordinateArray = convertIndexToLocations(destinationsIndex, locations); return indexCoordinateArray.toArray(new Coordinate[0]); } catch (Exception ex) { throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_DESTINATIONS); } } private MatrixRequestHandler(); static MatrixResult generateMatrixFromRequest(MatrixRequest request); static org.heigit.ors.matrix.MatrixRequest convertMatrixRequest(MatrixRequest request); static int convertMetrics(MatrixRequestEnums.Metrics[] metrics); }
|
@Test(expected = ParameterValueException.class) public void convertWrongDestinationsTest() throws ParameterValueException { String[] wrongDestinations = new String[]{"foo"}; MatrixRequestHandler.convertDestinations(wrongDestinations, this.coordinates); }
|
protected static Coordinate[] convertDestinations(String[] destinationsIndex, Coordinate[] locations) throws ParameterValueException { int length = destinationsIndex.length; if (length == 0) return locations; if (length == 1 && "all".equalsIgnoreCase(destinationsIndex[0])) return locations; try { ArrayList<Coordinate> indexCoordinateArray = convertIndexToLocations(destinationsIndex, locations); return indexCoordinateArray.toArray(new Coordinate[0]); } catch (Exception ex) { throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_DESTINATIONS); } }
|
MatrixRequestHandler { protected static Coordinate[] convertDestinations(String[] destinationsIndex, Coordinate[] locations) throws ParameterValueException { int length = destinationsIndex.length; if (length == 0) return locations; if (length == 1 && "all".equalsIgnoreCase(destinationsIndex[0])) return locations; try { ArrayList<Coordinate> indexCoordinateArray = convertIndexToLocations(destinationsIndex, locations); return indexCoordinateArray.toArray(new Coordinate[0]); } catch (Exception ex) { throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_DESTINATIONS); } } }
|
MatrixRequestHandler { protected static Coordinate[] convertDestinations(String[] destinationsIndex, Coordinate[] locations) throws ParameterValueException { int length = destinationsIndex.length; if (length == 0) return locations; if (length == 1 && "all".equalsIgnoreCase(destinationsIndex[0])) return locations; try { ArrayList<Coordinate> indexCoordinateArray = convertIndexToLocations(destinationsIndex, locations); return indexCoordinateArray.toArray(new Coordinate[0]); } catch (Exception ex) { throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_DESTINATIONS); } } private MatrixRequestHandler(); }
|
MatrixRequestHandler { protected static Coordinate[] convertDestinations(String[] destinationsIndex, Coordinate[] locations) throws ParameterValueException { int length = destinationsIndex.length; if (length == 0) return locations; if (length == 1 && "all".equalsIgnoreCase(destinationsIndex[0])) return locations; try { ArrayList<Coordinate> indexCoordinateArray = convertIndexToLocations(destinationsIndex, locations); return indexCoordinateArray.toArray(new Coordinate[0]); } catch (Exception ex) { throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_DESTINATIONS); } } private MatrixRequestHandler(); static MatrixResult generateMatrixFromRequest(MatrixRequest request); static org.heigit.ors.matrix.MatrixRequest convertMatrixRequest(MatrixRequest request); static int convertMetrics(MatrixRequestEnums.Metrics[] metrics); }
|
MatrixRequestHandler { protected static Coordinate[] convertDestinations(String[] destinationsIndex, Coordinate[] locations) throws ParameterValueException { int length = destinationsIndex.length; if (length == 0) return locations; if (length == 1 && "all".equalsIgnoreCase(destinationsIndex[0])) return locations; try { ArrayList<Coordinate> indexCoordinateArray = convertIndexToLocations(destinationsIndex, locations); return indexCoordinateArray.toArray(new Coordinate[0]); } catch (Exception ex) { throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_DESTINATIONS); } } private MatrixRequestHandler(); static MatrixResult generateMatrixFromRequest(MatrixRequest request); static org.heigit.ors.matrix.MatrixRequest convertMatrixRequest(MatrixRequest request); static int convertMetrics(MatrixRequestEnums.Metrics[] metrics); }
|
@Test public void convertIndexToLocationsTest() throws Exception { ArrayList<Coordinate> coordinate = MatrixRequestHandler.convertIndexToLocations(new String[]{"1"}, this.coordinates); Assert.assertEquals(8.686507, coordinate.get(0).x, 0); Assert.assertEquals(49.41943, coordinate.get(0).y, 0); Assert.assertEquals(Double.NaN, coordinate.get(0).z, 0); }
|
protected static ArrayList<Coordinate> convertIndexToLocations(String[] index, Coordinate[] locations) { ArrayList<Coordinate> indexCoordinates = new ArrayList<>(); for (String indexString : index) { int indexInteger = Integer.parseInt(indexString); indexCoordinates.add(locations[indexInteger]); } return indexCoordinates; }
|
MatrixRequestHandler { protected static ArrayList<Coordinate> convertIndexToLocations(String[] index, Coordinate[] locations) { ArrayList<Coordinate> indexCoordinates = new ArrayList<>(); for (String indexString : index) { int indexInteger = Integer.parseInt(indexString); indexCoordinates.add(locations[indexInteger]); } return indexCoordinates; } }
|
MatrixRequestHandler { protected static ArrayList<Coordinate> convertIndexToLocations(String[] index, Coordinate[] locations) { ArrayList<Coordinate> indexCoordinates = new ArrayList<>(); for (String indexString : index) { int indexInteger = Integer.parseInt(indexString); indexCoordinates.add(locations[indexInteger]); } return indexCoordinates; } private MatrixRequestHandler(); }
|
MatrixRequestHandler { protected static ArrayList<Coordinate> convertIndexToLocations(String[] index, Coordinate[] locations) { ArrayList<Coordinate> indexCoordinates = new ArrayList<>(); for (String indexString : index) { int indexInteger = Integer.parseInt(indexString); indexCoordinates.add(locations[indexInteger]); } return indexCoordinates; } private MatrixRequestHandler(); static MatrixResult generateMatrixFromRequest(MatrixRequest request); static org.heigit.ors.matrix.MatrixRequest convertMatrixRequest(MatrixRequest request); static int convertMetrics(MatrixRequestEnums.Metrics[] metrics); }
|
MatrixRequestHandler { protected static ArrayList<Coordinate> convertIndexToLocations(String[] index, Coordinate[] locations) { ArrayList<Coordinate> indexCoordinates = new ArrayList<>(); for (String indexString : index) { int indexInteger = Integer.parseInt(indexString); indexCoordinates.add(locations[indexInteger]); } return indexCoordinates; } private MatrixRequestHandler(); static MatrixResult generateMatrixFromRequest(MatrixRequest request); static org.heigit.ors.matrix.MatrixRequest convertMatrixRequest(MatrixRequest request); static int convertMetrics(MatrixRequestEnums.Metrics[] metrics); }
|
@Test(expected = Exception.class) public void convertWrongIndexToLocationsTest() throws Exception { MatrixRequestHandler.convertIndexToLocations(new String[]{"foo"}, this.coordinates); }
|
protected static ArrayList<Coordinate> convertIndexToLocations(String[] index, Coordinate[] locations) { ArrayList<Coordinate> indexCoordinates = new ArrayList<>(); for (String indexString : index) { int indexInteger = Integer.parseInt(indexString); indexCoordinates.add(locations[indexInteger]); } return indexCoordinates; }
|
MatrixRequestHandler { protected static ArrayList<Coordinate> convertIndexToLocations(String[] index, Coordinate[] locations) { ArrayList<Coordinate> indexCoordinates = new ArrayList<>(); for (String indexString : index) { int indexInteger = Integer.parseInt(indexString); indexCoordinates.add(locations[indexInteger]); } return indexCoordinates; } }
|
MatrixRequestHandler { protected static ArrayList<Coordinate> convertIndexToLocations(String[] index, Coordinate[] locations) { ArrayList<Coordinate> indexCoordinates = new ArrayList<>(); for (String indexString : index) { int indexInteger = Integer.parseInt(indexString); indexCoordinates.add(locations[indexInteger]); } return indexCoordinates; } private MatrixRequestHandler(); }
|
MatrixRequestHandler { protected static ArrayList<Coordinate> convertIndexToLocations(String[] index, Coordinate[] locations) { ArrayList<Coordinate> indexCoordinates = new ArrayList<>(); for (String indexString : index) { int indexInteger = Integer.parseInt(indexString); indexCoordinates.add(locations[indexInteger]); } return indexCoordinates; } private MatrixRequestHandler(); static MatrixResult generateMatrixFromRequest(MatrixRequest request); static org.heigit.ors.matrix.MatrixRequest convertMatrixRequest(MatrixRequest request); static int convertMetrics(MatrixRequestEnums.Metrics[] metrics); }
|
MatrixRequestHandler { protected static ArrayList<Coordinate> convertIndexToLocations(String[] index, Coordinate[] locations) { ArrayList<Coordinate> indexCoordinates = new ArrayList<>(); for (String indexString : index) { int indexInteger = Integer.parseInt(indexString); indexCoordinates.add(locations[indexInteger]); } return indexCoordinates; } private MatrixRequestHandler(); static MatrixResult generateMatrixFromRequest(MatrixRequest request); static org.heigit.ors.matrix.MatrixRequest convertMatrixRequest(MatrixRequest request); static int convertMetrics(MatrixRequestEnums.Metrics[] metrics); }
|
@Test public void convertUnitsTest() throws ParameterValueException { Assert.assertEquals(DistanceUnit.METERS, MatrixRequestHandler.convertUnits(APIEnums.Units.METRES)); Assert.assertEquals(DistanceUnit.KILOMETERS, MatrixRequestHandler.convertUnits(APIEnums.Units.KILOMETRES)); Assert.assertEquals(DistanceUnit.MILES, MatrixRequestHandler.convertUnits(APIEnums.Units.MILES)); }
|
protected static DistanceUnit convertUnits(APIEnums.Units unitsIn) throws ParameterValueException { DistanceUnit units = DistanceUnitUtil.getFromString(unitsIn.toString(), DistanceUnit.UNKNOWN); if (units == DistanceUnit.UNKNOWN) throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_UNITS, unitsIn.toString()); return units; }
|
MatrixRequestHandler { protected static DistanceUnit convertUnits(APIEnums.Units unitsIn) throws ParameterValueException { DistanceUnit units = DistanceUnitUtil.getFromString(unitsIn.toString(), DistanceUnit.UNKNOWN); if (units == DistanceUnit.UNKNOWN) throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_UNITS, unitsIn.toString()); return units; } }
|
MatrixRequestHandler { protected static DistanceUnit convertUnits(APIEnums.Units unitsIn) throws ParameterValueException { DistanceUnit units = DistanceUnitUtil.getFromString(unitsIn.toString(), DistanceUnit.UNKNOWN); if (units == DistanceUnit.UNKNOWN) throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_UNITS, unitsIn.toString()); return units; } private MatrixRequestHandler(); }
|
MatrixRequestHandler { protected static DistanceUnit convertUnits(APIEnums.Units unitsIn) throws ParameterValueException { DistanceUnit units = DistanceUnitUtil.getFromString(unitsIn.toString(), DistanceUnit.UNKNOWN); if (units == DistanceUnit.UNKNOWN) throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_UNITS, unitsIn.toString()); return units; } private MatrixRequestHandler(); static MatrixResult generateMatrixFromRequest(MatrixRequest request); static org.heigit.ors.matrix.MatrixRequest convertMatrixRequest(MatrixRequest request); static int convertMetrics(MatrixRequestEnums.Metrics[] metrics); }
|
MatrixRequestHandler { protected static DistanceUnit convertUnits(APIEnums.Units unitsIn) throws ParameterValueException { DistanceUnit units = DistanceUnitUtil.getFromString(unitsIn.toString(), DistanceUnit.UNKNOWN); if (units == DistanceUnit.UNKNOWN) throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_UNITS, unitsIn.toString()); return units; } private MatrixRequestHandler(); static MatrixResult generateMatrixFromRequest(MatrixRequest request); static org.heigit.ors.matrix.MatrixRequest convertMatrixRequest(MatrixRequest request); static int convertMetrics(MatrixRequestEnums.Metrics[] metrics); }
|
@Test public void convertToProfileTypeTest() throws ParameterValueException { Assert.assertEquals(1, MatrixRequestHandler.convertToMatrixProfileType(APIEnums.Profile.DRIVING_CAR)); Assert.assertEquals(2, MatrixRequestHandler.convertToMatrixProfileType(APIEnums.Profile.DRIVING_HGV)); Assert.assertEquals(10, MatrixRequestHandler.convertToMatrixProfileType(APIEnums.Profile.CYCLING_REGULAR)); Assert.assertEquals(12, MatrixRequestHandler.convertToMatrixProfileType(APIEnums.Profile.CYCLING_ROAD)); Assert.assertEquals(11, MatrixRequestHandler.convertToMatrixProfileType(APIEnums.Profile.CYCLING_MOUNTAIN)); Assert.assertEquals(17, MatrixRequestHandler.convertToMatrixProfileType(APIEnums.Profile.CYCLING_ELECTRIC)); Assert.assertEquals(20, MatrixRequestHandler.convertToMatrixProfileType(APIEnums.Profile.FOOT_WALKING)); Assert.assertEquals(21, MatrixRequestHandler.convertToMatrixProfileType(APIEnums.Profile.FOOT_HIKING)); Assert.assertEquals(30, MatrixRequestHandler.convertToMatrixProfileType(APIEnums.Profile.WHEELCHAIR)); }
|
protected static int convertToMatrixProfileType(APIEnums.Profile profile) throws ParameterValueException { try { int profileFromString = RoutingProfileType.getFromString(profile.toString()); if (profileFromString == 0) { throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_PROFILE); } return profileFromString; } catch (Exception e) { throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_PROFILE); } }
|
MatrixRequestHandler { protected static int convertToMatrixProfileType(APIEnums.Profile profile) throws ParameterValueException { try { int profileFromString = RoutingProfileType.getFromString(profile.toString()); if (profileFromString == 0) { throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_PROFILE); } return profileFromString; } catch (Exception e) { throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_PROFILE); } } }
|
MatrixRequestHandler { protected static int convertToMatrixProfileType(APIEnums.Profile profile) throws ParameterValueException { try { int profileFromString = RoutingProfileType.getFromString(profile.toString()); if (profileFromString == 0) { throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_PROFILE); } return profileFromString; } catch (Exception e) { throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_PROFILE); } } private MatrixRequestHandler(); }
|
MatrixRequestHandler { protected static int convertToMatrixProfileType(APIEnums.Profile profile) throws ParameterValueException { try { int profileFromString = RoutingProfileType.getFromString(profile.toString()); if (profileFromString == 0) { throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_PROFILE); } return profileFromString; } catch (Exception e) { throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_PROFILE); } } private MatrixRequestHandler(); static MatrixResult generateMatrixFromRequest(MatrixRequest request); static org.heigit.ors.matrix.MatrixRequest convertMatrixRequest(MatrixRequest request); static int convertMetrics(MatrixRequestEnums.Metrics[] metrics); }
|
MatrixRequestHandler { protected static int convertToMatrixProfileType(APIEnums.Profile profile) throws ParameterValueException { try { int profileFromString = RoutingProfileType.getFromString(profile.toString()); if (profileFromString == 0) { throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_PROFILE); } return profileFromString; } catch (Exception e) { throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_PROFILE); } } private MatrixRequestHandler(); static MatrixResult generateMatrixFromRequest(MatrixRequest request); static org.heigit.ors.matrix.MatrixRequest convertMatrixRequest(MatrixRequest request); static int convertMetrics(MatrixRequestEnums.Metrics[] metrics); }
|
@Test(expected = ParameterValueException.class) public void convertToWrongMatrixProfileTypeTest() throws ParameterValueException { MatrixRequestHandler.convertToMatrixProfileType(APIEnums.Profile.forValue("foo")); }
|
protected static int convertToMatrixProfileType(APIEnums.Profile profile) throws ParameterValueException { try { int profileFromString = RoutingProfileType.getFromString(profile.toString()); if (profileFromString == 0) { throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_PROFILE); } return profileFromString; } catch (Exception e) { throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_PROFILE); } }
|
MatrixRequestHandler { protected static int convertToMatrixProfileType(APIEnums.Profile profile) throws ParameterValueException { try { int profileFromString = RoutingProfileType.getFromString(profile.toString()); if (profileFromString == 0) { throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_PROFILE); } return profileFromString; } catch (Exception e) { throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_PROFILE); } } }
|
MatrixRequestHandler { protected static int convertToMatrixProfileType(APIEnums.Profile profile) throws ParameterValueException { try { int profileFromString = RoutingProfileType.getFromString(profile.toString()); if (profileFromString == 0) { throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_PROFILE); } return profileFromString; } catch (Exception e) { throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_PROFILE); } } private MatrixRequestHandler(); }
|
MatrixRequestHandler { protected static int convertToMatrixProfileType(APIEnums.Profile profile) throws ParameterValueException { try { int profileFromString = RoutingProfileType.getFromString(profile.toString()); if (profileFromString == 0) { throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_PROFILE); } return profileFromString; } catch (Exception e) { throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_PROFILE); } } private MatrixRequestHandler(); static MatrixResult generateMatrixFromRequest(MatrixRequest request); static org.heigit.ors.matrix.MatrixRequest convertMatrixRequest(MatrixRequest request); static int convertMetrics(MatrixRequestEnums.Metrics[] metrics); }
|
MatrixRequestHandler { protected static int convertToMatrixProfileType(APIEnums.Profile profile) throws ParameterValueException { try { int profileFromString = RoutingProfileType.getFromString(profile.toString()); if (profileFromString == 0) { throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_PROFILE); } return profileFromString; } catch (Exception e) { throw new ParameterValueException(MatrixErrorCodes.INVALID_PARAMETER_VALUE, MatrixRequest.PARAM_PROFILE); } } private MatrixRequestHandler(); static MatrixResult generateMatrixFromRequest(MatrixRequest request); static org.heigit.ors.matrix.MatrixRequest convertMatrixRequest(MatrixRequest request); static int convertMetrics(MatrixRequestEnums.Metrics[] metrics); }
|
@Test public void getIdTest() throws ParameterValueException { matrixLocationsRequest = new MatrixRequest(bareCoordinates); matrixLocationsListRequest = new MatrixRequest(listOfBareCoordinatesList); Assert.assertNull(matrixLocationsRequest.getId()); Assert.assertNull(matrixLocationsListRequest.getId()); }
|
public String getId() { return id; }
|
MatrixRequest { public String getId() { return id; } }
|
MatrixRequest { public String getId() { return id; } @JsonCreator MatrixRequest(@JsonProperty(value = "locations", required = true) List<List<Double>> locations); MatrixRequest(Double[][] locations); }
|
MatrixRequest { public String getId() { return id; } @JsonCreator MatrixRequest(@JsonProperty(value = "locations", required = true) List<List<Double>> locations); MatrixRequest(Double[][] locations); String getId(); void setId(String id); boolean hasId(); APIEnums.Profile getProfile(); void setProfile(APIEnums.Profile profile); List<List<Double>> getLocations(); void setLocations(List<List<Double>> locations); String[] getSources(); void setSources(String[] sources); boolean hasSources(); String[] getDestinations(); void setDestinations(String[] destinations); boolean hasDestinations(); MatrixRequestEnums.Metrics[] getMetrics(); Set<String> getMetricsStrings(); void setMetrics(MatrixRequestEnums.Metrics[] metrics); boolean hasMetrics(); boolean getResolveLocations(); void setResolveLocations(boolean resolveLocations); boolean hasResolveLocations(); APIEnums.Units getUnits(); void setUnits(APIEnums.Units units); boolean hasUnits(); Boolean getOptimized(); void setOptimized(boolean optimized); boolean hasOptimized(); APIEnums.MatrixResponseType getResponseType(); void setResponseType(APIEnums.MatrixResponseType responseType); }
|
MatrixRequest { public String getId() { return id; } @JsonCreator MatrixRequest(@JsonProperty(value = "locations", required = true) List<List<Double>> locations); MatrixRequest(Double[][] locations); String getId(); void setId(String id); boolean hasId(); APIEnums.Profile getProfile(); void setProfile(APIEnums.Profile profile); List<List<Double>> getLocations(); void setLocations(List<List<Double>> locations); String[] getSources(); void setSources(String[] sources); boolean hasSources(); String[] getDestinations(); void setDestinations(String[] destinations); boolean hasDestinations(); MatrixRequestEnums.Metrics[] getMetrics(); Set<String> getMetricsStrings(); void setMetrics(MatrixRequestEnums.Metrics[] metrics); boolean hasMetrics(); boolean getResolveLocations(); void setResolveLocations(boolean resolveLocations); boolean hasResolveLocations(); APIEnums.Units getUnits(); void setUnits(APIEnums.Units units); boolean hasUnits(); Boolean getOptimized(); void setOptimized(boolean optimized); boolean hasOptimized(); APIEnums.MatrixResponseType getResponseType(); void setResponseType(APIEnums.MatrixResponseType responseType); static final String PARAM_ID; static final String PARAM_PROFILE; static final String PARAM_LOCATIONS; static final String PARAM_SOURCES; static final String PARAM_DESTINATIONS; static final String PARAM_METRICS; static final String PARAM_RESOLVE_LOCATIONS; static final String PARAM_UNITS; static final String PARAM_OPTIMIZED; }
|
@Test public void setIdTest() throws ParameterValueException { matrixLocationsRequest = new MatrixRequest(bareCoordinates); matrixLocationsListRequest = new MatrixRequest(listOfBareCoordinatesList); matrixLocationsRequest.setId("foo1"); matrixLocationsListRequest.setId("foo2"); Assert.assertEquals("foo1", matrixLocationsRequest.getId()); Assert.assertEquals("foo2", matrixLocationsListRequest.getId()); }
|
public void setId(String id) { this.id = id; }
|
MatrixRequest { public void setId(String id) { this.id = id; } }
|
MatrixRequest { public void setId(String id) { this.id = id; } @JsonCreator MatrixRequest(@JsonProperty(value = "locations", required = true) List<List<Double>> locations); MatrixRequest(Double[][] locations); }
|
MatrixRequest { public void setId(String id) { this.id = id; } @JsonCreator MatrixRequest(@JsonProperty(value = "locations", required = true) List<List<Double>> locations); MatrixRequest(Double[][] locations); String getId(); void setId(String id); boolean hasId(); APIEnums.Profile getProfile(); void setProfile(APIEnums.Profile profile); List<List<Double>> getLocations(); void setLocations(List<List<Double>> locations); String[] getSources(); void setSources(String[] sources); boolean hasSources(); String[] getDestinations(); void setDestinations(String[] destinations); boolean hasDestinations(); MatrixRequestEnums.Metrics[] getMetrics(); Set<String> getMetricsStrings(); void setMetrics(MatrixRequestEnums.Metrics[] metrics); boolean hasMetrics(); boolean getResolveLocations(); void setResolveLocations(boolean resolveLocations); boolean hasResolveLocations(); APIEnums.Units getUnits(); void setUnits(APIEnums.Units units); boolean hasUnits(); Boolean getOptimized(); void setOptimized(boolean optimized); boolean hasOptimized(); APIEnums.MatrixResponseType getResponseType(); void setResponseType(APIEnums.MatrixResponseType responseType); }
|
MatrixRequest { public void setId(String id) { this.id = id; } @JsonCreator MatrixRequest(@JsonProperty(value = "locations", required = true) List<List<Double>> locations); MatrixRequest(Double[][] locations); String getId(); void setId(String id); boolean hasId(); APIEnums.Profile getProfile(); void setProfile(APIEnums.Profile profile); List<List<Double>> getLocations(); void setLocations(List<List<Double>> locations); String[] getSources(); void setSources(String[] sources); boolean hasSources(); String[] getDestinations(); void setDestinations(String[] destinations); boolean hasDestinations(); MatrixRequestEnums.Metrics[] getMetrics(); Set<String> getMetricsStrings(); void setMetrics(MatrixRequestEnums.Metrics[] metrics); boolean hasMetrics(); boolean getResolveLocations(); void setResolveLocations(boolean resolveLocations); boolean hasResolveLocations(); APIEnums.Units getUnits(); void setUnits(APIEnums.Units units); boolean hasUnits(); Boolean getOptimized(); void setOptimized(boolean optimized); boolean hasOptimized(); APIEnums.MatrixResponseType getResponseType(); void setResponseType(APIEnums.MatrixResponseType responseType); static final String PARAM_ID; static final String PARAM_PROFILE; static final String PARAM_LOCATIONS; static final String PARAM_SOURCES; static final String PARAM_DESTINATIONS; static final String PARAM_METRICS; static final String PARAM_RESOLVE_LOCATIONS; static final String PARAM_UNITS; static final String PARAM_OPTIMIZED; }
|
@Test public void hasIdTest() throws ParameterValueException { matrixLocationsRequest = new MatrixRequest(bareCoordinates); matrixLocationsListRequest = new MatrixRequest(listOfBareCoordinatesList); Assert.assertFalse(matrixLocationsRequest.hasId()); Assert.assertFalse(matrixLocationsListRequest.hasId()); matrixLocationsRequest.setId("foo1"); matrixLocationsListRequest.setId("foo2"); Assert.assertTrue(matrixLocationsRequest.hasId()); Assert.assertTrue(matrixLocationsListRequest.hasId()); }
|
public boolean hasId() { return this.id != null; }
|
MatrixRequest { public boolean hasId() { return this.id != null; } }
|
MatrixRequest { public boolean hasId() { return this.id != null; } @JsonCreator MatrixRequest(@JsonProperty(value = "locations", required = true) List<List<Double>> locations); MatrixRequest(Double[][] locations); }
|
MatrixRequest { public boolean hasId() { return this.id != null; } @JsonCreator MatrixRequest(@JsonProperty(value = "locations", required = true) List<List<Double>> locations); MatrixRequest(Double[][] locations); String getId(); void setId(String id); boolean hasId(); APIEnums.Profile getProfile(); void setProfile(APIEnums.Profile profile); List<List<Double>> getLocations(); void setLocations(List<List<Double>> locations); String[] getSources(); void setSources(String[] sources); boolean hasSources(); String[] getDestinations(); void setDestinations(String[] destinations); boolean hasDestinations(); MatrixRequestEnums.Metrics[] getMetrics(); Set<String> getMetricsStrings(); void setMetrics(MatrixRequestEnums.Metrics[] metrics); boolean hasMetrics(); boolean getResolveLocations(); void setResolveLocations(boolean resolveLocations); boolean hasResolveLocations(); APIEnums.Units getUnits(); void setUnits(APIEnums.Units units); boolean hasUnits(); Boolean getOptimized(); void setOptimized(boolean optimized); boolean hasOptimized(); APIEnums.MatrixResponseType getResponseType(); void setResponseType(APIEnums.MatrixResponseType responseType); }
|
MatrixRequest { public boolean hasId() { return this.id != null; } @JsonCreator MatrixRequest(@JsonProperty(value = "locations", required = true) List<List<Double>> locations); MatrixRequest(Double[][] locations); String getId(); void setId(String id); boolean hasId(); APIEnums.Profile getProfile(); void setProfile(APIEnums.Profile profile); List<List<Double>> getLocations(); void setLocations(List<List<Double>> locations); String[] getSources(); void setSources(String[] sources); boolean hasSources(); String[] getDestinations(); void setDestinations(String[] destinations); boolean hasDestinations(); MatrixRequestEnums.Metrics[] getMetrics(); Set<String> getMetricsStrings(); void setMetrics(MatrixRequestEnums.Metrics[] metrics); boolean hasMetrics(); boolean getResolveLocations(); void setResolveLocations(boolean resolveLocations); boolean hasResolveLocations(); APIEnums.Units getUnits(); void setUnits(APIEnums.Units units); boolean hasUnits(); Boolean getOptimized(); void setOptimized(boolean optimized); boolean hasOptimized(); APIEnums.MatrixResponseType getResponseType(); void setResponseType(APIEnums.MatrixResponseType responseType); static final String PARAM_ID; static final String PARAM_PROFILE; static final String PARAM_LOCATIONS; static final String PARAM_SOURCES; static final String PARAM_DESTINATIONS; static final String PARAM_METRICS; static final String PARAM_RESOLVE_LOCATIONS; static final String PARAM_UNITS; static final String PARAM_OPTIMIZED; }
|
@Test public void TestAvoidPolygons() { EdgeIteratorState iter1 = _graphStorage.edge(0, 1, 100, true); iter1.setWayGeometry(Helper.createPointList(0, 0, 10, 0)); EdgeIteratorState iter2 = _graphStorage.edge(0, 2, 200, true); iter2.setWayGeometry(Helper.createPointList(0, 0, -10, 0)); GeometryFactory gf = new GeometryFactory(); Polygon poly = gf.createPolygon(new Coordinate[]{ new Coordinate(-1,5), new Coordinate(1,5), new Coordinate(1,6), new Coordinate(-1,5)}); AvoidAreasEdgeFilter filter = new AvoidAreasEdgeFilter(new Polygon[] {poly}); assertFalse(filter.accept(iter1)); assertTrue(filter.accept(iter2)); }
|
@Override public final boolean accept(EdgeIteratorState iter ) { if (env == null) return true; boolean inEnv = false; PointList pl = iter.fetchWayGeometry(3); int size = pl.getSize(); double eMinX = Double.MAX_VALUE; double eMinY = Double.MAX_VALUE; double eMaxX = Double.MIN_VALUE; double eMaxY = Double.MIN_VALUE; for (int j = 0; j < pl.getSize(); j++) { double x = pl.getLon(j); double y = pl.getLat(j); if (env.contains(x, y)) { inEnv = true; break; } if (x < eMinX) eMinX = x; if (y < eMinY) eMinY = y; if (x > eMaxX) eMaxX = x; if (y > eMaxY) eMaxY = y; } if (inEnv || !(eMinX > env.getMaxX() || eMaxX < env.getMinX() || eMinY > env.getMaxY() || eMaxY < env.getMinY())) { coordSequence = new DefaultCoordinateSequence(new Coordinate[1], 1); if (size >= 2) { coordSequence.resize(size); for (int j = 0; j < size; j++) { double x = pl.getLon(j); double y = pl.getLat(j); Coordinate c = coordSequence.getCoordinate(j); if (c == null) { c = new Coordinate(x, y); coordSequence.setCoordinate(j, c); } else { c.x = x; c.y = y; } } LineString ls = geomFactory.createLineString(coordSequence); for (int i = 0; i < polys.length; i++) { Polygon poly = polys[i]; if (poly.contains(ls) || ls.crosses(poly)) { return false; } } } else { return false; } } return true; }
|
AvoidAreasEdgeFilter implements EdgeFilter { @Override public final boolean accept(EdgeIteratorState iter ) { if (env == null) return true; boolean inEnv = false; PointList pl = iter.fetchWayGeometry(3); int size = pl.getSize(); double eMinX = Double.MAX_VALUE; double eMinY = Double.MAX_VALUE; double eMaxX = Double.MIN_VALUE; double eMaxY = Double.MIN_VALUE; for (int j = 0; j < pl.getSize(); j++) { double x = pl.getLon(j); double y = pl.getLat(j); if (env.contains(x, y)) { inEnv = true; break; } if (x < eMinX) eMinX = x; if (y < eMinY) eMinY = y; if (x > eMaxX) eMaxX = x; if (y > eMaxY) eMaxY = y; } if (inEnv || !(eMinX > env.getMaxX() || eMaxX < env.getMinX() || eMinY > env.getMaxY() || eMaxY < env.getMinY())) { coordSequence = new DefaultCoordinateSequence(new Coordinate[1], 1); if (size >= 2) { coordSequence.resize(size); for (int j = 0; j < size; j++) { double x = pl.getLon(j); double y = pl.getLat(j); Coordinate c = coordSequence.getCoordinate(j); if (c == null) { c = new Coordinate(x, y); coordSequence.setCoordinate(j, c); } else { c.x = x; c.y = y; } } LineString ls = geomFactory.createLineString(coordSequence); for (int i = 0; i < polys.length; i++) { Polygon poly = polys[i]; if (poly.contains(ls) || ls.crosses(poly)) { return false; } } } else { return false; } } return true; } }
|
AvoidAreasEdgeFilter implements EdgeFilter { @Override public final boolean accept(EdgeIteratorState iter ) { if (env == null) return true; boolean inEnv = false; PointList pl = iter.fetchWayGeometry(3); int size = pl.getSize(); double eMinX = Double.MAX_VALUE; double eMinY = Double.MAX_VALUE; double eMaxX = Double.MIN_VALUE; double eMaxY = Double.MIN_VALUE; for (int j = 0; j < pl.getSize(); j++) { double x = pl.getLon(j); double y = pl.getLat(j); if (env.contains(x, y)) { inEnv = true; break; } if (x < eMinX) eMinX = x; if (y < eMinY) eMinY = y; if (x > eMaxX) eMaxX = x; if (y > eMaxY) eMaxY = y; } if (inEnv || !(eMinX > env.getMaxX() || eMaxX < env.getMinX() || eMinY > env.getMaxY() || eMaxY < env.getMinY())) { coordSequence = new DefaultCoordinateSequence(new Coordinate[1], 1); if (size >= 2) { coordSequence.resize(size); for (int j = 0; j < size; j++) { double x = pl.getLon(j); double y = pl.getLat(j); Coordinate c = coordSequence.getCoordinate(j); if (c == null) { c = new Coordinate(x, y); coordSequence.setCoordinate(j, c); } else { c.x = x; c.y = y; } } LineString ls = geomFactory.createLineString(coordSequence); for (int i = 0; i < polys.length; i++) { Polygon poly = polys[i]; if (poly.contains(ls) || ls.crosses(poly)) { return false; } } } else { return false; } } return true; } AvoidAreasEdgeFilter(Polygon[] polys); }
|
AvoidAreasEdgeFilter implements EdgeFilter { @Override public final boolean accept(EdgeIteratorState iter ) { if (env == null) return true; boolean inEnv = false; PointList pl = iter.fetchWayGeometry(3); int size = pl.getSize(); double eMinX = Double.MAX_VALUE; double eMinY = Double.MAX_VALUE; double eMaxX = Double.MIN_VALUE; double eMaxY = Double.MIN_VALUE; for (int j = 0; j < pl.getSize(); j++) { double x = pl.getLon(j); double y = pl.getLat(j); if (env.contains(x, y)) { inEnv = true; break; } if (x < eMinX) eMinX = x; if (y < eMinY) eMinY = y; if (x > eMaxX) eMaxX = x; if (y > eMaxY) eMaxY = y; } if (inEnv || !(eMinX > env.getMaxX() || eMaxX < env.getMinX() || eMinY > env.getMaxY() || eMaxY < env.getMinY())) { coordSequence = new DefaultCoordinateSequence(new Coordinate[1], 1); if (size >= 2) { coordSequence.resize(size); for (int j = 0; j < size; j++) { double x = pl.getLon(j); double y = pl.getLat(j); Coordinate c = coordSequence.getCoordinate(j); if (c == null) { c = new Coordinate(x, y); coordSequence.setCoordinate(j, c); } else { c.x = x; c.y = y; } } LineString ls = geomFactory.createLineString(coordSequence); for (int i = 0; i < polys.length; i++) { Polygon poly = polys[i]; if (poly.contains(ls) || ls.crosses(poly)) { return false; } } } else { return false; } } return true; } AvoidAreasEdgeFilter(Polygon[] polys); @Override final boolean accept(EdgeIteratorState iter ); }
|
AvoidAreasEdgeFilter implements EdgeFilter { @Override public final boolean accept(EdgeIteratorState iter ) { if (env == null) return true; boolean inEnv = false; PointList pl = iter.fetchWayGeometry(3); int size = pl.getSize(); double eMinX = Double.MAX_VALUE; double eMinY = Double.MAX_VALUE; double eMaxX = Double.MIN_VALUE; double eMaxY = Double.MIN_VALUE; for (int j = 0; j < pl.getSize(); j++) { double x = pl.getLon(j); double y = pl.getLat(j); if (env.contains(x, y)) { inEnv = true; break; } if (x < eMinX) eMinX = x; if (y < eMinY) eMinY = y; if (x > eMaxX) eMaxX = x; if (y > eMaxY) eMaxY = y; } if (inEnv || !(eMinX > env.getMaxX() || eMaxX < env.getMinX() || eMinY > env.getMaxY() || eMaxY < env.getMinY())) { coordSequence = new DefaultCoordinateSequence(new Coordinate[1], 1); if (size >= 2) { coordSequence.resize(size); for (int j = 0; j < size; j++) { double x = pl.getLon(j); double y = pl.getLat(j); Coordinate c = coordSequence.getCoordinate(j); if (c == null) { c = new Coordinate(x, y); coordSequence.setCoordinate(j, c); } else { c.x = x; c.y = y; } } LineString ls = geomFactory.createLineString(coordSequence); for (int i = 0; i < polys.length; i++) { Polygon poly = polys[i]; if (poly.contains(ls) || ls.crosses(poly)) { return false; } } } else { return false; } } return true; } AvoidAreasEdgeFilter(Polygon[] polys); @Override final boolean accept(EdgeIteratorState iter ); }
|
@Test public void getProfileTest() throws ParameterValueException { matrixLocationsRequest = new MatrixRequest(bareCoordinates); matrixLocationsListRequest = new MatrixRequest(listOfBareCoordinatesList); Assert.assertNull(matrixLocationsRequest.getProfile()); Assert.assertNull(matrixLocationsListRequest.getProfile()); }
|
public APIEnums.Profile getProfile() { return profile; }
|
MatrixRequest { public APIEnums.Profile getProfile() { return profile; } }
|
MatrixRequest { public APIEnums.Profile getProfile() { return profile; } @JsonCreator MatrixRequest(@JsonProperty(value = "locations", required = true) List<List<Double>> locations); MatrixRequest(Double[][] locations); }
|
MatrixRequest { public APIEnums.Profile getProfile() { return profile; } @JsonCreator MatrixRequest(@JsonProperty(value = "locations", required = true) List<List<Double>> locations); MatrixRequest(Double[][] locations); String getId(); void setId(String id); boolean hasId(); APIEnums.Profile getProfile(); void setProfile(APIEnums.Profile profile); List<List<Double>> getLocations(); void setLocations(List<List<Double>> locations); String[] getSources(); void setSources(String[] sources); boolean hasSources(); String[] getDestinations(); void setDestinations(String[] destinations); boolean hasDestinations(); MatrixRequestEnums.Metrics[] getMetrics(); Set<String> getMetricsStrings(); void setMetrics(MatrixRequestEnums.Metrics[] metrics); boolean hasMetrics(); boolean getResolveLocations(); void setResolveLocations(boolean resolveLocations); boolean hasResolveLocations(); APIEnums.Units getUnits(); void setUnits(APIEnums.Units units); boolean hasUnits(); Boolean getOptimized(); void setOptimized(boolean optimized); boolean hasOptimized(); APIEnums.MatrixResponseType getResponseType(); void setResponseType(APIEnums.MatrixResponseType responseType); }
|
MatrixRequest { public APIEnums.Profile getProfile() { return profile; } @JsonCreator MatrixRequest(@JsonProperty(value = "locations", required = true) List<List<Double>> locations); MatrixRequest(Double[][] locations); String getId(); void setId(String id); boolean hasId(); APIEnums.Profile getProfile(); void setProfile(APIEnums.Profile profile); List<List<Double>> getLocations(); void setLocations(List<List<Double>> locations); String[] getSources(); void setSources(String[] sources); boolean hasSources(); String[] getDestinations(); void setDestinations(String[] destinations); boolean hasDestinations(); MatrixRequestEnums.Metrics[] getMetrics(); Set<String> getMetricsStrings(); void setMetrics(MatrixRequestEnums.Metrics[] metrics); boolean hasMetrics(); boolean getResolveLocations(); void setResolveLocations(boolean resolveLocations); boolean hasResolveLocations(); APIEnums.Units getUnits(); void setUnits(APIEnums.Units units); boolean hasUnits(); Boolean getOptimized(); void setOptimized(boolean optimized); boolean hasOptimized(); APIEnums.MatrixResponseType getResponseType(); void setResponseType(APIEnums.MatrixResponseType responseType); static final String PARAM_ID; static final String PARAM_PROFILE; static final String PARAM_LOCATIONS; static final String PARAM_SOURCES; static final String PARAM_DESTINATIONS; static final String PARAM_METRICS; static final String PARAM_RESOLVE_LOCATIONS; static final String PARAM_UNITS; static final String PARAM_OPTIMIZED; }
|
@Test public void setProfileTest() throws ParameterValueException { matrixLocationsRequest = new MatrixRequest(bareCoordinates); matrixLocationsListRequest = new MatrixRequest(listOfBareCoordinatesList); matrixLocationsRequest.setProfile(APIEnums.Profile.DRIVING_CAR); Assert.assertEquals(APIEnums.Profile.DRIVING_CAR, matrixLocationsRequest.getProfile()); matrixLocationsListRequest.setProfile(APIEnums.Profile.DRIVING_HGV); Assert.assertEquals(APIEnums.Profile.DRIVING_HGV, matrixLocationsListRequest.getProfile()); }
|
public void setProfile(APIEnums.Profile profile) { this.profile = profile; }
|
MatrixRequest { public void setProfile(APIEnums.Profile profile) { this.profile = profile; } }
|
MatrixRequest { public void setProfile(APIEnums.Profile profile) { this.profile = profile; } @JsonCreator MatrixRequest(@JsonProperty(value = "locations", required = true) List<List<Double>> locations); MatrixRequest(Double[][] locations); }
|
MatrixRequest { public void setProfile(APIEnums.Profile profile) { this.profile = profile; } @JsonCreator MatrixRequest(@JsonProperty(value = "locations", required = true) List<List<Double>> locations); MatrixRequest(Double[][] locations); String getId(); void setId(String id); boolean hasId(); APIEnums.Profile getProfile(); void setProfile(APIEnums.Profile profile); List<List<Double>> getLocations(); void setLocations(List<List<Double>> locations); String[] getSources(); void setSources(String[] sources); boolean hasSources(); String[] getDestinations(); void setDestinations(String[] destinations); boolean hasDestinations(); MatrixRequestEnums.Metrics[] getMetrics(); Set<String> getMetricsStrings(); void setMetrics(MatrixRequestEnums.Metrics[] metrics); boolean hasMetrics(); boolean getResolveLocations(); void setResolveLocations(boolean resolveLocations); boolean hasResolveLocations(); APIEnums.Units getUnits(); void setUnits(APIEnums.Units units); boolean hasUnits(); Boolean getOptimized(); void setOptimized(boolean optimized); boolean hasOptimized(); APIEnums.MatrixResponseType getResponseType(); void setResponseType(APIEnums.MatrixResponseType responseType); }
|
MatrixRequest { public void setProfile(APIEnums.Profile profile) { this.profile = profile; } @JsonCreator MatrixRequest(@JsonProperty(value = "locations", required = true) List<List<Double>> locations); MatrixRequest(Double[][] locations); String getId(); void setId(String id); boolean hasId(); APIEnums.Profile getProfile(); void setProfile(APIEnums.Profile profile); List<List<Double>> getLocations(); void setLocations(List<List<Double>> locations); String[] getSources(); void setSources(String[] sources); boolean hasSources(); String[] getDestinations(); void setDestinations(String[] destinations); boolean hasDestinations(); MatrixRequestEnums.Metrics[] getMetrics(); Set<String> getMetricsStrings(); void setMetrics(MatrixRequestEnums.Metrics[] metrics); boolean hasMetrics(); boolean getResolveLocations(); void setResolveLocations(boolean resolveLocations); boolean hasResolveLocations(); APIEnums.Units getUnits(); void setUnits(APIEnums.Units units); boolean hasUnits(); Boolean getOptimized(); void setOptimized(boolean optimized); boolean hasOptimized(); APIEnums.MatrixResponseType getResponseType(); void setResponseType(APIEnums.MatrixResponseType responseType); static final String PARAM_ID; static final String PARAM_PROFILE; static final String PARAM_LOCATIONS; static final String PARAM_SOURCES; static final String PARAM_DESTINATIONS; static final String PARAM_METRICS; static final String PARAM_RESOLVE_LOCATIONS; static final String PARAM_UNITS; static final String PARAM_OPTIMIZED; }
|
@Test public void getLocationsTest() throws ParameterValueException { matrixLocationsRequest = new MatrixRequest(bareCoordinates); matrixLocationsListRequest = new MatrixRequest(listOfBareCoordinatesList); Assert.assertEquals(listOfBareCoordinatesList, matrixLocationsRequest.getLocations()); Assert.assertEquals(listOfBareCoordinatesList, matrixLocationsListRequest.getLocations()); }
|
public List<List<Double>> getLocations() { return locations; }
|
MatrixRequest { public List<List<Double>> getLocations() { return locations; } }
|
MatrixRequest { public List<List<Double>> getLocations() { return locations; } @JsonCreator MatrixRequest(@JsonProperty(value = "locations", required = true) List<List<Double>> locations); MatrixRequest(Double[][] locations); }
|
MatrixRequest { public List<List<Double>> getLocations() { return locations; } @JsonCreator MatrixRequest(@JsonProperty(value = "locations", required = true) List<List<Double>> locations); MatrixRequest(Double[][] locations); String getId(); void setId(String id); boolean hasId(); APIEnums.Profile getProfile(); void setProfile(APIEnums.Profile profile); List<List<Double>> getLocations(); void setLocations(List<List<Double>> locations); String[] getSources(); void setSources(String[] sources); boolean hasSources(); String[] getDestinations(); void setDestinations(String[] destinations); boolean hasDestinations(); MatrixRequestEnums.Metrics[] getMetrics(); Set<String> getMetricsStrings(); void setMetrics(MatrixRequestEnums.Metrics[] metrics); boolean hasMetrics(); boolean getResolveLocations(); void setResolveLocations(boolean resolveLocations); boolean hasResolveLocations(); APIEnums.Units getUnits(); void setUnits(APIEnums.Units units); boolean hasUnits(); Boolean getOptimized(); void setOptimized(boolean optimized); boolean hasOptimized(); APIEnums.MatrixResponseType getResponseType(); void setResponseType(APIEnums.MatrixResponseType responseType); }
|
MatrixRequest { public List<List<Double>> getLocations() { return locations; } @JsonCreator MatrixRequest(@JsonProperty(value = "locations", required = true) List<List<Double>> locations); MatrixRequest(Double[][] locations); String getId(); void setId(String id); boolean hasId(); APIEnums.Profile getProfile(); void setProfile(APIEnums.Profile profile); List<List<Double>> getLocations(); void setLocations(List<List<Double>> locations); String[] getSources(); void setSources(String[] sources); boolean hasSources(); String[] getDestinations(); void setDestinations(String[] destinations); boolean hasDestinations(); MatrixRequestEnums.Metrics[] getMetrics(); Set<String> getMetricsStrings(); void setMetrics(MatrixRequestEnums.Metrics[] metrics); boolean hasMetrics(); boolean getResolveLocations(); void setResolveLocations(boolean resolveLocations); boolean hasResolveLocations(); APIEnums.Units getUnits(); void setUnits(APIEnums.Units units); boolean hasUnits(); Boolean getOptimized(); void setOptimized(boolean optimized); boolean hasOptimized(); APIEnums.MatrixResponseType getResponseType(); void setResponseType(APIEnums.MatrixResponseType responseType); static final String PARAM_ID; static final String PARAM_PROFILE; static final String PARAM_LOCATIONS; static final String PARAM_SOURCES; static final String PARAM_DESTINATIONS; static final String PARAM_METRICS; static final String PARAM_RESOLVE_LOCATIONS; static final String PARAM_UNITS; static final String PARAM_OPTIMIZED; }
|
@Test public void setLocationsTest() throws ParameterValueException { matrixLocationsRequest = new MatrixRequest(bareCoordinates); matrixLocationsListRequest = new MatrixRequest(listOfBareCoordinatesList); matrixLocationsRequest.setLocations(listOfBareCoordinatesList); matrixLocationsListRequest.setLocations(listOfBareCoordinatesList); Assert.assertEquals(listOfBareCoordinatesList, matrixLocationsRequest.getLocations()); Assert.assertEquals(listOfBareCoordinatesList, matrixLocationsListRequest.getLocations()); }
|
public void setLocations(List<List<Double>> locations) { this.locations = locations; }
|
MatrixRequest { public void setLocations(List<List<Double>> locations) { this.locations = locations; } }
|
MatrixRequest { public void setLocations(List<List<Double>> locations) { this.locations = locations; } @JsonCreator MatrixRequest(@JsonProperty(value = "locations", required = true) List<List<Double>> locations); MatrixRequest(Double[][] locations); }
|
MatrixRequest { public void setLocations(List<List<Double>> locations) { this.locations = locations; } @JsonCreator MatrixRequest(@JsonProperty(value = "locations", required = true) List<List<Double>> locations); MatrixRequest(Double[][] locations); String getId(); void setId(String id); boolean hasId(); APIEnums.Profile getProfile(); void setProfile(APIEnums.Profile profile); List<List<Double>> getLocations(); void setLocations(List<List<Double>> locations); String[] getSources(); void setSources(String[] sources); boolean hasSources(); String[] getDestinations(); void setDestinations(String[] destinations); boolean hasDestinations(); MatrixRequestEnums.Metrics[] getMetrics(); Set<String> getMetricsStrings(); void setMetrics(MatrixRequestEnums.Metrics[] metrics); boolean hasMetrics(); boolean getResolveLocations(); void setResolveLocations(boolean resolveLocations); boolean hasResolveLocations(); APIEnums.Units getUnits(); void setUnits(APIEnums.Units units); boolean hasUnits(); Boolean getOptimized(); void setOptimized(boolean optimized); boolean hasOptimized(); APIEnums.MatrixResponseType getResponseType(); void setResponseType(APIEnums.MatrixResponseType responseType); }
|
MatrixRequest { public void setLocations(List<List<Double>> locations) { this.locations = locations; } @JsonCreator MatrixRequest(@JsonProperty(value = "locations", required = true) List<List<Double>> locations); MatrixRequest(Double[][] locations); String getId(); void setId(String id); boolean hasId(); APIEnums.Profile getProfile(); void setProfile(APIEnums.Profile profile); List<List<Double>> getLocations(); void setLocations(List<List<Double>> locations); String[] getSources(); void setSources(String[] sources); boolean hasSources(); String[] getDestinations(); void setDestinations(String[] destinations); boolean hasDestinations(); MatrixRequestEnums.Metrics[] getMetrics(); Set<String> getMetricsStrings(); void setMetrics(MatrixRequestEnums.Metrics[] metrics); boolean hasMetrics(); boolean getResolveLocations(); void setResolveLocations(boolean resolveLocations); boolean hasResolveLocations(); APIEnums.Units getUnits(); void setUnits(APIEnums.Units units); boolean hasUnits(); Boolean getOptimized(); void setOptimized(boolean optimized); boolean hasOptimized(); APIEnums.MatrixResponseType getResponseType(); void setResponseType(APIEnums.MatrixResponseType responseType); static final String PARAM_ID; static final String PARAM_PROFILE; static final String PARAM_LOCATIONS; static final String PARAM_SOURCES; static final String PARAM_DESTINATIONS; static final String PARAM_METRICS; static final String PARAM_RESOLVE_LOCATIONS; static final String PARAM_UNITS; static final String PARAM_OPTIMIZED; }
|
@Test public void setSourcesTest() throws ParameterValueException { matrixLocationsRequest = new MatrixRequest(bareCoordinates); matrixLocationsListRequest = new MatrixRequest(listOfBareCoordinatesList); matrixLocationsRequest.setSources(new String[]{"foo"}); matrixLocationsListRequest.setSources(new String[]{"foo"}); Assert.assertArrayEquals(new String[]{"foo"}, matrixLocationsRequest.getSources()); Assert.assertArrayEquals(new String[]{"foo"}, matrixLocationsListRequest.getSources()); }
|
public void setSources(String[] sources) { this.sources = sources; hasSources = true; }
|
MatrixRequest { public void setSources(String[] sources) { this.sources = sources; hasSources = true; } }
|
MatrixRequest { public void setSources(String[] sources) { this.sources = sources; hasSources = true; } @JsonCreator MatrixRequest(@JsonProperty(value = "locations", required = true) List<List<Double>> locations); MatrixRequest(Double[][] locations); }
|
MatrixRequest { public void setSources(String[] sources) { this.sources = sources; hasSources = true; } @JsonCreator MatrixRequest(@JsonProperty(value = "locations", required = true) List<List<Double>> locations); MatrixRequest(Double[][] locations); String getId(); void setId(String id); boolean hasId(); APIEnums.Profile getProfile(); void setProfile(APIEnums.Profile profile); List<List<Double>> getLocations(); void setLocations(List<List<Double>> locations); String[] getSources(); void setSources(String[] sources); boolean hasSources(); String[] getDestinations(); void setDestinations(String[] destinations); boolean hasDestinations(); MatrixRequestEnums.Metrics[] getMetrics(); Set<String> getMetricsStrings(); void setMetrics(MatrixRequestEnums.Metrics[] metrics); boolean hasMetrics(); boolean getResolveLocations(); void setResolveLocations(boolean resolveLocations); boolean hasResolveLocations(); APIEnums.Units getUnits(); void setUnits(APIEnums.Units units); boolean hasUnits(); Boolean getOptimized(); void setOptimized(boolean optimized); boolean hasOptimized(); APIEnums.MatrixResponseType getResponseType(); void setResponseType(APIEnums.MatrixResponseType responseType); }
|
MatrixRequest { public void setSources(String[] sources) { this.sources = sources; hasSources = true; } @JsonCreator MatrixRequest(@JsonProperty(value = "locations", required = true) List<List<Double>> locations); MatrixRequest(Double[][] locations); String getId(); void setId(String id); boolean hasId(); APIEnums.Profile getProfile(); void setProfile(APIEnums.Profile profile); List<List<Double>> getLocations(); void setLocations(List<List<Double>> locations); String[] getSources(); void setSources(String[] sources); boolean hasSources(); String[] getDestinations(); void setDestinations(String[] destinations); boolean hasDestinations(); MatrixRequestEnums.Metrics[] getMetrics(); Set<String> getMetricsStrings(); void setMetrics(MatrixRequestEnums.Metrics[] metrics); boolean hasMetrics(); boolean getResolveLocations(); void setResolveLocations(boolean resolveLocations); boolean hasResolveLocations(); APIEnums.Units getUnits(); void setUnits(APIEnums.Units units); boolean hasUnits(); Boolean getOptimized(); void setOptimized(boolean optimized); boolean hasOptimized(); APIEnums.MatrixResponseType getResponseType(); void setResponseType(APIEnums.MatrixResponseType responseType); static final String PARAM_ID; static final String PARAM_PROFILE; static final String PARAM_LOCATIONS; static final String PARAM_SOURCES; static final String PARAM_DESTINATIONS; static final String PARAM_METRICS; static final String PARAM_RESOLVE_LOCATIONS; static final String PARAM_UNITS; static final String PARAM_OPTIMIZED; }
|
@Test public void testSetLength() { Assert.assertFalse(options.hasLength()); options.setLength(123.4f); Assert.assertTrue(options.hasLength()); Assert.assertEquals((Float)123.4f, options.getLength()); }
|
public void setLength(Float length) { this.length = length; hasLength = true; }
|
RouteRequestRoundTripOptions { public void setLength(Float length) { this.length = length; hasLength = true; } }
|
RouteRequestRoundTripOptions { public void setLength(Float length) { this.length = length; hasLength = true; } }
|
RouteRequestRoundTripOptions { public void setLength(Float length) { this.length = length; hasLength = true; } Float getLength(); void setLength(Float length); Integer getPoints(); void setPoints(Integer points); Long getSeed(); void setSeed(Long seed); boolean hasLength(); boolean hasPoints(); boolean hasSeed(); }
|
RouteRequestRoundTripOptions { public void setLength(Float length) { this.length = length; hasLength = true; } Float getLength(); void setLength(Float length); Integer getPoints(); void setPoints(Integer points); Long getSeed(); void setSeed(Long seed); boolean hasLength(); boolean hasPoints(); boolean hasSeed(); static final String PARAM_LENGTH; static final String PARAM_POINTS; static final String PARAM_SEED; }
|
@Test public void testSetPoints() { Assert.assertFalse(options.hasPoints()); options.setPoints(12); Assert.assertTrue(options.hasPoints()); Assert.assertEquals((Integer) 12, options.getPoints()); }
|
public void setPoints(Integer points) { this.points = points; hasPoints = true; }
|
RouteRequestRoundTripOptions { public void setPoints(Integer points) { this.points = points; hasPoints = true; } }
|
RouteRequestRoundTripOptions { public void setPoints(Integer points) { this.points = points; hasPoints = true; } }
|
RouteRequestRoundTripOptions { public void setPoints(Integer points) { this.points = points; hasPoints = true; } Float getLength(); void setLength(Float length); Integer getPoints(); void setPoints(Integer points); Long getSeed(); void setSeed(Long seed); boolean hasLength(); boolean hasPoints(); boolean hasSeed(); }
|
RouteRequestRoundTripOptions { public void setPoints(Integer points) { this.points = points; hasPoints = true; } Float getLength(); void setLength(Float length); Integer getPoints(); void setPoints(Integer points); Long getSeed(); void setSeed(Long seed); boolean hasLength(); boolean hasPoints(); boolean hasSeed(); static final String PARAM_LENGTH; static final String PARAM_POINTS; static final String PARAM_SEED; }
|
@Test public void testSetSeed() { Assert.assertFalse(options.hasSeed()); options.setSeed(1234567890l); Assert.assertTrue(options.hasSeed()); Assert.assertEquals((Long) 1234567890l, options.getSeed()); }
|
public void setSeed(Long seed) { this.seed = seed; hasSeed = true; }
|
RouteRequestRoundTripOptions { public void setSeed(Long seed) { this.seed = seed; hasSeed = true; } }
|
RouteRequestRoundTripOptions { public void setSeed(Long seed) { this.seed = seed; hasSeed = true; } }
|
RouteRequestRoundTripOptions { public void setSeed(Long seed) { this.seed = seed; hasSeed = true; } Float getLength(); void setLength(Float length); Integer getPoints(); void setPoints(Integer points); Long getSeed(); void setSeed(Long seed); boolean hasLength(); boolean hasPoints(); boolean hasSeed(); }
|
RouteRequestRoundTripOptions { public void setSeed(Long seed) { this.seed = seed; hasSeed = true; } Float getLength(); void setLength(Float length); Integer getPoints(); void setPoints(Integer points); Long getSeed(); void setSeed(Long seed); boolean hasLength(); boolean hasPoints(); boolean hasSeed(); static final String PARAM_LENGTH; static final String PARAM_POINTS; static final String PARAM_SEED; }
|
@Test public void convertRouteRequestTest() throws Exception { RoutingRequest routingRequest; routingRequest = new RouteRequestHandler().convertRouteRequest(request); Assert.assertEquals(3, routingRequest.getCoordinates().length); Assert.assertEquals(RoutingProfileType.getFromString("driving-car"), routingRequest.getSearchParameters().getProfileType()); Assert.assertArrayEquals(new String[] {"avgspeed", "detourfactor"}, routingRequest.getAttributes()); Assert.assertTrue(routingRequest.getContinueStraight()); Assert.assertEquals(RouteExtraInfoFlag.getFromString("osmid"), routingRequest.getExtraInfo()); Assert.assertEquals("geojson", routingRequest.getGeometryFormat()); Assert.assertTrue(routingRequest.getIncludeGeometry()); Assert.assertTrue(routingRequest.getIncludeInstructions()); Assert.assertTrue(routingRequest.getIncludeRoundaboutExits()); Assert.assertTrue(routingRequest.getIncludeManeuvers()); Assert.assertEquals(RouteInstructionsFormat.HTML, routingRequest.getInstructionsFormat()); Assert.assertEquals("de", routingRequest.getLanguage()); Assert.assertEquals("geojson", routingRequest.getGeometryFormat()); Assert.assertTrue(routingRequest.getIncludeElevation()); Assert.assertEquals(WeightingMethod.FASTEST, routingRequest.getSearchParameters().getWeightingMethod()); Assert.assertEquals(DistanceUnit.METERS, routingRequest.getUnits()); Assert.assertTrue(routingRequest.getSearchParameters().getFlexibleMode()); Assert.assertEquals(BordersExtractor.Avoid.CONTROLLED, routingRequest.getSearchParameters().getAvoidBorders()); Assert.assertArrayEquals(new int[] {115}, routingRequest.getSearchParameters().getAvoidCountries()); Assert.assertEquals(AvoidFeatureFlags.getFromString("fords"), routingRequest.getSearchParameters().getAvoidFeatureTypes()); checkPolygon(routingRequest.getSearchParameters().getAvoidAreas(), geoJsonPolygon); ProfileWeightingCollection weightings = routingRequest.getSearchParameters().getProfileParameters().getWeightings(); ProfileWeighting weighting; Iterator<ProfileWeighting> iter = weightings.getIterator(); while (iter.hasNext() && (weighting = iter.next()) != null) { if (weighting.getName().equals("green")) { Assert.assertEquals(0.5, weighting.getParameters().getDouble("factor", -1), 0); } if (weighting.getName().equals("quiet")) { Assert.assertEquals(0.2, weighting.getParameters().getDouble("factor", -1), 0); } if (weighting.getName().equals("steepness_difficulty")) { Assert.assertEquals(3, weighting.getParameters().getInt("level", -1), 0); } } }
|
public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } RouteRequestHandler(); }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } RouteRequestHandler(); RouteResult[] generateRouteFromRequest(RouteRequest request); RoutingRequest convertRouteRequest(RouteRequest request); RouteSearchParameters processRequestOptions(RouteRequestOptions options, RouteSearchParameters params); @Override int convertRouteProfileType(APIEnums.Profile profile); }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } RouteRequestHandler(); RouteResult[] generateRouteFromRequest(RouteRequest request); RoutingRequest convertRouteRequest(RouteRequest request); RouteSearchParameters processRequestOptions(RouteRequestOptions options, RouteSearchParameters params); @Override int convertRouteProfileType(APIEnums.Profile profile); }
|
@Test public void TestVehicleParameters() throws Exception { request.setProfile(APIEnums.Profile.DRIVING_HGV); request.getRouteOptions().getProfileParams().setRestrictions(vehicleParams); request.getRouteOptions().setVehicleType(APIEnums.VehicleType.AGRICULTURAL); RoutingRequest routingRequest; routingRequest = new RouteRequestHandler().convertRouteRequest(request); VehicleParameters params = (VehicleParameters) routingRequest.getSearchParameters().getProfileParameters(); Assert.assertEquals(30.0, params.getWeight(), 0); Assert.assertEquals(10.0, params.getAxleload(), 0); Assert.assertEquals(5.0, params.getHeight(), 0); Assert.assertEquals(15.0, params.getLength(), 0); Assert.assertEquals(4.5, params.getWidth(), 0); Assert.assertEquals(new VehicleLoadCharacteristicsFlags().getFromString("hazmat"), params.getLoadCharacteristics()); }
|
public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } RouteRequestHandler(); }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } RouteRequestHandler(); RouteResult[] generateRouteFromRequest(RouteRequest request); RoutingRequest convertRouteRequest(RouteRequest request); RouteSearchParameters processRequestOptions(RouteRequestOptions options, RouteSearchParameters params); @Override int convertRouteProfileType(APIEnums.Profile profile); }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } RouteRequestHandler(); RouteResult[] generateRouteFromRequest(RouteRequest request); RoutingRequest convertRouteRequest(RouteRequest request); RouteSearchParameters processRequestOptions(RouteRequestOptions options, RouteSearchParameters params); @Override int convertRouteProfileType(APIEnums.Profile profile); }
|
@Test public void directRouteTest() { GHRequest ghRequest = new GHRequest(49.41281601436809, 8.686215877532959, 49.410163456220076, 8.687160015106201); GHResponse ghResponse = new ORSGraphHopper().constructFreeHandRoute(ghRequest); Assert.assertTrue(ghResponse.getHints().has("skipped_segment")); Assert.assertTrue(ghResponse.getHints().getBool("skipped_segment", false)); Assert.assertEquals(1, ghResponse.getAll().size()); PathWrapper directRouteWrapper = ghResponse.getAll().get(0); Assert.assertEquals(0, directRouteWrapper.getErrors().size()); Assert.assertEquals(0, directRouteWrapper.getDescription().size()); Assert.assertEquals(309.892f, directRouteWrapper.getDistance(), 3); Assert.assertEquals(0.0, directRouteWrapper.getAscend(), 0); Assert.assertEquals(0.0, directRouteWrapper.getDescend(), 0); Assert.assertEquals(0.0, directRouteWrapper.getRouteWeight(), 0); Assert.assertEquals(0, directRouteWrapper.getTime()); Assert.assertEquals("", directRouteWrapper.getDebugInfo()); Assert.assertEquals(2, directRouteWrapper.getInstructions().size()); Assert.assertEquals(1, directRouteWrapper.getInstructions().get(0).getPoints().size()); Assert.assertEquals(0, directRouteWrapper.getNumChanges()); Assert.assertEquals(0, directRouteWrapper.getLegs().size()); Assert.assertEquals(0, directRouteWrapper.getPathDetails().size()); Assert.assertNull(directRouteWrapper.getFare()); Assert.assertFalse(directRouteWrapper.isImpossible()); checkInstructions(directRouteWrapper.getInstructions()); checkPointList(directRouteWrapper.getWaypoints()); checkPointList(directRouteWrapper.getPoints()); }
|
public GHResponse constructFreeHandRoute(GHRequest request) { LineString directRouteGeometry = constructFreeHandRouteGeometry(request); PathWrapper directRoutePathWrapper = constructFreeHandRoutePathWrapper(directRouteGeometry); GHResponse directRouteResponse = new GHResponse(); directRouteResponse.add(directRoutePathWrapper); directRouteResponse.getHints().put("skipped_segment", "true"); return directRouteResponse; }
|
ORSGraphHopper extends GraphHopper { public GHResponse constructFreeHandRoute(GHRequest request) { LineString directRouteGeometry = constructFreeHandRouteGeometry(request); PathWrapper directRoutePathWrapper = constructFreeHandRoutePathWrapper(directRouteGeometry); GHResponse directRouteResponse = new GHResponse(); directRouteResponse.add(directRoutePathWrapper); directRouteResponse.getHints().put("skipped_segment", "true"); return directRouteResponse; } }
|
ORSGraphHopper extends GraphHopper { public GHResponse constructFreeHandRoute(GHRequest request) { LineString directRouteGeometry = constructFreeHandRouteGeometry(request); PathWrapper directRoutePathWrapper = constructFreeHandRoutePathWrapper(directRouteGeometry); GHResponse directRouteResponse = new GHResponse(); directRouteResponse.add(directRoutePathWrapper); directRouteResponse.getHints().put("skipped_segment", "true"); return directRouteResponse; } ORSGraphHopper(GraphProcessContext procCntx); ORSGraphHopper(); }
|
ORSGraphHopper extends GraphHopper { public GHResponse constructFreeHandRoute(GHRequest request) { LineString directRouteGeometry = constructFreeHandRouteGeometry(request); PathWrapper directRoutePathWrapper = constructFreeHandRoutePathWrapper(directRouteGeometry); GHResponse directRouteResponse = new GHResponse(); directRouteResponse.add(directRoutePathWrapper); directRouteResponse.getHints().put("skipped_segment", "true"); return directRouteResponse; } ORSGraphHopper(GraphProcessContext procCntx); ORSGraphHopper(); @Override GraphHopper init(CmdArgs args); @SuppressWarnings("unchecked") @Override GraphHopper importOrLoad(); @Override List<Path> calcPaths(GHRequest request, GHResponse ghRsp); RouteSegmentInfo getRouteSegment(double[] latitudes, double[] longitudes, String vehicle); GHResponse constructFreeHandRoute(GHRequest request); HashMap<Integer, Long> getTmcGraphEdges(); HashMap<Long, ArrayList<Integer>> getOsmId2EdgeIds(); @Override void postProcessing(); GraphHopper setCoreEnabled(boolean enable); final boolean isCoreEnabled(); void initCoreAlgoFactoryDecorator(); final CoreAlgoFactoryDecorator getCoreFactoryDecorator(); GraphHopper setCoreLMEnabled(boolean enable); final boolean isCoreLMEnabled(); void initCoreLMAlgoFactoryDecorator(); final boolean isCHAvailable(String weighting); final boolean isLMAvailable(String weighting); final boolean isCoreAvailable(String weighting); final boolean isFastIsochroneAvailable(RouteSearchContext searchContext, TravelRangeType travelRangeType); final FastIsochroneFactory getFastIsochroneFactory(); Eccentricity getEccentricity(); }
|
ORSGraphHopper extends GraphHopper { public GHResponse constructFreeHandRoute(GHRequest request) { LineString directRouteGeometry = constructFreeHandRouteGeometry(request); PathWrapper directRoutePathWrapper = constructFreeHandRoutePathWrapper(directRouteGeometry); GHResponse directRouteResponse = new GHResponse(); directRouteResponse.add(directRoutePathWrapper); directRouteResponse.getHints().put("skipped_segment", "true"); return directRouteResponse; } ORSGraphHopper(GraphProcessContext procCntx); ORSGraphHopper(); @Override GraphHopper init(CmdArgs args); @SuppressWarnings("unchecked") @Override GraphHopper importOrLoad(); @Override List<Path> calcPaths(GHRequest request, GHResponse ghRsp); RouteSegmentInfo getRouteSegment(double[] latitudes, double[] longitudes, String vehicle); GHResponse constructFreeHandRoute(GHRequest request); HashMap<Integer, Long> getTmcGraphEdges(); HashMap<Long, ArrayList<Integer>> getOsmId2EdgeIds(); @Override void postProcessing(); GraphHopper setCoreEnabled(boolean enable); final boolean isCoreEnabled(); void initCoreAlgoFactoryDecorator(); final CoreAlgoFactoryDecorator getCoreFactoryDecorator(); GraphHopper setCoreLMEnabled(boolean enable); final boolean isCoreLMEnabled(); void initCoreLMAlgoFactoryDecorator(); final boolean isCHAvailable(String weighting); final boolean isLMAvailable(String weighting); final boolean isCoreAvailable(String weighting); final boolean isFastIsochroneAvailable(RouteSearchContext searchContext, TravelRangeType travelRangeType); final FastIsochroneFactory getFastIsochroneFactory(); Eccentricity getEccentricity(); }
|
@Test public void TestWheelchairParameters() throws Exception { request.setProfile(APIEnums.Profile.WHEELCHAIR); request.getRouteOptions().getProfileParams().setRestrictions(wheelchairParams); RoutingRequest routingRequest; routingRequest = new RouteRequestHandler().convertRouteRequest(request); WheelchairParameters params = (WheelchairParameters) routingRequest.getSearchParameters().getProfileParameters(); Assert.assertEquals(WheelchairTypesEncoder.getSmoothnessType("good"), params.getSmoothnessType()); Assert.assertEquals(3.0f, params.getMaximumIncline(), 0); Assert.assertEquals(1.0f, params.getMaximumSlopedKerb(), 0); Assert.assertEquals(2.0f, params.getMinimumWidth(), 0); Assert.assertEquals(WheelchairTypesEncoder.getSurfaceType("asphalt"), params.getSurfaceType()); }
|
public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } RouteRequestHandler(); }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } RouteRequestHandler(); RouteResult[] generateRouteFromRequest(RouteRequest request); RoutingRequest convertRouteRequest(RouteRequest request); RouteSearchParameters processRequestOptions(RouteRequestOptions options, RouteSearchParameters params); @Override int convertRouteProfileType(APIEnums.Profile profile); }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } RouteRequestHandler(); RouteResult[] generateRouteFromRequest(RouteRequest request); RoutingRequest convertRouteRequest(RouteRequest request); RouteSearchParameters processRequestOptions(RouteRequestOptions options, RouteSearchParameters params); @Override int convertRouteProfileType(APIEnums.Profile profile); }
|
@Test public void testBearings() throws StatusCodeException { request.setBearings(new Double[][] {{10.0,10.0},{260.0, 90.0},{45.0, 30.0}}); RoutingRequest routingRequest = new RouteRequestHandler().convertRouteRequest(request); WayPointBearing[] bearings = routingRequest.getSearchParameters().getBearings(); Assert.assertEquals(10.0, bearings[0].getValue(), 0); Assert.assertEquals(10.0, bearings[0].getDeviation(), 0); Assert.assertEquals(260.0, bearings[1].getValue(), 0); Assert.assertEquals(90.0, bearings[1].getDeviation(), 0); Assert.assertEquals(45.0, bearings[2].getValue(), 0); Assert.assertEquals(30.0, bearings[2].getDeviation(), 0); }
|
public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } RouteRequestHandler(); }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } RouteRequestHandler(); RouteResult[] generateRouteFromRequest(RouteRequest request); RoutingRequest convertRouteRequest(RouteRequest request); RouteSearchParameters processRequestOptions(RouteRequestOptions options, RouteSearchParameters params); @Override int convertRouteProfileType(APIEnums.Profile profile); }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } RouteRequestHandler(); RouteResult[] generateRouteFromRequest(RouteRequest request); RoutingRequest convertRouteRequest(RouteRequest request); RouteSearchParameters processRequestOptions(RouteRequestOptions options, RouteSearchParameters params); @Override int convertRouteProfileType(APIEnums.Profile profile); }
|
@Test public void skippedBearingTest() throws Exception { request.setBearings(new Double[][] {{120.0, 90.0}, { , }, {90.0, 30.0}}); RoutingRequest routingRequest; routingRequest = new RouteRequestHandler().convertRouteRequest(request); Assert.assertEquals(3, routingRequest.getSearchParameters().getBearings().length); }
|
public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } RouteRequestHandler(); }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } RouteRequestHandler(); RouteResult[] generateRouteFromRequest(RouteRequest request); RoutingRequest convertRouteRequest(RouteRequest request); RouteSearchParameters processRequestOptions(RouteRequestOptions options, RouteSearchParameters params); @Override int convertRouteProfileType(APIEnums.Profile profile); }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } RouteRequestHandler(); RouteResult[] generateRouteFromRequest(RouteRequest request); RoutingRequest convertRouteRequest(RouteRequest request); RouteSearchParameters processRequestOptions(RouteRequestOptions options, RouteSearchParameters params); @Override int convertRouteProfileType(APIEnums.Profile profile); }
|
@Test(expected = ParameterValueException.class) public void invalidBearingLength() throws Exception { request.setBearings(new Double[][] {{123.0,123.0}}); new RouteRequestHandler().convertRouteRequest(request); }
|
public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } RouteRequestHandler(); }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } RouteRequestHandler(); RouteResult[] generateRouteFromRequest(RouteRequest request); RoutingRequest convertRouteRequest(RouteRequest request); RouteSearchParameters processRequestOptions(RouteRequestOptions options, RouteSearchParameters params); @Override int convertRouteProfileType(APIEnums.Profile profile); }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } RouteRequestHandler(); RouteResult[] generateRouteFromRequest(RouteRequest request); RoutingRequest convertRouteRequest(RouteRequest request); RouteSearchParameters processRequestOptions(RouteRequestOptions options, RouteSearchParameters params); @Override int convertRouteProfileType(APIEnums.Profile profile); }
|
@Test public void testRadius() throws StatusCodeException { request.setMaximumSearchRadii(new Double[] { 50.0, 20.0, 100.0}); RoutingRequest routingRequest = new RouteRequestHandler().convertRouteRequest(request); Assert.assertTrue(Arrays.equals(new double[] { 50.0, 20.0, 100.0 }, routingRequest.getSearchParameters().getMaximumRadiuses())); }
|
public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } RouteRequestHandler(); }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } RouteRequestHandler(); RouteResult[] generateRouteFromRequest(RouteRequest request); RoutingRequest convertRouteRequest(RouteRequest request); RouteSearchParameters processRequestOptions(RouteRequestOptions options, RouteSearchParameters params); @Override int convertRouteProfileType(APIEnums.Profile profile); }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } RouteRequestHandler(); RouteResult[] generateRouteFromRequest(RouteRequest request); RoutingRequest convertRouteRequest(RouteRequest request); RouteSearchParameters processRequestOptions(RouteRequestOptions options, RouteSearchParameters params); @Override int convertRouteProfileType(APIEnums.Profile profile); }
|
@Test(expected = ParameterValueException.class) public void invalidRadiusLength() throws Exception { request.setMaximumSearchRadii(new Double[] {10.0}); new RouteRequestHandler().convertRouteRequest(request); }
|
public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } RouteRequestHandler(); }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } RouteRequestHandler(); RouteResult[] generateRouteFromRequest(RouteRequest request); RoutingRequest convertRouteRequest(RouteRequest request); RouteSearchParameters processRequestOptions(RouteRequestOptions options, RouteSearchParameters params); @Override int convertRouteProfileType(APIEnums.Profile profile); }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } RouteRequestHandler(); RouteResult[] generateRouteFromRequest(RouteRequest request); RoutingRequest convertRouteRequest(RouteRequest request); RouteSearchParameters processRequestOptions(RouteRequestOptions options, RouteSearchParameters params); @Override int convertRouteProfileType(APIEnums.Profile profile); }
|
@Test(expected = ParameterValueException.class) public void onlySetOptimizationToFalse() throws Exception { request.setUseContractionHierarchies(true); new RouteRequestHandler().convertRouteRequest(request); }
|
public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } RouteRequestHandler(); }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } RouteRequestHandler(); RouteResult[] generateRouteFromRequest(RouteRequest request); RoutingRequest convertRouteRequest(RouteRequest request); RouteSearchParameters processRequestOptions(RouteRequestOptions options, RouteSearchParameters params); @Override int convertRouteProfileType(APIEnums.Profile profile); }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } RouteRequestHandler(); RouteResult[] generateRouteFromRequest(RouteRequest request); RoutingRequest convertRouteRequest(RouteRequest request); RouteSearchParameters processRequestOptions(RouteRequestOptions options, RouteSearchParameters params); @Override int convertRouteProfileType(APIEnums.Profile profile); }
|
@Test public void vehicleType() throws Exception{ RouteRequestOptions opts = request.getRouteOptions(); opts.setVehicleType(APIEnums.VehicleType.AGRICULTURAL); for (APIEnums.Profile profile : APIEnums.Profile.values()) { request.setProfile(profile); request.setRouteOptions(opts); if (profile != APIEnums.Profile.DRIVING_HGV) { try { new RouteRequestHandler().convertRouteRequest(request); } catch (Exception e) { Assert.assertTrue(e instanceof IncompatibleParameterException); } } else { new RouteRequestHandler().convertRouteRequest(request); } } }
|
public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } RouteRequestHandler(); }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } RouteRequestHandler(); RouteResult[] generateRouteFromRequest(RouteRequest request); RoutingRequest convertRouteRequest(RouteRequest request); RouteSearchParameters processRequestOptions(RouteRequestOptions options, RouteSearchParameters params); @Override int convertRouteProfileType(APIEnums.Profile profile); }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } RouteRequestHandler(); RouteResult[] generateRouteFromRequest(RouteRequest request); RoutingRequest convertRouteRequest(RouteRequest request); RouteSearchParameters processRequestOptions(RouteRequestOptions options, RouteSearchParameters params); @Override int convertRouteProfileType(APIEnums.Profile profile); }
|
@Test public void testSkippedSegments() throws StatusCodeException { List<Integer> skipSegments = new ArrayList<>(); skipSegments.add(0, 1); skipSegments.add(1, 2); request.setSkipSegments(skipSegments); RoutingRequest routingRequest = new RouteRequestHandler().convertRouteRequest(request); Assert.assertEquals(2, routingRequest.getSkipSegments().size()); Assert.assertEquals(Integer.valueOf(1), routingRequest.getSkipSegments().get(0)); Assert.assertEquals(Integer.valueOf(2), routingRequest.getSkipSegments().get(1)); }
|
public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } RouteRequestHandler(); }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } RouteRequestHandler(); RouteResult[] generateRouteFromRequest(RouteRequest request); RoutingRequest convertRouteRequest(RouteRequest request); RouteSearchParameters processRequestOptions(RouteRequestOptions options, RouteSearchParameters params); @Override int convertRouteProfileType(APIEnums.Profile profile); }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } RouteRequestHandler(); RouteResult[] generateRouteFromRequest(RouteRequest request); RoutingRequest convertRouteRequest(RouteRequest request); RouteSearchParameters processRequestOptions(RouteRequestOptions options, RouteSearchParameters params); @Override int convertRouteProfileType(APIEnums.Profile profile); }
|
@Test(expected = ParameterValueException.class) public void invalidSkipSegmentsLength() throws StatusCodeException { List<Integer> skip_segments = new ArrayList<>(); skip_segments.add(0, 1); skip_segments.add(0, 2); skip_segments.add(0, 2); request.setSkipSegments(skip_segments); new RouteRequestHandler().convertRouteRequest(request); }
|
public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } RouteRequestHandler(); }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } RouteRequestHandler(); RouteResult[] generateRouteFromRequest(RouteRequest request); RoutingRequest convertRouteRequest(RouteRequest request); RouteSearchParameters processRequestOptions(RouteRequestOptions options, RouteSearchParameters params); @Override int convertRouteProfileType(APIEnums.Profile profile); }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } RouteRequestHandler(); RouteResult[] generateRouteFromRequest(RouteRequest request); RoutingRequest convertRouteRequest(RouteRequest request); RouteSearchParameters processRequestOptions(RouteRequestOptions options, RouteSearchParameters params); @Override int convertRouteProfileType(APIEnums.Profile profile); }
|
@Test public void TestProcessWay() { ReaderWay rw = new ReaderWay(1); Coordinate[] cs = new Coordinate[] { new Coordinate(0.5,0.5), new Coordinate(1.5,0.5) }; _builder.processWay(rw, cs, null); Assert.assertEquals("c1", rw.getTag("country1")); Assert.assertEquals("c2", rw.getTag("country2")); ReaderWay rw2 = new ReaderWay(1); Coordinate[] cs2 = new Coordinate[] { new Coordinate(0.5,0.5), new Coordinate(0.75,0.5) }; _builder.processWay(rw2, cs2, null); Assert.assertEquals("c1", rw2.getTag("country1")); Assert.assertEquals("c1", rw2.getTag("country2")); }
|
@Override public void processWay(ReaderWay way) { LOGGER.warn("Borders requires geometry for the way!"); }
|
BordersGraphStorageBuilder extends AbstractGraphStorageBuilder { @Override public void processWay(ReaderWay way) { LOGGER.warn("Borders requires geometry for the way!"); } }
|
BordersGraphStorageBuilder extends AbstractGraphStorageBuilder { @Override public void processWay(ReaderWay way) { LOGGER.warn("Borders requires geometry for the way!"); } BordersGraphStorageBuilder(); }
|
BordersGraphStorageBuilder extends AbstractGraphStorageBuilder { @Override public void processWay(ReaderWay way) { LOGGER.warn("Borders requires geometry for the way!"); } BordersGraphStorageBuilder(); @Override GraphExtension init(GraphHopper graphhopper); void setBordersBuilder(CountryBordersReader cbr); @Override void processWay(ReaderWay way); @Override void processWay(ReaderWay way, Coordinate[] coords, HashMap<Integer, HashMap<String,String>> nodeTags); @Override void processEdge(ReaderWay way, EdgeIteratorState edge); @Override String getName(); String[] findBorderCrossing(Coordinate[] coords); CountryBordersReader getCbReader(); }
|
BordersGraphStorageBuilder extends AbstractGraphStorageBuilder { @Override public void processWay(ReaderWay way) { LOGGER.warn("Borders requires geometry for the way!"); } BordersGraphStorageBuilder(); @Override GraphExtension init(GraphHopper graphhopper); void setBordersBuilder(CountryBordersReader cbr); @Override void processWay(ReaderWay way); @Override void processWay(ReaderWay way, Coordinate[] coords, HashMap<Integer, HashMap<String,String>> nodeTags); @Override void processEdge(ReaderWay way, EdgeIteratorState edge); @Override String getName(); String[] findBorderCrossing(Coordinate[] coords); CountryBordersReader getCbReader(); static final String BUILDER_NAME; }
|
@Test(expected = EmptyElementException.class) public void emptySkipSegments() throws StatusCodeException { List<Integer> skip_segments = new ArrayList<>(); request.setSkipSegments(skip_segments); new RouteRequestHandler().convertRouteRequest(request); }
|
public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } RouteRequestHandler(); }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } RouteRequestHandler(); RouteResult[] generateRouteFromRequest(RouteRequest request); RoutingRequest convertRouteRequest(RouteRequest request); RouteSearchParameters processRequestOptions(RouteRequestOptions options, RouteSearchParameters params); @Override int convertRouteProfileType(APIEnums.Profile profile); }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } RouteRequestHandler(); RouteResult[] generateRouteFromRequest(RouteRequest request); RoutingRequest convertRouteRequest(RouteRequest request); RouteSearchParameters processRequestOptions(RouteRequestOptions options, RouteSearchParameters params); @Override int convertRouteProfileType(APIEnums.Profile profile); }
|
@Test(expected = ParameterOutOfRangeException.class) public void skipSegmentsValueTooBig() throws StatusCodeException { List<Integer> skip_segments = new ArrayList<>(); skip_segments.add(0, 99); request.setSkipSegments(skip_segments); new RouteRequestHandler().convertRouteRequest(request); }
|
public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } RouteRequestHandler(); }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } RouteRequestHandler(); RouteResult[] generateRouteFromRequest(RouteRequest request); RoutingRequest convertRouteRequest(RouteRequest request); RouteSearchParameters processRequestOptions(RouteRequestOptions options, RouteSearchParameters params); @Override int convertRouteProfileType(APIEnums.Profile profile); }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } RouteRequestHandler(); RouteResult[] generateRouteFromRequest(RouteRequest request); RoutingRequest convertRouteRequest(RouteRequest request); RouteSearchParameters processRequestOptions(RouteRequestOptions options, RouteSearchParameters params); @Override int convertRouteProfileType(APIEnums.Profile profile); }
|
@Test(expected = ParameterValueException.class) public void skipSegmentsValueTooSmall() throws StatusCodeException { List<Integer> skip_segments = new ArrayList<>(); skip_segments.add(0, -99); request.setSkipSegments(skip_segments); new RouteRequestHandler().convertRouteRequest(request); }
|
public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } RouteRequestHandler(); }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } RouteRequestHandler(); RouteResult[] generateRouteFromRequest(RouteRequest request); RoutingRequest convertRouteRequest(RouteRequest request); RouteSearchParameters processRequestOptions(RouteRequestOptions options, RouteSearchParameters params); @Override int convertRouteProfileType(APIEnums.Profile profile); }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } RouteRequestHandler(); RouteResult[] generateRouteFromRequest(RouteRequest request); RoutingRequest convertRouteRequest(RouteRequest request); RouteSearchParameters processRequestOptions(RouteRequestOptions options, RouteSearchParameters params); @Override int convertRouteProfileType(APIEnums.Profile profile); }
|
@Test public void convertRouteRequestTestForAlternativeRoutes() throws Exception { Double[][] coords = new Double[2][2]; coords[0] = new Double[] {24.5,39.2}; coords[1] = new Double[] {26.5,37.2}; RouteRequest arRequest = new RouteRequest(coords); arRequest.setProfile(APIEnums.Profile.DRIVING_CAR); RouteRequestAlternativeRoutes ar = new RouteRequestAlternativeRoutes(); ar.setTargetCount(3); ar.setShareFactor(0.9); ar.setWeightFactor(1.8); arRequest.setAlternativeRoutes(ar); RoutingRequest routingRequest = new RouteRequestHandler().convertRouteRequest(arRequest); Assert.assertEquals(3, routingRequest.getSearchParameters().getAlternativeRoutesCount()); Assert.assertEquals(0.9, routingRequest.getSearchParameters().getAlternativeRoutesShareFactor(), 0); Assert.assertEquals(1.8, routingRequest.getSearchParameters().getAlternativeRoutesWeightFactor(), 0); }
|
public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } RouteRequestHandler(); }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } RouteRequestHandler(); RouteResult[] generateRouteFromRequest(RouteRequest request); RoutingRequest convertRouteRequest(RouteRequest request); RouteSearchParameters processRequestOptions(RouteRequestOptions options, RouteSearchParameters params); @Override int convertRouteProfileType(APIEnums.Profile profile); }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } RouteRequestHandler(); RouteResult[] generateRouteFromRequest(RouteRequest request); RoutingRequest convertRouteRequest(RouteRequest request); RouteSearchParameters processRequestOptions(RouteRequestOptions options, RouteSearchParameters params); @Override int convertRouteProfileType(APIEnums.Profile profile); }
|
@Test(expected = MissingParameterException.class) public void testRoundTripNeedsLength() throws StatusCodeException { List<List<Double>> coordinates = new ArrayList<>(); coordinates.add(new ArrayList<>(Arrays.asList(12.1234, 34.3456))); request.setCoordinates(coordinates); RouteRequestRoundTripOptions rtOptions = new RouteRequestRoundTripOptions(); rtOptions.setPoints(4); RouteRequestOptions options = new RouteRequestOptions(); options.setRoundTripOptions(rtOptions); request.setRouteOptions(options); new RouteRequestHandler().convertRouteRequest(request); }
|
public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } RouteRequestHandler(); }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } RouteRequestHandler(); RouteResult[] generateRouteFromRequest(RouteRequest request); RoutingRequest convertRouteRequest(RouteRequest request); RouteSearchParameters processRequestOptions(RouteRequestOptions options, RouteSearchParameters params); @Override int convertRouteProfileType(APIEnums.Profile profile); }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } RouteRequestHandler(); RouteResult[] generateRouteFromRequest(RouteRequest request); RoutingRequest convertRouteRequest(RouteRequest request); RouteSearchParameters processRequestOptions(RouteRequestOptions options, RouteSearchParameters params); @Override int convertRouteProfileType(APIEnums.Profile profile); }
|
@Test(expected = ParameterValueException.class) public void testSingleCoordinateNotValidForNonRoundTrip() throws StatusCodeException { List<List<Double>> coordinates = new ArrayList<>(); coordinates.add(new ArrayList<>(Arrays.asList(12.1234, 34.3456))); request.setCoordinates(coordinates); new RouteRequestHandler().convertRouteRequest(request); }
|
public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } RouteRequestHandler(); }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } RouteRequestHandler(); RouteResult[] generateRouteFromRequest(RouteRequest request); RoutingRequest convertRouteRequest(RouteRequest request); RouteSearchParameters processRequestOptions(RouteRequestOptions options, RouteSearchParameters params); @Override int convertRouteProfileType(APIEnums.Profile profile); }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } RouteRequestHandler(); RouteResult[] generateRouteFromRequest(RouteRequest request); RoutingRequest convertRouteRequest(RouteRequest request); RouteSearchParameters processRequestOptions(RouteRequestOptions options, RouteSearchParameters params); @Override int convertRouteProfileType(APIEnums.Profile profile); }
|
@Test public void testSingleCoordinateValidForRoundTrip() throws StatusCodeException { List<List<Double>> coordinates = new ArrayList<>(); coordinates.add(new ArrayList<>(Arrays.asList(12.1234, 34.3456))); request.setCoordinates(coordinates); RouteRequestRoundTripOptions rtOptions = new RouteRequestRoundTripOptions(); rtOptions.setLength(400f); RouteRequestOptions options = new RouteRequestOptions(); options.setRoundTripOptions(rtOptions); request.setRouteOptions(options); RoutingRequest generatedRoutingRequest = new RouteRequestHandler().convertRouteRequest(request); Assert.assertEquals(1, generatedRoutingRequest.getCoordinates().length); }
|
public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } RouteRequestHandler(); }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } RouteRequestHandler(); RouteResult[] generateRouteFromRequest(RouteRequest request); RoutingRequest convertRouteRequest(RouteRequest request); RouteSearchParameters processRequestOptions(RouteRequestOptions options, RouteSearchParameters params); @Override int convertRouteProfileType(APIEnums.Profile profile); }
|
RouteRequestHandler extends GenericHandler { public RoutingRequest convertRouteRequest(RouteRequest request) throws StatusCodeException { RoutingRequest routingRequest = new RoutingRequest(); boolean isRoundTrip = request.hasRouteOptions() && request.getRouteOptions().hasRoundTripOptions(); routingRequest.setCoordinates(convertCoordinates(request.getCoordinates(), isRoundTrip)); routingRequest.setGeometryFormat(convertGeometryFormat(request.getResponseType())); if (request.hasUseElevation()) routingRequest.setIncludeElevation(request.getUseElevation()); if (request.hasContinueStraightAtWaypoints()) routingRequest.setContinueStraight(request.getContinueStraightAtWaypoints()); if (request.hasIncludeGeometry()) routingRequest.setIncludeGeometry(convertIncludeGeometry(request)); if (request.hasIncludeManeuvers()) routingRequest.setIncludeManeuvers(request.getIncludeManeuvers()); if (request.hasIncludeInstructions()) routingRequest.setIncludeInstructions(request.getIncludeInstructionsInResponse()); if (request.hasIncludeRoundaboutExitInfo()) routingRequest.setIncludeRoundaboutExits(request.getIncludeRoundaboutExitInfo()); if (request.hasAttributes()) routingRequest.setAttributes(convertAttributes(request.getAttributes())); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); for (APIEnums.ExtraInfo extra : request.getExtraInfo()) { if (extra.compareTo(APIEnums.ExtraInfo.COUNTRY_INFO) == 0) { routingRequest.setIncludeCountryInfo(true); } } } if (request.hasLanguage()) routingRequest.setLanguage(convertLanguage(request.getLanguage())); if (request.hasInstructionsFormat()) routingRequest.setInstructionsFormat(convertInstructionsFormat(request.getInstructionsFormat())); if (request.hasUnits()) routingRequest.setUnits(convertUnits(request.getUnits())); if (request.hasSimplifyGeometry()) { routingRequest.setGeometrySimplify(request.getSimplifyGeometry()); if (request.hasExtraInfo() && request.getSimplifyGeometry()) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_SIMPLIFY_GEOMETRY, "true", RouteRequest.PARAM_EXTRA_INFO, "*"); } } if (request.hasSkipSegments()) { routingRequest.setSkipSegments(processSkipSegments(request)); } if (request.hasId()) routingRequest.setId(request.getId()); if (request.hasMaximumSpeed()) { routingRequest.setMaximumSpeed(request.getMaximumSpeed()); } int profileType = -1; int coordinatesLength = request.getCoordinates().size(); RouteSearchParameters params = new RouteSearchParameters(); if (request.hasExtraInfo()) { routingRequest.setExtraInfo(convertExtraInfo(request.getExtraInfo())); params.setExtraInfo(convertExtraInfo(request.getExtraInfo())); } if (request.hasSuppressWarnings()) params.setSuppressWarnings(request.getSuppressWarnings()); try { profileType = convertRouteProfileType(request.getProfile()); params.setProfileType(profileType); } catch (Exception e) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_PROFILE); } if (request.hasRoutePreference()) params.setWeightingMethod(convertWeightingMethod(request.getRoutePreference())); if (request.hasBearings()) params.setBearings(convertBearings(request.getBearings(), coordinatesLength)); if (request.hasMaximumSearchRadii()) params.setMaximumRadiuses(convertMaxRadii(request.getMaximumSearchRadii(), coordinatesLength, profileType)); if (request.hasUseContractionHierarchies()) { params.setFlexibleMode(convertSetFlexibleMode(request.getUseContractionHierarchies())); params.setOptimized(request.getUseContractionHierarchies()); } if (request.hasRouteOptions()) { params = processRouteRequestOptions(request, params); } if (request.hasAlternativeRoutes()) { if (request.getCoordinates().size() > 2) { throw new IncompatibleParameterException(RoutingErrorCodes.INCOMPATIBLE_PARAMETERS, RouteRequest.PARAM_ALTERNATIVE_ROUTES, "(number of waypoints > 2)"); } RouteRequestAlternativeRoutes alternativeRoutes = request.getAlternativeRoutes(); if (alternativeRoutes.hasTargetCount()) { params.setAlternativeRoutesCount(alternativeRoutes.getTargetCount()); String paramMaxAlternativeRoutesCount = AppConfig.getGlobal().getRoutingProfileParameter(request.getProfile().toString(), "maximum_alternative_routes"); int countLimit = StringUtility.isNullOrEmpty(paramMaxAlternativeRoutesCount) ? 0 : Integer.parseInt(paramMaxAlternativeRoutesCount); if (countLimit > 0 && alternativeRoutes.getTargetCount() > countLimit) { throw new ParameterValueException(RoutingErrorCodes.INVALID_PARAMETER_VALUE, RouteRequest.PARAM_ALTERNATIVE_ROUTES, Integer.toString(alternativeRoutes.getTargetCount()), "The target alternative routes count has to be equal to or less than " + paramMaxAlternativeRoutesCount); } } if (alternativeRoutes.hasWeightFactor()) params.setAlternativeRoutesWeightFactor(alternativeRoutes.getWeightFactor()); if (alternativeRoutes.hasShareFactor()) params.setAlternativeRoutesShareFactor(alternativeRoutes.getShareFactor()); } if (request.hasMaximumSpeed()) { params.setMaximumSpeed(request.getMaximumSpeed()); } params.setConsiderTurnRestrictions(false); routingRequest.setSearchParameters(params); return routingRequest; } RouteRequestHandler(); RouteResult[] generateRouteFromRequest(RouteRequest request); RoutingRequest convertRouteRequest(RouteRequest request); RouteSearchParameters processRequestOptions(RouteRequestOptions options, RouteSearchParameters params); @Override int convertRouteProfileType(APIEnums.Profile profile); }
|
@Test public void testHasIncludeRoundaboutExitInfo() { request.setIncludeRoundaboutExitInfo(true); Assert.assertTrue(request.hasIncludeRoundaboutExitInfo()); }
|
public boolean hasIncludeRoundaboutExitInfo() { return hasIncludeRoundaboutExitInfo; }
|
RouteRequest { public boolean hasIncludeRoundaboutExitInfo() { return hasIncludeRoundaboutExitInfo; } }
|
RouteRequest { public boolean hasIncludeRoundaboutExitInfo() { return hasIncludeRoundaboutExitInfo; } @JsonCreator RouteRequest(@JsonProperty(value = PARAM_COORDINATES, required = true) List<List<Double>> coordinates); RouteRequest(Double[][] coordinates); RouteRequest(Coordinate start, Coordinate end); }
|
RouteRequest { public boolean hasIncludeRoundaboutExitInfo() { return hasIncludeRoundaboutExitInfo; } @JsonCreator RouteRequest(@JsonProperty(value = PARAM_COORDINATES, required = true) List<List<Double>> coordinates); RouteRequest(Double[][] coordinates); RouteRequest(Coordinate start, Coordinate end); String getId(); void setId(String id); boolean hasId(); List<List<Double>> getCoordinates(); void setCoordinates(List<List<Double>> coordinates); APIEnums.Profile getProfile(); void setProfile(APIEnums.Profile profile); APIEnums.Units getUnits(); void setUnits(APIEnums.Units units); APIEnums.Languages getLanguage(); void setLanguage(APIEnums.Languages language); APIEnums.RoutePreference getRoutePreference(); void setRoutePreference(APIEnums.RoutePreference routePreference); boolean hasRoutePreference(); APIEnums.RouteResponseType getResponseType(); void setResponseType(APIEnums.RouteResponseType responseType); APIEnums.ExtraInfo[] getExtraInfo(); void setExtraInfo(APIEnums.ExtraInfo[] extraInfo); RouteRequestOptions getRouteOptions(); void setRouteOptions(RouteRequestOptions routeOptions); boolean getIncludeGeometry(); void setIncludeGeometry(boolean includeGeometry); boolean getIncludeInstructionsInResponse(); void setIncludeInstructionsInResponse(Boolean includeInstructionsInResponse); APIEnums.InstructionsFormat getInstructionsFormat(); void setInstructionsFormat(APIEnums.InstructionsFormat instructionsFormat); boolean getIncludeRoundaboutExitInfo(); void setIncludeRoundaboutExitInfo(Boolean includeRoundaboutExitInfo); APIEnums.Attributes[] getAttributes(); void setAttributes(APIEnums.Attributes[] attributes); boolean getIncludeManeuvers(); void setIncludeManeuvers(Boolean includeManeuvers); Double[] getMaximumSearchRadii(); void setMaximumSearchRadii(Double[] maximumSearchRadii); Double[][] getBearings(); void setBearings(Double[][] bearings); boolean getContinueStraightAtWaypoints(); void setContinueStraightAtWaypoints(Boolean continueStraightAtWaypoints); boolean getUseElevation(); void setUseElevation(Boolean useElevation); boolean getUseContractionHierarchies(); void setUseContractionHierarchies(Boolean useContractionHierarchies); boolean getSuppressWarnings(); void setSuppressWarnings(boolean suppressWarnings); boolean getSimplifyGeometry(); void setSimplifyGeometry(boolean simplifyGeometry); List<Integer> getSkipSegments(); void setSkipSegments(List<Integer> skipSegments); RouteRequestAlternativeRoutes getAlternativeRoutes(); void setAlternativeRoutes(RouteRequestAlternativeRoutes alternativeRoutes); void setMaximumSpeed(Double maximumSpeed); double getMaximumSpeed(); boolean hasIncludeRoundaboutExitInfo(); boolean hasAttributes(); boolean hasIncludeManeuvers(); boolean hasMaximumSearchRadii(); boolean hasBearings(); boolean hasContinueStraightAtWaypoints(); boolean hasIncludeInstructions(); boolean hasIncludeGeometry(); boolean hasLanguage(); boolean hasInstructionsFormat(); boolean hasUnits(); boolean hasUseElevation(); boolean hasRouteOptions(); boolean hasUseContractionHierarchies(); boolean hasExtraInfo(); boolean hasSuppressWarnings(); boolean hasSimplifyGeometry(); boolean hasSkipSegments(); boolean hasAlternativeRoutes(); boolean hasMaximumSpeed(); }
|
RouteRequest { public boolean hasIncludeRoundaboutExitInfo() { return hasIncludeRoundaboutExitInfo; } @JsonCreator RouteRequest(@JsonProperty(value = PARAM_COORDINATES, required = true) List<List<Double>> coordinates); RouteRequest(Double[][] coordinates); RouteRequest(Coordinate start, Coordinate end); String getId(); void setId(String id); boolean hasId(); List<List<Double>> getCoordinates(); void setCoordinates(List<List<Double>> coordinates); APIEnums.Profile getProfile(); void setProfile(APIEnums.Profile profile); APIEnums.Units getUnits(); void setUnits(APIEnums.Units units); APIEnums.Languages getLanguage(); void setLanguage(APIEnums.Languages language); APIEnums.RoutePreference getRoutePreference(); void setRoutePreference(APIEnums.RoutePreference routePreference); boolean hasRoutePreference(); APIEnums.RouteResponseType getResponseType(); void setResponseType(APIEnums.RouteResponseType responseType); APIEnums.ExtraInfo[] getExtraInfo(); void setExtraInfo(APIEnums.ExtraInfo[] extraInfo); RouteRequestOptions getRouteOptions(); void setRouteOptions(RouteRequestOptions routeOptions); boolean getIncludeGeometry(); void setIncludeGeometry(boolean includeGeometry); boolean getIncludeInstructionsInResponse(); void setIncludeInstructionsInResponse(Boolean includeInstructionsInResponse); APIEnums.InstructionsFormat getInstructionsFormat(); void setInstructionsFormat(APIEnums.InstructionsFormat instructionsFormat); boolean getIncludeRoundaboutExitInfo(); void setIncludeRoundaboutExitInfo(Boolean includeRoundaboutExitInfo); APIEnums.Attributes[] getAttributes(); void setAttributes(APIEnums.Attributes[] attributes); boolean getIncludeManeuvers(); void setIncludeManeuvers(Boolean includeManeuvers); Double[] getMaximumSearchRadii(); void setMaximumSearchRadii(Double[] maximumSearchRadii); Double[][] getBearings(); void setBearings(Double[][] bearings); boolean getContinueStraightAtWaypoints(); void setContinueStraightAtWaypoints(Boolean continueStraightAtWaypoints); boolean getUseElevation(); void setUseElevation(Boolean useElevation); boolean getUseContractionHierarchies(); void setUseContractionHierarchies(Boolean useContractionHierarchies); boolean getSuppressWarnings(); void setSuppressWarnings(boolean suppressWarnings); boolean getSimplifyGeometry(); void setSimplifyGeometry(boolean simplifyGeometry); List<Integer> getSkipSegments(); void setSkipSegments(List<Integer> skipSegments); RouteRequestAlternativeRoutes getAlternativeRoutes(); void setAlternativeRoutes(RouteRequestAlternativeRoutes alternativeRoutes); void setMaximumSpeed(Double maximumSpeed); double getMaximumSpeed(); boolean hasIncludeRoundaboutExitInfo(); boolean hasAttributes(); boolean hasIncludeManeuvers(); boolean hasMaximumSearchRadii(); boolean hasBearings(); boolean hasContinueStraightAtWaypoints(); boolean hasIncludeInstructions(); boolean hasIncludeGeometry(); boolean hasLanguage(); boolean hasInstructionsFormat(); boolean hasUnits(); boolean hasUseElevation(); boolean hasRouteOptions(); boolean hasUseContractionHierarchies(); boolean hasExtraInfo(); boolean hasSuppressWarnings(); boolean hasSimplifyGeometry(); boolean hasSkipSegments(); boolean hasAlternativeRoutes(); boolean hasMaximumSpeed(); static final String PARAM_ID; static final String PARAM_COORDINATES; static final String PARAM_PROFILE; static final String PARAM_PREFERENCE; static final String PARAM_FORMAT; static final String PARAM_UNITS; static final String PARAM_LANGUAGE; static final String PARAM_GEOMETRY; static final String PARAM_INSTRUCTIONS; static final String PARAM_INSTRUCTIONS_FORMAT; static final String PARAM_ROUNDABOUT_EXITS; static final String PARAM_ATTRIBUTES; static final String PARAM_MANEUVERS; static final String PARAM_RADII; static final String PARAM_BEARINGS; static final String PARAM_CONTINUE_STRAIGHT; static final String PARAM_ELEVATION; static final String PARAM_EXTRA_INFO; static final String PARAM_OPTIMIZED; static final String PARAM_OPTIONS; static final String PARAM_SUPPRESS_WARNINGS; static final String PARAM_SIMPLIFY_GEOMETRY; static final String PARAM_SKIP_SEGMENTS; static final String PARAM_ALTERNATIVE_ROUTES; static final String PARAM_MAXIMUM_SPEED; }
|
@Test public void testHasAttributes() { request.setAttributes(new APIEnums.Attributes[] {APIEnums.Attributes.AVERAGE_SPEED}); Assert.assertTrue(request.hasAttributes()); }
|
public boolean hasAttributes() { return hasAttributes; }
|
RouteRequest { public boolean hasAttributes() { return hasAttributes; } }
|
RouteRequest { public boolean hasAttributes() { return hasAttributes; } @JsonCreator RouteRequest(@JsonProperty(value = PARAM_COORDINATES, required = true) List<List<Double>> coordinates); RouteRequest(Double[][] coordinates); RouteRequest(Coordinate start, Coordinate end); }
|
RouteRequest { public boolean hasAttributes() { return hasAttributes; } @JsonCreator RouteRequest(@JsonProperty(value = PARAM_COORDINATES, required = true) List<List<Double>> coordinates); RouteRequest(Double[][] coordinates); RouteRequest(Coordinate start, Coordinate end); String getId(); void setId(String id); boolean hasId(); List<List<Double>> getCoordinates(); void setCoordinates(List<List<Double>> coordinates); APIEnums.Profile getProfile(); void setProfile(APIEnums.Profile profile); APIEnums.Units getUnits(); void setUnits(APIEnums.Units units); APIEnums.Languages getLanguage(); void setLanguage(APIEnums.Languages language); APIEnums.RoutePreference getRoutePreference(); void setRoutePreference(APIEnums.RoutePreference routePreference); boolean hasRoutePreference(); APIEnums.RouteResponseType getResponseType(); void setResponseType(APIEnums.RouteResponseType responseType); APIEnums.ExtraInfo[] getExtraInfo(); void setExtraInfo(APIEnums.ExtraInfo[] extraInfo); RouteRequestOptions getRouteOptions(); void setRouteOptions(RouteRequestOptions routeOptions); boolean getIncludeGeometry(); void setIncludeGeometry(boolean includeGeometry); boolean getIncludeInstructionsInResponse(); void setIncludeInstructionsInResponse(Boolean includeInstructionsInResponse); APIEnums.InstructionsFormat getInstructionsFormat(); void setInstructionsFormat(APIEnums.InstructionsFormat instructionsFormat); boolean getIncludeRoundaboutExitInfo(); void setIncludeRoundaboutExitInfo(Boolean includeRoundaboutExitInfo); APIEnums.Attributes[] getAttributes(); void setAttributes(APIEnums.Attributes[] attributes); boolean getIncludeManeuvers(); void setIncludeManeuvers(Boolean includeManeuvers); Double[] getMaximumSearchRadii(); void setMaximumSearchRadii(Double[] maximumSearchRadii); Double[][] getBearings(); void setBearings(Double[][] bearings); boolean getContinueStraightAtWaypoints(); void setContinueStraightAtWaypoints(Boolean continueStraightAtWaypoints); boolean getUseElevation(); void setUseElevation(Boolean useElevation); boolean getUseContractionHierarchies(); void setUseContractionHierarchies(Boolean useContractionHierarchies); boolean getSuppressWarnings(); void setSuppressWarnings(boolean suppressWarnings); boolean getSimplifyGeometry(); void setSimplifyGeometry(boolean simplifyGeometry); List<Integer> getSkipSegments(); void setSkipSegments(List<Integer> skipSegments); RouteRequestAlternativeRoutes getAlternativeRoutes(); void setAlternativeRoutes(RouteRequestAlternativeRoutes alternativeRoutes); void setMaximumSpeed(Double maximumSpeed); double getMaximumSpeed(); boolean hasIncludeRoundaboutExitInfo(); boolean hasAttributes(); boolean hasIncludeManeuvers(); boolean hasMaximumSearchRadii(); boolean hasBearings(); boolean hasContinueStraightAtWaypoints(); boolean hasIncludeInstructions(); boolean hasIncludeGeometry(); boolean hasLanguage(); boolean hasInstructionsFormat(); boolean hasUnits(); boolean hasUseElevation(); boolean hasRouteOptions(); boolean hasUseContractionHierarchies(); boolean hasExtraInfo(); boolean hasSuppressWarnings(); boolean hasSimplifyGeometry(); boolean hasSkipSegments(); boolean hasAlternativeRoutes(); boolean hasMaximumSpeed(); }
|
RouteRequest { public boolean hasAttributes() { return hasAttributes; } @JsonCreator RouteRequest(@JsonProperty(value = PARAM_COORDINATES, required = true) List<List<Double>> coordinates); RouteRequest(Double[][] coordinates); RouteRequest(Coordinate start, Coordinate end); String getId(); void setId(String id); boolean hasId(); List<List<Double>> getCoordinates(); void setCoordinates(List<List<Double>> coordinates); APIEnums.Profile getProfile(); void setProfile(APIEnums.Profile profile); APIEnums.Units getUnits(); void setUnits(APIEnums.Units units); APIEnums.Languages getLanguage(); void setLanguage(APIEnums.Languages language); APIEnums.RoutePreference getRoutePreference(); void setRoutePreference(APIEnums.RoutePreference routePreference); boolean hasRoutePreference(); APIEnums.RouteResponseType getResponseType(); void setResponseType(APIEnums.RouteResponseType responseType); APIEnums.ExtraInfo[] getExtraInfo(); void setExtraInfo(APIEnums.ExtraInfo[] extraInfo); RouteRequestOptions getRouteOptions(); void setRouteOptions(RouteRequestOptions routeOptions); boolean getIncludeGeometry(); void setIncludeGeometry(boolean includeGeometry); boolean getIncludeInstructionsInResponse(); void setIncludeInstructionsInResponse(Boolean includeInstructionsInResponse); APIEnums.InstructionsFormat getInstructionsFormat(); void setInstructionsFormat(APIEnums.InstructionsFormat instructionsFormat); boolean getIncludeRoundaboutExitInfo(); void setIncludeRoundaboutExitInfo(Boolean includeRoundaboutExitInfo); APIEnums.Attributes[] getAttributes(); void setAttributes(APIEnums.Attributes[] attributes); boolean getIncludeManeuvers(); void setIncludeManeuvers(Boolean includeManeuvers); Double[] getMaximumSearchRadii(); void setMaximumSearchRadii(Double[] maximumSearchRadii); Double[][] getBearings(); void setBearings(Double[][] bearings); boolean getContinueStraightAtWaypoints(); void setContinueStraightAtWaypoints(Boolean continueStraightAtWaypoints); boolean getUseElevation(); void setUseElevation(Boolean useElevation); boolean getUseContractionHierarchies(); void setUseContractionHierarchies(Boolean useContractionHierarchies); boolean getSuppressWarnings(); void setSuppressWarnings(boolean suppressWarnings); boolean getSimplifyGeometry(); void setSimplifyGeometry(boolean simplifyGeometry); List<Integer> getSkipSegments(); void setSkipSegments(List<Integer> skipSegments); RouteRequestAlternativeRoutes getAlternativeRoutes(); void setAlternativeRoutes(RouteRequestAlternativeRoutes alternativeRoutes); void setMaximumSpeed(Double maximumSpeed); double getMaximumSpeed(); boolean hasIncludeRoundaboutExitInfo(); boolean hasAttributes(); boolean hasIncludeManeuvers(); boolean hasMaximumSearchRadii(); boolean hasBearings(); boolean hasContinueStraightAtWaypoints(); boolean hasIncludeInstructions(); boolean hasIncludeGeometry(); boolean hasLanguage(); boolean hasInstructionsFormat(); boolean hasUnits(); boolean hasUseElevation(); boolean hasRouteOptions(); boolean hasUseContractionHierarchies(); boolean hasExtraInfo(); boolean hasSuppressWarnings(); boolean hasSimplifyGeometry(); boolean hasSkipSegments(); boolean hasAlternativeRoutes(); boolean hasMaximumSpeed(); static final String PARAM_ID; static final String PARAM_COORDINATES; static final String PARAM_PROFILE; static final String PARAM_PREFERENCE; static final String PARAM_FORMAT; static final String PARAM_UNITS; static final String PARAM_LANGUAGE; static final String PARAM_GEOMETRY; static final String PARAM_INSTRUCTIONS; static final String PARAM_INSTRUCTIONS_FORMAT; static final String PARAM_ROUNDABOUT_EXITS; static final String PARAM_ATTRIBUTES; static final String PARAM_MANEUVERS; static final String PARAM_RADII; static final String PARAM_BEARINGS; static final String PARAM_CONTINUE_STRAIGHT; static final String PARAM_ELEVATION; static final String PARAM_EXTRA_INFO; static final String PARAM_OPTIMIZED; static final String PARAM_OPTIONS; static final String PARAM_SUPPRESS_WARNINGS; static final String PARAM_SIMPLIFY_GEOMETRY; static final String PARAM_SKIP_SEGMENTS; static final String PARAM_ALTERNATIVE_ROUTES; static final String PARAM_MAXIMUM_SPEED; }
|
@Test public void testHasMaximumSearchRadii() { request.setMaximumSearchRadii(new Double[] { 1.0 }); Assert.assertTrue(request.hasMaximumSearchRadii()); }
|
public boolean hasMaximumSearchRadii() { return hasMaximumSearchRadii; }
|
RouteRequest { public boolean hasMaximumSearchRadii() { return hasMaximumSearchRadii; } }
|
RouteRequest { public boolean hasMaximumSearchRadii() { return hasMaximumSearchRadii; } @JsonCreator RouteRequest(@JsonProperty(value = PARAM_COORDINATES, required = true) List<List<Double>> coordinates); RouteRequest(Double[][] coordinates); RouteRequest(Coordinate start, Coordinate end); }
|
RouteRequest { public boolean hasMaximumSearchRadii() { return hasMaximumSearchRadii; } @JsonCreator RouteRequest(@JsonProperty(value = PARAM_COORDINATES, required = true) List<List<Double>> coordinates); RouteRequest(Double[][] coordinates); RouteRequest(Coordinate start, Coordinate end); String getId(); void setId(String id); boolean hasId(); List<List<Double>> getCoordinates(); void setCoordinates(List<List<Double>> coordinates); APIEnums.Profile getProfile(); void setProfile(APIEnums.Profile profile); APIEnums.Units getUnits(); void setUnits(APIEnums.Units units); APIEnums.Languages getLanguage(); void setLanguage(APIEnums.Languages language); APIEnums.RoutePreference getRoutePreference(); void setRoutePreference(APIEnums.RoutePreference routePreference); boolean hasRoutePreference(); APIEnums.RouteResponseType getResponseType(); void setResponseType(APIEnums.RouteResponseType responseType); APIEnums.ExtraInfo[] getExtraInfo(); void setExtraInfo(APIEnums.ExtraInfo[] extraInfo); RouteRequestOptions getRouteOptions(); void setRouteOptions(RouteRequestOptions routeOptions); boolean getIncludeGeometry(); void setIncludeGeometry(boolean includeGeometry); boolean getIncludeInstructionsInResponse(); void setIncludeInstructionsInResponse(Boolean includeInstructionsInResponse); APIEnums.InstructionsFormat getInstructionsFormat(); void setInstructionsFormat(APIEnums.InstructionsFormat instructionsFormat); boolean getIncludeRoundaboutExitInfo(); void setIncludeRoundaboutExitInfo(Boolean includeRoundaboutExitInfo); APIEnums.Attributes[] getAttributes(); void setAttributes(APIEnums.Attributes[] attributes); boolean getIncludeManeuvers(); void setIncludeManeuvers(Boolean includeManeuvers); Double[] getMaximumSearchRadii(); void setMaximumSearchRadii(Double[] maximumSearchRadii); Double[][] getBearings(); void setBearings(Double[][] bearings); boolean getContinueStraightAtWaypoints(); void setContinueStraightAtWaypoints(Boolean continueStraightAtWaypoints); boolean getUseElevation(); void setUseElevation(Boolean useElevation); boolean getUseContractionHierarchies(); void setUseContractionHierarchies(Boolean useContractionHierarchies); boolean getSuppressWarnings(); void setSuppressWarnings(boolean suppressWarnings); boolean getSimplifyGeometry(); void setSimplifyGeometry(boolean simplifyGeometry); List<Integer> getSkipSegments(); void setSkipSegments(List<Integer> skipSegments); RouteRequestAlternativeRoutes getAlternativeRoutes(); void setAlternativeRoutes(RouteRequestAlternativeRoutes alternativeRoutes); void setMaximumSpeed(Double maximumSpeed); double getMaximumSpeed(); boolean hasIncludeRoundaboutExitInfo(); boolean hasAttributes(); boolean hasIncludeManeuvers(); boolean hasMaximumSearchRadii(); boolean hasBearings(); boolean hasContinueStraightAtWaypoints(); boolean hasIncludeInstructions(); boolean hasIncludeGeometry(); boolean hasLanguage(); boolean hasInstructionsFormat(); boolean hasUnits(); boolean hasUseElevation(); boolean hasRouteOptions(); boolean hasUseContractionHierarchies(); boolean hasExtraInfo(); boolean hasSuppressWarnings(); boolean hasSimplifyGeometry(); boolean hasSkipSegments(); boolean hasAlternativeRoutes(); boolean hasMaximumSpeed(); }
|
RouteRequest { public boolean hasMaximumSearchRadii() { return hasMaximumSearchRadii; } @JsonCreator RouteRequest(@JsonProperty(value = PARAM_COORDINATES, required = true) List<List<Double>> coordinates); RouteRequest(Double[][] coordinates); RouteRequest(Coordinate start, Coordinate end); String getId(); void setId(String id); boolean hasId(); List<List<Double>> getCoordinates(); void setCoordinates(List<List<Double>> coordinates); APIEnums.Profile getProfile(); void setProfile(APIEnums.Profile profile); APIEnums.Units getUnits(); void setUnits(APIEnums.Units units); APIEnums.Languages getLanguage(); void setLanguage(APIEnums.Languages language); APIEnums.RoutePreference getRoutePreference(); void setRoutePreference(APIEnums.RoutePreference routePreference); boolean hasRoutePreference(); APIEnums.RouteResponseType getResponseType(); void setResponseType(APIEnums.RouteResponseType responseType); APIEnums.ExtraInfo[] getExtraInfo(); void setExtraInfo(APIEnums.ExtraInfo[] extraInfo); RouteRequestOptions getRouteOptions(); void setRouteOptions(RouteRequestOptions routeOptions); boolean getIncludeGeometry(); void setIncludeGeometry(boolean includeGeometry); boolean getIncludeInstructionsInResponse(); void setIncludeInstructionsInResponse(Boolean includeInstructionsInResponse); APIEnums.InstructionsFormat getInstructionsFormat(); void setInstructionsFormat(APIEnums.InstructionsFormat instructionsFormat); boolean getIncludeRoundaboutExitInfo(); void setIncludeRoundaboutExitInfo(Boolean includeRoundaboutExitInfo); APIEnums.Attributes[] getAttributes(); void setAttributes(APIEnums.Attributes[] attributes); boolean getIncludeManeuvers(); void setIncludeManeuvers(Boolean includeManeuvers); Double[] getMaximumSearchRadii(); void setMaximumSearchRadii(Double[] maximumSearchRadii); Double[][] getBearings(); void setBearings(Double[][] bearings); boolean getContinueStraightAtWaypoints(); void setContinueStraightAtWaypoints(Boolean continueStraightAtWaypoints); boolean getUseElevation(); void setUseElevation(Boolean useElevation); boolean getUseContractionHierarchies(); void setUseContractionHierarchies(Boolean useContractionHierarchies); boolean getSuppressWarnings(); void setSuppressWarnings(boolean suppressWarnings); boolean getSimplifyGeometry(); void setSimplifyGeometry(boolean simplifyGeometry); List<Integer> getSkipSegments(); void setSkipSegments(List<Integer> skipSegments); RouteRequestAlternativeRoutes getAlternativeRoutes(); void setAlternativeRoutes(RouteRequestAlternativeRoutes alternativeRoutes); void setMaximumSpeed(Double maximumSpeed); double getMaximumSpeed(); boolean hasIncludeRoundaboutExitInfo(); boolean hasAttributes(); boolean hasIncludeManeuvers(); boolean hasMaximumSearchRadii(); boolean hasBearings(); boolean hasContinueStraightAtWaypoints(); boolean hasIncludeInstructions(); boolean hasIncludeGeometry(); boolean hasLanguage(); boolean hasInstructionsFormat(); boolean hasUnits(); boolean hasUseElevation(); boolean hasRouteOptions(); boolean hasUseContractionHierarchies(); boolean hasExtraInfo(); boolean hasSuppressWarnings(); boolean hasSimplifyGeometry(); boolean hasSkipSegments(); boolean hasAlternativeRoutes(); boolean hasMaximumSpeed(); static final String PARAM_ID; static final String PARAM_COORDINATES; static final String PARAM_PROFILE; static final String PARAM_PREFERENCE; static final String PARAM_FORMAT; static final String PARAM_UNITS; static final String PARAM_LANGUAGE; static final String PARAM_GEOMETRY; static final String PARAM_INSTRUCTIONS; static final String PARAM_INSTRUCTIONS_FORMAT; static final String PARAM_ROUNDABOUT_EXITS; static final String PARAM_ATTRIBUTES; static final String PARAM_MANEUVERS; static final String PARAM_RADII; static final String PARAM_BEARINGS; static final String PARAM_CONTINUE_STRAIGHT; static final String PARAM_ELEVATION; static final String PARAM_EXTRA_INFO; static final String PARAM_OPTIMIZED; static final String PARAM_OPTIONS; static final String PARAM_SUPPRESS_WARNINGS; static final String PARAM_SIMPLIFY_GEOMETRY; static final String PARAM_SKIP_SEGMENTS; static final String PARAM_ALTERNATIVE_ROUTES; static final String PARAM_MAXIMUM_SPEED; }
|
@Test public void TestFindBorderCrossing() { String[] names = _builder.findBorderCrossing(new Coordinate[] { new Coordinate(0.5,0.5), new Coordinate(1.5,0.5) }); Assert.assertEquals(2, names.length); Assert.assertTrue(names[0].equals("c1") || names[1].equals("c1")); Assert.assertTrue(names[0].equals("c2") || names[1].equals("c2")); }
|
public String[] findBorderCrossing(Coordinate[] coords) { ArrayList<CountryBordersPolygon> countries = new ArrayList<>(); boolean hasInternational = false; boolean overlap = false; int lsLen = coords.length; if(lsLen > 1) { for(int i=0; i<lsLen; i++) { Coordinate c = coords[i]; if(!Double.isNaN(c.x) && !Double.isNaN(c.y)) { CountryBordersPolygon[] cnts = cbReader.getCandidateCountry(c); for (CountryBordersPolygon cbp : cnts) { if (!countries.contains(cbp)) { countries.add(cbp); } } if(cnts.length == 0) hasInternational = true; } } } if(countries.size() > 1) { ArrayList<CountryBordersPolygon> temp = new ArrayList<>(); for(int i=0; i<lsLen; i++) { Coordinate c = coords[i]; if(!Double.isNaN(c.x) && !Double.isNaN(c.y)) { boolean found = false; int countriesFound = 0; for(CountryBordersPolygon cbp : countries) { if (cbp.inArea(c)) { found = true; countriesFound++; if(!temp.contains(cbp)) { temp.add(cbp); } } } if(countriesFound > 1) { overlap = true; } if(!found) { hasInternational = true; } } } countries = temp; } if(countries.size() > 1 && overlap) { boolean crosses = false; LineString ls = gf.createLineString(coords); for (CountryBordersPolygon cp : countries) { if (cp.crossesBoundary(ls)) { crosses = true; break; } } if(!crosses) { CountryBordersPolygon cp = countries.get(0); countries.clear(); countries.add(cp); } } ArrayList<String> names = new ArrayList<>(); for(int i=0; i<countries.size(); i++) { if (!names.contains(countries.get(i).getName())) names.add(countries.get(i).getName()); } if(hasInternational && !countries.isEmpty()) { names.add(CountryBordersReader.INTERNATIONAL_NAME); } return names.toArray(new String[names.size()]); }
|
BordersGraphStorageBuilder extends AbstractGraphStorageBuilder { public String[] findBorderCrossing(Coordinate[] coords) { ArrayList<CountryBordersPolygon> countries = new ArrayList<>(); boolean hasInternational = false; boolean overlap = false; int lsLen = coords.length; if(lsLen > 1) { for(int i=0; i<lsLen; i++) { Coordinate c = coords[i]; if(!Double.isNaN(c.x) && !Double.isNaN(c.y)) { CountryBordersPolygon[] cnts = cbReader.getCandidateCountry(c); for (CountryBordersPolygon cbp : cnts) { if (!countries.contains(cbp)) { countries.add(cbp); } } if(cnts.length == 0) hasInternational = true; } } } if(countries.size() > 1) { ArrayList<CountryBordersPolygon> temp = new ArrayList<>(); for(int i=0; i<lsLen; i++) { Coordinate c = coords[i]; if(!Double.isNaN(c.x) && !Double.isNaN(c.y)) { boolean found = false; int countriesFound = 0; for(CountryBordersPolygon cbp : countries) { if (cbp.inArea(c)) { found = true; countriesFound++; if(!temp.contains(cbp)) { temp.add(cbp); } } } if(countriesFound > 1) { overlap = true; } if(!found) { hasInternational = true; } } } countries = temp; } if(countries.size() > 1 && overlap) { boolean crosses = false; LineString ls = gf.createLineString(coords); for (CountryBordersPolygon cp : countries) { if (cp.crossesBoundary(ls)) { crosses = true; break; } } if(!crosses) { CountryBordersPolygon cp = countries.get(0); countries.clear(); countries.add(cp); } } ArrayList<String> names = new ArrayList<>(); for(int i=0; i<countries.size(); i++) { if (!names.contains(countries.get(i).getName())) names.add(countries.get(i).getName()); } if(hasInternational && !countries.isEmpty()) { names.add(CountryBordersReader.INTERNATIONAL_NAME); } return names.toArray(new String[names.size()]); } }
|
BordersGraphStorageBuilder extends AbstractGraphStorageBuilder { public String[] findBorderCrossing(Coordinate[] coords) { ArrayList<CountryBordersPolygon> countries = new ArrayList<>(); boolean hasInternational = false; boolean overlap = false; int lsLen = coords.length; if(lsLen > 1) { for(int i=0; i<lsLen; i++) { Coordinate c = coords[i]; if(!Double.isNaN(c.x) && !Double.isNaN(c.y)) { CountryBordersPolygon[] cnts = cbReader.getCandidateCountry(c); for (CountryBordersPolygon cbp : cnts) { if (!countries.contains(cbp)) { countries.add(cbp); } } if(cnts.length == 0) hasInternational = true; } } } if(countries.size() > 1) { ArrayList<CountryBordersPolygon> temp = new ArrayList<>(); for(int i=0; i<lsLen; i++) { Coordinate c = coords[i]; if(!Double.isNaN(c.x) && !Double.isNaN(c.y)) { boolean found = false; int countriesFound = 0; for(CountryBordersPolygon cbp : countries) { if (cbp.inArea(c)) { found = true; countriesFound++; if(!temp.contains(cbp)) { temp.add(cbp); } } } if(countriesFound > 1) { overlap = true; } if(!found) { hasInternational = true; } } } countries = temp; } if(countries.size() > 1 && overlap) { boolean crosses = false; LineString ls = gf.createLineString(coords); for (CountryBordersPolygon cp : countries) { if (cp.crossesBoundary(ls)) { crosses = true; break; } } if(!crosses) { CountryBordersPolygon cp = countries.get(0); countries.clear(); countries.add(cp); } } ArrayList<String> names = new ArrayList<>(); for(int i=0; i<countries.size(); i++) { if (!names.contains(countries.get(i).getName())) names.add(countries.get(i).getName()); } if(hasInternational && !countries.isEmpty()) { names.add(CountryBordersReader.INTERNATIONAL_NAME); } return names.toArray(new String[names.size()]); } BordersGraphStorageBuilder(); }
|
BordersGraphStorageBuilder extends AbstractGraphStorageBuilder { public String[] findBorderCrossing(Coordinate[] coords) { ArrayList<CountryBordersPolygon> countries = new ArrayList<>(); boolean hasInternational = false; boolean overlap = false; int lsLen = coords.length; if(lsLen > 1) { for(int i=0; i<lsLen; i++) { Coordinate c = coords[i]; if(!Double.isNaN(c.x) && !Double.isNaN(c.y)) { CountryBordersPolygon[] cnts = cbReader.getCandidateCountry(c); for (CountryBordersPolygon cbp : cnts) { if (!countries.contains(cbp)) { countries.add(cbp); } } if(cnts.length == 0) hasInternational = true; } } } if(countries.size() > 1) { ArrayList<CountryBordersPolygon> temp = new ArrayList<>(); for(int i=0; i<lsLen; i++) { Coordinate c = coords[i]; if(!Double.isNaN(c.x) && !Double.isNaN(c.y)) { boolean found = false; int countriesFound = 0; for(CountryBordersPolygon cbp : countries) { if (cbp.inArea(c)) { found = true; countriesFound++; if(!temp.contains(cbp)) { temp.add(cbp); } } } if(countriesFound > 1) { overlap = true; } if(!found) { hasInternational = true; } } } countries = temp; } if(countries.size() > 1 && overlap) { boolean crosses = false; LineString ls = gf.createLineString(coords); for (CountryBordersPolygon cp : countries) { if (cp.crossesBoundary(ls)) { crosses = true; break; } } if(!crosses) { CountryBordersPolygon cp = countries.get(0); countries.clear(); countries.add(cp); } } ArrayList<String> names = new ArrayList<>(); for(int i=0; i<countries.size(); i++) { if (!names.contains(countries.get(i).getName())) names.add(countries.get(i).getName()); } if(hasInternational && !countries.isEmpty()) { names.add(CountryBordersReader.INTERNATIONAL_NAME); } return names.toArray(new String[names.size()]); } BordersGraphStorageBuilder(); @Override GraphExtension init(GraphHopper graphhopper); void setBordersBuilder(CountryBordersReader cbr); @Override void processWay(ReaderWay way); @Override void processWay(ReaderWay way, Coordinate[] coords, HashMap<Integer, HashMap<String,String>> nodeTags); @Override void processEdge(ReaderWay way, EdgeIteratorState edge); @Override String getName(); String[] findBorderCrossing(Coordinate[] coords); CountryBordersReader getCbReader(); }
|
BordersGraphStorageBuilder extends AbstractGraphStorageBuilder { public String[] findBorderCrossing(Coordinate[] coords) { ArrayList<CountryBordersPolygon> countries = new ArrayList<>(); boolean hasInternational = false; boolean overlap = false; int lsLen = coords.length; if(lsLen > 1) { for(int i=0; i<lsLen; i++) { Coordinate c = coords[i]; if(!Double.isNaN(c.x) && !Double.isNaN(c.y)) { CountryBordersPolygon[] cnts = cbReader.getCandidateCountry(c); for (CountryBordersPolygon cbp : cnts) { if (!countries.contains(cbp)) { countries.add(cbp); } } if(cnts.length == 0) hasInternational = true; } } } if(countries.size() > 1) { ArrayList<CountryBordersPolygon> temp = new ArrayList<>(); for(int i=0; i<lsLen; i++) { Coordinate c = coords[i]; if(!Double.isNaN(c.x) && !Double.isNaN(c.y)) { boolean found = false; int countriesFound = 0; for(CountryBordersPolygon cbp : countries) { if (cbp.inArea(c)) { found = true; countriesFound++; if(!temp.contains(cbp)) { temp.add(cbp); } } } if(countriesFound > 1) { overlap = true; } if(!found) { hasInternational = true; } } } countries = temp; } if(countries.size() > 1 && overlap) { boolean crosses = false; LineString ls = gf.createLineString(coords); for (CountryBordersPolygon cp : countries) { if (cp.crossesBoundary(ls)) { crosses = true; break; } } if(!crosses) { CountryBordersPolygon cp = countries.get(0); countries.clear(); countries.add(cp); } } ArrayList<String> names = new ArrayList<>(); for(int i=0; i<countries.size(); i++) { if (!names.contains(countries.get(i).getName())) names.add(countries.get(i).getName()); } if(hasInternational && !countries.isEmpty()) { names.add(CountryBordersReader.INTERNATIONAL_NAME); } return names.toArray(new String[names.size()]); } BordersGraphStorageBuilder(); @Override GraphExtension init(GraphHopper graphhopper); void setBordersBuilder(CountryBordersReader cbr); @Override void processWay(ReaderWay way); @Override void processWay(ReaderWay way, Coordinate[] coords, HashMap<Integer, HashMap<String,String>> nodeTags); @Override void processEdge(ReaderWay way, EdgeIteratorState edge); @Override String getName(); String[] findBorderCrossing(Coordinate[] coords); CountryBordersReader getCbReader(); static final String BUILDER_NAME; }
|
@Test public void testHasBearings() { request.setBearings(new Double[][] {new Double[] {0.0, 90.0}}); Assert.assertTrue(request.hasBearings()); }
|
public boolean hasBearings() { return hasBearings; }
|
RouteRequest { public boolean hasBearings() { return hasBearings; } }
|
RouteRequest { public boolean hasBearings() { return hasBearings; } @JsonCreator RouteRequest(@JsonProperty(value = PARAM_COORDINATES, required = true) List<List<Double>> coordinates); RouteRequest(Double[][] coordinates); RouteRequest(Coordinate start, Coordinate end); }
|
RouteRequest { public boolean hasBearings() { return hasBearings; } @JsonCreator RouteRequest(@JsonProperty(value = PARAM_COORDINATES, required = true) List<List<Double>> coordinates); RouteRequest(Double[][] coordinates); RouteRequest(Coordinate start, Coordinate end); String getId(); void setId(String id); boolean hasId(); List<List<Double>> getCoordinates(); void setCoordinates(List<List<Double>> coordinates); APIEnums.Profile getProfile(); void setProfile(APIEnums.Profile profile); APIEnums.Units getUnits(); void setUnits(APIEnums.Units units); APIEnums.Languages getLanguage(); void setLanguage(APIEnums.Languages language); APIEnums.RoutePreference getRoutePreference(); void setRoutePreference(APIEnums.RoutePreference routePreference); boolean hasRoutePreference(); APIEnums.RouteResponseType getResponseType(); void setResponseType(APIEnums.RouteResponseType responseType); APIEnums.ExtraInfo[] getExtraInfo(); void setExtraInfo(APIEnums.ExtraInfo[] extraInfo); RouteRequestOptions getRouteOptions(); void setRouteOptions(RouteRequestOptions routeOptions); boolean getIncludeGeometry(); void setIncludeGeometry(boolean includeGeometry); boolean getIncludeInstructionsInResponse(); void setIncludeInstructionsInResponse(Boolean includeInstructionsInResponse); APIEnums.InstructionsFormat getInstructionsFormat(); void setInstructionsFormat(APIEnums.InstructionsFormat instructionsFormat); boolean getIncludeRoundaboutExitInfo(); void setIncludeRoundaboutExitInfo(Boolean includeRoundaboutExitInfo); APIEnums.Attributes[] getAttributes(); void setAttributes(APIEnums.Attributes[] attributes); boolean getIncludeManeuvers(); void setIncludeManeuvers(Boolean includeManeuvers); Double[] getMaximumSearchRadii(); void setMaximumSearchRadii(Double[] maximumSearchRadii); Double[][] getBearings(); void setBearings(Double[][] bearings); boolean getContinueStraightAtWaypoints(); void setContinueStraightAtWaypoints(Boolean continueStraightAtWaypoints); boolean getUseElevation(); void setUseElevation(Boolean useElevation); boolean getUseContractionHierarchies(); void setUseContractionHierarchies(Boolean useContractionHierarchies); boolean getSuppressWarnings(); void setSuppressWarnings(boolean suppressWarnings); boolean getSimplifyGeometry(); void setSimplifyGeometry(boolean simplifyGeometry); List<Integer> getSkipSegments(); void setSkipSegments(List<Integer> skipSegments); RouteRequestAlternativeRoutes getAlternativeRoutes(); void setAlternativeRoutes(RouteRequestAlternativeRoutes alternativeRoutes); void setMaximumSpeed(Double maximumSpeed); double getMaximumSpeed(); boolean hasIncludeRoundaboutExitInfo(); boolean hasAttributes(); boolean hasIncludeManeuvers(); boolean hasMaximumSearchRadii(); boolean hasBearings(); boolean hasContinueStraightAtWaypoints(); boolean hasIncludeInstructions(); boolean hasIncludeGeometry(); boolean hasLanguage(); boolean hasInstructionsFormat(); boolean hasUnits(); boolean hasUseElevation(); boolean hasRouteOptions(); boolean hasUseContractionHierarchies(); boolean hasExtraInfo(); boolean hasSuppressWarnings(); boolean hasSimplifyGeometry(); boolean hasSkipSegments(); boolean hasAlternativeRoutes(); boolean hasMaximumSpeed(); }
|
RouteRequest { public boolean hasBearings() { return hasBearings; } @JsonCreator RouteRequest(@JsonProperty(value = PARAM_COORDINATES, required = true) List<List<Double>> coordinates); RouteRequest(Double[][] coordinates); RouteRequest(Coordinate start, Coordinate end); String getId(); void setId(String id); boolean hasId(); List<List<Double>> getCoordinates(); void setCoordinates(List<List<Double>> coordinates); APIEnums.Profile getProfile(); void setProfile(APIEnums.Profile profile); APIEnums.Units getUnits(); void setUnits(APIEnums.Units units); APIEnums.Languages getLanguage(); void setLanguage(APIEnums.Languages language); APIEnums.RoutePreference getRoutePreference(); void setRoutePreference(APIEnums.RoutePreference routePreference); boolean hasRoutePreference(); APIEnums.RouteResponseType getResponseType(); void setResponseType(APIEnums.RouteResponseType responseType); APIEnums.ExtraInfo[] getExtraInfo(); void setExtraInfo(APIEnums.ExtraInfo[] extraInfo); RouteRequestOptions getRouteOptions(); void setRouteOptions(RouteRequestOptions routeOptions); boolean getIncludeGeometry(); void setIncludeGeometry(boolean includeGeometry); boolean getIncludeInstructionsInResponse(); void setIncludeInstructionsInResponse(Boolean includeInstructionsInResponse); APIEnums.InstructionsFormat getInstructionsFormat(); void setInstructionsFormat(APIEnums.InstructionsFormat instructionsFormat); boolean getIncludeRoundaboutExitInfo(); void setIncludeRoundaboutExitInfo(Boolean includeRoundaboutExitInfo); APIEnums.Attributes[] getAttributes(); void setAttributes(APIEnums.Attributes[] attributes); boolean getIncludeManeuvers(); void setIncludeManeuvers(Boolean includeManeuvers); Double[] getMaximumSearchRadii(); void setMaximumSearchRadii(Double[] maximumSearchRadii); Double[][] getBearings(); void setBearings(Double[][] bearings); boolean getContinueStraightAtWaypoints(); void setContinueStraightAtWaypoints(Boolean continueStraightAtWaypoints); boolean getUseElevation(); void setUseElevation(Boolean useElevation); boolean getUseContractionHierarchies(); void setUseContractionHierarchies(Boolean useContractionHierarchies); boolean getSuppressWarnings(); void setSuppressWarnings(boolean suppressWarnings); boolean getSimplifyGeometry(); void setSimplifyGeometry(boolean simplifyGeometry); List<Integer> getSkipSegments(); void setSkipSegments(List<Integer> skipSegments); RouteRequestAlternativeRoutes getAlternativeRoutes(); void setAlternativeRoutes(RouteRequestAlternativeRoutes alternativeRoutes); void setMaximumSpeed(Double maximumSpeed); double getMaximumSpeed(); boolean hasIncludeRoundaboutExitInfo(); boolean hasAttributes(); boolean hasIncludeManeuvers(); boolean hasMaximumSearchRadii(); boolean hasBearings(); boolean hasContinueStraightAtWaypoints(); boolean hasIncludeInstructions(); boolean hasIncludeGeometry(); boolean hasLanguage(); boolean hasInstructionsFormat(); boolean hasUnits(); boolean hasUseElevation(); boolean hasRouteOptions(); boolean hasUseContractionHierarchies(); boolean hasExtraInfo(); boolean hasSuppressWarnings(); boolean hasSimplifyGeometry(); boolean hasSkipSegments(); boolean hasAlternativeRoutes(); boolean hasMaximumSpeed(); static final String PARAM_ID; static final String PARAM_COORDINATES; static final String PARAM_PROFILE; static final String PARAM_PREFERENCE; static final String PARAM_FORMAT; static final String PARAM_UNITS; static final String PARAM_LANGUAGE; static final String PARAM_GEOMETRY; static final String PARAM_INSTRUCTIONS; static final String PARAM_INSTRUCTIONS_FORMAT; static final String PARAM_ROUNDABOUT_EXITS; static final String PARAM_ATTRIBUTES; static final String PARAM_MANEUVERS; static final String PARAM_RADII; static final String PARAM_BEARINGS; static final String PARAM_CONTINUE_STRAIGHT; static final String PARAM_ELEVATION; static final String PARAM_EXTRA_INFO; static final String PARAM_OPTIMIZED; static final String PARAM_OPTIONS; static final String PARAM_SUPPRESS_WARNINGS; static final String PARAM_SIMPLIFY_GEOMETRY; static final String PARAM_SKIP_SEGMENTS; static final String PARAM_ALTERNATIVE_ROUTES; static final String PARAM_MAXIMUM_SPEED; }
|
@Test public void testHasUseElevation() { request.setUseElevation(true); Assert.assertTrue(request.hasUseElevation()); }
|
public boolean hasUseElevation() { return hasUseElevation; }
|
RouteRequest { public boolean hasUseElevation() { return hasUseElevation; } }
|
RouteRequest { public boolean hasUseElevation() { return hasUseElevation; } @JsonCreator RouteRequest(@JsonProperty(value = PARAM_COORDINATES, required = true) List<List<Double>> coordinates); RouteRequest(Double[][] coordinates); RouteRequest(Coordinate start, Coordinate end); }
|
RouteRequest { public boolean hasUseElevation() { return hasUseElevation; } @JsonCreator RouteRequest(@JsonProperty(value = PARAM_COORDINATES, required = true) List<List<Double>> coordinates); RouteRequest(Double[][] coordinates); RouteRequest(Coordinate start, Coordinate end); String getId(); void setId(String id); boolean hasId(); List<List<Double>> getCoordinates(); void setCoordinates(List<List<Double>> coordinates); APIEnums.Profile getProfile(); void setProfile(APIEnums.Profile profile); APIEnums.Units getUnits(); void setUnits(APIEnums.Units units); APIEnums.Languages getLanguage(); void setLanguage(APIEnums.Languages language); APIEnums.RoutePreference getRoutePreference(); void setRoutePreference(APIEnums.RoutePreference routePreference); boolean hasRoutePreference(); APIEnums.RouteResponseType getResponseType(); void setResponseType(APIEnums.RouteResponseType responseType); APIEnums.ExtraInfo[] getExtraInfo(); void setExtraInfo(APIEnums.ExtraInfo[] extraInfo); RouteRequestOptions getRouteOptions(); void setRouteOptions(RouteRequestOptions routeOptions); boolean getIncludeGeometry(); void setIncludeGeometry(boolean includeGeometry); boolean getIncludeInstructionsInResponse(); void setIncludeInstructionsInResponse(Boolean includeInstructionsInResponse); APIEnums.InstructionsFormat getInstructionsFormat(); void setInstructionsFormat(APIEnums.InstructionsFormat instructionsFormat); boolean getIncludeRoundaboutExitInfo(); void setIncludeRoundaboutExitInfo(Boolean includeRoundaboutExitInfo); APIEnums.Attributes[] getAttributes(); void setAttributes(APIEnums.Attributes[] attributes); boolean getIncludeManeuvers(); void setIncludeManeuvers(Boolean includeManeuvers); Double[] getMaximumSearchRadii(); void setMaximumSearchRadii(Double[] maximumSearchRadii); Double[][] getBearings(); void setBearings(Double[][] bearings); boolean getContinueStraightAtWaypoints(); void setContinueStraightAtWaypoints(Boolean continueStraightAtWaypoints); boolean getUseElevation(); void setUseElevation(Boolean useElevation); boolean getUseContractionHierarchies(); void setUseContractionHierarchies(Boolean useContractionHierarchies); boolean getSuppressWarnings(); void setSuppressWarnings(boolean suppressWarnings); boolean getSimplifyGeometry(); void setSimplifyGeometry(boolean simplifyGeometry); List<Integer> getSkipSegments(); void setSkipSegments(List<Integer> skipSegments); RouteRequestAlternativeRoutes getAlternativeRoutes(); void setAlternativeRoutes(RouteRequestAlternativeRoutes alternativeRoutes); void setMaximumSpeed(Double maximumSpeed); double getMaximumSpeed(); boolean hasIncludeRoundaboutExitInfo(); boolean hasAttributes(); boolean hasIncludeManeuvers(); boolean hasMaximumSearchRadii(); boolean hasBearings(); boolean hasContinueStraightAtWaypoints(); boolean hasIncludeInstructions(); boolean hasIncludeGeometry(); boolean hasLanguage(); boolean hasInstructionsFormat(); boolean hasUnits(); boolean hasUseElevation(); boolean hasRouteOptions(); boolean hasUseContractionHierarchies(); boolean hasExtraInfo(); boolean hasSuppressWarnings(); boolean hasSimplifyGeometry(); boolean hasSkipSegments(); boolean hasAlternativeRoutes(); boolean hasMaximumSpeed(); }
|
RouteRequest { public boolean hasUseElevation() { return hasUseElevation; } @JsonCreator RouteRequest(@JsonProperty(value = PARAM_COORDINATES, required = true) List<List<Double>> coordinates); RouteRequest(Double[][] coordinates); RouteRequest(Coordinate start, Coordinate end); String getId(); void setId(String id); boolean hasId(); List<List<Double>> getCoordinates(); void setCoordinates(List<List<Double>> coordinates); APIEnums.Profile getProfile(); void setProfile(APIEnums.Profile profile); APIEnums.Units getUnits(); void setUnits(APIEnums.Units units); APIEnums.Languages getLanguage(); void setLanguage(APIEnums.Languages language); APIEnums.RoutePreference getRoutePreference(); void setRoutePreference(APIEnums.RoutePreference routePreference); boolean hasRoutePreference(); APIEnums.RouteResponseType getResponseType(); void setResponseType(APIEnums.RouteResponseType responseType); APIEnums.ExtraInfo[] getExtraInfo(); void setExtraInfo(APIEnums.ExtraInfo[] extraInfo); RouteRequestOptions getRouteOptions(); void setRouteOptions(RouteRequestOptions routeOptions); boolean getIncludeGeometry(); void setIncludeGeometry(boolean includeGeometry); boolean getIncludeInstructionsInResponse(); void setIncludeInstructionsInResponse(Boolean includeInstructionsInResponse); APIEnums.InstructionsFormat getInstructionsFormat(); void setInstructionsFormat(APIEnums.InstructionsFormat instructionsFormat); boolean getIncludeRoundaboutExitInfo(); void setIncludeRoundaboutExitInfo(Boolean includeRoundaboutExitInfo); APIEnums.Attributes[] getAttributes(); void setAttributes(APIEnums.Attributes[] attributes); boolean getIncludeManeuvers(); void setIncludeManeuvers(Boolean includeManeuvers); Double[] getMaximumSearchRadii(); void setMaximumSearchRadii(Double[] maximumSearchRadii); Double[][] getBearings(); void setBearings(Double[][] bearings); boolean getContinueStraightAtWaypoints(); void setContinueStraightAtWaypoints(Boolean continueStraightAtWaypoints); boolean getUseElevation(); void setUseElevation(Boolean useElevation); boolean getUseContractionHierarchies(); void setUseContractionHierarchies(Boolean useContractionHierarchies); boolean getSuppressWarnings(); void setSuppressWarnings(boolean suppressWarnings); boolean getSimplifyGeometry(); void setSimplifyGeometry(boolean simplifyGeometry); List<Integer> getSkipSegments(); void setSkipSegments(List<Integer> skipSegments); RouteRequestAlternativeRoutes getAlternativeRoutes(); void setAlternativeRoutes(RouteRequestAlternativeRoutes alternativeRoutes); void setMaximumSpeed(Double maximumSpeed); double getMaximumSpeed(); boolean hasIncludeRoundaboutExitInfo(); boolean hasAttributes(); boolean hasIncludeManeuvers(); boolean hasMaximumSearchRadii(); boolean hasBearings(); boolean hasContinueStraightAtWaypoints(); boolean hasIncludeInstructions(); boolean hasIncludeGeometry(); boolean hasLanguage(); boolean hasInstructionsFormat(); boolean hasUnits(); boolean hasUseElevation(); boolean hasRouteOptions(); boolean hasUseContractionHierarchies(); boolean hasExtraInfo(); boolean hasSuppressWarnings(); boolean hasSimplifyGeometry(); boolean hasSkipSegments(); boolean hasAlternativeRoutes(); boolean hasMaximumSpeed(); static final String PARAM_ID; static final String PARAM_COORDINATES; static final String PARAM_PROFILE; static final String PARAM_PREFERENCE; static final String PARAM_FORMAT; static final String PARAM_UNITS; static final String PARAM_LANGUAGE; static final String PARAM_GEOMETRY; static final String PARAM_INSTRUCTIONS; static final String PARAM_INSTRUCTIONS_FORMAT; static final String PARAM_ROUNDABOUT_EXITS; static final String PARAM_ATTRIBUTES; static final String PARAM_MANEUVERS; static final String PARAM_RADII; static final String PARAM_BEARINGS; static final String PARAM_CONTINUE_STRAIGHT; static final String PARAM_ELEVATION; static final String PARAM_EXTRA_INFO; static final String PARAM_OPTIMIZED; static final String PARAM_OPTIONS; static final String PARAM_SUPPRESS_WARNINGS; static final String PARAM_SIMPLIFY_GEOMETRY; static final String PARAM_SKIP_SEGMENTS; static final String PARAM_ALTERNATIVE_ROUTES; static final String PARAM_MAXIMUM_SPEED; }
|
@Test public void testHasRouteOptions() { request.setRouteOptions(new RouteRequestOptions()); Assert.assertTrue(request.hasRouteOptions()); }
|
public boolean hasRouteOptions() { return hasRouteOptions; }
|
RouteRequest { public boolean hasRouteOptions() { return hasRouteOptions; } }
|
RouteRequest { public boolean hasRouteOptions() { return hasRouteOptions; } @JsonCreator RouteRequest(@JsonProperty(value = PARAM_COORDINATES, required = true) List<List<Double>> coordinates); RouteRequest(Double[][] coordinates); RouteRequest(Coordinate start, Coordinate end); }
|
RouteRequest { public boolean hasRouteOptions() { return hasRouteOptions; } @JsonCreator RouteRequest(@JsonProperty(value = PARAM_COORDINATES, required = true) List<List<Double>> coordinates); RouteRequest(Double[][] coordinates); RouteRequest(Coordinate start, Coordinate end); String getId(); void setId(String id); boolean hasId(); List<List<Double>> getCoordinates(); void setCoordinates(List<List<Double>> coordinates); APIEnums.Profile getProfile(); void setProfile(APIEnums.Profile profile); APIEnums.Units getUnits(); void setUnits(APIEnums.Units units); APIEnums.Languages getLanguage(); void setLanguage(APIEnums.Languages language); APIEnums.RoutePreference getRoutePreference(); void setRoutePreference(APIEnums.RoutePreference routePreference); boolean hasRoutePreference(); APIEnums.RouteResponseType getResponseType(); void setResponseType(APIEnums.RouteResponseType responseType); APIEnums.ExtraInfo[] getExtraInfo(); void setExtraInfo(APIEnums.ExtraInfo[] extraInfo); RouteRequestOptions getRouteOptions(); void setRouteOptions(RouteRequestOptions routeOptions); boolean getIncludeGeometry(); void setIncludeGeometry(boolean includeGeometry); boolean getIncludeInstructionsInResponse(); void setIncludeInstructionsInResponse(Boolean includeInstructionsInResponse); APIEnums.InstructionsFormat getInstructionsFormat(); void setInstructionsFormat(APIEnums.InstructionsFormat instructionsFormat); boolean getIncludeRoundaboutExitInfo(); void setIncludeRoundaboutExitInfo(Boolean includeRoundaboutExitInfo); APIEnums.Attributes[] getAttributes(); void setAttributes(APIEnums.Attributes[] attributes); boolean getIncludeManeuvers(); void setIncludeManeuvers(Boolean includeManeuvers); Double[] getMaximumSearchRadii(); void setMaximumSearchRadii(Double[] maximumSearchRadii); Double[][] getBearings(); void setBearings(Double[][] bearings); boolean getContinueStraightAtWaypoints(); void setContinueStraightAtWaypoints(Boolean continueStraightAtWaypoints); boolean getUseElevation(); void setUseElevation(Boolean useElevation); boolean getUseContractionHierarchies(); void setUseContractionHierarchies(Boolean useContractionHierarchies); boolean getSuppressWarnings(); void setSuppressWarnings(boolean suppressWarnings); boolean getSimplifyGeometry(); void setSimplifyGeometry(boolean simplifyGeometry); List<Integer> getSkipSegments(); void setSkipSegments(List<Integer> skipSegments); RouteRequestAlternativeRoutes getAlternativeRoutes(); void setAlternativeRoutes(RouteRequestAlternativeRoutes alternativeRoutes); void setMaximumSpeed(Double maximumSpeed); double getMaximumSpeed(); boolean hasIncludeRoundaboutExitInfo(); boolean hasAttributes(); boolean hasIncludeManeuvers(); boolean hasMaximumSearchRadii(); boolean hasBearings(); boolean hasContinueStraightAtWaypoints(); boolean hasIncludeInstructions(); boolean hasIncludeGeometry(); boolean hasLanguage(); boolean hasInstructionsFormat(); boolean hasUnits(); boolean hasUseElevation(); boolean hasRouteOptions(); boolean hasUseContractionHierarchies(); boolean hasExtraInfo(); boolean hasSuppressWarnings(); boolean hasSimplifyGeometry(); boolean hasSkipSegments(); boolean hasAlternativeRoutes(); boolean hasMaximumSpeed(); }
|
RouteRequest { public boolean hasRouteOptions() { return hasRouteOptions; } @JsonCreator RouteRequest(@JsonProperty(value = PARAM_COORDINATES, required = true) List<List<Double>> coordinates); RouteRequest(Double[][] coordinates); RouteRequest(Coordinate start, Coordinate end); String getId(); void setId(String id); boolean hasId(); List<List<Double>> getCoordinates(); void setCoordinates(List<List<Double>> coordinates); APIEnums.Profile getProfile(); void setProfile(APIEnums.Profile profile); APIEnums.Units getUnits(); void setUnits(APIEnums.Units units); APIEnums.Languages getLanguage(); void setLanguage(APIEnums.Languages language); APIEnums.RoutePreference getRoutePreference(); void setRoutePreference(APIEnums.RoutePreference routePreference); boolean hasRoutePreference(); APIEnums.RouteResponseType getResponseType(); void setResponseType(APIEnums.RouteResponseType responseType); APIEnums.ExtraInfo[] getExtraInfo(); void setExtraInfo(APIEnums.ExtraInfo[] extraInfo); RouteRequestOptions getRouteOptions(); void setRouteOptions(RouteRequestOptions routeOptions); boolean getIncludeGeometry(); void setIncludeGeometry(boolean includeGeometry); boolean getIncludeInstructionsInResponse(); void setIncludeInstructionsInResponse(Boolean includeInstructionsInResponse); APIEnums.InstructionsFormat getInstructionsFormat(); void setInstructionsFormat(APIEnums.InstructionsFormat instructionsFormat); boolean getIncludeRoundaboutExitInfo(); void setIncludeRoundaboutExitInfo(Boolean includeRoundaboutExitInfo); APIEnums.Attributes[] getAttributes(); void setAttributes(APIEnums.Attributes[] attributes); boolean getIncludeManeuvers(); void setIncludeManeuvers(Boolean includeManeuvers); Double[] getMaximumSearchRadii(); void setMaximumSearchRadii(Double[] maximumSearchRadii); Double[][] getBearings(); void setBearings(Double[][] bearings); boolean getContinueStraightAtWaypoints(); void setContinueStraightAtWaypoints(Boolean continueStraightAtWaypoints); boolean getUseElevation(); void setUseElevation(Boolean useElevation); boolean getUseContractionHierarchies(); void setUseContractionHierarchies(Boolean useContractionHierarchies); boolean getSuppressWarnings(); void setSuppressWarnings(boolean suppressWarnings); boolean getSimplifyGeometry(); void setSimplifyGeometry(boolean simplifyGeometry); List<Integer> getSkipSegments(); void setSkipSegments(List<Integer> skipSegments); RouteRequestAlternativeRoutes getAlternativeRoutes(); void setAlternativeRoutes(RouteRequestAlternativeRoutes alternativeRoutes); void setMaximumSpeed(Double maximumSpeed); double getMaximumSpeed(); boolean hasIncludeRoundaboutExitInfo(); boolean hasAttributes(); boolean hasIncludeManeuvers(); boolean hasMaximumSearchRadii(); boolean hasBearings(); boolean hasContinueStraightAtWaypoints(); boolean hasIncludeInstructions(); boolean hasIncludeGeometry(); boolean hasLanguage(); boolean hasInstructionsFormat(); boolean hasUnits(); boolean hasUseElevation(); boolean hasRouteOptions(); boolean hasUseContractionHierarchies(); boolean hasExtraInfo(); boolean hasSuppressWarnings(); boolean hasSimplifyGeometry(); boolean hasSkipSegments(); boolean hasAlternativeRoutes(); boolean hasMaximumSpeed(); static final String PARAM_ID; static final String PARAM_COORDINATES; static final String PARAM_PROFILE; static final String PARAM_PREFERENCE; static final String PARAM_FORMAT; static final String PARAM_UNITS; static final String PARAM_LANGUAGE; static final String PARAM_GEOMETRY; static final String PARAM_INSTRUCTIONS; static final String PARAM_INSTRUCTIONS_FORMAT; static final String PARAM_ROUNDABOUT_EXITS; static final String PARAM_ATTRIBUTES; static final String PARAM_MANEUVERS; static final String PARAM_RADII; static final String PARAM_BEARINGS; static final String PARAM_CONTINUE_STRAIGHT; static final String PARAM_ELEVATION; static final String PARAM_EXTRA_INFO; static final String PARAM_OPTIMIZED; static final String PARAM_OPTIONS; static final String PARAM_SUPPRESS_WARNINGS; static final String PARAM_SIMPLIFY_GEOMETRY; static final String PARAM_SKIP_SEGMENTS; static final String PARAM_ALTERNATIVE_ROUTES; static final String PARAM_MAXIMUM_SPEED; }
|
@Test public void testHasUseContractionHierarchies() { request.setUseContractionHierarchies(true); Assert.assertTrue(request.hasUseContractionHierarchies()); }
|
public boolean hasUseContractionHierarchies() { return hasUseContractionHierarchies; }
|
RouteRequest { public boolean hasUseContractionHierarchies() { return hasUseContractionHierarchies; } }
|
RouteRequest { public boolean hasUseContractionHierarchies() { return hasUseContractionHierarchies; } @JsonCreator RouteRequest(@JsonProperty(value = PARAM_COORDINATES, required = true) List<List<Double>> coordinates); RouteRequest(Double[][] coordinates); RouteRequest(Coordinate start, Coordinate end); }
|
RouteRequest { public boolean hasUseContractionHierarchies() { return hasUseContractionHierarchies; } @JsonCreator RouteRequest(@JsonProperty(value = PARAM_COORDINATES, required = true) List<List<Double>> coordinates); RouteRequest(Double[][] coordinates); RouteRequest(Coordinate start, Coordinate end); String getId(); void setId(String id); boolean hasId(); List<List<Double>> getCoordinates(); void setCoordinates(List<List<Double>> coordinates); APIEnums.Profile getProfile(); void setProfile(APIEnums.Profile profile); APIEnums.Units getUnits(); void setUnits(APIEnums.Units units); APIEnums.Languages getLanguage(); void setLanguage(APIEnums.Languages language); APIEnums.RoutePreference getRoutePreference(); void setRoutePreference(APIEnums.RoutePreference routePreference); boolean hasRoutePreference(); APIEnums.RouteResponseType getResponseType(); void setResponseType(APIEnums.RouteResponseType responseType); APIEnums.ExtraInfo[] getExtraInfo(); void setExtraInfo(APIEnums.ExtraInfo[] extraInfo); RouteRequestOptions getRouteOptions(); void setRouteOptions(RouteRequestOptions routeOptions); boolean getIncludeGeometry(); void setIncludeGeometry(boolean includeGeometry); boolean getIncludeInstructionsInResponse(); void setIncludeInstructionsInResponse(Boolean includeInstructionsInResponse); APIEnums.InstructionsFormat getInstructionsFormat(); void setInstructionsFormat(APIEnums.InstructionsFormat instructionsFormat); boolean getIncludeRoundaboutExitInfo(); void setIncludeRoundaboutExitInfo(Boolean includeRoundaboutExitInfo); APIEnums.Attributes[] getAttributes(); void setAttributes(APIEnums.Attributes[] attributes); boolean getIncludeManeuvers(); void setIncludeManeuvers(Boolean includeManeuvers); Double[] getMaximumSearchRadii(); void setMaximumSearchRadii(Double[] maximumSearchRadii); Double[][] getBearings(); void setBearings(Double[][] bearings); boolean getContinueStraightAtWaypoints(); void setContinueStraightAtWaypoints(Boolean continueStraightAtWaypoints); boolean getUseElevation(); void setUseElevation(Boolean useElevation); boolean getUseContractionHierarchies(); void setUseContractionHierarchies(Boolean useContractionHierarchies); boolean getSuppressWarnings(); void setSuppressWarnings(boolean suppressWarnings); boolean getSimplifyGeometry(); void setSimplifyGeometry(boolean simplifyGeometry); List<Integer> getSkipSegments(); void setSkipSegments(List<Integer> skipSegments); RouteRequestAlternativeRoutes getAlternativeRoutes(); void setAlternativeRoutes(RouteRequestAlternativeRoutes alternativeRoutes); void setMaximumSpeed(Double maximumSpeed); double getMaximumSpeed(); boolean hasIncludeRoundaboutExitInfo(); boolean hasAttributes(); boolean hasIncludeManeuvers(); boolean hasMaximumSearchRadii(); boolean hasBearings(); boolean hasContinueStraightAtWaypoints(); boolean hasIncludeInstructions(); boolean hasIncludeGeometry(); boolean hasLanguage(); boolean hasInstructionsFormat(); boolean hasUnits(); boolean hasUseElevation(); boolean hasRouteOptions(); boolean hasUseContractionHierarchies(); boolean hasExtraInfo(); boolean hasSuppressWarnings(); boolean hasSimplifyGeometry(); boolean hasSkipSegments(); boolean hasAlternativeRoutes(); boolean hasMaximumSpeed(); }
|
RouteRequest { public boolean hasUseContractionHierarchies() { return hasUseContractionHierarchies; } @JsonCreator RouteRequest(@JsonProperty(value = PARAM_COORDINATES, required = true) List<List<Double>> coordinates); RouteRequest(Double[][] coordinates); RouteRequest(Coordinate start, Coordinate end); String getId(); void setId(String id); boolean hasId(); List<List<Double>> getCoordinates(); void setCoordinates(List<List<Double>> coordinates); APIEnums.Profile getProfile(); void setProfile(APIEnums.Profile profile); APIEnums.Units getUnits(); void setUnits(APIEnums.Units units); APIEnums.Languages getLanguage(); void setLanguage(APIEnums.Languages language); APIEnums.RoutePreference getRoutePreference(); void setRoutePreference(APIEnums.RoutePreference routePreference); boolean hasRoutePreference(); APIEnums.RouteResponseType getResponseType(); void setResponseType(APIEnums.RouteResponseType responseType); APIEnums.ExtraInfo[] getExtraInfo(); void setExtraInfo(APIEnums.ExtraInfo[] extraInfo); RouteRequestOptions getRouteOptions(); void setRouteOptions(RouteRequestOptions routeOptions); boolean getIncludeGeometry(); void setIncludeGeometry(boolean includeGeometry); boolean getIncludeInstructionsInResponse(); void setIncludeInstructionsInResponse(Boolean includeInstructionsInResponse); APIEnums.InstructionsFormat getInstructionsFormat(); void setInstructionsFormat(APIEnums.InstructionsFormat instructionsFormat); boolean getIncludeRoundaboutExitInfo(); void setIncludeRoundaboutExitInfo(Boolean includeRoundaboutExitInfo); APIEnums.Attributes[] getAttributes(); void setAttributes(APIEnums.Attributes[] attributes); boolean getIncludeManeuvers(); void setIncludeManeuvers(Boolean includeManeuvers); Double[] getMaximumSearchRadii(); void setMaximumSearchRadii(Double[] maximumSearchRadii); Double[][] getBearings(); void setBearings(Double[][] bearings); boolean getContinueStraightAtWaypoints(); void setContinueStraightAtWaypoints(Boolean continueStraightAtWaypoints); boolean getUseElevation(); void setUseElevation(Boolean useElevation); boolean getUseContractionHierarchies(); void setUseContractionHierarchies(Boolean useContractionHierarchies); boolean getSuppressWarnings(); void setSuppressWarnings(boolean suppressWarnings); boolean getSimplifyGeometry(); void setSimplifyGeometry(boolean simplifyGeometry); List<Integer> getSkipSegments(); void setSkipSegments(List<Integer> skipSegments); RouteRequestAlternativeRoutes getAlternativeRoutes(); void setAlternativeRoutes(RouteRequestAlternativeRoutes alternativeRoutes); void setMaximumSpeed(Double maximumSpeed); double getMaximumSpeed(); boolean hasIncludeRoundaboutExitInfo(); boolean hasAttributes(); boolean hasIncludeManeuvers(); boolean hasMaximumSearchRadii(); boolean hasBearings(); boolean hasContinueStraightAtWaypoints(); boolean hasIncludeInstructions(); boolean hasIncludeGeometry(); boolean hasLanguage(); boolean hasInstructionsFormat(); boolean hasUnits(); boolean hasUseElevation(); boolean hasRouteOptions(); boolean hasUseContractionHierarchies(); boolean hasExtraInfo(); boolean hasSuppressWarnings(); boolean hasSimplifyGeometry(); boolean hasSkipSegments(); boolean hasAlternativeRoutes(); boolean hasMaximumSpeed(); static final String PARAM_ID; static final String PARAM_COORDINATES; static final String PARAM_PROFILE; static final String PARAM_PREFERENCE; static final String PARAM_FORMAT; static final String PARAM_UNITS; static final String PARAM_LANGUAGE; static final String PARAM_GEOMETRY; static final String PARAM_INSTRUCTIONS; static final String PARAM_INSTRUCTIONS_FORMAT; static final String PARAM_ROUNDABOUT_EXITS; static final String PARAM_ATTRIBUTES; static final String PARAM_MANEUVERS; static final String PARAM_RADII; static final String PARAM_BEARINGS; static final String PARAM_CONTINUE_STRAIGHT; static final String PARAM_ELEVATION; static final String PARAM_EXTRA_INFO; static final String PARAM_OPTIMIZED; static final String PARAM_OPTIONS; static final String PARAM_SUPPRESS_WARNINGS; static final String PARAM_SIMPLIFY_GEOMETRY; static final String PARAM_SKIP_SEGMENTS; static final String PARAM_ALTERNATIVE_ROUTES; static final String PARAM_MAXIMUM_SPEED; }
|
@Test public void testHasExtraInfo() { request.setExtraInfo(new APIEnums.ExtraInfo[] { APIEnums.ExtraInfo.SURFACE }); Assert.assertTrue(request.hasExtraInfo()); }
|
public boolean hasExtraInfo() { return hasExtraInfo; }
|
RouteRequest { public boolean hasExtraInfo() { return hasExtraInfo; } }
|
RouteRequest { public boolean hasExtraInfo() { return hasExtraInfo; } @JsonCreator RouteRequest(@JsonProperty(value = PARAM_COORDINATES, required = true) List<List<Double>> coordinates); RouteRequest(Double[][] coordinates); RouteRequest(Coordinate start, Coordinate end); }
|
RouteRequest { public boolean hasExtraInfo() { return hasExtraInfo; } @JsonCreator RouteRequest(@JsonProperty(value = PARAM_COORDINATES, required = true) List<List<Double>> coordinates); RouteRequest(Double[][] coordinates); RouteRequest(Coordinate start, Coordinate end); String getId(); void setId(String id); boolean hasId(); List<List<Double>> getCoordinates(); void setCoordinates(List<List<Double>> coordinates); APIEnums.Profile getProfile(); void setProfile(APIEnums.Profile profile); APIEnums.Units getUnits(); void setUnits(APIEnums.Units units); APIEnums.Languages getLanguage(); void setLanguage(APIEnums.Languages language); APIEnums.RoutePreference getRoutePreference(); void setRoutePreference(APIEnums.RoutePreference routePreference); boolean hasRoutePreference(); APIEnums.RouteResponseType getResponseType(); void setResponseType(APIEnums.RouteResponseType responseType); APIEnums.ExtraInfo[] getExtraInfo(); void setExtraInfo(APIEnums.ExtraInfo[] extraInfo); RouteRequestOptions getRouteOptions(); void setRouteOptions(RouteRequestOptions routeOptions); boolean getIncludeGeometry(); void setIncludeGeometry(boolean includeGeometry); boolean getIncludeInstructionsInResponse(); void setIncludeInstructionsInResponse(Boolean includeInstructionsInResponse); APIEnums.InstructionsFormat getInstructionsFormat(); void setInstructionsFormat(APIEnums.InstructionsFormat instructionsFormat); boolean getIncludeRoundaboutExitInfo(); void setIncludeRoundaboutExitInfo(Boolean includeRoundaboutExitInfo); APIEnums.Attributes[] getAttributes(); void setAttributes(APIEnums.Attributes[] attributes); boolean getIncludeManeuvers(); void setIncludeManeuvers(Boolean includeManeuvers); Double[] getMaximumSearchRadii(); void setMaximumSearchRadii(Double[] maximumSearchRadii); Double[][] getBearings(); void setBearings(Double[][] bearings); boolean getContinueStraightAtWaypoints(); void setContinueStraightAtWaypoints(Boolean continueStraightAtWaypoints); boolean getUseElevation(); void setUseElevation(Boolean useElevation); boolean getUseContractionHierarchies(); void setUseContractionHierarchies(Boolean useContractionHierarchies); boolean getSuppressWarnings(); void setSuppressWarnings(boolean suppressWarnings); boolean getSimplifyGeometry(); void setSimplifyGeometry(boolean simplifyGeometry); List<Integer> getSkipSegments(); void setSkipSegments(List<Integer> skipSegments); RouteRequestAlternativeRoutes getAlternativeRoutes(); void setAlternativeRoutes(RouteRequestAlternativeRoutes alternativeRoutes); void setMaximumSpeed(Double maximumSpeed); double getMaximumSpeed(); boolean hasIncludeRoundaboutExitInfo(); boolean hasAttributes(); boolean hasIncludeManeuvers(); boolean hasMaximumSearchRadii(); boolean hasBearings(); boolean hasContinueStraightAtWaypoints(); boolean hasIncludeInstructions(); boolean hasIncludeGeometry(); boolean hasLanguage(); boolean hasInstructionsFormat(); boolean hasUnits(); boolean hasUseElevation(); boolean hasRouteOptions(); boolean hasUseContractionHierarchies(); boolean hasExtraInfo(); boolean hasSuppressWarnings(); boolean hasSimplifyGeometry(); boolean hasSkipSegments(); boolean hasAlternativeRoutes(); boolean hasMaximumSpeed(); }
|
RouteRequest { public boolean hasExtraInfo() { return hasExtraInfo; } @JsonCreator RouteRequest(@JsonProperty(value = PARAM_COORDINATES, required = true) List<List<Double>> coordinates); RouteRequest(Double[][] coordinates); RouteRequest(Coordinate start, Coordinate end); String getId(); void setId(String id); boolean hasId(); List<List<Double>> getCoordinates(); void setCoordinates(List<List<Double>> coordinates); APIEnums.Profile getProfile(); void setProfile(APIEnums.Profile profile); APIEnums.Units getUnits(); void setUnits(APIEnums.Units units); APIEnums.Languages getLanguage(); void setLanguage(APIEnums.Languages language); APIEnums.RoutePreference getRoutePreference(); void setRoutePreference(APIEnums.RoutePreference routePreference); boolean hasRoutePreference(); APIEnums.RouteResponseType getResponseType(); void setResponseType(APIEnums.RouteResponseType responseType); APIEnums.ExtraInfo[] getExtraInfo(); void setExtraInfo(APIEnums.ExtraInfo[] extraInfo); RouteRequestOptions getRouteOptions(); void setRouteOptions(RouteRequestOptions routeOptions); boolean getIncludeGeometry(); void setIncludeGeometry(boolean includeGeometry); boolean getIncludeInstructionsInResponse(); void setIncludeInstructionsInResponse(Boolean includeInstructionsInResponse); APIEnums.InstructionsFormat getInstructionsFormat(); void setInstructionsFormat(APIEnums.InstructionsFormat instructionsFormat); boolean getIncludeRoundaboutExitInfo(); void setIncludeRoundaboutExitInfo(Boolean includeRoundaboutExitInfo); APIEnums.Attributes[] getAttributes(); void setAttributes(APIEnums.Attributes[] attributes); boolean getIncludeManeuvers(); void setIncludeManeuvers(Boolean includeManeuvers); Double[] getMaximumSearchRadii(); void setMaximumSearchRadii(Double[] maximumSearchRadii); Double[][] getBearings(); void setBearings(Double[][] bearings); boolean getContinueStraightAtWaypoints(); void setContinueStraightAtWaypoints(Boolean continueStraightAtWaypoints); boolean getUseElevation(); void setUseElevation(Boolean useElevation); boolean getUseContractionHierarchies(); void setUseContractionHierarchies(Boolean useContractionHierarchies); boolean getSuppressWarnings(); void setSuppressWarnings(boolean suppressWarnings); boolean getSimplifyGeometry(); void setSimplifyGeometry(boolean simplifyGeometry); List<Integer> getSkipSegments(); void setSkipSegments(List<Integer> skipSegments); RouteRequestAlternativeRoutes getAlternativeRoutes(); void setAlternativeRoutes(RouteRequestAlternativeRoutes alternativeRoutes); void setMaximumSpeed(Double maximumSpeed); double getMaximumSpeed(); boolean hasIncludeRoundaboutExitInfo(); boolean hasAttributes(); boolean hasIncludeManeuvers(); boolean hasMaximumSearchRadii(); boolean hasBearings(); boolean hasContinueStraightAtWaypoints(); boolean hasIncludeInstructions(); boolean hasIncludeGeometry(); boolean hasLanguage(); boolean hasInstructionsFormat(); boolean hasUnits(); boolean hasUseElevation(); boolean hasRouteOptions(); boolean hasUseContractionHierarchies(); boolean hasExtraInfo(); boolean hasSuppressWarnings(); boolean hasSimplifyGeometry(); boolean hasSkipSegments(); boolean hasAlternativeRoutes(); boolean hasMaximumSpeed(); static final String PARAM_ID; static final String PARAM_COORDINATES; static final String PARAM_PROFILE; static final String PARAM_PREFERENCE; static final String PARAM_FORMAT; static final String PARAM_UNITS; static final String PARAM_LANGUAGE; static final String PARAM_GEOMETRY; static final String PARAM_INSTRUCTIONS; static final String PARAM_INSTRUCTIONS_FORMAT; static final String PARAM_ROUNDABOUT_EXITS; static final String PARAM_ATTRIBUTES; static final String PARAM_MANEUVERS; static final String PARAM_RADII; static final String PARAM_BEARINGS; static final String PARAM_CONTINUE_STRAIGHT; static final String PARAM_ELEVATION; static final String PARAM_EXTRA_INFO; static final String PARAM_OPTIMIZED; static final String PARAM_OPTIONS; static final String PARAM_SUPPRESS_WARNINGS; static final String PARAM_SIMPLIFY_GEOMETRY; static final String PARAM_SKIP_SEGMENTS; static final String PARAM_ALTERNATIVE_ROUTES; static final String PARAM_MAXIMUM_SPEED; }
|
@Test public void testHasSuppressWarnings() { request.setSuppressWarnings(true); Assert.assertTrue(request.hasSuppressWarnings()); }
|
public boolean hasSuppressWarnings() { return hasSuppressWarnings; }
|
RouteRequest { public boolean hasSuppressWarnings() { return hasSuppressWarnings; } }
|
RouteRequest { public boolean hasSuppressWarnings() { return hasSuppressWarnings; } @JsonCreator RouteRequest(@JsonProperty(value = PARAM_COORDINATES, required = true) List<List<Double>> coordinates); RouteRequest(Double[][] coordinates); RouteRequest(Coordinate start, Coordinate end); }
|
RouteRequest { public boolean hasSuppressWarnings() { return hasSuppressWarnings; } @JsonCreator RouteRequest(@JsonProperty(value = PARAM_COORDINATES, required = true) List<List<Double>> coordinates); RouteRequest(Double[][] coordinates); RouteRequest(Coordinate start, Coordinate end); String getId(); void setId(String id); boolean hasId(); List<List<Double>> getCoordinates(); void setCoordinates(List<List<Double>> coordinates); APIEnums.Profile getProfile(); void setProfile(APIEnums.Profile profile); APIEnums.Units getUnits(); void setUnits(APIEnums.Units units); APIEnums.Languages getLanguage(); void setLanguage(APIEnums.Languages language); APIEnums.RoutePreference getRoutePreference(); void setRoutePreference(APIEnums.RoutePreference routePreference); boolean hasRoutePreference(); APIEnums.RouteResponseType getResponseType(); void setResponseType(APIEnums.RouteResponseType responseType); APIEnums.ExtraInfo[] getExtraInfo(); void setExtraInfo(APIEnums.ExtraInfo[] extraInfo); RouteRequestOptions getRouteOptions(); void setRouteOptions(RouteRequestOptions routeOptions); boolean getIncludeGeometry(); void setIncludeGeometry(boolean includeGeometry); boolean getIncludeInstructionsInResponse(); void setIncludeInstructionsInResponse(Boolean includeInstructionsInResponse); APIEnums.InstructionsFormat getInstructionsFormat(); void setInstructionsFormat(APIEnums.InstructionsFormat instructionsFormat); boolean getIncludeRoundaboutExitInfo(); void setIncludeRoundaboutExitInfo(Boolean includeRoundaboutExitInfo); APIEnums.Attributes[] getAttributes(); void setAttributes(APIEnums.Attributes[] attributes); boolean getIncludeManeuvers(); void setIncludeManeuvers(Boolean includeManeuvers); Double[] getMaximumSearchRadii(); void setMaximumSearchRadii(Double[] maximumSearchRadii); Double[][] getBearings(); void setBearings(Double[][] bearings); boolean getContinueStraightAtWaypoints(); void setContinueStraightAtWaypoints(Boolean continueStraightAtWaypoints); boolean getUseElevation(); void setUseElevation(Boolean useElevation); boolean getUseContractionHierarchies(); void setUseContractionHierarchies(Boolean useContractionHierarchies); boolean getSuppressWarnings(); void setSuppressWarnings(boolean suppressWarnings); boolean getSimplifyGeometry(); void setSimplifyGeometry(boolean simplifyGeometry); List<Integer> getSkipSegments(); void setSkipSegments(List<Integer> skipSegments); RouteRequestAlternativeRoutes getAlternativeRoutes(); void setAlternativeRoutes(RouteRequestAlternativeRoutes alternativeRoutes); void setMaximumSpeed(Double maximumSpeed); double getMaximumSpeed(); boolean hasIncludeRoundaboutExitInfo(); boolean hasAttributes(); boolean hasIncludeManeuvers(); boolean hasMaximumSearchRadii(); boolean hasBearings(); boolean hasContinueStraightAtWaypoints(); boolean hasIncludeInstructions(); boolean hasIncludeGeometry(); boolean hasLanguage(); boolean hasInstructionsFormat(); boolean hasUnits(); boolean hasUseElevation(); boolean hasRouteOptions(); boolean hasUseContractionHierarchies(); boolean hasExtraInfo(); boolean hasSuppressWarnings(); boolean hasSimplifyGeometry(); boolean hasSkipSegments(); boolean hasAlternativeRoutes(); boolean hasMaximumSpeed(); }
|
RouteRequest { public boolean hasSuppressWarnings() { return hasSuppressWarnings; } @JsonCreator RouteRequest(@JsonProperty(value = PARAM_COORDINATES, required = true) List<List<Double>> coordinates); RouteRequest(Double[][] coordinates); RouteRequest(Coordinate start, Coordinate end); String getId(); void setId(String id); boolean hasId(); List<List<Double>> getCoordinates(); void setCoordinates(List<List<Double>> coordinates); APIEnums.Profile getProfile(); void setProfile(APIEnums.Profile profile); APIEnums.Units getUnits(); void setUnits(APIEnums.Units units); APIEnums.Languages getLanguage(); void setLanguage(APIEnums.Languages language); APIEnums.RoutePreference getRoutePreference(); void setRoutePreference(APIEnums.RoutePreference routePreference); boolean hasRoutePreference(); APIEnums.RouteResponseType getResponseType(); void setResponseType(APIEnums.RouteResponseType responseType); APIEnums.ExtraInfo[] getExtraInfo(); void setExtraInfo(APIEnums.ExtraInfo[] extraInfo); RouteRequestOptions getRouteOptions(); void setRouteOptions(RouteRequestOptions routeOptions); boolean getIncludeGeometry(); void setIncludeGeometry(boolean includeGeometry); boolean getIncludeInstructionsInResponse(); void setIncludeInstructionsInResponse(Boolean includeInstructionsInResponse); APIEnums.InstructionsFormat getInstructionsFormat(); void setInstructionsFormat(APIEnums.InstructionsFormat instructionsFormat); boolean getIncludeRoundaboutExitInfo(); void setIncludeRoundaboutExitInfo(Boolean includeRoundaboutExitInfo); APIEnums.Attributes[] getAttributes(); void setAttributes(APIEnums.Attributes[] attributes); boolean getIncludeManeuvers(); void setIncludeManeuvers(Boolean includeManeuvers); Double[] getMaximumSearchRadii(); void setMaximumSearchRadii(Double[] maximumSearchRadii); Double[][] getBearings(); void setBearings(Double[][] bearings); boolean getContinueStraightAtWaypoints(); void setContinueStraightAtWaypoints(Boolean continueStraightAtWaypoints); boolean getUseElevation(); void setUseElevation(Boolean useElevation); boolean getUseContractionHierarchies(); void setUseContractionHierarchies(Boolean useContractionHierarchies); boolean getSuppressWarnings(); void setSuppressWarnings(boolean suppressWarnings); boolean getSimplifyGeometry(); void setSimplifyGeometry(boolean simplifyGeometry); List<Integer> getSkipSegments(); void setSkipSegments(List<Integer> skipSegments); RouteRequestAlternativeRoutes getAlternativeRoutes(); void setAlternativeRoutes(RouteRequestAlternativeRoutes alternativeRoutes); void setMaximumSpeed(Double maximumSpeed); double getMaximumSpeed(); boolean hasIncludeRoundaboutExitInfo(); boolean hasAttributes(); boolean hasIncludeManeuvers(); boolean hasMaximumSearchRadii(); boolean hasBearings(); boolean hasContinueStraightAtWaypoints(); boolean hasIncludeInstructions(); boolean hasIncludeGeometry(); boolean hasLanguage(); boolean hasInstructionsFormat(); boolean hasUnits(); boolean hasUseElevation(); boolean hasRouteOptions(); boolean hasUseContractionHierarchies(); boolean hasExtraInfo(); boolean hasSuppressWarnings(); boolean hasSimplifyGeometry(); boolean hasSkipSegments(); boolean hasAlternativeRoutes(); boolean hasMaximumSpeed(); static final String PARAM_ID; static final String PARAM_COORDINATES; static final String PARAM_PROFILE; static final String PARAM_PREFERENCE; static final String PARAM_FORMAT; static final String PARAM_UNITS; static final String PARAM_LANGUAGE; static final String PARAM_GEOMETRY; static final String PARAM_INSTRUCTIONS; static final String PARAM_INSTRUCTIONS_FORMAT; static final String PARAM_ROUNDABOUT_EXITS; static final String PARAM_ATTRIBUTES; static final String PARAM_MANEUVERS; static final String PARAM_RADII; static final String PARAM_BEARINGS; static final String PARAM_CONTINUE_STRAIGHT; static final String PARAM_ELEVATION; static final String PARAM_EXTRA_INFO; static final String PARAM_OPTIMIZED; static final String PARAM_OPTIONS; static final String PARAM_SUPPRESS_WARNINGS; static final String PARAM_SIMPLIFY_GEOMETRY; static final String PARAM_SKIP_SEGMENTS; static final String PARAM_ALTERNATIVE_ROUTES; static final String PARAM_MAXIMUM_SPEED; }
|
@Test public void testHasSkipSegments() { List<Integer> testSegments = new ArrayList<>(); testSegments.add(0, 1); Assert.assertFalse(request.hasSkipSegments()); request.setSkipSegments(testSegments); Assert.assertTrue(request.hasSkipSegments()); }
|
public boolean hasSkipSegments() { return hasSkipSegments;}
|
RouteRequest { public boolean hasSkipSegments() { return hasSkipSegments;} }
|
RouteRequest { public boolean hasSkipSegments() { return hasSkipSegments;} @JsonCreator RouteRequest(@JsonProperty(value = PARAM_COORDINATES, required = true) List<List<Double>> coordinates); RouteRequest(Double[][] coordinates); RouteRequest(Coordinate start, Coordinate end); }
|
RouteRequest { public boolean hasSkipSegments() { return hasSkipSegments;} @JsonCreator RouteRequest(@JsonProperty(value = PARAM_COORDINATES, required = true) List<List<Double>> coordinates); RouteRequest(Double[][] coordinates); RouteRequest(Coordinate start, Coordinate end); String getId(); void setId(String id); boolean hasId(); List<List<Double>> getCoordinates(); void setCoordinates(List<List<Double>> coordinates); APIEnums.Profile getProfile(); void setProfile(APIEnums.Profile profile); APIEnums.Units getUnits(); void setUnits(APIEnums.Units units); APIEnums.Languages getLanguage(); void setLanguage(APIEnums.Languages language); APIEnums.RoutePreference getRoutePreference(); void setRoutePreference(APIEnums.RoutePreference routePreference); boolean hasRoutePreference(); APIEnums.RouteResponseType getResponseType(); void setResponseType(APIEnums.RouteResponseType responseType); APIEnums.ExtraInfo[] getExtraInfo(); void setExtraInfo(APIEnums.ExtraInfo[] extraInfo); RouteRequestOptions getRouteOptions(); void setRouteOptions(RouteRequestOptions routeOptions); boolean getIncludeGeometry(); void setIncludeGeometry(boolean includeGeometry); boolean getIncludeInstructionsInResponse(); void setIncludeInstructionsInResponse(Boolean includeInstructionsInResponse); APIEnums.InstructionsFormat getInstructionsFormat(); void setInstructionsFormat(APIEnums.InstructionsFormat instructionsFormat); boolean getIncludeRoundaboutExitInfo(); void setIncludeRoundaboutExitInfo(Boolean includeRoundaboutExitInfo); APIEnums.Attributes[] getAttributes(); void setAttributes(APIEnums.Attributes[] attributes); boolean getIncludeManeuvers(); void setIncludeManeuvers(Boolean includeManeuvers); Double[] getMaximumSearchRadii(); void setMaximumSearchRadii(Double[] maximumSearchRadii); Double[][] getBearings(); void setBearings(Double[][] bearings); boolean getContinueStraightAtWaypoints(); void setContinueStraightAtWaypoints(Boolean continueStraightAtWaypoints); boolean getUseElevation(); void setUseElevation(Boolean useElevation); boolean getUseContractionHierarchies(); void setUseContractionHierarchies(Boolean useContractionHierarchies); boolean getSuppressWarnings(); void setSuppressWarnings(boolean suppressWarnings); boolean getSimplifyGeometry(); void setSimplifyGeometry(boolean simplifyGeometry); List<Integer> getSkipSegments(); void setSkipSegments(List<Integer> skipSegments); RouteRequestAlternativeRoutes getAlternativeRoutes(); void setAlternativeRoutes(RouteRequestAlternativeRoutes alternativeRoutes); void setMaximumSpeed(Double maximumSpeed); double getMaximumSpeed(); boolean hasIncludeRoundaboutExitInfo(); boolean hasAttributes(); boolean hasIncludeManeuvers(); boolean hasMaximumSearchRadii(); boolean hasBearings(); boolean hasContinueStraightAtWaypoints(); boolean hasIncludeInstructions(); boolean hasIncludeGeometry(); boolean hasLanguage(); boolean hasInstructionsFormat(); boolean hasUnits(); boolean hasUseElevation(); boolean hasRouteOptions(); boolean hasUseContractionHierarchies(); boolean hasExtraInfo(); boolean hasSuppressWarnings(); boolean hasSimplifyGeometry(); boolean hasSkipSegments(); boolean hasAlternativeRoutes(); boolean hasMaximumSpeed(); }
|
RouteRequest { public boolean hasSkipSegments() { return hasSkipSegments;} @JsonCreator RouteRequest(@JsonProperty(value = PARAM_COORDINATES, required = true) List<List<Double>> coordinates); RouteRequest(Double[][] coordinates); RouteRequest(Coordinate start, Coordinate end); String getId(); void setId(String id); boolean hasId(); List<List<Double>> getCoordinates(); void setCoordinates(List<List<Double>> coordinates); APIEnums.Profile getProfile(); void setProfile(APIEnums.Profile profile); APIEnums.Units getUnits(); void setUnits(APIEnums.Units units); APIEnums.Languages getLanguage(); void setLanguage(APIEnums.Languages language); APIEnums.RoutePreference getRoutePreference(); void setRoutePreference(APIEnums.RoutePreference routePreference); boolean hasRoutePreference(); APIEnums.RouteResponseType getResponseType(); void setResponseType(APIEnums.RouteResponseType responseType); APIEnums.ExtraInfo[] getExtraInfo(); void setExtraInfo(APIEnums.ExtraInfo[] extraInfo); RouteRequestOptions getRouteOptions(); void setRouteOptions(RouteRequestOptions routeOptions); boolean getIncludeGeometry(); void setIncludeGeometry(boolean includeGeometry); boolean getIncludeInstructionsInResponse(); void setIncludeInstructionsInResponse(Boolean includeInstructionsInResponse); APIEnums.InstructionsFormat getInstructionsFormat(); void setInstructionsFormat(APIEnums.InstructionsFormat instructionsFormat); boolean getIncludeRoundaboutExitInfo(); void setIncludeRoundaboutExitInfo(Boolean includeRoundaboutExitInfo); APIEnums.Attributes[] getAttributes(); void setAttributes(APIEnums.Attributes[] attributes); boolean getIncludeManeuvers(); void setIncludeManeuvers(Boolean includeManeuvers); Double[] getMaximumSearchRadii(); void setMaximumSearchRadii(Double[] maximumSearchRadii); Double[][] getBearings(); void setBearings(Double[][] bearings); boolean getContinueStraightAtWaypoints(); void setContinueStraightAtWaypoints(Boolean continueStraightAtWaypoints); boolean getUseElevation(); void setUseElevation(Boolean useElevation); boolean getUseContractionHierarchies(); void setUseContractionHierarchies(Boolean useContractionHierarchies); boolean getSuppressWarnings(); void setSuppressWarnings(boolean suppressWarnings); boolean getSimplifyGeometry(); void setSimplifyGeometry(boolean simplifyGeometry); List<Integer> getSkipSegments(); void setSkipSegments(List<Integer> skipSegments); RouteRequestAlternativeRoutes getAlternativeRoutes(); void setAlternativeRoutes(RouteRequestAlternativeRoutes alternativeRoutes); void setMaximumSpeed(Double maximumSpeed); double getMaximumSpeed(); boolean hasIncludeRoundaboutExitInfo(); boolean hasAttributes(); boolean hasIncludeManeuvers(); boolean hasMaximumSearchRadii(); boolean hasBearings(); boolean hasContinueStraightAtWaypoints(); boolean hasIncludeInstructions(); boolean hasIncludeGeometry(); boolean hasLanguage(); boolean hasInstructionsFormat(); boolean hasUnits(); boolean hasUseElevation(); boolean hasRouteOptions(); boolean hasUseContractionHierarchies(); boolean hasExtraInfo(); boolean hasSuppressWarnings(); boolean hasSimplifyGeometry(); boolean hasSkipSegments(); boolean hasAlternativeRoutes(); boolean hasMaximumSpeed(); static final String PARAM_ID; static final String PARAM_COORDINATES; static final String PARAM_PROFILE; static final String PARAM_PREFERENCE; static final String PARAM_FORMAT; static final String PARAM_UNITS; static final String PARAM_LANGUAGE; static final String PARAM_GEOMETRY; static final String PARAM_INSTRUCTIONS; static final String PARAM_INSTRUCTIONS_FORMAT; static final String PARAM_ROUNDABOUT_EXITS; static final String PARAM_ATTRIBUTES; static final String PARAM_MANEUVERS; static final String PARAM_RADII; static final String PARAM_BEARINGS; static final String PARAM_CONTINUE_STRAIGHT; static final String PARAM_ELEVATION; static final String PARAM_EXTRA_INFO; static final String PARAM_OPTIMIZED; static final String PARAM_OPTIONS; static final String PARAM_SUPPRESS_WARNINGS; static final String PARAM_SIMPLIFY_GEOMETRY; static final String PARAM_SKIP_SEGMENTS; static final String PARAM_ALTERNATIVE_ROUTES; static final String PARAM_MAXIMUM_SPEED; }
|
@Test public void testHasAlternativeRoutes() { RouteRequestAlternativeRoutes ar = new RouteRequestAlternativeRoutes(); Assert.assertFalse(request.hasAlternativeRoutes()); request.setAlternativeRoutes(ar); Assert.assertTrue(request.hasAlternativeRoutes()); }
|
public boolean hasAlternativeRoutes() { return hasAlternativeRoutes; }
|
RouteRequest { public boolean hasAlternativeRoutes() { return hasAlternativeRoutes; } }
|
RouteRequest { public boolean hasAlternativeRoutes() { return hasAlternativeRoutes; } @JsonCreator RouteRequest(@JsonProperty(value = PARAM_COORDINATES, required = true) List<List<Double>> coordinates); RouteRequest(Double[][] coordinates); RouteRequest(Coordinate start, Coordinate end); }
|
RouteRequest { public boolean hasAlternativeRoutes() { return hasAlternativeRoutes; } @JsonCreator RouteRequest(@JsonProperty(value = PARAM_COORDINATES, required = true) List<List<Double>> coordinates); RouteRequest(Double[][] coordinates); RouteRequest(Coordinate start, Coordinate end); String getId(); void setId(String id); boolean hasId(); List<List<Double>> getCoordinates(); void setCoordinates(List<List<Double>> coordinates); APIEnums.Profile getProfile(); void setProfile(APIEnums.Profile profile); APIEnums.Units getUnits(); void setUnits(APIEnums.Units units); APIEnums.Languages getLanguage(); void setLanguage(APIEnums.Languages language); APIEnums.RoutePreference getRoutePreference(); void setRoutePreference(APIEnums.RoutePreference routePreference); boolean hasRoutePreference(); APIEnums.RouteResponseType getResponseType(); void setResponseType(APIEnums.RouteResponseType responseType); APIEnums.ExtraInfo[] getExtraInfo(); void setExtraInfo(APIEnums.ExtraInfo[] extraInfo); RouteRequestOptions getRouteOptions(); void setRouteOptions(RouteRequestOptions routeOptions); boolean getIncludeGeometry(); void setIncludeGeometry(boolean includeGeometry); boolean getIncludeInstructionsInResponse(); void setIncludeInstructionsInResponse(Boolean includeInstructionsInResponse); APIEnums.InstructionsFormat getInstructionsFormat(); void setInstructionsFormat(APIEnums.InstructionsFormat instructionsFormat); boolean getIncludeRoundaboutExitInfo(); void setIncludeRoundaboutExitInfo(Boolean includeRoundaboutExitInfo); APIEnums.Attributes[] getAttributes(); void setAttributes(APIEnums.Attributes[] attributes); boolean getIncludeManeuvers(); void setIncludeManeuvers(Boolean includeManeuvers); Double[] getMaximumSearchRadii(); void setMaximumSearchRadii(Double[] maximumSearchRadii); Double[][] getBearings(); void setBearings(Double[][] bearings); boolean getContinueStraightAtWaypoints(); void setContinueStraightAtWaypoints(Boolean continueStraightAtWaypoints); boolean getUseElevation(); void setUseElevation(Boolean useElevation); boolean getUseContractionHierarchies(); void setUseContractionHierarchies(Boolean useContractionHierarchies); boolean getSuppressWarnings(); void setSuppressWarnings(boolean suppressWarnings); boolean getSimplifyGeometry(); void setSimplifyGeometry(boolean simplifyGeometry); List<Integer> getSkipSegments(); void setSkipSegments(List<Integer> skipSegments); RouteRequestAlternativeRoutes getAlternativeRoutes(); void setAlternativeRoutes(RouteRequestAlternativeRoutes alternativeRoutes); void setMaximumSpeed(Double maximumSpeed); double getMaximumSpeed(); boolean hasIncludeRoundaboutExitInfo(); boolean hasAttributes(); boolean hasIncludeManeuvers(); boolean hasMaximumSearchRadii(); boolean hasBearings(); boolean hasContinueStraightAtWaypoints(); boolean hasIncludeInstructions(); boolean hasIncludeGeometry(); boolean hasLanguage(); boolean hasInstructionsFormat(); boolean hasUnits(); boolean hasUseElevation(); boolean hasRouteOptions(); boolean hasUseContractionHierarchies(); boolean hasExtraInfo(); boolean hasSuppressWarnings(); boolean hasSimplifyGeometry(); boolean hasSkipSegments(); boolean hasAlternativeRoutes(); boolean hasMaximumSpeed(); }
|
RouteRequest { public boolean hasAlternativeRoutes() { return hasAlternativeRoutes; } @JsonCreator RouteRequest(@JsonProperty(value = PARAM_COORDINATES, required = true) List<List<Double>> coordinates); RouteRequest(Double[][] coordinates); RouteRequest(Coordinate start, Coordinate end); String getId(); void setId(String id); boolean hasId(); List<List<Double>> getCoordinates(); void setCoordinates(List<List<Double>> coordinates); APIEnums.Profile getProfile(); void setProfile(APIEnums.Profile profile); APIEnums.Units getUnits(); void setUnits(APIEnums.Units units); APIEnums.Languages getLanguage(); void setLanguage(APIEnums.Languages language); APIEnums.RoutePreference getRoutePreference(); void setRoutePreference(APIEnums.RoutePreference routePreference); boolean hasRoutePreference(); APIEnums.RouteResponseType getResponseType(); void setResponseType(APIEnums.RouteResponseType responseType); APIEnums.ExtraInfo[] getExtraInfo(); void setExtraInfo(APIEnums.ExtraInfo[] extraInfo); RouteRequestOptions getRouteOptions(); void setRouteOptions(RouteRequestOptions routeOptions); boolean getIncludeGeometry(); void setIncludeGeometry(boolean includeGeometry); boolean getIncludeInstructionsInResponse(); void setIncludeInstructionsInResponse(Boolean includeInstructionsInResponse); APIEnums.InstructionsFormat getInstructionsFormat(); void setInstructionsFormat(APIEnums.InstructionsFormat instructionsFormat); boolean getIncludeRoundaboutExitInfo(); void setIncludeRoundaboutExitInfo(Boolean includeRoundaboutExitInfo); APIEnums.Attributes[] getAttributes(); void setAttributes(APIEnums.Attributes[] attributes); boolean getIncludeManeuvers(); void setIncludeManeuvers(Boolean includeManeuvers); Double[] getMaximumSearchRadii(); void setMaximumSearchRadii(Double[] maximumSearchRadii); Double[][] getBearings(); void setBearings(Double[][] bearings); boolean getContinueStraightAtWaypoints(); void setContinueStraightAtWaypoints(Boolean continueStraightAtWaypoints); boolean getUseElevation(); void setUseElevation(Boolean useElevation); boolean getUseContractionHierarchies(); void setUseContractionHierarchies(Boolean useContractionHierarchies); boolean getSuppressWarnings(); void setSuppressWarnings(boolean suppressWarnings); boolean getSimplifyGeometry(); void setSimplifyGeometry(boolean simplifyGeometry); List<Integer> getSkipSegments(); void setSkipSegments(List<Integer> skipSegments); RouteRequestAlternativeRoutes getAlternativeRoutes(); void setAlternativeRoutes(RouteRequestAlternativeRoutes alternativeRoutes); void setMaximumSpeed(Double maximumSpeed); double getMaximumSpeed(); boolean hasIncludeRoundaboutExitInfo(); boolean hasAttributes(); boolean hasIncludeManeuvers(); boolean hasMaximumSearchRadii(); boolean hasBearings(); boolean hasContinueStraightAtWaypoints(); boolean hasIncludeInstructions(); boolean hasIncludeGeometry(); boolean hasLanguage(); boolean hasInstructionsFormat(); boolean hasUnits(); boolean hasUseElevation(); boolean hasRouteOptions(); boolean hasUseContractionHierarchies(); boolean hasExtraInfo(); boolean hasSuppressWarnings(); boolean hasSimplifyGeometry(); boolean hasSkipSegments(); boolean hasAlternativeRoutes(); boolean hasMaximumSpeed(); static final String PARAM_ID; static final String PARAM_COORDINATES; static final String PARAM_PROFILE; static final String PARAM_PREFERENCE; static final String PARAM_FORMAT; static final String PARAM_UNITS; static final String PARAM_LANGUAGE; static final String PARAM_GEOMETRY; static final String PARAM_INSTRUCTIONS; static final String PARAM_INSTRUCTIONS_FORMAT; static final String PARAM_ROUNDABOUT_EXITS; static final String PARAM_ATTRIBUTES; static final String PARAM_MANEUVERS; static final String PARAM_RADII; static final String PARAM_BEARINGS; static final String PARAM_CONTINUE_STRAIGHT; static final String PARAM_ELEVATION; static final String PARAM_EXTRA_INFO; static final String PARAM_OPTIMIZED; static final String PARAM_OPTIONS; static final String PARAM_SUPPRESS_WARNINGS; static final String PARAM_SIMPLIFY_GEOMETRY; static final String PARAM_SKIP_SEGMENTS; static final String PARAM_ALTERNATIVE_ROUTES; static final String PARAM_MAXIMUM_SPEED; }
|
@Test public void getIdTest() { IsochronesRequest request = new IsochronesRequest(); Assert.assertNull(request.getId()); }
|
public String getId() { return id; }
|
IsochronesRequest { public String getId() { return id; } }
|
IsochronesRequest { public String getId() { return id; } @JsonCreator IsochronesRequest(); }
|
IsochronesRequest { public String getId() { return id; } @JsonCreator IsochronesRequest(); String getId(); void setId(String id); boolean hasId(); APIEnums.Units getAreaUnit(); void setAreaUnit(APIEnums.Units areaUnit); boolean hasAreaUnits(); Double getSmoothing(); void setSmoothing(Double smoothing); boolean hasSmoothing(); APIEnums.RouteResponseType getResponseType(); void setResponseType(APIEnums.RouteResponseType responseType); boolean getIntersections(); void setIntersections(Boolean intersections); boolean hasIntersections(); APIEnums.Units getRangeUnit(); void setRangeUnit(APIEnums.Units rangeUnit); boolean hasRangeUnits(); IsochronesRequestEnums.Attributes[] getAttributes(); void setAttributes(IsochronesRequestEnums.Attributes[] attributes); boolean hasAttributes(); Double[][] getLocations(); void setLocations(Double[][] locations); boolean hasLocations(); IsochronesRequestEnums.LocationType getLocationType(); void setLocationType(IsochronesRequestEnums.LocationType locationType); boolean hasLocationType(); APIEnums.Profile getProfile(); void setProfile(APIEnums.Profile profile); RouteRequestOptions getIsochronesOptions(); void setIsochronesOptions(RouteRequestOptions isochronesOptions); boolean hasOptions(); List<Double> getRange(); void setRange(List<Double> range); boolean hasRange(); IsochronesRequestEnums.RangeType getRangeType(); void setRangeType(IsochronesRequestEnums.RangeType rangeType); boolean hasRangeType(); Double getInterval(); void setInterval(Double interval); boolean hasInterval(); }
|
IsochronesRequest { public String getId() { return id; } @JsonCreator IsochronesRequest(); String getId(); void setId(String id); boolean hasId(); APIEnums.Units getAreaUnit(); void setAreaUnit(APIEnums.Units areaUnit); boolean hasAreaUnits(); Double getSmoothing(); void setSmoothing(Double smoothing); boolean hasSmoothing(); APIEnums.RouteResponseType getResponseType(); void setResponseType(APIEnums.RouteResponseType responseType); boolean getIntersections(); void setIntersections(Boolean intersections); boolean hasIntersections(); APIEnums.Units getRangeUnit(); void setRangeUnit(APIEnums.Units rangeUnit); boolean hasRangeUnits(); IsochronesRequestEnums.Attributes[] getAttributes(); void setAttributes(IsochronesRequestEnums.Attributes[] attributes); boolean hasAttributes(); Double[][] getLocations(); void setLocations(Double[][] locations); boolean hasLocations(); IsochronesRequestEnums.LocationType getLocationType(); void setLocationType(IsochronesRequestEnums.LocationType locationType); boolean hasLocationType(); APIEnums.Profile getProfile(); void setProfile(APIEnums.Profile profile); RouteRequestOptions getIsochronesOptions(); void setIsochronesOptions(RouteRequestOptions isochronesOptions); boolean hasOptions(); List<Double> getRange(); void setRange(List<Double> range); boolean hasRange(); IsochronesRequestEnums.RangeType getRangeType(); void setRangeType(IsochronesRequestEnums.RangeType rangeType); boolean hasRangeType(); Double getInterval(); void setInterval(Double interval); boolean hasInterval(); static final String PARAM_ID; static final String PARAM_PROFILE; static final String PARAM_LOCATIONS; static final String PARAM_LOCATION_TYPE; static final String PARAM_OPTIONS; static final String PARAM_RANGE; static final String PARAM_RANGE_TYPE; static final String PARAM_RANGE_UNITS; static final String PARAM_AREA_UNITS; static final String PARAM_INTERSECTIONS; static final String PARAM_ATTRIBUTES; static final String PARAM_INTERVAL; static final String PARAM_SMOOTHING; }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.