201305.mbox/raw/%3c20130527172859.0F7802388C28@eris.apache.org%3e

+
+    /*
+     * 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.
+     */
+    package org.apache.chemistry.opencmis.client.runtime;
+
+    import java.io.Serializable;
+    import java.util.Collections;
+    import java.util.Set;
+    import java.util.TreeSet;
+
+    import org.apache.chemistry.opencmis.client.api.OperationContext;
+    import org.apache.chemistry.opencmis.commons.PropertyIds;
+    import org.apache.chemistry.opencmis.commons.enums.IncludeRelationships;
+
+    /**
+     * {@link OperationContext} implementation.
+     */
+    public class OperationContextImpl implements OperationContext, Serializable {
+
+        public static final String PROPERTIES_STAR = "*";
+        public static final String RENDITION_NONE = "cmis:none";
+
+        private static final long serialVersionUID = 1L;
+
+        private TreeSet<String> filter;
+        private boolean loadSecondaryTypeProperties;
+        private boolean includeAcls;
+        private boolean includeAllowableActions;
+        private boolean includePolicies;
+        private IncludeRelationships includeRelationships;
+        private TreeSet<String> renditionFilter;
+        private boolean includePathSegments;
+        private String orderBy;
+        private boolean cacheEnabled;
+        private String cacheKey;
+        private int maxItemsPerPage;
+
+        /**
+         * Default constructor.
+         */
+        public OperationContextImpl() {
+            setFilter(null);
+            setLoadSecondaryTypeProperties(false);
+            setIncludeAcls(false);
+            setIncludeAllowableActions(true);
+            setIncludePolicies(false);
+            setIncludeRelationships(IncludeRelationships.NONE);
+            setRenditionFilter(null);
+            setIncludePathSegments(true);
+            setOrderBy(null);
+            setCacheEnabled(false);
+            generateCacheKey();
+
+            setMaxItemsPerPage(100); // default
+        }
+
+        /**
+         * Copy constructor.
+         */
+        public OperationContextImpl(OperationContext source) {
+            setFilter(source.getFilter());
+            setLoadSecondaryTypeProperties(source.loadSecondaryTypeProperties());
+            setIncludeAcls(source.isIncludeAcls());
+            setIncludeAllowableActions(source.isIncludeAllowableActions());
+            setIncludePolicies(source.isIncludePolicies());
+            setIncludeRelationships(source.getIncludeRelationships());
+            setRenditionFilter(source.getRenditionFilter());
+            setIncludePathSegments(source.isIncludePathSegments());
+            setOrderBy(source.getOrderBy());
+            setCacheEnabled(source.isCacheEnabled());
+            generateCacheKey();
+
+            setMaxItemsPerPage(source.getMaxItemsPerPage());
+        }
+
+        /**
+         * Constructor with parameters.
+         */
+        public OperationContextImpl(Set<String> propertyFilter, boolean includeAcls, boolean includeAllowableActions,
+                boolean includePolicies, IncludeRelationships includeRelationships, Set<String> renditionFilter,
+                boolean includePathSegments, String orderBy, boolean cacheEnabled, int maxItemsPerPage) {
+            setFilter(propertyFilter);
+            setIncludeAcls(includeAcls);
+            setIncludeAllowableActions(includeAllowableActions);
+            setIncludePolicies(includePolicies);
+            setIncludeRelationships(includeRelationships);
+            setRenditionFilter(renditionFilter);
+            setIncludePathSegments(includePathSegments);
+            setOrderBy(orderBy);
+            setCacheEnabled(cacheEnabled);
+            generateCacheKey();
+
+            setMaxItemsPerPage(maxItemsPerPage);
+        }
+
+        public Set<String> getFilter() {
+            if (this.filter == null) {
+                return null;
+            }
+
+            return Collections.unmodifiableSet(this.filter);
+        }
+
+        public void setFilter(Set<String> propertyFilter) {
+            if (propertyFilter != null) {
+                TreeSet<String> tempSet = new TreeSet<String>();
+
+                for (String oid : propertyFilter) {
+                    if (oid == null) {
+                        continue;
+                    }
+
+                    String toid = oid.trim();
+                    if (toid.length() == 0) {
+                        continue;
+                    }
+                    if (toid.equals(PROPERTIES_STAR)) {
+                        tempSet = new TreeSet<String>();
+                        tempSet.add(PROPERTIES_STAR);
+                        break;
+                    }
+                    if (toid.indexOf(',') > -1) {
+                        throw new IllegalArgumentException("Query id must not contain a comma!");
+                    }
+
+                    tempSet.add(toid);
+                }
+
+                if (tempSet.size() == 0) {
+                    this.filter = null;
+                } else {
+                    this.filter = tempSet;
+                }
+            } else {
+                this.filter = null;
+            }
+
+            generateCacheKey();
+        }
+
+        public void setFilterString(String propertyFilter) {
+            if ((propertyFilter == null) || (propertyFilter.trim().length() == 0)) {
+                setFilter(null);
+                return;
+            }
+
+            String[] propertyIds = propertyFilter.split(",");
+            TreeSet<String> tempSet = new TreeSet<String>();
+            for (String pid : propertyIds) {
+                tempSet.add(pid);
+            }
+
+            setFilter(tempSet);
+        }
+
+        public String getFilterString() {
+            if (this.filter == null) {
+                return null;
+            }
+
+            if (this.filter.contains(PROPERTIES_STAR)) {
+                return PROPERTIES_STAR;
+            }
+
+            this.filter.add(PropertyIds.OBJECT_ID);
+            this.filter.add(PropertyIds.BASE_TYPE_ID);
+            this.filter.add(PropertyIds.OBJECT_TYPE_ID);
+            if (loadSecondaryTypeProperties) {
+                this.filter.add(PropertyIds.SECONDARY_OBJECT_TYPE_IDS);
+            }
+
+            StringBuilder sb = new StringBuilder();
+
+            for (String oid : this.filter) {
+                if (sb.length() > 0) {
+                    sb.append(",");
+                }
+
+                sb.append(oid);
+            }
+
+            return sb.toString();
+        }
+
+        public void setLoadSecondaryTypeProperties(boolean load) {
+            this.loadSecondaryTypeProperties = load;
+        }
+
+        public boolean loadSecondaryTypeProperties() {
+            return loadSecondaryTypeProperties;
+        }
+
+        public boolean isIncludeAcls() {
+            return includeAcls;
+        }
+
+        public void setIncludeAcls(boolean include) {
+            this.includeAcls = include;
+            generateCacheKey();
+        }
+
+        public boolean isIncludeAllowableActions() {
+            return this.includeAllowableActions;
+        }
+
+        public void setIncludeAllowableActions(boolean include) {
+            this.includeAllowableActions = include;
+            generateCacheKey();
+        }
+
+        public boolean isIncludePolicies() {
+            return this.includePolicies;
+        }
+
+        public void setIncludePolicies(boolean include) {
+            this.includePolicies = include;
+            generateCacheKey();
+        }
+
+        public IncludeRelationships getIncludeRelationships() {
+            return this.includeRelationships;
+        }
+
+        public void setIncludeRelationships(IncludeRelationships include) {
+            this.includeRelationships = include;
+            generateCacheKey();
+        }
+
+        public Set<String> getRenditionFilter() {
+            if (this.renditionFilter == null) {
+                return null;
+            }
+
+            return Collections.unmodifiableSet(this.renditionFilter);
+        }
+
+        public void setRenditionFilter(Set<String> renditionFilter) {
+            TreeSet<String> tempSet = new TreeSet<String>();
+
+            if (renditionFilter != null) {
+                for (String rf : renditionFilter) {
+                    if (rf == null) {
+                        continue;
+                    }
+
+                    String trf = rf.trim();
+                    if (trf.length() == 0) {
+                        continue;
+                    }
+                    if (trf.indexOf(',') > -1) {
+                        throw new IllegalArgumentException("Rendition must not contain a comma!");
+                    }
+
+                    tempSet.add(trf);
+                }
+
+                if (tempSet.size() == 0) {
+                    tempSet.add(RENDITION_NONE);
+                }
+            } else {
+                tempSet.add(RENDITION_NONE);
+            }
+
+            this.renditionFilter = tempSet;
+            generateCacheKey();
+        }
+
+        public void setRenditionFilterString(String renditionFilter) {
+            if ((renditionFilter == null) || (renditionFilter.trim().length() == 0)) {
+                setRenditionFilter(null);
+                return;
+            }
+
+            String[] renditions = renditionFilter.split(",");
+            TreeSet<String> tempSet = new TreeSet<String>();
+            for (String rend : renditions) {
+                tempSet.add(rend);
+            }
+
+            setRenditionFilter(tempSet);
+        }
+
+        public String getRenditionFilterString() {
+            if (this.renditionFilter == null) {
+                return null;
+            }
+
+            StringBuilder sb = new StringBuilder();
+
+            for (String rf : this.renditionFilter) {
+                if (sb.length() > 0) {
+                    sb.append(",");
+                }
+
+                sb.append(rf);
+            }
+
+            return sb.toString();
+        }
+
+        public boolean isIncludePathSegments() {
+            return includePathSegments;
+        }
+
+        public void setIncludePathSegments(boolean include) {
+            this.includePathSegments = include;
+        }
+
+        public String getOrderBy() {
+            return this.orderBy;
+        }
+
+        public void setOrderBy(String orderBy) {
+            this.orderBy = orderBy;
+        }
+
+        public boolean isCacheEnabled() {
+            return cacheEnabled;
+        }
+
+        public void setCacheEnabled(boolean cacheEnabled) {
+            this.cacheEnabled = cacheEnabled;
+        }
+
+        public String getCacheKey() {
+            return cacheKey;
+        }
+
+        /**
+         * Generates a new cache key from all parameters that are relevant for
+         * caching.
+         */
+        protected void generateCacheKey() {
+            if (!cacheEnabled) {
+                cacheKey = null;
+            }
+
+            StringBuilder sb = new StringBuilder();
+
+            sb.append(includeAcls ? "1" : "0");
+            sb.append(includeAllowableActions ? "1" : "0");
+            sb.append(includePolicies ? "1" : "0");
+            sb.append("|");
+            sb.append(filter == null ? "" : getFilterString());
+            sb.append("|");
+            sb.append(includeRelationships == null ? "" : includeRelationships.value());
+
+            sb.append("|");
+            sb.append(renditionFilter == null ? "" : getRenditionFilterString());
+
+            cacheKey = sb.toString();
+        }
+
+        public int getMaxItemsPerPage() {
+            return this.maxItemsPerPage;
+        }
+
+        public void setMaxItemsPerPage(int maxItemsPerPage) {
+            if (maxItemsPerPage < 1) {
+                throw new IllegalArgumentException("itemsPerPage must be > 0!");
+            }
+
+            this.maxItemsPerPage = maxItemsPerPage;
+        }
+    }
+