@Override public void store(Long key, Data value) { if (!enabled) { return; } final Object actualValue; if (binary) { // WARNING: we can't pass original Data to the user actualValue = Arrays.copyOf(value.toByteArray(), value.totalSize()); } else { actualValue = serializationService.toObject(value); } store.store(key, actualValue); }
public void setAttributes(Data d) { Model m; String type = d.getType(); switch(type) { case "Type1": m.setType(type); m.setDuration(d.getDuration()) m.setBenefit(d.getBenefit()) m.setPermission(d.getPermission()); break; case "TYPE2": m.setType(type); m.setLab(true); break; } }
protected JsonParser createParser(Object obj) throws IOException { Data data = (Data) obj; return factory.createParser(data.toByteArray(), HEAP_DATA_OVERHEAD + UTF_CHARACTER_COUNT_FIELD_SIZE, data.dataSize() - UTF_CHARACTER_COUNT_FIELD_SIZE); } }
@Override public boolean equals(Object o) { if (this == o) { return true; } if (o == null) { return false; } if (!(o instanceof Data)) { return false; } Data data = (Data) o; if (getType() != data.getType()) { return false; } final int dataSize = dataSize(); if (dataSize != data.dataSize()) { return false; } return dataSize == 0 || equals(this.payload, data.toByteArray()); }
private void copyWithoutHeader(Data src, byte[] dst, int dstOffset) { byte[] bytes = src.toByteArray(); System.arraycopy(bytes, HeapData.TYPE_OFFSET, dst, dstOffset, bytes.length - HeapData.TYPE_OFFSET); }
public PortableReader createPortableReader(Data data) throws IOException { if (!data.isPortable()) { throw new IllegalArgumentException("Given data is not Portable! -> " + data.getType()); } BufferObjectDataInput in = createObjectDataInput(data); return portableSerializer.createReader(in); }
public Payload constructPayload(final Data data) { //implement any thread safety mechanism as requirdhere. // synchronized is just for explanatory purposes synchronized (data) { if (data.getType().equals("PayloadA")) { return new PayloadA.Builder(data.getDeviceId()) //.setGuid("someGuid") //other setters .build(); } else { return new PayloadB.Builder(data.getEventType()) //.setCreationDate("someCreationDate") // other setters .build(); } } }
public List<Data> conflateList (List<Data> longList) { List<Data> resultList = new ArrayList<Data>(); for (Data element: longList) { if (element.getType() == 'i' && (resultList.size() == 0 || resultList.get(resultList.size() - 1).getType() == 'o')) { // only the first consecutive `i` is added resultList.add(lastElement); } if (element.getType() == 'o') { if (resultList.size() == 0 || resultList.get(resultList.size() - 1).getType() == 'i') { // all `o`s are at least temporarily added resultList.add(element); } else { // consecutive `o`s are replaced resultList.set(resultList.size() - 1, element); } } } return resultList; }
private Getter instantiateGetter(Object targetObject, String attributeName) { String attributeNameWithoutArguments = extractAttributeNameNameWithoutArguments(attributeName); ValueExtractor valueExtractor = extractors.get(attributeNameWithoutArguments); if (valueExtractor != null) { Object arguments = argumentsParser.parse(extractArgumentsFromAttributeName(attributeName)); return new ExtractorGetter(ss, valueExtractor, arguments); } else { if (targetObject instanceof Data) { if (((Data) targetObject).isPortable()) { if (genericPortableGetter == null) { // will be initialised a couple of times in the worst case genericPortableGetter = new PortableGetter(ss); } return genericPortableGetter; } else if (((Data) targetObject).isJson()) { if (jsonDataGetter == null) { // will be initialised a couple of times in the worst case jsonDataGetter = new JsonDataGetter(); } return jsonDataGetter; } else { throw new HazelcastSerializationException("No Data getter found for type " + ((Data) targetObject).getType()); } } else if (targetObject instanceof HazelcastJsonValue) { return JsonGetter.INSTANCE; } else { return ReflectionHelper.createGetter(targetObject, attributeName); } } }
@Override protected long getKeyStorageMemoryCost(K key) { if (key instanceof Data) { return // reference to this key data inside map ("store" field) REFERENCE_SIZE // heap cost of this key data + ((Data) key).getHeapCost(); } else { // memory cost for non-data typed instance is not supported return 0L; } }
@Override public String toString() { StringBuilder sb = new StringBuilder("SessionState {"); sb.append(", attributes=" + ((attributes == null) ? 0 : attributes.size())); if (attributes != null) { for (Map.Entry<String, Data> entry : attributes.entrySet()) { Data data = entry.getValue(); int len = (data == null) ? 0 : data.dataSize(); sb.append("\n\t"); sb.append(entry.getKey() + "[" + len + "]"); } } sb.append("\n}"); return sb.toString(); } }
@Override public final int getPartitionId(Data key) { return HashUtil.hashToIndex(key.getPartitionHash(), partitionCount); }
static boolean shouldCache(Object value) { return value instanceof Data && !((Data) value).isPortable(); }
/** * Returns the form of this data that is queryable. * Returns {@link Data} if {@code target} is * <ul> * <li>a portable object either in Data form or Object form</li> * <li>a {@link HazelcastJsonValue} in Data form</li> * </ul> * Otherwise, returns object form. * * @return Data or Object */ private Object getTargetObject(Object target) { Data targetData; if (target instanceof Portable) { targetData = ss.toData(target); if (targetData.isPortable()) { return targetData; } } if (target instanceof Data) { targetData = (Data) target; if (targetData.isPortable() || targetData.isJson()) { return targetData; } else { // convert non-portable Data to object return ss.toObject(target); } } return target; }
@Override public InternalCompletableFuture<Void> addAsync(Object obj) { checkNotNull(obj, "Object is null"); Data data = toData(obj); ClientMessage request = CardinalityEstimatorAddCodec.encodeRequest(name, data.hash64()); return invokeOnPartitionAsync(request, ADD_DECODER); }
@Override public boolean equals(Object o) { if (this == o) { return true; } if (o == null) { return false; } if (!(o instanceof Data)) { return false; } Data data = (Data) o; if (getType() != data.getType()) { return false; } final int dataSize = dataSize(); if (dataSize != data.dataSize()) { return false; } return dataSize == 0 || equals(this.payload, data.toByteArray()); }
private void writeWithoutHeader(Data src, OutputStream dst) { byte[] bytes = src.toByteArray(); try { dst.write(bytes, HeapData.TYPE_OFFSET, bytes.length - HeapData.TYPE_OFFSET); } catch (IOException e) { throw new RuntimeException(e); // should never happen } }