* 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 constructor.

     */

    private Converter() {

    }

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

    // --- 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());

        // 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.setSupportsMultifiling(capabilities.isCapabilityMultifiling());

        result.setSupportsUnfiling(capabilities.isCapabilityUnfiling());

        result.setSupportsVersionSpecificFiling(capabilities.isCapabilityVersionSpecificFiling());

        // 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.setPermission(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) {

        if (repositoryInfo == null) {

            return null;

        }

        CmisRepositoryInfoType result = new CmisRepositoryInfoType();

        result.setAclCapability(convert(repositoryInfo.getAclCapabilities()));

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

        result.setChangesIncomplete(repositoryInfo.getChangesIncomplete());

        result.setCmisVersionSupported(repositoryInfo.getCmisVersionSupported());

        result.setLatestChangeLogToken(repositoryInfo.getLatestChangeLogToken());

        result.setPrincipalAnonymous(repositoryInfo.getPrincipalIdAnonymous());

        result.setPrincipalAnyone(repositoryInfo.getPrincipalIdAnyone());

        result.setProductName(repositoryInfo.getProductName());

        result.setProductVersion(repositoryInfo.getProductVersion());

        result.setRepositoryDescription(repositoryInfo.getDescription());

        result.setRepositoryId(repositoryInfo.getId());

        result.setRepositoryName(repositoryInfo.getName());

        result.setRootFolderId(repositoryInfo.getRootFolderId());

        result.setThinClientURI(repositoryInfo.getThinClientUri());

        result.setVendorName(repositoryInfo.getVendorName());

        if (repositoryInfo.getChangesOnType() != null) {

            for (BaseTypeId boti : repositoryInfo.getChangesOnType()) {

                result.getChangesOnType().add(convert(EnumBaseObjectTypeIds.class, boti));

            }

        }

        // handle extensions

        convertExtension(repositoryInfo, result);

        return result;

    }

    /**

     * Converts a repository capability object.

     */

    public static CmisRepositoryCapabilitiesType convert(RepositoryCapabilities capabilities) {

        if (capabilities == null) {

            return null;

        }

        CmisRepositoryCapabilitiesType result = new CmisRepositoryCapabilitiesType();

        result.setCapabilityACL(convert(EnumCapabilityACL.class, capabilities.getAclCapability()));

        result.setCapabilityAllVersionsSearchable(capabilities.isAllVersionsSearchableSupported());

        result.setCapabilityChanges(convert(EnumCapabilityChanges.class, capabilities.getChangesCapability()));

        result.setCapabilityContentStreamUpdatability(convert(EnumCapabilityContentStreamUpdates.class,

                capabilities.getContentStreamUpdatesCapability()));

        result.setCapabilityGetDescendants(capabilities.isGetDescendantsSupported());

        result.setCapabilityGetFolderTree(capabilities.isGetFolderTreeSupported());

        result.setCapabilityJoin(convert(EnumCapabilityJoin.class, capabilities.getJoinCapability()));

        result.setCapabilityMultifiling(capabilities.isMultifilingSupported());

        result.setCapabilityPWCSearchable(capabilities.isPwcSearchableSupported());

        result.setCapabilityPWCUpdatable(capabilities.isPwcUpdatableSupported());

        result.setCapabilityQuery(convert(EnumCapabilityQuery.class, capabilities.getQueryCapability()));

        result.setCapabilityRenditions(convert(EnumCapabilityRendition.class, capabilities.getRenditionsCapability()));

        result.setCapabilityUnfiling(capabilities.isUnfilingSupported());

        result.setCapabilityVersionSpecificFiling(capabilities.isVersionSpecificFilingSupported());

        // handle extensions

        convertExtension(capabilities, result);

        return result;

    }

    /**

     * Converts a ACL capability object.

     */

    public static CmisACLCapabilityType convert(AclCapabilities aclCapabilities) {

        if (aclCapabilities == null) {

            return null;

        }

        CmisACLCapabilityType result = new CmisACLCapabilityType();

        result.setSupportedPermissions(convert(EnumSupportedPermissions.class,

                aclCapabilities.getSupportedPermissions()));

        result.setPropagation(convert(EnumACLPropagation.class, aclCapabilities.getAclPropagation()));

        if (aclCapabilities.getPermissions() != null) {

            for (PermissionDefinition pdd : aclCapabilities.getPermissions()) {

                CmisPermissionDefinition permDef = new CmisPermissionDefinition();

                permDef.setDescription(pdd.getDescription());

                permDef.setPermission(pdd.getId());

                convertExtension(pdd, permDef);

                result.getPermissions().add(permDef);

            }

        }

        if (aclCapabilities.getPermissionMapping() != null) {

            for (PermissionMapping pmd : aclCapabilities.getPermissionMapping().values()) {

                CmisPermissionMapping permMap = new CmisPermissionMapping();

                permMap.setKey(EnumAllowableActionsKey.fromValue(pmd.getKey()));

                if (pmd.getPermissions() != null) {

                    for (String permission : pmd.getPermissions()) {

                        permMap.getPermission().add(permission);

                    }

                }

                convertExtension(pmd, permMap);

                result.getMapping().add(permMap);

            }

        }

        // handle extensions

        convertExtension(aclCapabilities, result);

        return result;

    }

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

    // --- Types ---

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

    /**

     * Converts a type definition object.

     */

    public static TypeDefinition convert(CmisTypeDefinitionType typeDefinition) {

        if (typeDefinition == null) {

            return null;

        }

        AbstractTypeDefinition result = null;

        if (typeDefinition instanceof CmisTypeFolderDefinitionType) {

            result = new FolderTypeDefinitionImpl();

        } else if (typeDefinition instanceof CmisTypeDocumentDefinitionType) {

            result = new DocumentTypeDefinitionImpl();

            ((DocumentTypeDefinitionImpl) result).setContentStreamAllowed(convert(ContentStreamAllowed.class,

                    ((CmisTypeDocumentDefinitionType) typeDefinition).getContentStreamAllowed()));

            ((DocumentTypeDefinitionImpl) result).setIsVersionable(((CmisTypeDocumentDefinitionType) typeDefinition)

                    .isVersionable());

        } else if (typeDefinition instanceof CmisTypeRelationshipDefinitionType) {

            result = new RelationshipTypeDefinitionImpl();

            ((RelationshipTypeDefinitionImpl) result)

                    .setAllowedSourceTypes(((CmisTypeRelationshipDefinitionType) typeDefinition)

                            .getAllowedSourceTypes());

            ((RelationshipTypeDefinitionImpl) result)

                    .setAllowedTargetTypes(((CmisTypeRelationshipDefinitionType) typeDefinition)

                            .getAllowedTargetTypes());

        } else if (typeDefinition instanceof CmisTypePolicyDefinitionType) {

            result = new PolicyTypeDefinitionImpl();

        } else {

            throw new CmisRuntimeException("Type '" + typeDefinition.getId() + "' does not match a base type!");

        }

        result.setBaseTypeId(convert(BaseTypeId.class, typeDefinition.getBaseId()));

        result.setDescription(typeDefinition.getDescription());

        result.setDisplayName(typeDefinition.getDisplayName());

        result.setId(typeDefinition.getId());

        result.setIsControllableAcl(typeDefinition.isControllableACL());

        result.setIsControllablePolicy(typeDefinition.isControllablePolicy());

        result.setIsCreatable(typeDefinition.isCreatable());

        result.setIsFileable(typeDefinition.isFileable());

        result.setIsFulltextIndexed(typeDefinition.isFulltextIndexed());

        result.setIsIncludedInSupertypeQuery(typeDefinition.isIncludedInSupertypeQuery());

        result.setIsQueryable(typeDefinition.isQueryable());

        result.setLocalName(typeDefinition.getLocalName());

        result.setLocalNamespace(typeDefinition.getLocalNamespace());

        result.setParentTypeId(typeDefinition.getParentId());

        result.setQueryName(typeDefinition.getQueryName());

        for (CmisPropertyDefinitionType propertyDefinition : typeDefinition.getPropertyDefinition()) {

            result.addPropertyDefinition(convert(propertyDefinition));

        }

        // handle extensions

        convertExtension(typeDefinition, result);

        return result;

    }

    /**

     * Converts a property definition object.

     */

    public static PropertyDefinition<?> convert(CmisPropertyDefinitionType propertyDefinition) {

        if (propertyDefinition == null) {

            return null;

        }

        AbstractPropertyDefinition<?> result = null;

        if (propertyDefinition instanceof CmisPropertyStringDefinitionType) {

            result = new PropertyStringDefinitionImpl();

            ((PropertyStringDefinitionImpl) result)

                    .setChoices(convertChoiceStringList(((CmisPropertyStringDefinitionType) propertyDefinition)

                            .getChoice()));

            CmisPropertyString prop = ((CmisPropertyStringDefinitionType) propertyDefinition).getDefaultValue();

            if (prop != null) {

                ((PropertyStringDefinitionImpl) result).setDefaultValue(prop.getValue());

            }

            // specific

            ((PropertyStringDefinitionImpl) result)

                    .setMaxLength(((CmisPropertyStringDefinitionType) propertyDefinition).getMaxLength());

        } else if (propertyDefinition instanceof CmisPropertyIdDefinitionType) {

            result = new PropertyIdDefinitionImpl();

            ((PropertyIdDefinitionImpl) result)

                    .setChoices(convertChoiceIdList(((CmisPropertyIdDefinitionType) propertyDefinition).getChoice()));

            CmisPropertyId prop = ((CmisPropertyIdDefinitionType) propertyDefinition).getDefaultValue();

            if (prop != null) {

                ((PropertyIdDefinitionImpl) result).setDefaultValue(prop.getValue());

            }

        } else if (propertyDefinition instanceof CmisPropertyIntegerDefinitionType) {

            result = new PropertyIntegerDefinitionImpl();

            ((PropertyIntegerDefinitionImpl) result)

                    .setChoices(convertChoiceIntegerList(((CmisPropertyIntegerDefinitionType) propertyDefinition)

                            .getChoice()));

            CmisPropertyInteger prop = ((CmisPropertyIntegerDefinitionType) propertyDefinition).getDefaultValue();

            if (prop != null) {

                ((PropertyIntegerDefinitionImpl) result).setDefaultValue(prop.getValue());

            }

            // specific

            ((PropertyIntegerDefinitionImpl) result)

                    .setMinValue(((CmisPropertyIntegerDefinitionType) propertyDefinition).getMinValue());

            ((PropertyIntegerDefinitionImpl) result)

                    .setMaxValue(((CmisPropertyIntegerDefinitionType) propertyDefinition).getMaxValue());

        } else if (propertyDefinition instanceof CmisPropertyDecimalDefinitionType) {

            result = new PropertyDecimalDefinitionImpl();

            ((PropertyDecimalDefinitionImpl) result)

                    .setChoices(convertChoiceDecimalList(((CmisPropertyDecimalDefinitionType) propertyDefinition)

                            .getChoice()));

            CmisPropertyDecimal prop = ((CmisPropertyDecimalDefinitionType) propertyDefinition).getDefaultValue();

            if (prop != null) {

                ((PropertyDecimalDefinitionImpl) result).setDefaultValue(prop.getValue());

            }

            // specific

            ((PropertyDecimalDefinitionImpl) result)

                    .setMinValue(((CmisPropertyDecimalDefinitionType) propertyDefinition).getMinValue());

            ((PropertyDecimalDefinitionImpl) result)

                    .setMaxValue(((CmisPropertyDecimalDefinitionType) propertyDefinition).getMaxValue());

        } else if (propertyDefinition instanceof CmisPropertyBooleanDefinitionType) {

            result = new PropertyBooleanDefinitionImpl();

            ((PropertyBooleanDefinitionImpl) result)

                    .setChoices(convertChoiceBooleanList(((CmisPropertyBooleanDefinitionType) propertyDefinition)

                            .getChoice()));

            CmisPropertyBoolean prop = ((CmisPropertyBooleanDefinitionType) propertyDefinition).getDefaultValue();

            if (prop != null) {

                ((PropertyBooleanDefinitionImpl) result).setDefaultValue(prop.getValue());

            }

        } else if (propertyDefinition instanceof CmisPropertyDateTimeDefinitionType) {

            result = new PropertyDateTimeDefinitionImpl();

            ((PropertyDateTimeDefinitionImpl) result)

                    .setChoices(convertChoiceDateTimeList(((CmisPropertyDateTimeDefinitionType) propertyDefinition)

                            .getChoice()));

            CmisPropertyDateTime prop = ((CmisPropertyDateTimeDefinitionType) propertyDefinition).getDefaultValue();

            if (prop != null) {

                ((PropertyDateTimeDefinitionImpl) result).setDefaultValue(convertXMLCalendar(prop.getValue()));

            }

            // specific

            ((PropertyDateTimeDefinitionImpl) result).setDateTimeResolution(convert(DateTimeResolution.class,