> enc = new ArrayDeque<>(data.getEncoding());
this.byteCount = packing.bytesPerElement;
this.isUnsigned = !packing.signed;
this.srcSize = data.length();
enc.add(this);
output.setEncoding(enc);
return output;
}
static class Packing {
final boolean signed;
final long size;
final int bytesPerElement;
Packing(boolean signed, long size, int bytesPerElement) {
this.signed = signed;
this.size = size;
this.bytesPerElement = bytesPerElement;
}
}
private Packing determinePacking(int[] input) {
boolean signed = IntStream.of(input).anyMatch(i -> i < 0);
long size8 = packingSize(input, signed ? 0x7F : 0xFF);
long size16 = packingSize(input, signed ? 0x7FFF : 0xFFFF);
if (input.length * 4L < size16 * 2) {
// 4 byte packing is the most effective
return new Packing(signed, input.length, 4);
} else if (size16 * 2 < size8) {
// 2 byte packing is the most effective
return new Packing(signed, size16, 2);
} else {
return new Packing(signed, size8, 1);
}
}
private long packingSize(int[] input, int upperLimit) {
int lowerLimit = -upperLimit - 1;
long size = 0;
for (int value : input) {
if (value == 0) {
size += 1;
} else if (value > 0) {
size += Math.ceil(value / (double) upperLimit);
if (value % upperLimit == 0) {
size += 1;
}
} else {
size += Math.ceil(value / (double) lowerLimit);
if (value % lowerLimit == 0) {
size += 1;
}
}
}
// hard check for negative array sizes overflow
if (size < 0) {
return Long.MAX_VALUE;
}
return size;
}
@Override
public String toString() {
return "IntegerPackingEncoding{" +
"byteCount=" + byteCount +
", isUnsigned=" + isUnsigned +
", srcSize=" + srcSize +
'}';
}
}
IntervalQuantizationEncoding.java 0000664 0000000 0000000 00000007004 14766323153 0035447 0 ustar 00root root 0000000 0000000 ciftools-java-ciftools-java-7.0.1/src/main/java/org/rcsb/cif/binary/encoding package org.rcsb.cif.binary.encoding;
import org.rcsb.cif.binary.data.Float32Array;
import org.rcsb.cif.binary.data.Float64Array;
import org.rcsb.cif.binary.data.FloatArray;
import org.rcsb.cif.binary.data.Int32Array;
import java.util.ArrayDeque;
import java.util.Deque;
import java.util.LinkedHashMap;
import java.util.Map;
/**
* Converts an array of floating point numbers to a {@link Int32Array} where the values are quantized within a
* given interval into specified number of discrete steps. Values lower than the minimum value or greater than the
* maximum are represented by the respective boundary values.
*
*
* FixedPoint {
* kind = "IntervalQuantization"
* min: number,
* max: number,
* numSteps: number,
* srcType: Float32 | Float64
* }
* Example
* [0.5, 1, 1.5, 2, 3, 1.345 ]
* ---IntervalQuantization--->
* { min = 1, max = 2, numSteps = 3 } [0, 0, 1, 2, 2, 1]
*
*/
public class IntervalQuantizationEncoding implements Encoding {
private int min;
private int max;
private int numSteps;
private int srcType;
public IntervalQuantizationEncoding() {
// need to constructor for future support
}
public IntervalQuantizationEncoding(int min, int max, int numSteps, int srcType) {
this.min = min;
this.max = max;
this.numSteps = numSteps;
this.srcType = srcType;
}
@Override
public Map getMapRepresentation() {
Map map = new LinkedHashMap<>();
map.put("kind", "IntervalQuantization");
map.put("min", min);
map.put("max", max);
map.put("numSteps", numSteps);
map.put("srcType", srcType);
return map;
}
@Override
public FloatArray decode(Int32Array data) {
double delta = (max - min) / (numSteps - 1.0);
int[] intData = data.getData();
double[] output = new double[intData.length];
for (int i = 0; i < intData.length; i++) {
output[i] = min + delta * intData[i];
}
return srcType == 32 ? new Float32Array(output, data.getEncoding()) :
new Float64Array(output, data.getEncoding());
}
@Override
public Int32Array encode(FloatArray data) {
double[] input = data.getData();
this.srcType = data.getType();
if (input.length == 0) {
Deque> enc = new ArrayDeque<>(data.getEncoding());
this.srcType = 3;
enc.add(this);
return new Int32Array(new int[0], enc);
}
if (max < min) {
int t = min;
min = max;
max = t;
}
double delta = (max - min) / (numSteps - 1.0);
int[] output = new int[input.length];
for (int i = 0; i < input.length; i++) {
double v = input[i];
if (v <= min) {
output[i] = 0;
} else if (v >= max) {
output[i] = numSteps - 1;
} else {
output[i] = delta == 0 ? 0 : (int) Math.round((v - min) / delta);
}
}
Deque> enc = new ArrayDeque<>(data.getEncoding());
enc.add(this);
return new Int32Array(output, enc);
}
@Override
public String toString() {
return "IntervalQuantizationEncoding{" +
"min=" + min +
", max=" + max +
", numSteps=" + numSteps +
", srcType=" + srcType +
'}';
}
} ciftools-java-ciftools-java-7.0.1/src/main/java/org/rcsb/cif/binary/encoding/RunLengthEncoding.java 0000664 0000000 0000000 00000006516 14766323153 0033250 0 ustar 00root root 0000000 0000000 package org.rcsb.cif.binary.encoding;
import org.rcsb.cif.binary.data.Int32Array;
import org.rcsb.cif.binary.data.IntArray;
import java.util.ArrayDeque;
import java.util.Deque;
import java.util.LinkedHashMap;
import java.util.Map;
/**
* Represents each integer value in the input as a pair of (value, number of repeats) and stores the result
* sequentially as {@link Int32Array}. Additionally, stores the size of the original array to make decoding
* easier.
*
*
* RunLength {
* kind = "RunLength"
* srcType: int[]
* srcSize: number
* }
* Example
* [1, 1, 1, 2, 3, 3]
* ---RunLength--->
* { srcSize = 6 } [1, 3, 2, 1, 3, 2]
*
*/
public class RunLengthEncoding implements Encoding {
private int srcType;
private int srcSize;
public RunLengthEncoding() {
}
public RunLengthEncoding(int srcType, int srcSize) {
this.srcType = srcType;
this.srcSize = srcSize;
}
@Override
public Map getMapRepresentation() {
Map map = new LinkedHashMap<>();
map.put("kind", "RunLength");
map.put("srcType", srcType);
map.put("srcSize", srcSize);
return map;
}
@Override
public IntArray decode(Int32Array data) {
int[] input = data.getData();
if (input.length == 0) {
return data;
}
int dataOffset = 0;
IntArray output = IntArray.create(srcType, srcSize);
output.setEncoding(data.getEncoding());
int[] outputArray = output.getData();
for (int i = 0; i < data.length(); i += 2) {
int value = input[i]; // value to be repeated
int length = input[i + 1]; // number of repeats
for (int j = 0; j < length; ++j) {
outputArray[dataOffset++] = value;
}
}
return output;
}
@Override
public Int32Array encode(IntArray data) {
int[] input = data.getData();
if (input.length == 0) {
Deque> enc = new ArrayDeque<>(data.getEncoding());
this.srcType = 3;
this.srcSize = 0;
enc.add(this);
return new Int32Array(new int[0], enc);
}
// calculate output size
int fullLength = 2;
for (int i = 1; i < input.length; i++) {
if (input[i - 1] != input[i]) {
fullLength += 2;
}
}
int[] output = new int[fullLength];
int offset = 0;
int runLength = 1;
for (int i = 1; i < input.length; i++) {
if (input[i - 1] != input[i]) {
output[offset] = input[i - 1];
output[offset + 1] = runLength;
runLength = 1;
offset += 2;
} else {
++runLength;
}
}
output[offset] = input[input.length - 1];
output[offset + 1] = runLength;
Deque> enc = new ArrayDeque<>(data.getEncoding());
this.srcType = 3;
this.srcSize = input.length;
enc.add(this);
return new Int32Array(output, enc);
}
@Override
public String toString() {
return "RunLengthEncoding{" +
"srcType=" + srcType +
", srcSize=" + srcSize +
'}';
}
}
StringArrayEncoding.java 0000664 0000000 0000000 00000012241 14766323153 0033520 0 ustar 00root root 0000000 0000000 ciftools-java-ciftools-java-7.0.1/src/main/java/org/rcsb/cif/binary/encoding package org.rcsb.cif.binary.encoding;
import org.rcsb.cif.EncodingStrategyHint;
import org.rcsb.cif.binary.Classifier;
import org.rcsb.cif.binary.data.ByteArray;
import org.rcsb.cif.binary.data.Int32Array;
import org.rcsb.cif.binary.data.StringArray;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Deque;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
/**
* Stores an array of strings as a concatenation of all unique strings, an array of offsets describing substrings,
* and indices into the offset array. Indices to corresponding substrings.
*
*
* StringArray {
* kind = "StringArray"
* dataEncoding: Encoding[]
* stringData: string
* offsetEncoding: Encoding[]
* offsets: Uint8Array
* }
* Example
* ['a','AB','a']
* ---StringArray--->
* { stringData = 'aAB', offsets = [0, 1, 3] } [0, 1, 0]
*
*/
public class StringArrayEncoding implements Encoding {
private Deque> dataEncoding;
private String stringData;
private Deque> offsetEncoding;
private byte[] offsets;
public StringArrayEncoding() {
}
public StringArrayEncoding(String stringData, byte[] offsets, Deque> outputEncoding, Deque> offsetEncoding) {
this.dataEncoding = outputEncoding;
this.stringData = stringData;
this.offsetEncoding = offsetEncoding;
this.offsets = offsets;
}
@Override
public Map getMapRepresentation() {
Map map = new LinkedHashMap<>();
map.put("kind", "StringArray");
map.put("dataEncoding", toArray(dataEncoding));
map.put("stringData", stringData);
map.put("offsetEncoding", toArray(offsetEncoding));
map.put("offsets", offsets);
return map;
}
private Map[] toArray(Deque> deque) {
return deque.stream()
.map(Encoding::getMapRepresentation)
.toArray(Map[]::new);
}
@Override
public StringArray decode(ByteArray data) {
int[] offsets = (int[]) new ByteArray(this.offsets, offsetEncoding)
.decode()
.getData();
data.setEncoding(dataEncoding);
int[] indices = (int[]) data.decode().getData();
String[] strings = new String[offsets.length];
strings[0] = "";
for (int i = 1; i < offsets.length; i++) {
strings[i] = stringData.substring(offsets[i - 1], offsets[i]);
}
int offset = 0;
String[] result = new String[indices.length];
for (int index : indices) {
result[offset++] = strings[index + 1];
}
return new StringArray(result, data.getEncoding());
}
@Override
public ByteArray encode(StringArray data) {
String[] input = data.getData();
Map map = new HashMap<>();
List strings = new ArrayList<>();
int[] outputArray = new int[input.length];
List offsetList = new ArrayList<>();
offsetList.add(0);
int accLength = 0;
int i = 0;
for (String s : input) {
// handle null strings
if (s == null) {
outputArray[i++] = -1;
continue;
}
if (map.containsKey(s)) {
int index = map.get(s);
outputArray[i++] = index;
} else {
// increment the length
accLength += s.length();
// store the string and index
int index = strings.size();
strings.add(s);
map.put(s, index);
// store offset
offsetList.add(accLength);
outputArray[i++] = index;
}
}
int[] offsetArray = new int[offsetList.size()];
for (int j = 0; j < offsetList.size(); j++) {
offsetArray[j] = offsetList.get(j);
}
Int32Array offsetPlain = new Int32Array(offsetArray);
EncodingStrategyHint offsetHint = Classifier.classify(offsetPlain);
ByteArray offsets = Classifier.encode(offsetPlain, offsetHint.getEncoding());
Int32Array outputPlain = new Int32Array(outputArray);
EncodingStrategyHint outputHint = Classifier.classify(outputPlain);
ByteArray output = Classifier.encode(outputPlain, outputHint.getEncoding());
Deque> enc = new ArrayDeque<>(data.getEncoding());
this.offsets = offsets.getData();
this.offsetEncoding = offsets.getEncoding();
this.stringData = String.join("", strings);
this.dataEncoding = output.getEncoding();
enc.add(this);
return new ByteArray(output.getData(), enc);
}
@Override
public String toString() {
return "StringArrayEncoding{" +
"dataEncoding=" + dataEncoding +
", stringData='" + stringData + '\'' +
", offsetEncoding=" + offsetEncoding +
", offsets=" + Arrays.toString(offsets) +
'}';
}
}
ciftools-java-ciftools-java-7.0.1/src/main/java/org/rcsb/cif/model/ 0000775 0000000 0000000 00000000000 14766323153 0025046 5 ustar 00root root 0000000 0000000 ciftools-java-ciftools-java-7.0.1/src/main/java/org/rcsb/cif/model/Block.java 0000664 0000000 0000000 00000005036 14766323153 0026747 0 ustar 00root root 0000000 0000000 package org.rcsb.cif.model;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Stream;
/**
* Represents a {@link Block} in a {@link CifFile}.
*/
public interface Block {
/**
* The header of this {@link Block}.
* @return String of the header
*/
String getBlockHeader();
/**
* Retrieve a particular {@link Category} by name.
* @param name the category name
* @return the corresponding {@link Category}, if none exists a instance of {@link Category} is returned as
* proxy
*/
Category getCategory(String name);
/**
* Retrieve a {@link Column} by name. This is relevant for CCDC files that identify columns by 'flat' names such as
* "cell_length_a"
* @param name the category name and column name, joined by an underscore
* @return the corresponding {@link Column}, if none exists a instance of {@link Column} is returned as proxy
*/
default Column getColumn(String name) {
Map categories = getCategories();
if (categories.containsKey(name)) {
return categories.get(name).getColumn("");
} else {
return Column.EmptyColumn.UNNAMED_COLUMN;
}
}
/**
* Access to the category map wrapped by this block.
* @return a map with category names as keys and instances as values
*/
Map getCategories();
/**
* Traverses all present categories.
* @return a Stream of all {@link Category} instances
*/
default Stream categories() {
return getCategories().values().stream();
}
/**
* All save frames associated to this {@link Block}.
* @return collection of save frames
*/
List getSaveFrames();
/**
* Convenience method to traverse all save frames.
* @return a {@link Stream} of all save frames.
*/
default Stream saveFrames() {
return getSaveFrames().stream();
}
/**
* 'Type-safe' access to arbitrary categories.
* @param name the category name to retrieve
* @param wrapper a mapping function that ensures that correct behavior of this category
* @param the desired type
* @return typed instance of the requested category
*/
default C getCategory(String name, Function wrapper) {
Category category = getCategory(name);
return wrapper.apply(category != null ? category : new Category.EmptyCategory(name));
}
}
ciftools-java-ciftools-java-7.0.1/src/main/java/org/rcsb/cif/model/BlockBuilder.java 0000664 0000000 0000000 00000002763 14766323153 0030262 0 ustar 00root root 0000000 0000000 package org.rcsb.cif.model;
import java.util.Map;
/**
* The specification of a builder for generic {@link Block} instances.
* @param the parent builder type
*/
public interface BlockBuilder
{
/**
* Descend 1 level and enter a new Category.
* @param categoryName the name for this category
* @return a parent-aware builder instance at category level
*/
CategoryBuilder, P> enterCategory(String categoryName);
/**
* The header of this block.
* @return a String
*/
String getBlockHeader();
/**
* The category map of this builder (and Block about to be created).
* @return a map with category names as keys and Category instances as values
*/
Map getCategories();
/**
* A hook to make this instance aware of the data in all child nodes.
* @param categoryBuilder the child builder to digest
*/
void digest(CategoryBuilder, P> categoryBuilder);
/**
* Leave this block and move back to the parent builder at CifFile level.
* @return the parent builder
*/
P leaveBlock();
/**
* Build this block as a detached instance.
* @return the Block described by this builder
*/
Block build();
/**
* Add a category to this builder.
* @param category some category with data
* @return this builder instance
*/
BlockBuilder