├── .gitignore ├── .travis.yml ├── .travis └── maven-settings.xml ├── LICENSE ├── README.md ├── pom.xml └── src ├── main └── java │ └── io │ └── vavr │ └── hibernate │ └── userstype │ ├── ListUserType.java │ └── PersistentList.java └── test └── java └── io └── vavr └── hibernate └── ListUserTypeTest.java /.gitignore: -------------------------------------------------------------------------------- 1 | target 2 | .idea 3 | *.iml 4 | *.ipr 5 | *.iws 6 | ### Java template 7 | # Compiled class file 8 | *.class 9 | 10 | # Log file 11 | *.log 12 | 13 | # BlueJ files 14 | *.ctxt 15 | 16 | # Mobile Tools for Java (J2ME) 17 | .mtj.tmp/ 18 | 19 | # Package Files # 20 | *.jar 21 | *.war 22 | *.ear 23 | *.zip 24 | *.tar.gz 25 | *.rar 26 | 27 | # virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml 28 | hs_err_pid* 29 | ### JetBrains template 30 | # Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio and Webstorm 31 | # Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839 32 | 33 | # User-specific stuff: 34 | .idea/**/workspace.xml 35 | .idea/**/tasks.xml 36 | .idea/dictionaries 37 | 38 | # Sensitive or high-churn files: 39 | .idea/**/dataSources/ 40 | .idea/**/dataSources.ids 41 | .idea/**/dataSources.xml 42 | .idea/**/dataSources.local.xml 43 | .idea/**/sqlDataSources.xml 44 | .idea/**/dynamic.xml 45 | .idea/**/uiDesigner.xml 46 | 47 | # Gradle: 48 | .idea/**/gradle.xml 49 | .idea/**/libraries 50 | 51 | # Mongo Explorer plugin: 52 | .idea/**/mongoSettings.xml 53 | 54 | ## File-based project format: 55 | 56 | ## Plugin-specific files: 57 | 58 | # IntelliJ 59 | /out/ 60 | 61 | # mpeltonen/sbt-idea plugin 62 | .idea_modules/ 63 | 64 | # JIRA plugin 65 | atlassian-ide-plugin.xml 66 | 67 | # Crashlytics plugin (for Android Studio and IntelliJ) 68 | com_crashlytics_export_strings.xml 69 | crashlytics.properties 70 | crashlytics-build.properties 71 | fabric.properties 72 | -------------------------------------------------------------------------------- /.travis.yml: -------------------------------------------------------------------------------- 1 | language: java 2 | jdk: 3 | - oraclejdk8 4 | env: 5 | global: 6 | - secure: D8Z2pmvfy0LETBW5A6xzdU/Q8dEkbVAptbofWZIpHEl4dWC6vVux3A5MeRIXp6Sv5n/Vyw4pIh+dXcUrrLtofhLksTLIEgeNpG6hC+ctMYMxW63U2skIxa6RQ8iZy5/qQ9btJH3hd4hJI3u2sQ2NgHpw/KCj1sRrT8aIrS9QQl4zxxLd8D8HPUlr3O/eV1Ik38quCPmmrp/6jRJnZnE1Y3IcNqt/L0CLsZwqued6WyqWBU/2yskGxmij5i88RPgxN1oau6HUtPW8lqJhwdnTOgi9/t9kDkItopPC25A6gSGwwI75gF1jvWe95aQQfqLwHnOZcjEEBs3836ibQT5PPTr9vtKLssH35uM22pAWIlP38zilOIVN4Jy3nYC983ef7ZtBLuBFBatmOUBYOrlFN4GdlVPUOcbZFsBnjQnDoSADJ+fDt6Q/WJ2knudfc82kle0Jul8fIKP5OIGLk1ZhhuBYkbM6k8l3offk/cRIhVI5D94zm2UJkw+8MAlP6ffcPNMUzCU9YofaB0lX3j5/JKwntph27VnNUsplsUtM0uOEtN+4VuzdzAXDnm1yp4fGObffrMUJ9coG+kEBYaKFoLgFoVv1H76Xn1FLWtbqBOnC6Se5FPoxYVD2eYMjNRuEP9sYs63jS0oYjWj+Z2z1rkH26BgyGcCZxCj7qTzvTwE= 7 | - secure: DTfPB0fMpchGnbeV5YVevVQBoqow1WCeSZqgjKigsVgkKTFhuX03Wnbjce7E669p2vioPclxrF6jvjegDZCexIjUYNRZhfNZtvaZ6/kzwOC9vlC9b+5WJ6XSG6gm7YZaQ2TP353c8bqBSyVW2LvECtwZZxM3x6pt8zA2UX100uh/+0Ftc3QbBoBXZkgaXfCT84P/OO52hPuZZl04u+TJabrwt3TPxRUIcxTrGUnW37wOPxyYt6qcFZplAmjorm6vFIcE0FNH90yViqEp3rKBtQGgDW0XnmoTYLRCEDDdRmTyGFoOjjnpZuaA41iiUJx6F3H63zAQOpB8mefjvYGKcnvIVHTHWfPOwNycSiATQ9g8QV5Z3y6HE+Kk5wDcL/USiOl4tn651s4eY+tE2sswpRyMfQa/f6x73xYT0Wqa22Xss4uzLtVJhxcZIku8pxDSJg40XQxSUXwuwfU3OJvNjsKVPjXnZ3QYrvQN7A6ZEDRw60BLQ+XVvlHSdLAeWPbtUWeUc1ke/x7QhTGIskkGlvV9AlW6LQDkfX5YwjQ9ZYCyAmfSjmN4J01oBQbbj+/XoS1iIna7VpWEEPbMw6sG+CF3jyk14EwmU2l8G3ZxtXBkzzCH5joIOTQZh8iUZ1BxTqBWlExHlcaUHJxG12udc/MLzkKUDIcOEIOlkzuwfhU= 8 | before_install: 9 | - sudo apt-get update 10 | - sudo apt-get install --only-upgrade -y oracle-java8-installer 11 | - pip install --user codecov 12 | script: 13 | - mvn clean test -B 14 | - mvn clean test -B -Dfasterxml.version=2.8.4 15 | after_success: 16 | - codecov 17 | - mvn clean deploy -DskipTests --settings .travis/maven-settings.xml -------------------------------------------------------------------------------- /.travis/maven-settings.xml: -------------------------------------------------------------------------------- 1 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | sonatype-nexus-snapshots 13 | ${env.SONATYPE_USER} 14 | ${env.SONATYPE_PASS} 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | Copyright 2014-2017 Vavr, http://vavr.io 2 | 3 | Licensed under the Apache License, Version 2.0 (the "License"); 4 | you may not use this file except in compliance with the License. 5 | You may obtain a copy of the License at 6 | 7 | http://www.apache.org/licenses/LICENSE-2.0 8 | 9 | Unless required by applicable law or agreed to in writing, software 10 | distributed under the License is distributed on an "AS IS" BASIS, 11 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 | See the License for the specific language governing permissions and 13 | limitations under the License. 14 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | Hibernate module for Vavr 2 | - 3 | 4 | This is currently a total WIP. 5 | Initial goals 6 | 7 | 1. Get a `List` wiring in via a UserType 8 | 2. Get an `Option` wired in via a UserType 9 | 3. Auto-support `List` through registration. 10 | 4. Auto-support `Option` through registration. 11 | 12 | 13 | Notes: 14 | - 15 | `PersistentList` must be one of type vavr `List` and be of type `PersistentCollection` 16 | to be supported by hibernate. Currently implementation is super verbose because it must delegate 17 | so many methods. Lombok `@Delegate` doesn't really help because of it's limitations. 18 | Lombok `@Delegate` only delegates methods for 1 level of hierarchy and `List` has at least 4 19 | and implements multiple interfaces. 20 | 21 | `TypeDescriptor` is the mechanism by which hibernate auto-registers it's 22 | type marshalling scheme. 23 | 24 | Current test in place fails as planned. Get that to work and we are have something. 25 | 26 | -------------------------------------------------------------------------------- /pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | 5 | org.sonatype.oss 6 | oss-parent 7 | 9 8 | 9 | 10 | io.vavr 11 | vavr-hibernate 12 | 1.0.0-SNAPSHOT 13 | jar 14 | http://vavr.io 15 | Vavr-Hibernate 16 | Hibernate datatype module for Vavr.io 17 | 18 | 19 | The Apache Software License, Version 2.0 20 | http://www.apache.org/licenses/LICENSE-2.0.txt 21 | repo 22 | 23 | 24 | 25 | scm:git:git@github.com:vavr-io/vavr-hibernate.git 26 | scm:git:git@github.com:vavr-io/vavr-hibernate.git 27 | git@github.com:vavr-io/vavr-hibernate.git 28 | HEAD 29 | 30 | 31 | 32 | 33 | cbongiorno 34 | Christian Bongiorno 35 | christian.bongiorno@gmail.com 36 | 37 | 38 | 39 | 40 | UTF-8 41 | 1.8 42 | 4.12 43 | 1.0.0-SNAPSHOT 44 | 3.2 45 | 2.7.2 46 | 4.0.0 47 | 0.7.5.201505241946 48 | 1.5 49 | 2.5.1 50 | 2.1 51 | 1.5.3.RELEASE 52 | 53 | 54 | 55 | 56 | io.vavr 57 | vavr 58 | ${vavr.version} 59 | 60 | 61 | 62 | junit 63 | junit 64 | ${junit.version} 65 | test 66 | 67 | 68 | org.assertj 69 | assertj-core 70 | 2.2.0 71 | test 72 | 73 | 74 | 75 | org.projectlombok 76 | lombok 77 | 1.16.16 78 | provided 79 | 80 | 81 | org.hibernate 82 | hibernate-core 83 | 5.2.10.Final 84 | 85 | 86 | org.springframework.boot 87 | spring-boot-autoconfigure 88 | ${spring-boot.version} 89 | test 90 | 91 | 92 | org.springframework.boot 93 | spring-boot-test-autoconfigure 94 | ${spring-boot.version} 95 | test 96 | 97 | 98 | org.springframework 99 | spring-test 100 | 4.3.4.RELEASE 101 | test 102 | 103 | 104 | org.springframework 105 | spring-tx 106 | 4.3.4.RELEASE 107 | test 108 | 109 | 110 | org.springframework.boot 111 | spring-boot-starter-data-jpa 112 | 113 | 114 | org.hibernate 115 | hibernate-entitymanager 116 | 117 | 118 | ${spring-boot.version} 119 | test 120 | 121 | 122 | 123 | org.hsqldb 124 | hsqldb 125 | test 126 | 2.3.1 127 | 128 | 129 | 130 | 131 | 132 | 133 | org.apache.maven.plugins 134 | maven-compiler-plugin 135 | ${maven.compiler.version} 136 | 137 | ${java.version} 138 | ${java.version} 139 | true 140 | true 141 | 142 | -Xlint:all 143 | -Werror 144 | 145 | -Xlint:-processing 146 | 147 | 148 | 149 | 150 | org.codehaus.mojo 151 | versions-maven-plugin 152 | ${maven.versions.version} 153 | 154 | 155 | 156 | 157 | 158 | org.apache.maven.plugins 159 | maven-release-plugin 160 | ${maven.release.version} 161 | 162 | 163 | forked-path 164 | false 165 | 166 | ${arguments} -Psonatype-oss-release 167 | 168 | 169 | 170 | 171 | 172 | 173 | 174 | 175 | ci 176 | 177 | 178 | env.CI 179 | 180 | 181 | 182 | 183 | 184 | org.jacoco 185 | jacoco-maven-plugin 186 | ${maven.jacoco.version} 187 | 188 | 189 | 190 | prepare-agent 191 | 192 | 193 | 194 | report 195 | test 196 | 197 | report 198 | 199 | 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | release-sign-artifacts 208 | 209 | 210 | 211 | performRelease 212 | true 213 | 214 | 215 | 216 | 217 | 218 | org.apache.maven.plugins 219 | maven-gpg-plugin 220 | ${maven.gpg.version} 221 | 222 | 223 | sign-artifacts 224 | verify 225 | 226 | sign 227 | 228 | 229 | 230 | 231 | 232 | 233 | 234 | 235 | 236 | -------------------------------------------------------------------------------- /src/main/java/io/vavr/hibernate/userstype/ListUserType.java: -------------------------------------------------------------------------------- 1 | package io.vavr.hibernate.userstype; 2 | 3 | import io.vavr.collection.List; 4 | import java.util.Iterator; 5 | import java.util.Map; 6 | import org.hibernate.HibernateException; 7 | import org.hibernate.collection.spi.PersistentCollection; 8 | import org.hibernate.engine.spi.SharedSessionContractImplementor; 9 | import org.hibernate.persister.collection.CollectionPersister; 10 | import org.hibernate.usertype.UserCollectionType; 11 | 12 | /** 13 | * @author cbongiorno on 7/3/17. 14 | */ 15 | public class ListUserType implements UserCollectionType { 16 | 17 | @Override 18 | public PersistentCollection instantiate(SharedSessionContractImplementor session, 19 | CollectionPersister persister) throws HibernateException { 20 | return null; 21 | } 22 | 23 | @Override 24 | public PersistentCollection wrap(SharedSessionContractImplementor session, Object collection) { 25 | return null; 26 | } 27 | 28 | @Override 29 | public Iterator getElementsIterator(Object collection) { 30 | return ((List)collection).iterator(); 31 | } 32 | 33 | @Override 34 | public boolean contains(Object collection, Object entity) { 35 | return ((List)collection).contains(entity); 36 | } 37 | 38 | @Override 39 | public Object indexOf(Object collection, Object entity) { 40 | return ((List)collection).indexOf(entity); 41 | } 42 | 43 | @Override 44 | public Object replaceElements(Object original, Object target, CollectionPersister persister, 45 | Object owner, Map copyCache, SharedSessionContractImplementor session) 46 | throws HibernateException { 47 | return null; 48 | } 49 | 50 | @Override 51 | public Object instantiate(int anticipatedSize) { 52 | return List.empty(); 53 | } 54 | } 55 | -------------------------------------------------------------------------------- /src/main/java/io/vavr/hibernate/userstype/PersistentList.java: -------------------------------------------------------------------------------- 1 | package io.vavr.hibernate.userstype; 2 | 3 | import io.vavr.CheckedFunction0; 4 | import io.vavr.Function1; 5 | import io.vavr.PartialFunction; 6 | import io.vavr.Tuple; 7 | import io.vavr.Tuple1; 8 | import io.vavr.Tuple2; 9 | import io.vavr.Tuple3; 10 | import io.vavr.collection.Array; 11 | import io.vavr.collection.CharSeq; 12 | import io.vavr.collection.List; 13 | import io.vavr.collection.Map; 14 | import io.vavr.collection.PriorityQueue; 15 | import io.vavr.collection.Queue; 16 | import io.vavr.collection.Seq; 17 | import io.vavr.collection.SortedMap; 18 | import io.vavr.collection.SortedSet; 19 | import io.vavr.collection.Tree; 20 | import io.vavr.collection.Vector; 21 | import io.vavr.control.Either; 22 | import io.vavr.control.Option; 23 | import io.vavr.control.Try; 24 | import io.vavr.control.Validation; 25 | import java.io.PrintStream; 26 | import java.io.PrintWriter; 27 | import java.io.Serializable; 28 | import java.sql.ResultSet; 29 | import java.sql.SQLException; 30 | import java.util.Collection; 31 | import java.util.Comparator; 32 | import java.util.Iterator; 33 | import java.util.Objects; 34 | import java.util.Optional; 35 | import java.util.Set; 36 | import java.util.Spliterator; 37 | import java.util.concurrent.CompletableFuture; 38 | import java.util.function.BiConsumer; 39 | import java.util.function.BiFunction; 40 | import java.util.function.BiPredicate; 41 | import java.util.function.Consumer; 42 | import java.util.function.Function; 43 | import java.util.function.Predicate; 44 | import java.util.function.Supplier; 45 | import java.util.stream.Collector; 46 | import java.util.stream.Stream; 47 | import lombok.EqualsAndHashCode; 48 | import org.hibernate.HibernateException; 49 | import org.hibernate.collection.internal.AbstractPersistentCollection; 50 | import org.hibernate.engine.spi.SharedSessionContractImplementor; 51 | import org.hibernate.loader.CollectionAliases; 52 | import org.hibernate.persister.collection.CollectionPersister; 53 | import org.hibernate.type.Type; 54 | 55 | /** 56 | * @author cbongiorno on 7/5/17. 57 | */ 58 | @EqualsAndHashCode(of = "delegate") 59 | public class PersistentList extends AbstractPersistentCollection implements List { 60 | 61 | 62 | private List delegate = List.empty(); 63 | 64 | 65 | public PersistentList(SharedSessionContractImplementor session) { 66 | super(session); 67 | } 68 | 69 | public PersistentList(SharedSessionContractImplementor session, List delegate) { 70 | super(session); 71 | this.delegate = delegate; 72 | 73 | } 74 | 75 | @Override 76 | public boolean empty() { 77 | return delegate.isEmpty(); 78 | } 79 | 80 | @Override 81 | public Collection getOrphans(Serializable snapshot, String entityName) throws HibernateException { 82 | return null; 83 | } 84 | 85 | @Override 86 | public void initializeFromCache(CollectionPersister persister, Serializable disassembled, 87 | Object owner) { 88 | System.out.println(); 89 | } 90 | 91 | @Override 92 | public Iterator entries(CollectionPersister persister) { 93 | return delegate.iterator(); 94 | } 95 | 96 | private transient List loadingEntries; 97 | 98 | @Override 99 | public Object readFrom(ResultSet rs, CollectionPersister role, CollectionAliases descriptor, 100 | Object owner) throws HibernateException, SQLException { 101 | 102 | final Object element = role 103 | .readElement(rs, owner, descriptor.getSuffixedElementAliases(), getSession()); 104 | if (element != null) { 105 | final Object index = role.readIndex(rs, descriptor.getSuffixedIndexAliases(), getSession()); 106 | loadingEntries = Option.of(loadingEntries).filter(Objects::nonNull).getOrElse(List.empty()); 107 | loadingEntries = loadingEntries.append(Tuple.of(index, element)); 108 | } 109 | return element; 110 | } 111 | 112 | @Override 113 | public Object getIndex(Object entry, int i, CollectionPersister persister) { 114 | return delegate.get(i); 115 | } 116 | 117 | @Override 118 | public Object getElement(Object entry) { 119 | return entry; 120 | } 121 | 122 | @Override 123 | public Object getSnapshotElement(Object entry, int i) { 124 | // supposed to copy this element. 125 | return entry; 126 | } 127 | 128 | @Override 129 | @SuppressWarnings("unchecked") 130 | public void beforeInitialize(CollectionPersister persister, int anticipatedSize) { 131 | this.delegate = (List) persister.getCollectionType().instantiate(anticipatedSize); 132 | 133 | } 134 | 135 | @Override 136 | public boolean equalsSnapshot(CollectionPersister persister) { 137 | return false; 138 | } 139 | 140 | @Override 141 | public boolean isSnapshotEmpty(Serializable snapshot) { 142 | return ((List) snapshot).isEmpty(); 143 | } 144 | 145 | @Override 146 | public Serializable disassemble(CollectionPersister persister) { 147 | return delegate.map(v -> persister.getElementType().disassemble(v, getSession(), null)); 148 | } 149 | 150 | @Override 151 | public Serializable getSnapshot(CollectionPersister persister) { 152 | return delegate.map(v -> persister.getElementType().deepCopy(v, persister.getFactory())); 153 | } 154 | 155 | @Override 156 | @SuppressWarnings("unchecked") 157 | public boolean entryExists(Object entry, int i) { 158 | return delegate.contains((T) entry); 159 | } 160 | 161 | @Override 162 | public boolean needsInserting(Object entry, int i, Type elemType) { 163 | return !delegate.get(i).equals(entry); 164 | } 165 | 166 | @Override 167 | public boolean needsUpdating(Object entry, int i, Type elemType) { 168 | return false; 169 | } 170 | 171 | @Override 172 | public Iterator getDeletes(CollectionPersister persister, boolean indexIsFormula) { 173 | return null; 174 | } 175 | 176 | @Override 177 | public boolean isWrapper(Object collection) { 178 | return false; 179 | } 180 | 181 | 182 | @Override 183 | public T fold(T zero, BiFunction combine) { 184 | return delegate.fold(zero, combine); 185 | } 186 | 187 | @Override 188 | public boolean isMemoized() { 189 | return delegate.isMemoized(); 190 | } 191 | 192 | 193 | @Override 194 | public int indexOfSlice(Iterable that, int from) { 195 | return delegate.indexOfSlice(that, from); 196 | } 197 | 198 | @Override 199 | public int indexWhere(Predicate predicate, int from) { 200 | return delegate.indexWhere(predicate, from); 201 | } 202 | 203 | 204 | @Override 205 | public T apply(Integer index) { 206 | return delegate.apply(index); 207 | } 208 | 209 | @Override 210 | public T reduce(BiFunction op) { 211 | return delegate.reduce(op); 212 | } 213 | 214 | @Override 215 | public boolean isDefinedAt(Integer index) { 216 | return delegate.isDefinedAt(index); 217 | } 218 | 219 | 220 | @Override 221 | public int lastIndexOfSlice(Iterable that, int end) { 222 | return delegate.lastIndexOfSlice(that, end); 223 | } 224 | 225 | 226 | @Override 227 | public int lastIndexWhere(Predicate predicate, int end) { 228 | return delegate.lastIndexWhere(predicate, end); 229 | } 230 | 231 | @Override 232 | public Option reduceOption(BiFunction op) { 233 | return delegate.reduceOption(op); 234 | } 235 | 236 | 237 | @Override 238 | public boolean isAsync() { 239 | return delegate.isAsync(); 240 | } 241 | 242 | 243 | @Override 244 | public boolean isEmpty() { 245 | return delegate.isEmpty(); 246 | } 247 | 248 | 249 | @Override 250 | public boolean isLazy() { 251 | return delegate.isLazy(); 252 | } 253 | 254 | @Override 255 | public Option> arrangeBy( 256 | Function getKey) { 257 | return delegate.arrangeBy(getKey); 258 | } 259 | 260 | @Override 261 | public int arity() { 262 | return delegate.arity(); 263 | } 264 | 265 | @Override 266 | public Function1 curried() { 267 | return delegate.curried(); 268 | } 269 | 270 | @Override 271 | public Function1, T> tupled() { 272 | return delegate.tupled(); 273 | } 274 | 275 | @Override 276 | public R collect(Collector collector) { 277 | return delegate.collect(collector); 278 | } 279 | 280 | @Override 281 | public Function1 reversed() { 282 | return delegate.reversed(); 283 | } 284 | 285 | @Override 286 | public Function1 memoized() { 287 | return delegate.memoized(); 288 | } 289 | 290 | 291 | @Override 292 | public R collect(Supplier supplier, 293 | BiConsumer accumulator, 294 | BiConsumer combiner) { 295 | return delegate.collect(supplier, accumulator, combiner); 296 | } 297 | 298 | @Override 299 | public io.vavr.collection.Iterator reverseIterator() { 300 | return delegate.reverseIterator(); 301 | } 302 | 303 | @Override 304 | public Option average() { 305 | return delegate.average(); 306 | } 307 | 308 | @Override 309 | public PartialFunction partial( 310 | Predicate isDefinedAt) { 311 | return delegate.partial(isDefinedAt); 312 | } 313 | 314 | @Override 315 | public int segmentLength(Predicate predicate, int from) { 316 | return delegate.segmentLength(predicate, from); 317 | } 318 | 319 | @Override 320 | public boolean contains(T element) { 321 | return delegate.contains(element); 322 | } 323 | 324 | 325 | @Override 326 | public boolean corresponds(Iterable that, 327 | BiPredicate predicate) { 328 | return delegate.corresponds(that, predicate); 329 | } 330 | 331 | @Override 332 | public Function1 andThen( 333 | Function after) { 334 | return delegate.andThen(after); 335 | } 336 | 337 | @Override 338 | public boolean containsSlice(Iterable that) { 339 | return delegate.containsSlice(that); 340 | } 341 | 342 | @Override 343 | public Function1 compose( 344 | Function before) { 345 | return delegate.compose(before); 346 | } 347 | 348 | @Override 349 | public io.vavr.collection.Iterator> crossProduct() { 350 | return delegate.crossProduct(); 351 | } 352 | 353 | 354 | @Override 355 | public boolean eq(Object o) { 356 | return delegate.eq(o); 357 | } 358 | 359 | @Override 360 | public boolean containsAll(Iterable elements) { 361 | return delegate.containsAll(elements); 362 | } 363 | 364 | @Override 365 | public io.vavr.collection.Iterator> crossProduct( 366 | Iterable that) { 367 | return delegate.crossProduct(that); 368 | } 369 | 370 | 371 | @Override 372 | public int count(Predicate predicate) { 373 | return delegate.count(predicate); 374 | } 375 | 376 | @Override 377 | public int search(T element) { 378 | return delegate.search(element); 379 | } 380 | 381 | @Override 382 | public boolean exists(Predicate predicate) { 383 | return delegate.exists(predicate); 384 | } 385 | 386 | @Override 387 | public boolean endsWith(Seq that) { 388 | return delegate.endsWith(that); 389 | } 390 | 391 | 392 | @Override 393 | public boolean forAll(Predicate predicate) { 394 | return delegate.forAll(predicate); 395 | } 396 | 397 | 398 | @Override 399 | public int search(T element, Comparator comparator) { 400 | return delegate.search(element, comparator); 401 | } 402 | 403 | @Override 404 | public void forEach(Consumer action) { 405 | delegate.forEach(action); 406 | } 407 | 408 | 409 | @Override 410 | public int indexOf(T element) { 411 | return delegate.indexOf(element); 412 | } 413 | 414 | 415 | @Override 416 | public Option indexOfOption(T element) { 417 | return delegate.indexOfOption(element); 418 | } 419 | 420 | @Override 421 | public Option indexOfOption(T element, int from) { 422 | return delegate.indexOfOption(element, from); 423 | } 424 | 425 | @Override 426 | public T getOrElse(T other) { 427 | return delegate.getOrElse(other); 428 | } 429 | 430 | @Override 431 | public T getOrElse(Supplier supplier) { 432 | return delegate.getOrElse(supplier); 433 | } 434 | 435 | @Override 436 | public int indexOfSlice(Iterable that) { 437 | return delegate.indexOfSlice(that); 438 | } 439 | 440 | @Override 441 | public Option indexOfSliceOption(Iterable that) { 442 | return delegate.indexOfSliceOption(that); 443 | } 444 | 445 | @Override 446 | public T getOrElseThrow(Supplier supplier) throws X { 447 | return delegate.getOrElseThrow(supplier); 448 | } 449 | 450 | @Override 451 | public T getOrElseTry(CheckedFunction0 supplier) { 452 | return delegate.getOrElseTry(supplier); 453 | } 454 | 455 | @Override 456 | public T getOrNull() { 457 | return delegate.getOrNull(); 458 | } 459 | 460 | @Override 461 | public Option indexOfSliceOption(Iterable that, int from) { 462 | return delegate.indexOfSliceOption(that, from); 463 | } 464 | 465 | 466 | @Override 467 | public int indexWhere(Predicate predicate) { 468 | return delegate.indexWhere(predicate); 469 | } 470 | 471 | 472 | 473 | @Override 474 | public Option indexWhereOption(Predicate predicate) { 475 | return delegate.indexWhereOption(predicate); 476 | } 477 | 478 | @Override 479 | public boolean existsUnique(Predicate predicate) { 480 | return delegate.existsUnique(predicate); 481 | } 482 | 483 | 484 | @Override 485 | public Option indexWhereOption(Predicate predicate, int from) { 486 | return delegate.indexWhereOption(predicate, from); 487 | } 488 | 489 | 490 | @Override 491 | public Option find(Predicate predicate) { 492 | return delegate.find(predicate); 493 | } 494 | 495 | @Override 496 | // //@GwtIncompatible("java.io.PrintStream is not implemented") 497 | public void out(PrintStream out) { 498 | delegate.out(out); 499 | } 500 | 501 | @Override 502 | public Option findLast(Predicate predicate) { 503 | return delegate.findLast(predicate); 504 | } 505 | 506 | 507 | @Override 508 | // //@GwtIncompatible("java.io.PrintWriter is not implemented") 509 | public void out(PrintWriter writer) { 510 | delegate.out(writer); 511 | } 512 | 513 | 514 | @Override 515 | public U foldLeft(U zero, BiFunction f) { 516 | return delegate.foldLeft(zero, f); 517 | } 518 | 519 | @Override 520 | public io.vavr.collection.Iterator iterator(int index) { 521 | return delegate.iterator(index); 522 | } 523 | 524 | // //@GwtIncompatible 525 | 526 | 527 | @Override 528 | // //@GwtIncompatible("java.io.PrintStream is not implemented") 529 | public void stderr() { 530 | delegate.stderr(); 531 | } 532 | 533 | @Override 534 | public int lastIndexOf(T element) { 535 | return delegate.lastIndexOf(element); 536 | } 537 | 538 | @Override 539 | public T get() { 540 | return delegate.get(); 541 | } 542 | 543 | @Override 544 | public Option lastIndexOfOption(T element) { 545 | return delegate.lastIndexOfOption(element); 546 | } 547 | 548 | @Override 549 | //@GwtIncompatible("java.io.PrintStream is not implemented") 550 | public void stdout() { 551 | delegate.stdout(); 552 | } 553 | 554 | 555 | @Override 556 | public int lastIndexWhere(Predicate predicate) { 557 | return delegate.lastIndexWhere(predicate); 558 | } 559 | 560 | @Override 561 | public Array toArray() { 562 | return delegate.toArray(); 563 | } 564 | 565 | @Override 566 | public CharSeq toCharSeq() { 567 | return delegate.toCharSeq(); 568 | } 569 | 570 | @Override 571 | public Option lastIndexWhereOption(Predicate predicate) { 572 | return delegate.lastIndexWhereOption(predicate); 573 | } 574 | 575 | 576 | @Override 577 | //@GwtIncompatible 578 | public CompletableFuture toCompletableFuture() { 579 | return delegate.toCompletableFuture(); 580 | } 581 | 582 | @Override 583 | public Option lastIndexWhereOption(Predicate predicate, 584 | int end) { 585 | return delegate.lastIndexWhereOption(predicate, end); 586 | } 587 | 588 | 589 | @Override 590 | public Validation toInvalid(U value) { 591 | return delegate.toInvalid(value); 592 | } 593 | 594 | @Override 595 | public Function1> lift() { 596 | return delegate.lift(); 597 | } 598 | 599 | @Override 600 | public T head() { 601 | return delegate.head(); 602 | } 603 | 604 | @Override 605 | public Validation toInvalid( 606 | Supplier valueSupplier) { 607 | return delegate.toInvalid(valueSupplier); 608 | } 609 | 610 | @Override 611 | public Option headOption() { 612 | return delegate.headOption(); 613 | } 614 | 615 | @Override 616 | public Object[] toJavaArray() { 617 | return delegate.toJavaArray(); 618 | } 619 | 620 | 621 | @Override 622 | public Option lastIndexOfOption(T element, int end) { 623 | return delegate.lastIndexOfOption(element, end); 624 | } 625 | 626 | 627 | @Override 628 | public int lastIndexOfSlice(Iterable that) { 629 | return delegate.lastIndexOfSlice(that); 630 | } 631 | 632 | @Override 633 | //@GwtIncompatible("reflection is not supported") 634 | public T[] toJavaArray(Class componentType) { 635 | return delegate.toJavaArray(componentType); 636 | } 637 | 638 | @Override 639 | public Option lastIndexOfSliceOption(Iterable that) { 640 | return delegate.lastIndexOfSliceOption(that); 641 | } 642 | 643 | 644 | @Override 645 | public Option lastIndexOfSliceOption(Iterable that, int end) { 646 | return delegate.lastIndexOfSliceOption(that, end); 647 | } 648 | 649 | @Override 650 | public > C toJavaCollection( 651 | Function factory) { 652 | return delegate.toJavaCollection(factory); 653 | } 654 | 655 | @Override 656 | public java.util.List toJavaList() { 657 | return delegate.toJavaList(); 658 | } 659 | 660 | @Override 661 | public int hashCode() { 662 | return delegate.hashCode(); 663 | } 664 | 665 | @Override 666 | public > LIST toJavaList( 667 | Function factory) { 668 | return delegate.toJavaList(factory); 669 | } 670 | 671 | @Override 672 | public java.util.Map toJavaMap( 673 | Function> f) { 674 | return delegate.toJavaMap(f); 675 | } 676 | 677 | @Override 678 | public boolean isDistinct() { 679 | return delegate.isDistinct(); 680 | } 681 | 682 | 683 | @Override 684 | public boolean isOrdered() { 685 | return delegate.isOrdered(); 686 | } 687 | 688 | @Override 689 | public > MAP toJavaMap(Supplier factory, 690 | Function keyMapper, 691 | Function valueMapper) { 692 | return delegate.toJavaMap(factory, keyMapper, valueMapper); 693 | } 694 | 695 | @Override 696 | public List append(T element) { 697 | return delegate.append(element); 698 | } 699 | 700 | @Override 701 | public List appendAll(Iterable elements) { 702 | return delegate.appendAll(elements); 703 | } 704 | 705 | // //@GwtIncompatible a package private annotation? That's a first 706 | @Override 707 | public java.util.List asJava() { 708 | return delegate.asJava(); 709 | } 710 | 711 | @Override 712 | public boolean isSingleValued() { 713 | return delegate.isSingleValued(); 714 | } 715 | 716 | @Override 717 | public List asJava(Consumer> action) { 718 | return delegate.asJava(action); 719 | } 720 | 721 | @Override 722 | public int prefixLength(Predicate predicate) { 723 | return delegate.prefixLength(predicate); 724 | } 725 | 726 | // //@GwtIncompatible 727 | @Override 728 | public java.util.List asJavaMutable() { 729 | return delegate.asJavaMutable(); 730 | } 731 | 732 | @Override 733 | public > MAP toJavaMap(Supplier factory, 734 | Function> f) { 735 | return delegate.toJavaMap(factory, f); 736 | } 737 | 738 | // //@GwtIncompatible 739 | @Override 740 | public List asJavaMutable(Consumer> action) { 741 | return delegate.asJavaMutable(action); 742 | } 743 | 744 | @Override 745 | public List collect(PartialFunction partialFunction) { 746 | return delegate.collect(partialFunction); 747 | } 748 | 749 | @Override 750 | public io.vavr.collection.Iterator iterator() { 751 | return delegate.iterator(); 752 | } 753 | 754 | @Override 755 | public List> combinations() { 756 | return delegate.combinations(); 757 | } 758 | 759 | 760 | @Override 761 | public List> combinations(int k) { 762 | return delegate.combinations(k); 763 | } 764 | 765 | @Override 766 | public io.vavr.collection.Iterator> crossProduct(int power) { 767 | return delegate.crossProduct(power); 768 | } 769 | 770 | @Override 771 | public List distinct() { 772 | return delegate.distinct(); 773 | } 774 | 775 | @Override 776 | public Optional toJavaOptional() { 777 | return delegate.toJavaOptional(); 778 | } 779 | 780 | @Override 781 | public T last() { 782 | return delegate.last(); 783 | } 784 | 785 | @Override 786 | public List distinctBy(Comparator comparator) { 787 | return delegate.distinctBy(comparator); 788 | } 789 | 790 | @Override 791 | public Set toJavaSet() { 792 | return delegate.toJavaSet(); 793 | } 794 | 795 | @Override 796 | public List distinctBy(Function keyExtractor) { 797 | return delegate.distinctBy(keyExtractor); 798 | } 799 | 800 | @Override 801 | public Option lastOption() { 802 | return delegate.lastOption(); 803 | } 804 | 805 | @Override 806 | public List drop(int n) { 807 | return delegate.drop(n); 808 | } 809 | 810 | @Override 811 | public > SET toJavaSet( 812 | Function factory) { 813 | return delegate.toJavaSet(factory); 814 | } 815 | 816 | @Override 817 | public List dropUntil(Predicate predicate) { 818 | return delegate.dropUntil(predicate); 819 | } 820 | 821 | @Override 822 | public Stream toJavaStream() { 823 | return delegate.toJavaStream(); 824 | } 825 | 826 | @Override 827 | public List dropWhile(Predicate predicate) { 828 | return delegate.dropWhile(predicate); 829 | } 830 | 831 | @Override 832 | public Stream toJavaParallelStream() { 833 | return delegate.toJavaParallelStream(); 834 | } 835 | 836 | @Override 837 | public List dropRight(int n) { 838 | return delegate.dropRight(n); 839 | } 840 | 841 | @Override 842 | public List dropRightUntil(Predicate predicate) { 843 | return delegate.dropRightUntil(predicate); 844 | } 845 | 846 | @Override 847 | public Option max() { 848 | return delegate.max(); 849 | } 850 | 851 | @Override 852 | public Either toLeft(R right) { 853 | return delegate.toLeft(right); 854 | } 855 | 856 | @Override 857 | public List dropRightWhile(Predicate predicate) { 858 | return delegate.dropRightWhile(predicate); 859 | } 860 | 861 | @Override 862 | public List filter(Predicate predicate) { 863 | return delegate.filter(predicate); 864 | } 865 | 866 | @Override 867 | public Either toLeft(Supplier right) { 868 | return delegate.toLeft(right); 869 | } 870 | 871 | @Override 872 | public Option maxBy(Comparator comparator) { 873 | return delegate.maxBy(comparator); 874 | } 875 | 876 | @Override 877 | public List toList() { 878 | return delegate.toList(); 879 | } 880 | 881 | @Override 882 | public List flatMap( 883 | Function> mapper) { 884 | return delegate.flatMap(mapper); 885 | } 886 | 887 | @Override 888 | public Map toMap( 889 | Function keyMapper, 890 | Function valueMapper) { 891 | return delegate.toMap(keyMapper, valueMapper); 892 | } 893 | 894 | @Override 895 | public > Option maxBy( 896 | Function f) { 897 | return delegate.maxBy(f); 898 | } 899 | 900 | @Override 901 | public T get(int index) { 902 | return delegate.get(index); 903 | } 904 | 905 | @Override 906 | public Map toMap( 907 | Function> f) { 908 | return delegate.toMap(f); 909 | } 910 | 911 | @Override 912 | public Map> groupBy( 913 | Function classifier) { 914 | return delegate.groupBy(classifier); 915 | } 916 | 917 | @Override 918 | public io.vavr.collection.Iterator> grouped(int size) { 919 | return delegate.grouped(size); 920 | } 921 | 922 | @Override 923 | public boolean hasDefiniteSize() { 924 | return delegate.hasDefiniteSize(); 925 | } 926 | 927 | @Override 928 | public int indexOf(T element, int from) { 929 | return delegate.indexOf(element, from); 930 | } 931 | 932 | @Override 933 | public Option min() { 934 | return delegate.min(); 935 | } 936 | 937 | @Override 938 | public List init() { 939 | return delegate.init(); 940 | } 941 | 942 | @Override 943 | public Map toLinkedMap( 944 | Function keyMapper, 945 | Function valueMapper) { 946 | return delegate.toLinkedMap(keyMapper, valueMapper); 947 | } 948 | 949 | @Override 950 | public Option> initOption() { 951 | return delegate.initOption(); 952 | } 953 | 954 | @Override 955 | public Option minBy(Comparator comparator) { 956 | return delegate.minBy(comparator); 957 | } 958 | 959 | @Override 960 | public int length() { 961 | return delegate.length(); 962 | } 963 | 964 | @Override 965 | public List insert(int index, T element) { 966 | return delegate.insert(index, element); 967 | } 968 | 969 | @Override 970 | public Map toLinkedMap( 971 | Function> f) { 972 | return delegate.toLinkedMap(f); 973 | } 974 | 975 | @Override 976 | public List insertAll(int index, Iterable elements) { 977 | return delegate.insertAll(index, elements); 978 | } 979 | 980 | @Override 981 | public > Option minBy( 982 | Function f) { 983 | return delegate.minBy(f); 984 | } 985 | 986 | @Override 987 | public , V> SortedMap toSortedMap( 988 | Function keyMapper, 989 | Function valueMapper) { 990 | return delegate.toSortedMap(keyMapper, valueMapper); 991 | } 992 | 993 | @Override 994 | public List intersperse(T element) { 995 | return delegate.intersperse(element); 996 | } 997 | 998 | @Override 999 | public CharSeq mkCharSeq() { 1000 | return delegate.mkCharSeq(); 1001 | } 1002 | 1003 | @Override 1004 | public boolean isTraversableAgain() { 1005 | return delegate.isTraversableAgain(); 1006 | } 1007 | 1008 | @Override 1009 | public boolean startsWith(Iterable that) { 1010 | return delegate.startsWith(that); 1011 | } 1012 | 1013 | @Override 1014 | public int lastIndexOf(T element, int end) { 1015 | return delegate.lastIndexOf(element, end); 1016 | } 1017 | 1018 | @Override 1019 | public , V> SortedMap toSortedMap( 1020 | Function> f) { 1021 | return delegate.toSortedMap(f); 1022 | } 1023 | 1024 | @Override 1025 | public CharSeq mkCharSeq(CharSequence delimiter) { 1026 | return delegate.mkCharSeq(delimiter); 1027 | } 1028 | 1029 | @Override 1030 | public List map(Function mapper) { 1031 | return delegate.map(mapper); 1032 | } 1033 | 1034 | @Override 1035 | public boolean startsWith(Iterable that, int offset) { 1036 | return delegate.startsWith(that, offset); 1037 | } 1038 | 1039 | @Override 1040 | public SortedMap toSortedMap( 1041 | Comparator comparator, 1042 | Function keyMapper, 1043 | Function valueMapper) { 1044 | return delegate.toSortedMap(comparator, keyMapper, valueMapper); 1045 | } 1046 | 1047 | @Override 1048 | public List orElse(Iterable other) { 1049 | return delegate.orElse(other); 1050 | } 1051 | 1052 | @Override 1053 | public List orElse( 1054 | Supplier> supplier) { 1055 | return delegate.orElse(supplier); 1056 | } 1057 | 1058 | @Override 1059 | public CharSeq mkCharSeq(CharSequence prefix, CharSequence delimiter, 1060 | CharSequence suffix) { 1061 | return delegate.mkCharSeq(prefix, delimiter, suffix); 1062 | } 1063 | 1064 | @Override 1065 | public List padTo(int length, T element) { 1066 | return delegate.padTo(length, element); 1067 | } 1068 | 1069 | @Override 1070 | public List leftPadTo(int length, T element) { 1071 | return delegate.leftPadTo(length, element); 1072 | } 1073 | 1074 | @Override 1075 | public String mkString() { 1076 | return delegate.mkString(); 1077 | } 1078 | 1079 | @Override 1080 | public SortedMap toSortedMap( 1081 | Comparator comparator, 1082 | Function> f) { 1083 | return delegate.toSortedMap(comparator, f); 1084 | } 1085 | 1086 | @Override 1087 | public List patch(int from, Iterable that, int replaced) { 1088 | return delegate.patch(from, that, replaced); 1089 | } 1090 | 1091 | @Override 1092 | public String mkString(CharSequence delimiter) { 1093 | return delegate.mkString(delimiter); 1094 | } 1095 | 1096 | @Override 1097 | public Tuple2, List> partition(Predicate predicate) { 1098 | return delegate.partition(predicate); 1099 | } 1100 | 1101 | @Override 1102 | public Option toOption() { 1103 | return delegate.toOption(); 1104 | } 1105 | 1106 | @Override 1107 | public String mkString(CharSequence prefix, CharSequence delimiter, CharSequence suffix) { 1108 | return delegate.mkString(prefix, delimiter, suffix); 1109 | } 1110 | 1111 | @Override 1112 | public T peek() { 1113 | return delegate.peek(); 1114 | } 1115 | 1116 | @Override 1117 | public Either toEither(L left) { 1118 | return delegate.toEither(left); 1119 | } 1120 | 1121 | @Override 1122 | public boolean nonEmpty() { 1123 | return delegate.nonEmpty(); 1124 | } 1125 | 1126 | @Override 1127 | public Option peekOption() { 1128 | return delegate.peekOption(); 1129 | } 1130 | 1131 | @Override 1132 | public Either toEither( 1133 | Supplier leftSupplier) { 1134 | return delegate.toEither(leftSupplier); 1135 | } 1136 | 1137 | @Override 1138 | public List peek(Consumer action) { 1139 | return delegate.peek(action); 1140 | } 1141 | 1142 | @Override 1143 | public List> permutations() { 1144 | return delegate.permutations(); 1145 | } 1146 | 1147 | @Override 1148 | public Validation toValidation(L invalid) { 1149 | return delegate.toValidation(invalid); 1150 | } 1151 | 1152 | @Override 1153 | public List pop() { 1154 | return delegate.pop(); 1155 | } 1156 | 1157 | @Override 1158 | public Validation toValidation( 1159 | Supplier invalidSupplier) { 1160 | return delegate.toValidation(invalidSupplier); 1161 | } 1162 | 1163 | @Override 1164 | public Option> popOption() { 1165 | return delegate.popOption(); 1166 | } 1167 | 1168 | @Override 1169 | public Queue toQueue() { 1170 | return delegate.toQueue(); 1171 | } 1172 | 1173 | @Override 1174 | public Tuple2> pop2() { 1175 | return delegate.pop2(); 1176 | } 1177 | 1178 | @Override 1179 | public PriorityQueue toPriorityQueue() { 1180 | return delegate.toPriorityQueue(); 1181 | } 1182 | 1183 | @Override 1184 | public Number product() { 1185 | return delegate.product(); 1186 | } 1187 | 1188 | @Override 1189 | public Option>> pop2Option() { 1190 | return delegate.pop2Option(); 1191 | } 1192 | 1193 | @Override 1194 | public List prepend(T element) { 1195 | return delegate.prepend(element); 1196 | } 1197 | 1198 | @Override 1199 | public List prependAll(Iterable elements) { 1200 | return delegate.prependAll(elements); 1201 | } 1202 | 1203 | @Override 1204 | public PriorityQueue toPriorityQueue( 1205 | Comparator comparator) { 1206 | return delegate.toPriorityQueue(comparator); 1207 | } 1208 | 1209 | @Override 1210 | public List push(T element) { 1211 | return delegate.push(element); 1212 | } 1213 | 1214 | @Override 1215 | public T reduceLeft(BiFunction op) { 1216 | return delegate.reduceLeft(op); 1217 | } 1218 | 1219 | @Override 1220 | public Either toRight(L left) { 1221 | return delegate.toRight(left); 1222 | } 1223 | 1224 | @Override 1225 | public List push(T[] elements) { 1226 | return delegate.push(elements); 1227 | } 1228 | 1229 | @Override 1230 | public Option reduceLeftOption( 1231 | BiFunction op) { 1232 | return delegate.reduceLeftOption(op); 1233 | } 1234 | 1235 | @Override 1236 | public Either toRight(Supplier left) { 1237 | return delegate.toRight(left); 1238 | } 1239 | 1240 | @Override 1241 | public List pushAll(Iterable elements) { 1242 | return delegate.pushAll(elements); 1243 | } 1244 | 1245 | @Override 1246 | public io.vavr.collection.Set toSet() { 1247 | return delegate.toSet(); 1248 | } 1249 | 1250 | @Override 1251 | public T reduceRight(BiFunction op) { 1252 | return delegate.reduceRight(op); 1253 | } 1254 | 1255 | @Override 1256 | public List remove(T element) { 1257 | return delegate.remove(element); 1258 | } 1259 | 1260 | @Override 1261 | public io.vavr.collection.Set toLinkedSet() { 1262 | return delegate.toLinkedSet(); 1263 | } 1264 | 1265 | @Override 1266 | public U foldRight(U zero, BiFunction f) { 1267 | return delegate.foldRight(zero, f); 1268 | } 1269 | 1270 | @Override 1271 | public Option reduceRightOption( 1272 | BiFunction op) { 1273 | return delegate.reduceRightOption(op); 1274 | } 1275 | 1276 | @Override 1277 | public SortedSet toSortedSet() throws ClassCastException { 1278 | return delegate.toSortedSet(); 1279 | } 1280 | 1281 | @Override 1282 | public List removeFirst(Predicate predicate) { 1283 | return delegate.removeFirst(predicate); 1284 | } 1285 | 1286 | @Override 1287 | public SortedSet toSortedSet(Comparator comparator) { 1288 | return delegate.toSortedSet(comparator); 1289 | } 1290 | 1291 | @Override 1292 | public List removeLast(Predicate predicate) { 1293 | return delegate.removeLast(predicate); 1294 | } 1295 | 1296 | @Override 1297 | public List removeAt(int index) { 1298 | return delegate.removeAt(index); 1299 | } 1300 | 1301 | @Override 1302 | public io.vavr.collection.Stream toStream() { 1303 | return delegate.toStream(); 1304 | } 1305 | 1306 | @Override 1307 | public Try toTry() { 1308 | return delegate.toTry(); 1309 | } 1310 | 1311 | @Override 1312 | public List removeAll(T element) { 1313 | return delegate.removeAll(element); 1314 | } 1315 | 1316 | @Override 1317 | public List removeAll(Iterable elements) { 1318 | return delegate.removeAll(elements); 1319 | } 1320 | 1321 | @Override 1322 | public List removeAll(Predicate predicate) { 1323 | return delegate.removeAll(predicate); 1324 | } 1325 | 1326 | @Override 1327 | public Try toTry( 1328 | Supplier ifEmpty) { 1329 | return delegate.toTry(ifEmpty); 1330 | } 1331 | 1332 | @Override 1333 | public List replace(T currentElement, T newElement) { 1334 | return delegate.replace(currentElement, newElement); 1335 | } 1336 | 1337 | @Override 1338 | public Tree toTree() { 1339 | return delegate.toTree(); 1340 | } 1341 | 1342 | @Override 1343 | public List replaceAll(T currentElement, T newElement) { 1344 | return delegate.replaceAll(currentElement, newElement); 1345 | } 1346 | 1347 | @Override 1348 | public Validation toValid(E error) { 1349 | return delegate.toValid(error); 1350 | } 1351 | 1352 | @Override 1353 | public Function1 withDefaultValue(T defaultValue) { 1354 | return delegate.withDefaultValue(defaultValue); 1355 | } 1356 | 1357 | @Override 1358 | public List retainAll(Iterable elements) { 1359 | return delegate.retainAll(elements); 1360 | } 1361 | 1362 | @Override 1363 | public Validation toValid( 1364 | Supplier errorSupplier) { 1365 | return delegate.toValid(errorSupplier); 1366 | } 1367 | 1368 | @Override 1369 | public List reverse() { 1370 | return delegate.reverse(); 1371 | } 1372 | 1373 | @Override 1374 | public Function1 withDefault( 1375 | Function defaultFunction) { 1376 | return delegate.withDefault(defaultFunction); 1377 | } 1378 | 1379 | @Override 1380 | public List scan(T zero, 1381 | BiFunction operation) { 1382 | return delegate.scan(zero, operation); 1383 | } 1384 | 1385 | @Override 1386 | public Vector toVector() { 1387 | return delegate.toVector(); 1388 | } 1389 | 1390 | @Override 1391 | public List scanLeft(U zero, 1392 | BiFunction operation) { 1393 | return delegate.scanLeft(zero, operation); 1394 | } 1395 | 1396 | @Override 1397 | public boolean isSequential() { 1398 | return delegate.isSequential(); 1399 | } 1400 | 1401 | @Override 1402 | public T single() { 1403 | return delegate.single(); 1404 | } 1405 | 1406 | @Override 1407 | public List scanRight(U zero, 1408 | BiFunction operation) { 1409 | return delegate.scanRight(zero, operation); 1410 | } 1411 | 1412 | @Override 1413 | public List shuffle() { 1414 | return delegate.shuffle(); 1415 | } 1416 | 1417 | @Override 1418 | public List slice(int beginIndex, int endIndex) { 1419 | return delegate.slice(beginIndex, endIndex); 1420 | } 1421 | 1422 | @Override 1423 | public Option singleOption() { 1424 | return delegate.singleOption(); 1425 | } 1426 | 1427 | @Override 1428 | public int size() { 1429 | return delegate.size(); 1430 | } 1431 | 1432 | @Override 1433 | public io.vavr.collection.Iterator> slideBy( 1434 | Function classifier) { 1435 | return delegate.slideBy(classifier); 1436 | } 1437 | 1438 | @Override 1439 | public io.vavr.collection.Iterator> sliding(int size) { 1440 | return delegate.sliding(size); 1441 | } 1442 | 1443 | @Override 1444 | public String toString() { 1445 | return delegate.toString(); 1446 | } 1447 | 1448 | @Override 1449 | public io.vavr.collection.Iterator> sliding(int size, int step) { 1450 | return delegate.sliding(size, step); 1451 | } 1452 | 1453 | @Override 1454 | public List sorted() { 1455 | return delegate.sorted(); 1456 | } 1457 | 1458 | @Override 1459 | public List sorted(Comparator comparator) { 1460 | return delegate.sorted(comparator); 1461 | } 1462 | 1463 | @Override 1464 | public > List sortBy( 1465 | Function mapper) { 1466 | return delegate.sortBy(mapper); 1467 | } 1468 | 1469 | @Override 1470 | public List sortBy(Comparator comparator, 1471 | Function mapper) { 1472 | return delegate.sortBy(comparator, mapper); 1473 | } 1474 | 1475 | @Override 1476 | public Tuple2, List> span(Predicate predicate) { 1477 | return delegate.span(predicate); 1478 | } 1479 | 1480 | @Override 1481 | public Tuple2, List> splitAt(int n) { 1482 | return delegate.splitAt(n); 1483 | } 1484 | 1485 | @Override 1486 | public Tuple2, List> splitAt(Predicate predicate) { 1487 | return delegate.splitAt(predicate); 1488 | } 1489 | 1490 | @Override 1491 | public Tuple2, List> splitAtInclusive( 1492 | Predicate predicate) { 1493 | return delegate.splitAtInclusive(predicate); 1494 | } 1495 | 1496 | @Override 1497 | public Spliterator spliterator() { 1498 | return delegate.spliterator(); 1499 | } 1500 | 1501 | @Override 1502 | public String stringPrefix() { 1503 | return delegate.stringPrefix(); 1504 | } 1505 | 1506 | @Override 1507 | public List subSequence(int beginIndex) { 1508 | return delegate.subSequence(beginIndex); 1509 | } 1510 | 1511 | @Override 1512 | public List subSequence(int beginIndex, int endIndex) { 1513 | return delegate.subSequence(beginIndex, endIndex); 1514 | } 1515 | 1516 | @Override 1517 | public Number sum() { 1518 | return delegate.sum(); 1519 | } 1520 | 1521 | @Override 1522 | public List tail() { 1523 | return delegate.tail(); 1524 | } 1525 | 1526 | @Override 1527 | public Option> tailOption() { 1528 | return delegate.tailOption(); 1529 | } 1530 | 1531 | @Override 1532 | public List take(int n) { 1533 | return delegate.take(n); 1534 | } 1535 | 1536 | @Override 1537 | public List takeRight(int n) { 1538 | return delegate.takeRight(n); 1539 | } 1540 | 1541 | @Override 1542 | public List takeUntil(Predicate predicate) { 1543 | return delegate.takeUntil(predicate); 1544 | } 1545 | 1546 | @Override 1547 | public List takeWhile(Predicate predicate) { 1548 | return delegate.takeWhile(predicate); 1549 | } 1550 | 1551 | @Override 1552 | public U transform( 1553 | Function, ? extends U> f) { 1554 | return delegate.transform(f); 1555 | } 1556 | 1557 | @Override 1558 | public Tuple2, List> unzip( 1559 | Function> unzipper) { 1560 | return delegate.unzip(unzipper); 1561 | } 1562 | 1563 | @Override 1564 | public Tuple3, List, List> unzip3( 1565 | Function> unzipper) { 1566 | return delegate.unzip3(unzipper); 1567 | } 1568 | 1569 | @Override 1570 | public List update(int index, T element) { 1571 | return delegate.update(index, element); 1572 | } 1573 | 1574 | @Override 1575 | public List update(int index, Function updater) { 1576 | return delegate.update(index, updater); 1577 | } 1578 | 1579 | @Override 1580 | public List> zip(Iterable that) { 1581 | return delegate.zip(that); 1582 | } 1583 | 1584 | @Override 1585 | public List zipWith(Iterable that, 1586 | BiFunction mapper) { 1587 | return delegate.zipWith(that, mapper); 1588 | } 1589 | 1590 | @Override 1591 | public List> zipAll(Iterable that, T thisElem, U thatElem) { 1592 | return delegate.zipAll(that, thisElem, thatElem); 1593 | } 1594 | 1595 | @Override 1596 | public List> zipWithIndex() { 1597 | return delegate.zipWithIndex(); 1598 | } 1599 | 1600 | @Override 1601 | public List zipWithIndex( 1602 | BiFunction mapper) { 1603 | return delegate.zipWithIndex(mapper); 1604 | } 1605 | } 1606 | -------------------------------------------------------------------------------- /src/test/java/io/vavr/hibernate/ListUserTypeTest.java: -------------------------------------------------------------------------------- 1 | package io.vavr.hibernate; 2 | 3 | import static org.assertj.core.api.Assertions.assertThat; 4 | 5 | import io.vavr.collection.List; 6 | import javax.persistence.Entity; 7 | import javax.persistence.GeneratedValue; 8 | import javax.persistence.Id; 9 | import javax.persistence.ManyToMany; 10 | import lombok.Getter; 11 | import lombok.NoArgsConstructor; 12 | import org.hibernate.annotations.CollectionType; 13 | import org.hibernate.annotations.Type; 14 | import org.junit.Test; 15 | import org.junit.runner.RunWith; 16 | import org.springframework.beans.factory.annotation.Autowired; 17 | import org.springframework.boot.autoconfigure.SpringBootApplication; 18 | import org.springframework.data.repository.CrudRepository; 19 | import org.springframework.test.context.junit4.SpringRunner; 20 | 21 | 22 | @RunWith(SpringRunner.class) 23 | public class ListUserTypeTest { 24 | 25 | @Autowired 26 | private PersonRepository people; 27 | 28 | @SpringBootApplication 29 | static class Configuration { 30 | 31 | } 32 | 33 | 34 | @Test 35 | public void readsPersonIntoJavaslangOptionById() { 36 | 37 | Person adrian = new Person("Adrian", "Bongiorno"); 38 | Person maya = new Person("Maya", "Bongiorno"); 39 | Person viola = new Person("Viola", "Bongiorno", List.of(adrian, maya)); 40 | Person me = new Person("Christian", "Bongiorno", List.of(adrian, maya)); 41 | 42 | Iterable people = this.people.save(List.of(adrian, maya, viola, me)); 43 | 44 | Person result = this.people.findOne(me.getId()); 45 | 46 | assertThat(result).isNotNull(); 47 | assertThat(result).isEqualTo(me); 48 | assertThat(result.getChildren()).containsExactly(adrian, maya); 49 | } 50 | 51 | @Getter 52 | @Entity 53 | @NoArgsConstructor 54 | public class Person { 55 | 56 | private @GeneratedValue 57 | @Id 58 | Long id; 59 | private String firstname; 60 | 61 | private String lastname; 62 | 63 | @ManyToMany 64 | @CollectionType(type = "io.vavr.hibernate.userstype.ListUserType") 65 | private List children; 66 | 67 | public Person(String firstname, String lastname, List children) { 68 | this.firstname = firstname; 69 | this.lastname = lastname; 70 | this.children = children; 71 | } 72 | 73 | public Person(String firstname, String lastname) { 74 | this(firstname, lastname, List.empty()); 75 | } 76 | } 77 | 78 | public interface PersonRepository extends CrudRepository { 79 | 80 | } 81 | } 82 | --------------------------------------------------------------------------------