001package com.nimbusds.infinispan.persistence.common;
002
003
004import java.util.Date;
005import java.util.concurrent.TimeUnit;
006
007import org.infinispan.container.versioning.EntryVersion;
008import org.infinispan.metadata.InternalMetadata;
009import org.infinispan.metadata.Metadata;
010
011
012/**
013 * Infinispan metadata builder. Can be used to reconstruct Infinispan metadata
014 * for an entry.
015 */
016public class InternalMetadataBuilder implements InternalMetadata.Builder {
017
018
019        /**
020         * The entry creation time, as a Unix timestamp in milliseconds, -1 if
021         * not specified.
022         */
023        private long created = -1L;
024
025
026        /**
027         * The entry last use time, as a Unix timestamp in milliseconds, -1 if
028         * not specified.
029         */
030        private long lastUsed = -1L;
031
032
033        /**
034         * The entry lifespan, in milliseconds. -1 implies permanent.
035         */
036        private long lifespan = -1L;
037
038
039        /**
040         * The entry max idle time, in milliseconds. -1 implies none.
041         */
042        private long maxIdle = -1L;
043
044
045        /**
046         * The entry version, {@code null} if not specified.
047         */
048        private EntryVersion entryVersion;
049
050
051        /**
052         * Sets the entry creation timestamp.
053         *
054         * @param date The entry creation time, {@code null} if not specified.
055         *
056         * @return This builder.
057         */
058        public InternalMetadataBuilder created(final Date date) {
059                return created(date != null ? date.getTime() : -1L);
060        }
061
062
063        /**
064         * Sets the entry creation timestamp.
065         *
066         * @param l The entry creation Unix timestamp, in milliseconds, -1 if
067         *          not specified.
068         *
069         * @return This builder.
070         */
071        public InternalMetadataBuilder created(final long l) {
072                created = l;
073                return this;
074        }
075
076
077        /**
078         * Sets the entry last use timestamp.
079         *
080         * @param date The entry last use time, {@code null} if not specified.
081         *
082         * @return This builder.
083         */
084        public InternalMetadataBuilder lastUsed(final Date date) {
085                return lastUsed(date != null ? date.getTime() : -1L);
086        }
087
088
089        /**
090         * Sets the entry last use timestamp.
091         *
092         * @param l The entry last use Unix timestamp, in milliseconds, -1 if
093         *          not specified.
094         *
095         * @return This builder.
096         */
097        public InternalMetadataBuilder lastUsed(final long l) {
098                lastUsed = l;
099                return this;
100        }
101
102
103        @Override
104        public InternalMetadataBuilder lifespan(final long l, TimeUnit timeUnit) {
105                if (l < 0) {
106                        lifespan = -1L;
107                } else {
108                        lifespan = timeUnit.toMillis(l);
109                }
110
111                return this;
112        }
113
114
115        @Override
116        public InternalMetadataBuilder lifespan(final long l) {
117                lifespan = l;
118                return this;
119        }
120
121
122        @Override
123        public InternalMetadataBuilder maxIdle(final long l, TimeUnit timeUnit) {
124                if (l < 0) {
125                        maxIdle = -1L;
126                } else {
127                        maxIdle = timeUnit.toMillis(l);
128                }
129
130                return this;
131        }
132
133
134        @Override
135        public InternalMetadataBuilder maxIdle(final long l) {
136                maxIdle = l;
137                return this;
138        }
139
140
141        @Override
142        public InternalMetadataBuilder version(final EntryVersion entryVersion) {
143                this.entryVersion = entryVersion;
144                return this;
145        }
146
147
148        @Override
149        public InternalMetadata build() {
150
151                final InternalMetadataBuilder builder = this;
152
153                return new InternalMetadata() {
154                        @Override
155                        public long created() {
156                                return created;
157                        }
158
159
160                        @Override
161                        public long lastUsed() {
162                                return lastUsed;
163                        }
164
165
166                        @Override
167                        public boolean isExpired(long now) {
168                                // Copied from private class org.infinispan.metadata.impl.InternalMetadataImpl
169                                long expiry = expiryTime();
170                                return expiry > 0 && expiry <= now;
171                        }
172
173
174                        @Override
175                        public long expiryTime() {
176                                // Copied from private class org.infinispan.metadata.impl.InternalMetadataImpl
177                                long lset = lifespan > -1 ? created + lifespan : -1;
178                                long muet = maxIdle > -1 ? lastUsed + maxIdle : -1;
179                                if (lset == -1) return muet;
180                                if (muet == -1) return lset;
181                                return Math.min(lset, muet);
182                        }
183
184
185                        @Override
186                        public long lifespan() {
187                                return lifespan;
188                        }
189
190
191                        @Override
192                        public long maxIdle() {
193                                return maxIdle;
194                        }
195
196
197                        @Override
198                        public EntryVersion version() {
199                                return entryVersion;
200                        }
201
202
203                        @Override
204                        public Builder builder() {
205                                return builder;
206                        }
207                };
208        }
209
210
211        @Override
212        public Metadata.Builder merge(final Metadata metadata) {
213
214                // Copied from org.infinispan.metadata.EmbeddedMetadata
215
216                if (lifespan == -1L) { // if lifespan not set, apply default
217                        lifespan = metadata.lifespan();
218                }
219
220                if (maxIdle == -1L) { // if maxIdle not set, apply default
221                        maxIdle = metadata.maxIdle();
222                }
223
224                if (entryVersion == null)
225                        entryVersion = metadata.version();
226
227                return this;
228        }
229}