@Override public Map<QName, Object> getFields() { return record.getFields(); }
private Map<QName, Object> getFieldsToUpdate(Record record) { // Work with a copy of the map Map<QName, Object> fields = new HashMap<QName, Object>(); fields.putAll(record.getFields()); for (QName qName : record.getFieldsToDelete()) { fields.put(qName, FieldFlags.getDeleteMarker()); } return fields; }
@Override public Map<QName, Object> getFields() { return Collections.unmodifiableMap(delegate.getFields()); }
private Record merge(Record record, Record original) { Record result = original.clone(); if (record.getRecordTypeName() != null) { result.setRecordType(record.getRecordTypeName()); } // TODO merge meta map for(Map.Entry<QName,Object> entry : record.getFields().entrySet()) { result.setField(entry.getKey(), entry.getValue()); } for (QName toDelete : record.getFieldsToDelete()) { result.getFields().remove(toDelete); } return result; }
private static void reduceFields(Record record, Set<QName> fieldsToInclude) { Iterator<QName> it = record.getFields().keySet().iterator(); while (it.hasNext()) { QName name = it.next(); if (!fieldsToInclude.contains(name)) { it.remove(); } } } }
@Override public Map<SchemaId, Object> getFieldsById() { Map<QName, Object> fields = record.getFields(); Map<SchemaId, Object> fieldsById = new HashMap<SchemaId, Object>(fields.size()); for (Map.Entry<SchemaId, QName> entry : mapping.entrySet()) { Object value = fields.get(entry.getValue()); if (value != null) { fieldsById.put(entry.getKey(), value); } } return fieldsById; }
private static void filterFields(Record record, Set<QName> fields) { Iterator<Map.Entry<QName, Object>> fieldsIt = record.getFields().entrySet().iterator(); while (fieldsIt.hasNext()) { Map.Entry<QName, Object> entry = fieldsIt.next(); if (!fields.contains(entry.getKey())) { fieldsIt.remove(); } } } }
@Override protected Record readNestedRecord(ValueHandle handle, ReadContext context) throws InterruptedException, RepositoryException, JsonFormatException { Record record = super.readNestedRecord(handle, context); return record.getFields().isEmpty() ? null : record; }
/** * If it is a system field, evaluates it, if not, returns the normal field value from the record. * Does not throw a FieldNotFoundException, rather returns null. */ public Object softEval(Record record, QName fieldType, TypeManager typeManager) throws RepositoryException, InterruptedException { if (isSystemField(fieldType)) { return fieldsByName.get(fieldType).eval(record, typeManager); } else { return record.getFields().get(fieldType); } }
private static void printRecordValue(PrintStream out, int indent, Record record) { println(out, indent, "Record of type " + record.getRecordTypeName() + ", version " + record.getRecordTypeVersion()); for (Map.Entry<QName, Object> field : record.getFields().entrySet()) { printField(out, indent, field.getKey(), field.getValue()); } }
/** * This is for link extraction from nested records. */ private static void extractRecord(Record record, LinkCollector collector, FieldType ctxField, RecordId ctxRecord, LRepository repository) throws RepositoryException, InterruptedException { for (Map.Entry<QName, Object> field : record.getFields().entrySet()) { FieldType fieldType; try { fieldType = repository.getTypeManager().getFieldTypeByName(field.getKey()); } catch (FieldTypeNotFoundException e) { // Can not do anything with a field if we cannot load its type continue; } // The ctxField and ctxRecord need to stay the top-level ones! It does not matter how // deeply nested a link occurs, as far as the link index is concerned, it still occurs // with the field of the top level record. extract(field.getValue(), fieldType, collector, ctxField, ctxRecord, repository); } }
/** * Removes any versioned information from the supplied record object. */ public static void reduceToNonVersioned(Record record, Set<QName> fields, TypeManager typeManager) throws RepositoryException, InterruptedException { if (record.getVersion() == null) { // The record has no versions so there should be no versioned fields in it return; } Iterator<Map.Entry<QName, Object>> fieldsIt = record.getFields().entrySet().iterator(); while (fieldsIt.hasNext()) { Map.Entry<QName, Object> entry = fieldsIt.next(); if (fields != null && !fields.contains(entry.getKey())) { fieldsIt.remove(); } else if (typeManager.getFieldTypeByName(entry.getKey()).getScope() != Scope.NON_VERSIONED) { fieldsIt.remove(); } } // Remove versioned record type info record.setRecordType(Scope.VERSIONED, (QName) null, null); record.setRecordType(Scope.VERSIONED_MUTABLE, (QName) null, null); }
@Override public String format(Object record, ValueType valueType, FormatContext formatCtx) throws InterruptedException { StringBuilder builder = new StringBuilder(); TypeManager typeManager = formatCtx.repository.getTypeManager(); for (Map.Entry<QName, Object> field : ((Record)record).getFields().entrySet()) { ValueType fieldValueType; try { fieldValueType = typeManager.getFieldTypeByName(field.getKey()).getValueType(); } catch (RepositoryException e) { // error loading field type: skip this field continue; } String result = formatCtx.format(field.getValue(), fieldValueType, formatCtx); if (result != null) { if (builder.length() > 0) { builder.append(" "); } builder.append(result); } } return returnBuilderResult(builder); } }
Map<QName, Object> fields = record.getFields(); for (Entry<QName, Object> entry : fields.entrySet()) { if (detectRecordRecursion(entry.getValue(), parentRecords)) {
for (Map.Entry<QName, Object> field : record.getFields().entrySet()) { FieldType fieldType = null; try {
@Override public String format(Object record, ValueType valueType, FormatContext formatCtx) throws InterruptedException { TypeManager typeManager = formatCtx.repository.getTypeManager(); StringWriter writer = new StringWriter(); try { JsonGenerator gen = JsonFormat.JSON_FACTORY.createJsonGenerator(writer); gen.writeStartObject(); for (Map.Entry<QName, Object> field : ((Record) record).getFields().entrySet()) { ValueType fieldValueType; try { fieldValueType = typeManager.getFieldTypeByName(field.getKey()).getValueType(); } catch (RepositoryException e) { continue; } String result = formatCtx.format(field.getValue(), fieldValueType, formatCtx); if (result != null) { gen.writeStringField(field.getKey().getName(), result); } } gen.writeEndObject(); gen.flush(); } catch (IOException e) { throw new InterruptedException(e.getMessage()); } return returnBuilderResult(new StringBuilder(writer.toString())); } }
private void checkCreatePreconditions(Record record) throws InvalidRecordException { ArgumentValidator.notNull(record, "record"); if (record.getRecordTypeName() == null) { throw new InvalidRecordException("The recordType cannot be null for a record to be created.", record.getId()); } if (record.getFields().isEmpty()) { throw new InvalidRecordException("Creating an empty record is not allowed", record.getId()); } }
@Override public IdRecord readWithIds(RecordId recordId, Long aLong, List<SchemaId> schemaIds) throws RepositoryException, InterruptedException { Record record = getRecord(recordId); TypeManager typeManager = this.getTypeManager(); Map<SchemaId, QName> map = Maps.newHashMap(); for (QName qname : record.getFields().keySet()) { map.put(typeManager.getFieldTypeByName(qname).getId(), qname); } Map<Scope,SchemaId> recordTypeIds = Maps.newHashMap(); for (Scope scope : Scope.values()) { RecordType recordType = typeManager.getRecordTypeByName(record.getRecordTypeName(scope), record.getVersion()); if (recordType != null) { recordTypeIds.put(scope, recordType.getId()); } } IdRecord idRecord = new IdRecordImpl(record, map, recordTypeIds); return idRecord; }
throws InterruptedException, RepositoryException { Map<QName, Object> originalFields = originalRecord.getFields(); EnumSet<Scope> changedScopes = EnumSet.noneOf(Scope.class);
Map<QName, Object> recordFields = record.getFields(); List<QName> expectedFields = new ArrayList<QName>();