/*
|
* The contents of this file are subject to the terms of the Common Development and
|
* Distribution License (the License). You may not use this file except in compliance with the
|
* License.
|
*
|
* You can obtain a copy of the License at legal/CDDLv1.0.txt. See the License for the
|
* specific language governing permission and limitations under the License.
|
*
|
* When distributing Covered Software, include this CDDL Header Notice in each file and include
|
* the License file at legal/CDDLv1.0.txt. If applicable, add the following below the CDDL
|
* Header, with the fields enclosed by brackets [] replaced by your own identifying
|
* information: "Portions Copyrighted [year] [name of copyright owner]".
|
*
|
* Copyright 2012 ForgeRock AS. All rights reserved.
|
*/
|
|
package org.forgerock.opendj.rest2ldap;
|
|
import java.util.ArrayList;
|
import java.util.Collections;
|
import java.util.LinkedHashMap;
|
import java.util.LinkedHashSet;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Set;
|
import java.util.concurrent.atomic.AtomicInteger;
|
|
import org.forgerock.json.fluent.JsonPointer;
|
import org.forgerock.json.fluent.JsonValue;
|
import org.forgerock.opendj.ldap.Attribute;
|
import org.forgerock.opendj.ldap.Entry;
|
import org.forgerock.opendj.ldap.ErrorResultException;
|
import org.forgerock.opendj.ldap.ResultHandler;
|
import org.forgerock.resource.provider.Context;
|
|
/**
|
*
|
*/
|
public final class CompositeAttributeMapper implements AttributeMapper {
|
private final Set<String> allLDAPAttributes;
|
private final List<AttributeMapper> attributeMappers;
|
|
/**
|
* Creates a new composite attribute mapper.
|
*
|
* @param attributeMappers
|
* The list of attribute mappers.
|
*/
|
public CompositeAttributeMapper(final List<AttributeMapper> attributeMappers) {
|
this.attributeMappers = new ArrayList<AttributeMapper>(attributeMappers);
|
Set<String> tmp = new LinkedHashSet<String>(attributeMappers.size());
|
for (final AttributeMapper mapper : attributeMappers) {
|
tmp.addAll(mapper.getAllLDAPAttributes());
|
}
|
allLDAPAttributes = Collections.unmodifiableSet(tmp);
|
}
|
|
/**
|
* {@inheritDoc}
|
*/
|
public Set<String> getAllLDAPAttributes() {
|
return allLDAPAttributes;
|
}
|
|
/**
|
* {@inheritDoc}
|
*/
|
public void getLDAPAttributesFor(JsonPointer resourceAttribute, Set<String> ldapAttributes) {
|
for (AttributeMapper attribute : attributeMappers) {
|
attribute.getLDAPAttributesFor(resourceAttribute, ldapAttributes);
|
}
|
}
|
|
/**
|
* {@inheritDoc}
|
*/
|
public void toJson(Context c, Entry e, final ResultHandler<Map<String, Object>> h) {
|
ResultHandler<Map<String, Object>> resultAccumulater =
|
new ResultHandler<Map<String, Object>>() {
|
private final AtomicInteger latch = new AtomicInteger(attributeMappers.size());
|
private final List<Map<String, Object>> results =
|
new ArrayList<Map<String, Object>>(latch.get());
|
|
public void handleErrorResult(ErrorResultException error) {
|
// Ensure that handler is only invoked once.
|
if (latch.getAndSet(0) > 0) {
|
h.handleErrorResult(error);
|
}
|
}
|
|
public void handleResult(Map<String, Object> result) {
|
synchronized (this) {
|
results.add(result);
|
}
|
if (latch.decrementAndGet() == 0) {
|
final Map<String, Object> mergeResult;
|
switch (results.size()) {
|
case 0:
|
mergeResult = Collections.<String, Object> emptyMap();
|
break;
|
case 1:
|
mergeResult = results.get(0);
|
break;
|
default:
|
mergeResult = new LinkedHashMap<String, Object>();
|
mergeJsonValues(results, mergeResult);
|
break;
|
}
|
h.handleResult(mergeResult);
|
}
|
}
|
};
|
|
for (AttributeMapper mapper : attributeMappers) {
|
mapper.toJson(c, e, resultAccumulater);
|
}
|
}
|
|
/**
|
* {@inheritDoc}
|
*/
|
public void toLDAP(Context c, JsonValue v, ResultHandler<List<Attribute>> h) {
|
// TODO Auto-generated method stub
|
|
}
|
|
/**
|
* Merge the provided list of JSON values into a single value.
|
*
|
* @param srcValues
|
* The source values.
|
* @param dstValue
|
* The destination value, into which which the values should be
|
* merged.
|
*/
|
private void mergeJsonValues(List<Map<String, Object>> srcValues, Map<String, Object> dstValue) {
|
for (Map<String, Object> value : srcValues) {
|
mergeJsonValue(value, dstValue);
|
}
|
}
|
|
/**
|
* Merge one JSON value into another.
|
*
|
* @param srcValue
|
* The source value.
|
* @param dstValue
|
* The destination value, into which which the value should be
|
* merged.
|
*/
|
@SuppressWarnings("unchecked")
|
private void mergeJsonValue(Map<String, Object> srcValue, Map<String, Object> dstValue) {
|
for (Map.Entry<String, Object> record : srcValue.entrySet()) {
|
String key = record.getKey();
|
Object newValue = record.getValue();
|
Object existingValue = dstValue.get(key);
|
if (existingValue == null) {
|
// Value is new, so just add it.
|
dstValue.put(key, newValue);
|
} else if (existingValue instanceof Map && newValue instanceof Map) {
|
// Merge two maps - create a new Map, in case the existing one
|
// is unmodifiable.
|
existingValue =
|
new LinkedHashMap<String, Object>((Map<String, Object>) existingValue);
|
mergeJsonValue((Map<String, Object>) newValue, (Map<String, Object>) existingValue);
|
} else if (existingValue instanceof List && newValue instanceof List) {
|
// Merge two lists- create a new List, in case the existing one
|
// is unmodifiable.
|
List<Object> tmp = new ArrayList<Object>((List<Object>) existingValue);
|
tmp.addAll((List<Object>) newValue);
|
existingValue = tmp;
|
}
|
|
// Replace the existing value.
|
dstValue.put(key, newValue);
|
}
|
}
|
}
|
