/*
* Copyright (C) 2011 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.i18n.phonenumbers.geocoding;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.nio.ByteBuffer;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Map.Entry;
import java.util.SortedMap;
import java.util.SortedSet;
import java.util.TreeSet;
/**
* Flyweight area code map storage strategy that uses a table to store unique strings and shorts to
* store the prefix and description indexes when possible. It is particularly space-efficient when
* the provided area code map contains a lot of redundant descriptions.
*
* @author Philippe Liard
*/
class FlyweightMapStorage extends AreaCodeMapStorageStrategy {
// Size of short and integer types in bytes.
private static final int SHORT_SIZE = Short.SIZE / 8;
private static final int INT_SIZE = Integer.SIZE / 8;
// The number of bytes used to store a phone number prefix.
private int prefixSizeInBytes;
// The number of bytes used to store a description index. It is computed from the size of the
// description pool containing all the strings.
private int descIndexSizeInBytes;
private ByteBuffer phoneNumberPrefixes;
private ByteBuffer descriptionIndexes;
// Sorted string array of unique description strings.
private String[] descriptionPool;
public FlyweightMapStorage() {}
@Override
public boolean isFlyweight() {
return true;
}
/**
* Gets the minimum number of bytes that can be used to store the provided {@code value}.
*/
private static int getOptimalNumberOfBytesForValue(int value) {
return value <= Short.MAX_VALUE ? SHORT_SIZE : INT_SIZE;
}
/**
* Stores the provided {@code value} to the provided byte {@code buffer} at the specified {@code
* index} using the provided {@code wordSize} in bytes. Note that only integer and short sizes are
* supported.
*
* @param buffer the byte buffer to which the value is stored
* @param wordSize the number of bytes used to store the provided value
* @param index the index to which the value is stored
* @param value the value that is stored assuming it does not require more than the specified
* number of bytes.
*/
private static void storeWordInBuffer(ByteBuffer buffer, int wordSize, int index, int value) {
index *= wordSize;
if (wordSize == SHORT_SIZE) {
buffer.putShort(index, (short) value);
} else {
buffer.putInt(index, value);
}
}
/**
* Reads the {@code value} at the specified {@code index} from the provided byte {@code buffer}.
* Note that only integer and short sizes are supported.
*
* @param buffer the byte buffer from which the value is read
* @param wordSize the number of bytes used to store the value
* @param index the index where the value is read from
*
* @return the value read from the buffer
*/
private static int readWordFromBuffer(ByteBuffer buffer, int wordSize, int index) {
index *= wordSize;
return wordSize == SHORT_SIZE ? buffer.getShort(index) : buffer.getInt(index);
}
@Override
public int getPrefix(int index) {
return readWordFromBuffer(phoneNumberPrefixes, prefixSizeInBytes, index);
}
@Override
public String getDescription(int index) {
return descriptionPool[readWordFromBuffer(descriptionIndexes, descIndexSizeInBytes, index)];
}
@Override
public void readFromSortedMap(SortedMap<Integer, String> sortedAreaCodeMap) {
SortedSet<String> descriptionsSet = new TreeSet<String>();
numOfEntries = sortedAreaCodeMap.size();
prefixSizeInBytes = getOptimalNumberOfBytesForValue(sortedAreaCodeMap.lastKey());
phoneNumberPrefixes = ByteBuffer.allocate(numOfEntries * prefixSizeInBytes);
// Fill the phone number prefixes byte buffer, the set of possible lengths of prefixes and the
// description set.
int index = 0;
for (Entry<Integer, String> entry : sortedAreaCodeMap.entrySet()) {
int prefix = entry.getKey();
storeWordInBuffer(phoneNumberPrefixes, prefixSizeInBytes, index++, prefix);
possibleLengths.add((int) Math.log10(prefix) + 1);
descriptionsSet.add(entry.getValue());
}
// Create the description pool.
descIndexSizeInBytes = getOptimalNumberOfBytesForValue(descriptionsSet.size() - 1);
descriptionIndexes = ByteBuffer.allocate(numOfEntries * descIndexSizeInBytes);
descriptionPool = new String[descriptionsSet.size()];
descriptionsSet.toArray(descriptionPool);
// Map the phone number prefixes to the descriptions.
index = 0;
for (int i = 0; i < numOfEntries; i++) {
int prefix = readWordFromBuffer(phoneNumberPrefixes, prefixSizeInBytes, i);
String description = sortedAreaCodeMap.get(prefix);
int positionInDescriptionPool =
Arrays.binarySearch(descriptionPool, description, new Comparator<String>() {
public int compare(String o1, String o2) { return o1.compareTo(o2); }
});
storeWordInBuffer(descriptionIndexes, descIndexSizeInBytes, index++,
positionInDescriptionPool);
}
}
/**
* Stores a value which is read from the provided {@code objectInput} to the provided byte {@code
* buffer} at the specified {@code index}.
*
* @param objectInput the object input stream from which the value is read
* @param wordSize the number of bytes used to store the value read from the stream
* @param outputBuffer the byte buffer to which the value is stored
* @param index the index where the value is stored in the buffer
* @throws IOException if an error occurred reading from the object input stream
*/
private static void readExternalWord(ObjectInput objectInput, int wordSize,
ByteBuffer outputBuffer, int index) throws IOException {
index *= wordSize;
if (wordSize == SHORT_SIZE) {
outputBuffer.putShort(index, objectInput.readShort());
} else {
outputBuffer.putInt(index, objectInput.readInt());
}
}
@Override
public void readExternal(ObjectInput objectInput) throws IOException {
// Read binary words sizes.
prefixSizeInBytes = objectInput.readInt();
descIndexSizeInBytes = objectInput.readInt();
// Read possible lengths.
int sizeOfLengths = objectInput.readInt();
possibleLengths.clear();
for (int i = 0; i < sizeOfLengths; i++) {
possibleLengths.add(objectInput.readInt());
}
// Read description pool size.
int descriptionPoolSize = objectInput.readInt();
// Read description pool.
if (descriptionPool == null || descriptionPool.length < descriptionPoolSize) {
descriptionPool = new String[descriptionPoolSize];
}
for (int i = 0; i < descriptionPoolSize; i++) {
String description = objectInput.readUTF();
descriptionPool[i] = description;
}
// Read entries.
numOfEntries = objectInput.readInt();
if (phoneNumberPrefixes == null || phoneNumberPrefixes.capacity() < numOfEntries) {
phoneNumberPrefixes = ByteBuffer.allocate(numOfEntries * prefixSizeInBytes);
}
if (descriptionIndexes == null || descriptionIndexes.capacity() < numOfEntries) {
descriptionIndexes = ByteBuffer.allocate(numOfEntries * descIndexSizeInBytes);
}
for (int i = 0; i < numOfEntries; i++) {
readExternalWord(objectInput, prefixSizeInBytes, phoneNumberPrefixes, i);
readExternalWord(objectInput, descIndexSizeInBytes, descriptionIndexes, i);
}
}
/**
* Writes the value read from the provided byte {@code buffer} at the specified {@code index} to
* the provided {@code objectOutput}.
*
* @param objectOutput the object output stream to which the value is written
* @param wordSize the number of bytes used to store the value
* @param inputBuffer the byte buffer from which the value is read
* @param index the index of the value in the the byte buffer
* @throws IOException if an error occurred writing to the provided object output stream
*/
private static void writeExternalWord(ObjectOutput objectOutput, int wordSize,
ByteBuffer inputBuffer, int index) throws IOException {
index *= wordSize;
if (wordSize == SHORT_SIZE) {
objectOutput.writeShort(inputBuffer.getShort(index));
} else {
objectOutput.writeInt(inputBuffer.getInt(index));
}
}
@Override
public void writeExternal(ObjectOutput objectOutput) throws IOException {
// Write binary words sizes.
objectOutput.writeInt(prefixSizeInBytes);
objectOutput.writeInt(descIndexSizeInBytes);
// Write possible lengths.
int sizeOfLengths = possibleLengths.size();
objectOutput.writeInt(sizeOfLengths);
for (Integer length : possibleLengths) {
objectOutput.writeInt(length);
}
// Write description pool size.
objectOutput.writeInt(descriptionPool.length);
// Write description pool.
for (String description : descriptionPool) {
objectOutput.writeUTF(description);
}
// Write entries.
objectOutput.writeInt(numOfEntries);
for (int i = 0; i < numOfEntries; i++) {
writeExternalWord(objectOutput, prefixSizeInBytes, phoneNumberPrefixes, i);
writeExternalWord(objectOutput, descIndexSizeInBytes, descriptionIndexes, i);
}
}
}