* Licensed to the Apache Software Foundation (ASF) under one

* or more contributor license agreements.  See the NOTICE file

* distributed with this work for additional information

* regarding copyright ownership.  The ASF licenses this file

* to you 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.

*/

* Contains converter methods.

*/

    private static final String DEFAULT_EXTENSION_NS = "http://chemistry.apache.org/opencmis/extension";

    private static final int BUFFER_SIZE = 64 * 1024;

    private static final Logger LOG = LoggerFactory.getLogger(WSConverter.class);

    private static final BigInteger BIG_INT_32 = BigInteger.valueOf(32);

    private static final BigInteger BIG_INT_64 = BigInteger.valueOf(64);

    private static Class<?> streamDataHandlerClass1;

    private static Method streamDataHandlerReadMethod1;

    private static Class<?> streamDataHandlerClass2;

    private static Method streamDataHandlerReadMethod2;

    static {

        try {

            streamDataHandlerClass1 = Class.forName("org.jvnet.staxex.StreamingDataHandler");

            streamDataHandlerReadMethod1 = streamDataHandlerClass1.getMethod("readOnce", new Class<?>[0]);

        } catch (Exception e) {

            streamDataHandlerClass1 = null;

            streamDataHandlerReadMethod1 = null;

        }

        try {

            streamDataHandlerClass2 = Class.forName("com.sun.xml.internal.org.jvnet.staxex.StreamingDataHandler");

            streamDataHandlerReadMethod2 = streamDataHandlerClass2.getMethod("readOnce", new Class<?>[0]);

        } catch (Exception e) {

            streamDataHandlerClass2 = null;

            streamDataHandlerReadMethod2 = null;

        }

    }

    /**

     * Private constructor.

     */

    private WSConverter() {

    }

    // -------------------------------------------------------------------------

    // --- Repository Info ---

    // -------------------------------------------------------------------------

    /**

     * Converts a repository info object.

     */

    public static RepositoryInfo convert(CmisRepositoryInfoType repositoryInfo) {

        if (repositoryInfo == null) {

            return null;

        }

        RepositoryInfoImpl result = new RepositoryInfoImpl();

        result.setAclCapabilities(convert(repositoryInfo.getAclCapability()));

        result.setChangesIncomplete(repositoryInfo.isChangesIncomplete());

        List<BaseTypeId> baseObjectTypeIds = new ArrayList<BaseTypeId>();

        for (EnumBaseObjectTypeIds bot : repositoryInfo.getChangesOnType()) {

            baseObjectTypeIds.add(convert(BaseTypeId.class, bot));

        }

        result.setChangesOnType(baseObjectTypeIds);

        result.setCmisVersionSupported(repositoryInfo.getCmisVersionSupported());

        result.setLatestChangeLogToken(repositoryInfo.getLatestChangeLogToken());

        result.setPrincipalAnonymous(repositoryInfo.getPrincipalAnonymous());

        result.setPrincipalAnyone(repositoryInfo.getPrincipalAnyone());

        result.setProductName(repositoryInfo.getProductName());

        result.setProductVersion(repositoryInfo.getProductVersion());

        result.setCapabilities(convert(repositoryInfo.getCapabilities()));

        result.setDescription(repositoryInfo.getRepositoryDescription());

        result.setId(repositoryInfo.getRepositoryId());

        result.setName(repositoryInfo.getRepositoryName());

        result.setRootFolder(repositoryInfo.getRootFolderId());

        result.setThinClientUri(repositoryInfo.getThinClientURI());

        result.setVendorName(repositoryInfo.getVendorName());

        if (isNotEmpty(repositoryInfo.getExtendedFeatures())) {

            List<ExtensionFeature> extensionFeatures = new ArrayList<ExtensionFeature>();

            result.setExtensionFeature(extensionFeatures);

            for (CmisExtensionFeatureType feature : repositoryInfo.getExtendedFeatures()) {

                ExtensionFeatureImpl target = new ExtensionFeatureImpl();

                target.setId(feature.getId());

                target.setUrl(feature.getUrl());

                target.setCommonName(feature.getCommonName());

                target.setVersionLabel(feature.getVersionLabel());

                target.setDescription(feature.getDescription());

                if (isNotEmpty(feature.getFeatureData())) {

                    Map<String, String> featureData = new HashMap<String, String>();

                    for (CmisExtensionFeatureKeyValuePair keyValue : feature.getFeatureData()) {

                        featureData.put(keyValue.getKey(), keyValue.getValue());

                    }

                    target.setFeatureData(featureData);

                }

                convertExtension(feature, target);

                extensionFeatures.add(target);

            }

        }

        // handle extensions

        convertExtension(repositoryInfo, result);

        return result;

    }

    /**

     * Converts a repository capability object.

     */

    public static RepositoryCapabilities convert(CmisRepositoryCapabilitiesType capabilities) {

        if (capabilities == null) {

            return null;

        }

        RepositoryCapabilitiesImpl result = new RepositoryCapabilitiesImpl();

        result.setAllVersionsSearchable(capabilities.isCapabilityAllVersionsSearchable());

        result.setCapabilityAcl(convert(CapabilityAcl.class, capabilities.getCapabilityACL()));

        result.setCapabilityChanges(convert(CapabilityChanges.class, capabilities.getCapabilityChanges()));

        result.setCapabilityContentStreamUpdates(convert(CapabilityContentStreamUpdates.class,

                capabilities.getCapabilityContentStreamUpdatability()));

        result.setCapabilityJoin(convert(CapabilityJoin.class, capabilities.getCapabilityJoin()));

        result.setCapabilityQuery(convert(CapabilityQuery.class, capabilities.getCapabilityQuery()));

        result.setCapabilityRendition(convert(CapabilityRenditions.class, capabilities.getCapabilityRenditions()));

        result.setIsPwcSearchable(capabilities.isCapabilityPWCSearchable());

        result.setIsPwcUpdatable(capabilities.isCapabilityPWCUpdatable());

        result.setSupportsGetDescendants(capabilities.isCapabilityGetDescendants());

        result.setSupportsGetFolderTree(capabilities.isCapabilityGetFolderTree());

        result.setCapabilityOrderBy(convert(CapabilityOrderBy.class, capabilities.getCapabilityOrderBy()));

        result.setSupportsMultifiling(capabilities.isCapabilityMultifiling());

        result.setSupportsUnfiling(capabilities.isCapabilityUnfiling());

        result.setSupportsVersionSpecificFiling(capabilities.isCapabilityVersionSpecificFiling());

        if (capabilities.getCapabilityCreatablePropertyTypes() != null) {

            CmisCreatablePropertyTypesType creatablePropertyTypes = capabilities.getCapabilityCreatablePropertyTypes();

            CreatablePropertyTypesImpl target = new CreatablePropertyTypesImpl();

            result.setCreatablePropertyTypes(target);

            if (isNotEmpty(creatablePropertyTypes.getCanCreate())) {

                Set<PropertyType> propertyTypeSet = EnumSet.noneOf(PropertyType.class);

                target.setCanCreate(propertyTypeSet);

                for (EnumPropertyType propType : creatablePropertyTypes.getCanCreate()) {

                    PropertyType propertyType = convert(PropertyType.class, propType);

                    if (propertyType != null) {

                        propertyTypeSet.add(propertyType);

                    }

                }

            }

            convertExtension(creatablePropertyTypes, target);

        }

        if (capabilities.getCapabilityNewTypeSettableAttributes() != null) {

            CmisNewTypeSettableAttributes newTypeSettableAttributes = capabilities

                    .getCapabilityNewTypeSettableAttributes();

            NewTypeSettableAttributesImpl target = new NewTypeSettableAttributesImpl();

            result.setNewTypeSettableAttributes(target);

            target.setCanSetId(newTypeSettableAttributes.isId());

            target.setCanSetLocalName(newTypeSettableAttributes.isLocalName());

            target.setCanSetLocalNamespace(newTypeSettableAttributes.isLocalNamespace());

            target.setCanSetDisplayName(newTypeSettableAttributes.isDisplayName());

            target.setCanSetQueryName(newTypeSettableAttributes.isQueryName());

            target.setCanSetDescription(newTypeSettableAttributes.isDescription());

            target.setCanSetCreatable(newTypeSettableAttributes.isCreatable());

            target.setCanSetFileable(newTypeSettableAttributes.isFileable());

            target.setCanSetQueryable(newTypeSettableAttributes.isQueryable());

            target.setCanSetFulltextIndexed(newTypeSettableAttributes.isFulltextIndexed());

            target.setCanSetIncludedInSupertypeQuery(newTypeSettableAttributes.isIncludedInSupertypeQuery());

            target.setCanSetControllablePolicy(newTypeSettableAttributes.isControllablePolicy());

            target.setCanSetControllableAcl(newTypeSettableAttributes.isControllableACL());

            convertExtension(newTypeSettableAttributes, target);

        }

        // handle extensions

        convertExtension(capabilities, result);

        return result;

    }

    /**

     * Converts a ACL capability object.

     */

    public static AclCapabilities convert(CmisACLCapabilityType aclCapabilities) {

        if (aclCapabilities == null) {

            return null;

        }

        AclCapabilitiesDataImpl result = new AclCapabilitiesDataImpl();

        result.setSupportedPermissions(convert(SupportedPermissions.class, aclCapabilities.getSupportedPermissions()));

        result.setAclPropagation(convert(AclPropagation.class, aclCapabilities.getPropagation()));

        List<PermissionDefinition> permissionDefinitionList = new ArrayList<PermissionDefinition>();

        for (CmisPermissionDefinition permDef : aclCapabilities.getPermissions()) {

            PermissionDefinitionDataImpl permDefData = new PermissionDefinitionDataImpl();

            permDefData.setId(permDef.getPermission());

            permDefData.setDescription(permDef.getDescription());

            convertExtension(permDef, permDefData);

            permissionDefinitionList.add(permDefData);

        }

        result.setPermissionDefinitionData(permissionDefinitionList);

        Map<String, PermissionMapping> permissionMapping = new LinkedHashMap<String, PermissionMapping>();

        for (CmisPermissionMapping permMapping : aclCapabilities.getMapping()) {

            if (permMapping.getKey() != null) {

                PermissionMappingDataImpl permMappingData = new PermissionMappingDataImpl();

                String key = permMapping.getKey().value();

                permMappingData.setKey(key);

                permMappingData.setPermissions(permMapping.getPermission());

                convertExtension(permMapping, permMappingData);

                permissionMapping.put(key, permMappingData);

            }

        }

        result.setPermissionMappingData(permissionMapping);

        // handle extensions

        convertExtension(aclCapabilities, result);

        return result;

    }

    /**

     * Converts a repository info object.

     */

    public static CmisRepositoryInfoType convert(RepositoryInfo repositoryInfo, CmisVersion cmisVersion) {

        if (repositoryInfo == null) {

            return null;