Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * JBoss, Home of Professional Open Source
   * Copyright 2012, Red Hat, Inc., and individual contributors
   * by the @authors tag. See the copyright.txt in the distribution for a
   * full listing of individual contributors.
   *
   * Licensed 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.jboss.weld.context;
 
 
 
 
 import  edu.umd.cs.findbugs.annotations.SuppressWarnings;

Produces wrappers for Contextuals which are serializable.

Author(s):
Jozef Hartinger
Martin Kouba
 
 
     private SerializableContextualFactory() {
     }
 
     @java.lang.SuppressWarnings({ "rawtypes""unchecked" })
     public static <C extends Contextual<I>, I> SerializableContextual<C, I> create(String contextId, C contextualContextualStore contextualStore,
             BeanIdentifierIndex beanIdentifierIndex) {
         if (contextual instanceof Bean) {
             if (contextual instanceof PassivationCapable) {
                 return new PassivationCapableSerializableBean(contextId, Reflections.<Beancast(contextual), contextualStorebeanIdentifierIndex);
             } else {
                 return new DefaultSerializableBean(contextId, Reflections.<Beancast(contextual), contextualStorebeanIdentifierIndex);
             }
         } else {
             if (contextual instanceof PassivationCapable) {
                 return new PassivationCapableSerializableContextual(contextIdcontextualcontextualStorebeanIdentifierIndex);
             } else {
                 return new DefaultSerializableContextual<C, I>(contextIdcontextualcontextualStorebeanIdentifierIndex);
             }
         }
     }
 
     private static final class SerializableContextualHolder<C extends Contextual<I>, I> implements Serializable {
 
         private static final long serialVersionUID = 46941665668478370L;
 
         @SuppressWarnings(value = "SE_TRANSIENT_FIELD_NOT_RESTORED", justification = "A cache which is lazily loaded")
         // A cached, transient version of the contextual
         private transient C cached;
 
         // Only one of the three fields is used at the same time - directly serializable contextual, bean identifier or index
         private final C serializable;
         private final BeanIdentifier identifier;
         private final Integer identifierIndex;
 
         private final String contextId;
 
         private transient ContextualStore cachedContextualStore;
 
         private transient BeanIdentifierIndex beanIdentifierIndex;
 
         SerializableContextualHolder(String contextId, C contextualContextualStore contextualStoreBeanIdentifierIndex beanIdentifierIndex) {
             this. = contextId;
             this. = contextualStore;
             if (contextual instanceof Serializable) {
                 // the contextual is serializable, so we can just use it
                 this. = contextual;
                 this. = null;
                 this. = null;
             } else {
                 this. = null;
                 BeanIdentifier beanIdentifier = getId(contextualcontextualStore);
                 // The index may not be built yet
                 Integer idx = beanIdentifierIndex.isBuilt() ? beanIdentifierIndex.getIndex(beanIdentifier) : null;
                 if (idx != null) {
                     this. = idx;
                     this. = null;
                } else {
                    this. = null;
                    this. = beanIdentifier;
                }
            }
            // cache the contextual
            this. = contextual;
        }
        protected BeanIdentifier getId(C contextualContextualStore contextualStore) {
            return contextualStore.putIfAbsent(contextual);
        }
        protected ContextualStore getContextualStore() {
            if ( == null) {
                this. = Container.instance().services().get(ContextualStore.class);
            }
            return this.;
        }
        protected BeanIdentifierIndex getBeanIdentifierIndex() {
            if ( == null) {
                 = Container.instance().services().get(BeanIdentifierIndex.class);
            }
            return ;
        }
        protected C get() {
            if ( == null) {
                loadContextual();
            }
            return ;
        }
        private void loadContextual() {
            if ( != null) {
                 = ;
            } else if ( != null) {
            } else if ( != null) {
                 = getContextualStore().<C, I> getContextual();
            }
            if ( == null) {
                throw new IllegalStateException("Error restoring serialized contextual with id " + );
            }
        }
    }
    private abstract static class AbstractSerializableBean<B extends Bean<I>, I> extends ForwardingBean<I> implements SerializableContextual<B, I>, WrappedContextual<I> {
        private static final long serialVersionUID = 7594992948498685840L;
        private final SerializableContextualHolder<B, I> holder;
        AbstractSerializableBean(String contextId, B beanContextualStore contextualStoreBeanIdentifierIndex beanIdentifierIndex) {
            this. = new SerializableContextualHolder<B, I>(contextIdbeancontextualStorebeanIdentifierIndex);
        }
        @Override
        public B get() {
            return .get();
        }
        @Override
        public Bean<I> delegate() {
            return get();
        }
        @Override
        public boolean equals(Object obj) {
            // if the arriving object is also a AbstractSerializableBean, then unwrap it
            if (obj instanceof AbstractSerializableBean<?, ?>) {
                return delegate().equals(((AbstractSerializableBean<?, ?>) obj).get());
            } else {
                return delegate().equals(obj);
            }
        }
        @Override
        public int hashCode() {
            return delegate().hashCode();
        }
    }
    private abstract static class AbstractSerializableContextual<C extends Contextual<I>, I> extends ForwardingContextual<I> implements
            SerializableContextual<C, I>, WrappedContextual<I> {
        private static final long serialVersionUID = 107855630671709443L;
        private final SerializableContextualHolder<C, I> holder;
        AbstractSerializableContextual(String contextId, C contextualContextualStore contextualStoreBeanIdentifierIndex beanIdentifierIndex) {
            this. = new SerializableContextualHolder<C, I>(contextIdcontextualcontextualStorebeanIdentifierIndex);
        }
        @Override
        public Contextual<I> delegate() {
            return get();
        }
        public C get() {
            return .get();
        }
        @Override
        public boolean equals(Object obj) {
            // if the arriving object is also a AbstractSerializableContextual, then unwrap it
            if (obj instanceof AbstractSerializableContextual<?, ?>) {
                return delegate().equals(((AbstractSerializableContextual<?, ?>) obj).get());
            } else {
                return delegate().equals(obj);
            }
        }
        @Override
        public int hashCode() {
            return delegate().hashCode();
        }
    }
    // for Contextuals that are not PassivationCapable - bean id is generated (may not be portable between container instances)
    private static class DefaultSerializableContextual<C extends Contextual<I>, I> extends AbstractSerializableContextual<C, I> {
        private static final long serialVersionUID = -5102624795925717767L;
        public DefaultSerializableContextual(String contextId, C contextualContextualStore contextualStoreBeanIdentifierIndex beanIdentifierIndex) {
            super(contextIdcontextualcontextualStorebeanIdentifierIndex);
        }
    }
    // every Contextual with passivating scope should implement PassivationCapable
    private static class PassivationCapableSerializableContextual<C extends Contextual<I> & PassivationCapable, I> extends AbstractSerializableContextual<C, I>
            implements PassivationCapable {
        private static final long serialVersionUID = -2753893863961869301L;
        public PassivationCapableSerializableContextual(String contextId, C contextualContextualStore contextualStoreBeanIdentifierIndex beanIdentifierIndex) {
            super(contextIdcontextualcontextualStorebeanIdentifierIndex);
        }
        @Override
        public String getId() {
            return get().getId();
        }
    }
    private static class DefaultSerializableBean<B extends Bean<I>, I> extends AbstractSerializableBean<B, I> {
        private static final long serialVersionUID = -8901252027789701049L;
        public DefaultSerializableBean(String contextId, B beanContextualStore contextualStoreBeanIdentifierIndex beanIdentifierIndex) {
            super(contextIdbeancontextualStorebeanIdentifierIndex);
        }
    }
    private static class PassivationCapableSerializableBean<B extends Bean<I> & PassivationCapable, I> extends AbstractSerializableBean<B, I> implements
            PassivationCapable {
        private static final long serialVersionUID = 7458443513156329183L;
        public PassivationCapableSerializableBean(String contextId, B beanContextualStore contextualStoreBeanIdentifierIndex beanIdentifierIndex) {
            super(contextIdbeancontextualStorebeanIdentifierIndex);
        }
        @Override
        public String getId() {
            return get().getId();
        }
    }
New to GrepCode? Check out our FAQ X