1 /* 2 * Copyright 2009 The Apache Software Foundation 3 * 4 * Licensed to the Apache Software Foundation (ASF) under one 5 * or more contributor license agreements. See the NOTICE file 6 * distributed with this work for additional information 7 * regarding copyright ownership. The ASF licenses this file 8 * to you under the Apache License, Version 2.0 (the 9 * "License"); you may not use this file except in compliance 10 * with the License. You may obtain a copy of the License at 11 * 12 * http://www.apache.org/licenses/LICENSE-2.0 13 * 14 * Unless required by applicable law or agreed to in writing, software 15 * distributed under the License is distributed on an "AS IS" BASIS, 16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 17 * See the License for the specific language governing permissions and 18 * limitations under the License. 19 */ 20 21 package org.apache.hadoop.hbase.io; 22 23 import java.io.DataInput; 24 import java.io.DataOutput; 25 import java.io.IOException; 26 27 import org.apache.hadoop.io.Writable; 28 29 import org.apache.hadoop.hbase.util.Bytes; 30 31 /** 32 * Represents an interval of version timestamps. 33 * <p> 34 * Evaluated according to minStamp <= timestamp < maxStamp 35 * or [minStamp,maxStamp) in interval notation. 36 * <p> 37 * Only used internally; should not be accessed directly by clients. 38 */ 39 public class TimeRange implements Writable { 40 private long minStamp = 0L; 41 private long maxStamp = Long.MAX_VALUE; 42 private boolean allTime = false; 43 44 /** 45 * Default constructor. 46 * Represents interval [0, Long.MAX_VALUE) (allTime) 47 */ 48 public TimeRange() { 49 allTime = true; 50 } 51 52 /** 53 * Represents interval [minStamp, Long.MAX_VALUE) 54 * @param minStamp the minimum timestamp value, inclusive 55 */ 56 public TimeRange(long minStamp) { 57 this.minStamp = minStamp; 58 } 59 60 /** 61 * Represents interval [minStamp, Long.MAX_VALUE) 62 * @param minStamp the minimum timestamp value, inclusive 63 */ 64 public TimeRange(byte [] minStamp) { 65 this.minStamp = Bytes.toLong(minStamp); 66 } 67 68 /** 69 * Represents interval [minStamp, maxStamp) 70 * @param minStamp the minimum timestamp, inclusive 71 * @param maxStamp the maximum timestamp, exclusive 72 * @throws IOException 73 */ 74 public TimeRange(long minStamp, long maxStamp) 75 throws IOException { 76 if(maxStamp < minStamp) { 77 throw new IOException("maxStamp is smaller than minStamp"); 78 } 79 this.minStamp = minStamp; 80 this.maxStamp = maxStamp; 81 } 82 83 /** 84 * Represents interval [minStamp, maxStamp) 85 * @param minStamp the minimum timestamp, inclusive 86 * @param maxStamp the maximum timestamp, exclusive 87 * @throws IOException 88 */ 89 public TimeRange(byte [] minStamp, byte [] maxStamp) 90 throws IOException { 91 this(Bytes.toLong(minStamp), Bytes.toLong(maxStamp)); 92 } 93 94 /** 95 * @return the smallest timestamp that should be considered 96 */ 97 public long getMin() { 98 return minStamp; 99 } 100 101 /** 102 * @return the biggest timestamp that should be considered 103 */ 104 public long getMax() { 105 return maxStamp; 106 } 107 108 /** 109 * Check if the specified timestamp is within this TimeRange. 110 * <p> 111 * Returns true if within interval [minStamp, maxStamp), false 112 * if not. 113 * @param bytes timestamp to check 114 * @param offset offset into the bytes 115 * @return true if within TimeRange, false if not 116 */ 117 public boolean withinTimeRange(byte [] bytes, int offset) { 118 if(allTime) return true; 119 return withinTimeRange(Bytes.toLong(bytes, offset)); 120 } 121 122 /** 123 * Check if the specified timestamp is within this TimeRange. 124 * <p> 125 * Returns true if within interval [minStamp, maxStamp), false 126 * if not. 127 * @param timestamp timestamp to check 128 * @return true if within TimeRange, false if not 129 */ 130 public boolean withinTimeRange(long timestamp) { 131 if(allTime) return true; 132 // check if >= minStamp 133 return (minStamp <= timestamp && timestamp < maxStamp); 134 } 135 136 /** 137 * Check if the specified timestamp is within this TimeRange. 138 * <p> 139 * Returns true if within interval [minStamp, maxStamp), false 140 * if not. 141 * @param timestamp timestamp to check 142 * @return true if within TimeRange, false if not 143 */ 144 public boolean withinOrAfterTimeRange(long timestamp) { 145 if(allTime) return true; 146 // check if >= minStamp 147 return (timestamp >= minStamp); 148 } 149 150 /** 151 * Compare the timestamp to timerange 152 * @param timestamp 153 * @return -1 if timestamp is less than timerange, 154 * 0 if timestamp is within timerange, 155 * 1 if timestamp is greater than timerange 156 */ 157 public int compare(long timestamp) { 158 if (timestamp < minStamp) { 159 return -1; 160 } else if (timestamp >= maxStamp) { 161 return 1; 162 } else { 163 return 0; 164 } 165 } 166 167 @Override 168 public String toString() { 169 StringBuilder sb = new StringBuilder(); 170 sb.append("maxStamp="); 171 sb.append(this.maxStamp); 172 sb.append(", minStamp="); 173 sb.append(this.minStamp); 174 return sb.toString(); 175 } 176 177 //Writable 178 public void readFields(final DataInput in) throws IOException { 179 this.minStamp = in.readLong(); 180 this.maxStamp = in.readLong(); 181 this.allTime = in.readBoolean(); 182 } 183 184 public void write(final DataOutput out) throws IOException { 185 out.writeLong(minStamp); 186 out.writeLong(maxStamp); 187 out.writeBoolean(this.allTime); 188 } 189 }