Datasets:

---

CM

/

codexglue_code2text_java

like 4

[ "public", "static", "void", "addLoadInstruction", "(", "CodeAttribute", "code", ",", "String", "type", ",", "int", "variable", ")", "{", "char", "tp", "=", "type", ".", "charAt", "(", "0", ")", ";", "if", "(", "tp", "!=", "'", "'", "&&", "tp", "!=", "'", "'", ")", "{", "// we have a primitive type", "switch", "(", "tp", ")", "{", "case", "'", "'", ":", "code", ".", "lload", "(", "variable", ")", ";", "break", ";", "case", "'", "'", ":", "code", ".", "dload", "(", "variable", ")", ";", "break", ";", "case", "'", "'", ":", "code", ".", "fload", "(", "variable", ")", ";", "break", ";", "default", ":", "code", ".", "iload", "(", "variable", ")", ";", "}", "}", "else", "{", "code", ".", "aload", "(", "variable", ")", ";", "}", "}" ]

[ "Adds", "the", "correct", "load", "instruction", "based", "on", "the", "type", "descriptor" ]

[ "public", "static", "void", "pushClassType", "(", "CodeAttribute", "b", ",", "String", "classType", ")", "{", "if", "(", "classType", ".", "length", "(", ")", "!=", "1", ")", "{", "if", "(", "classType", ".", "startsWith", "(", "\"L\"", ")", "&&", "classType", ".", "endsWith", "(", "\";\"", ")", ")", "{", "classType", "=", "classType", ".", "substring", "(", "1", ",", "classType", ".", "length", "(", ")", "-", "1", ")", ";", "}", "b", ".", "loadClass", "(", "classType", ")", ";", "}", "else", "{", "char", "type", "=", "classType", ".", "charAt", "(", "0", ")", ";", "switch", "(", "type", ")", "{", "case", "'", "'", ":", "b", ".", "getstatic", "(", "Integer", ".", "class", ".", "getName", "(", ")", ",", "TYPE", ",", "LJAVA_LANG_CLASS", ")", ";", "break", ";", "case", "'", "'", ":", "b", ".", "getstatic", "(", "Long", ".", "class", ".", "getName", "(", ")", ",", "TYPE", ",", "LJAVA_LANG_CLASS", ")", ";", "break", ";", "case", "'", "'", ":", "b", ".", "getstatic", "(", "Short", ".", "class", ".", "getName", "(", ")", ",", "TYPE", ",", "LJAVA_LANG_CLASS", ")", ";", "break", ";", "case", "'", "'", ":", "b", ".", "getstatic", "(", "Float", ".", "class", ".", "getName", "(", ")", ",", "TYPE", ",", "LJAVA_LANG_CLASS", ")", ";", "break", ";", "case", "'", "'", ":", "b", ".", "getstatic", "(", "Double", ".", "class", ".", "getName", "(", ")", ",", "TYPE", ",", "LJAVA_LANG_CLASS", ")", ";", "break", ";", "case", "'", "'", ":", "b", ".", "getstatic", "(", "Byte", ".", "class", ".", "getName", "(", ")", ",", "TYPE", ",", "LJAVA_LANG_CLASS", ")", ";", "break", ";", "case", "'", "'", ":", "b", ".", "getstatic", "(", "Character", ".", "class", ".", "getName", "(", ")", ",", "TYPE", ",", "LJAVA_LANG_CLASS", ")", ";", "break", ";", "case", "'", "'", ":", "b", ".", "getstatic", "(", "Boolean", ".", "class", ".", "getName", "(", ")", ",", "TYPE", ",", "LJAVA_LANG_CLASS", ")", ";", "break", ";", "default", ":", "throw", "new", "RuntimeException", "(", "\"Cannot handle primitive type: \"", "+", "type", ")", ";", "}", "}", "}" ]

[ "Pushes", "a", "class", "type", "onto", "the", "stack", "from", "the", "string", "representation", "This", "can", "also", "handle", "primitives" ]

[ "private", "void", "checkBindings", "(", "EnhancedAnnotation", "<", "T", ">", "annotatedAnnotation", ")", "{", "Set", "<", "Annotation", ">", "bindings", "=", "annotatedAnnotation", ".", "getMetaAnnotations", "(", "Qualifier", ".", "class", ")", ";", "if", "(", "bindings", ".", "size", "(", ")", ">", "0", ")", "{", "for", "(", "Annotation", "annotation", ":", "bindings", ")", "{", "if", "(", "!", "annotation", ".", "annotationType", "(", ")", ".", "equals", "(", "Named", ".", "class", ")", ")", "{", "throw", "MetadataLogger", ".", "LOG", ".", "qualifierOnStereotype", "(", "annotatedAnnotation", ")", ";", "}", "}", "}", "}" ]

[ "Validates", "the", "binding", "types" ]

[ "private", "void", "initBeanNameDefaulted", "(", "EnhancedAnnotation", "<", "T", ">", "annotatedAnnotation", ")", "{", "if", "(", "annotatedAnnotation", ".", "isAnnotationPresent", "(", "Named", ".", "class", ")", ")", "{", "if", "(", "!", "\"\"", ".", "equals", "(", "annotatedAnnotation", ".", "getAnnotation", "(", "Named", ".", "class", ")", ".", "value", "(", ")", ")", ")", "{", "throw", "MetadataLogger", ".", "LOG", ".", "valueOnNamedStereotype", "(", "annotatedAnnotation", ")", ";", "}", "beanNameDefaulted", "=", "true", ";", "}", "}" ]

[ "Initializes", "the", "bean", "name", "defaulted" ]

[ "private", "void", "initDefaultScopeType", "(", "EnhancedAnnotation", "<", "T", ">", "annotatedAnnotation", ")", "{", "Set", "<", "Annotation", ">", "scopeTypes", "=", "new", "HashSet", "<", "Annotation", ">", "(", ")", ";", "scopeTypes", ".", "addAll", "(", "annotatedAnnotation", ".", "getMetaAnnotations", "(", "Scope", ".", "class", ")", ")", ";", "scopeTypes", ".", "addAll", "(", "annotatedAnnotation", ".", "getMetaAnnotations", "(", "NormalScope", ".", "class", ")", ")", ";", "if", "(", "scopeTypes", ".", "size", "(", ")", ">", "1", ")", "{", "throw", "MetadataLogger", ".", "LOG", ".", "multipleScopes", "(", "annotatedAnnotation", ")", ";", "}", "else", "if", "(", "scopeTypes", ".", "size", "(", ")", "==", "1", ")", "{", "this", ".", "defaultScopeType", "=", "scopeTypes", ".", "iterator", "(", ")", ".", "next", "(", ")", ";", "}", "}" ]

[ "Initializes", "the", "default", "scope", "type" ]

[ "public", "static", "Type", "boxedType", "(", "Type", "type", ")", "{", "if", "(", "type", "instanceof", "Class", "<", "?", ">", ")", "{", "return", "boxedClass", "(", "(", "Class", "<", "?", ">", ")", "type", ")", ";", "}", "else", "{", "return", "type", ";", "}", "}" ]

[ "Gets", "the", "boxed", "type", "of", "a", "class" ]

[ "public", "static", "Type", "getCanonicalType", "(", "Class", "<", "?", ">", "clazz", ")", "{", "if", "(", "clazz", ".", "isArray", "(", ")", ")", "{", "Class", "<", "?", ">", "componentType", "=", "clazz", ".", "getComponentType", "(", ")", ";", "Type", "resolvedComponentType", "=", "getCanonicalType", "(", "componentType", ")", ";", "if", "(", "componentType", "!=", "resolvedComponentType", ")", "{", "// identity check intentional", "// a different identity means that we actually replaced the component Class with a ParameterizedType", "return", "new", "GenericArrayTypeImpl", "(", "resolvedComponentType", ")", ";", "}", "}", "if", "(", "clazz", ".", "getTypeParameters", "(", ")", ".", "length", ">", "0", ")", "{", "Type", "[", "]", "actualTypeParameters", "=", "clazz", ".", "getTypeParameters", "(", ")", ";", "return", "new", "ParameterizedTypeImpl", "(", "clazz", ",", "actualTypeParameters", ",", "clazz", ".", "getDeclaringClass", "(", ")", ")", ";", "}", "return", "clazz", ";", "}" ]

[ "Returns", "a", "canonical", "type", "for", "a", "given", "class", "." ]

[ "public", "static", "boolean", "isArray", "(", "Type", "type", ")", "{", "return", "(", "type", "instanceof", "GenericArrayType", ")", "||", "(", "type", "instanceof", "Class", "<", "?", ">", "&&", "(", "(", "Class", "<", "?", ">", ")", "type", ")", ".", "isArray", "(", ")", ")", ";", "}" ]

[ "Determines", "whether", "the", "given", "type", "is", "an", "array", "type", "." ]

[ "public", "static", "Type", "getArrayComponentType", "(", "Type", "type", ")", "{", "if", "(", "type", "instanceof", "GenericArrayType", ")", "{", "return", "GenericArrayType", ".", "class", ".", "cast", "(", "type", ")", ".", "getGenericComponentType", "(", ")", ";", "}", "if", "(", "type", "instanceof", "Class", "<", "?", ">", ")", "{", "Class", "<", "?", ">", "clazz", "=", "(", "Class", "<", "?", ">", ")", "type", ";", "if", "(", "clazz", ".", "isArray", "(", ")", ")", "{", "return", "clazz", ".", "getComponentType", "(", ")", ";", "}", "}", "throw", "new", "IllegalArgumentException", "(", "\"Not an array type \"", "+", "type", ")", ";", "}" ]

[ "Determines", "the", "component", "type", "for", "a", "given", "array", "type", "." ]

[ "public", "static", "boolean", "isArrayOfUnboundedTypeVariablesOrObjects", "(", "Type", "[", "]", "types", ")", "{", "for", "(", "Type", "type", ":", "types", ")", "{", "if", "(", "Object", ".", "class", ".", "equals", "(", "type", ")", ")", "{", "continue", ";", "}", "if", "(", "type", "instanceof", "TypeVariable", "<", "?", ">", ")", "{", "Type", "[", "]", "bounds", "=", "(", "(", "TypeVariable", "<", "?", ">", ")", "type", ")", ".", "getBounds", "(", ")", ";", "if", "(", "bounds", "==", "null", "||", "bounds", ".", "length", "==", "0", "||", "(", "bounds", ".", "length", "==", "1", "&&", "Object", ".", "class", ".", "equals", "(", "bounds", "[", "0", "]", ")", ")", ")", "{", "continue", ";", "}", "}", "return", "false", ";", "}", "return", "true", ";", "}" ]

[ "Determines", "whether", "the", "given", "array", "only", "contains", "unbounded", "type", "variables", "or", "Object", ".", "class", "." ]

[ "public", "<", "T", ">", "T", "get", "(", "Contextual", "<", "T", ">", "contextual", ",", "CreationalContext", "<", "T", ">", "creationalContext", ")", "{", "if", "(", "!", "isActive", "(", ")", ")", "{", "throw", "new", "ContextNotActiveException", "(", ")", ";", "}", "if", "(", "creationalContext", "!=", "null", ")", "{", "T", "instance", "=", "contextual", ".", "create", "(", "creationalContext", ")", ";", "if", "(", "creationalContext", "instanceof", "WeldCreationalContext", "<", "?", ">", ")", "{", "addDependentInstance", "(", "instance", ",", "contextual", ",", "(", "WeldCreationalContext", "<", "T", ">", ")", "creationalContext", ")", ";", "}", "return", "instance", ";", "}", "else", "{", "return", "null", ";", "}", "}" ]

[ "Overridden", "method", "always", "creating", "a", "new", "instance" ]

[ "public", "void", "createEnablement", "(", ")", "{", "GlobalEnablementBuilder", "builder", "=", "beanManager", ".", "getServices", "(", ")", ".", "get", "(", "GlobalEnablementBuilder", ".", "class", ")", ";", "ModuleEnablement", "enablement", "=", "builder", ".", "createModuleEnablement", "(", "this", ")", ";", "beanManager", ".", "setEnabled", "(", "enablement", ")", ";", "if", "(", "BootstrapLogger", ".", "LOG", ".", "isDebugEnabled", "(", ")", ")", "{", "BootstrapLogger", ".", "LOG", ".", "enabledAlternatives", "(", "this", ".", "beanManager", ",", "WeldCollections", ".", "toMultiRowString", "(", "enablement", ".", "getAllAlternatives", "(", ")", ")", ")", ";", "BootstrapLogger", ".", "LOG", ".", "enabledDecorators", "(", "this", ".", "beanManager", ",", "WeldCollections", ".", "toMultiRowString", "(", "enablement", ".", "getDecorators", "(", ")", ")", ")", ";", "BootstrapLogger", ".", "LOG", ".", "enabledInterceptors", "(", "this", ".", "beanManager", ",", "WeldCollections", ".", "toMultiRowString", "(", "enablement", ".", "getInterceptors", "(", ")", ")", ")", ";", "}", "}" ]

[ "Initializes", "module", "enablement", "." ]

[ "public", "static", "<", "T", ">", "DecoratorImpl", "<", "T", ">", "of", "(", "BeanAttributes", "<", "T", ">", "attributes", ",", "EnhancedAnnotatedType", "<", "T", ">", "clazz", ",", "BeanManagerImpl", "beanManager", ")", "{", "return", "new", "DecoratorImpl", "<", "T", ">", "(", "attributes", ",", "clazz", ",", "beanManager", ")", ";", "}" ]

[ "Creates", "a", "decorator", "bean" ]

[ "protected", "void", "merge", "(", "Set", "<", "Annotation", ">", "stereotypeAnnotations", ")", "{", "final", "MetaAnnotationStore", "store", "=", "manager", ".", "getServices", "(", ")", ".", "get", "(", "MetaAnnotationStore", ".", "class", ")", ";", "for", "(", "Annotation", "stereotypeAnnotation", ":", "stereotypeAnnotations", ")", "{", "// Retrieve and merge all metadata from stereotypes", "StereotypeModel", "<", "?", ">", "stereotype", "=", "store", ".", "getStereotype", "(", "stereotypeAnnotation", ".", "annotationType", "(", ")", ")", ";", "if", "(", "stereotype", "==", "null", ")", "{", "throw", "MetadataLogger", ".", "LOG", ".", "stereotypeNotRegistered", "(", "stereotypeAnnotation", ")", ";", "}", "if", "(", "stereotype", ".", "isAlternative", "(", ")", ")", "{", "alternative", "=", "true", ";", "}", "if", "(", "stereotype", ".", "getDefaultScopeType", "(", ")", "!=", "null", ")", "{", "possibleScopeTypes", ".", "add", "(", "stereotype", ".", "getDefaultScopeType", "(", ")", ")", ";", "}", "if", "(", "stereotype", ".", "isBeanNameDefaulted", "(", ")", ")", "{", "beanNameDefaulted", "=", "true", ";", "}", "this", ".", "stereotypes", ".", "add", "(", "stereotypeAnnotation", ".", "annotationType", "(", ")", ")", ";", "// Merge in inherited stereotypes", "merge", "(", "stereotype", ".", "getInheritedStereotypes", "(", ")", ")", ";", "}", "}" ]

[ "Perform", "the", "merge" ]

[ "@", "Override", "public", "void", "run", "(", ")", "{", "try", "{", "threadContext", ".", "activate", "(", ")", ";", "// run the original thread", "runnable", ".", "run", "(", ")", ";", "}", "finally", "{", "threadContext", ".", "invalidate", "(", ")", ";", "threadContext", ".", "deactivate", "(", ")", ";", "}", "}" ]

[ "Set", "up", "the", "ThreadContext", "and", "delegate", "." ]

[ "protected", "AbstractBeanDeployer", "<", "E", ">", "deploySpecialized", "(", ")", "{", "// ensure that all decorators are initialized before initializing", "// the rest of the beans", "for", "(", "DecoratorImpl", "<", "?", ">", "bean", ":", "getEnvironment", "(", ")", ".", "getDecorators", "(", ")", ")", "{", "bean", ".", "initialize", "(", "getEnvironment", "(", ")", ")", ";", "containerLifecycleEvents", ".", "fireProcessBean", "(", "getManager", "(", ")", ",", "bean", ")", ";", "manager", ".", "addDecorator", "(", "bean", ")", ";", "BootstrapLogger", ".", "LOG", ".", "foundDecorator", "(", "bean", ")", ";", "}", "for", "(", "InterceptorImpl", "<", "?", ">", "bean", ":", "getEnvironment", "(", ")", ".", "getInterceptors", "(", ")", ")", "{", "bean", ".", "initialize", "(", "getEnvironment", "(", ")", ")", ";", "containerLifecycleEvents", ".", "fireProcessBean", "(", "getManager", "(", ")", ",", "bean", ")", ";", "manager", ".", "addInterceptor", "(", "bean", ")", ";", "BootstrapLogger", ".", "LOG", ".", "foundInterceptor", "(", "bean", ")", ";", "}", "return", "this", ";", "}" ]

[ "interceptors", "decorators", "and", "observers", "go", "first" ]

[ "public", "static", "void", "validateObserverMethod", "(", "ObserverMethod", "<", "?", ">", "observerMethod", ",", "BeanManager", "beanManager", ",", "ObserverMethod", "<", "?", ">", "originalObserverMethod", ")", "{", "Set", "<", "Annotation", ">", "qualifiers", "=", "observerMethod", ".", "getObservedQualifiers", "(", ")", ";", "if", "(", "observerMethod", ".", "getBeanClass", "(", ")", "==", "null", ")", "{", "throw", "EventLogger", ".", "LOG", ".", "observerMethodsMethodReturnsNull", "(", "\"getBeanClass\"", ",", "observerMethod", ")", ";", "}", "if", "(", "observerMethod", ".", "getObservedType", "(", ")", "==", "null", ")", "{", "throw", "EventLogger", ".", "LOG", ".", "observerMethodsMethodReturnsNull", "(", "\"getObservedType\"", ",", "observerMethod", ")", ";", "}", "Bindings", ".", "validateQualifiers", "(", "qualifiers", ",", "beanManager", ",", "observerMethod", ",", "\"ObserverMethod.getObservedQualifiers\"", ")", ";", "if", "(", "observerMethod", ".", "getReception", "(", ")", "==", "null", ")", "{", "throw", "EventLogger", ".", "LOG", ".", "observerMethodsMethodReturnsNull", "(", "\"getReception\"", ",", "observerMethod", ")", ";", "}", "if", "(", "observerMethod", ".", "getTransactionPhase", "(", ")", "==", "null", ")", "{", "throw", "EventLogger", ".", "LOG", ".", "observerMethodsMethodReturnsNull", "(", "\"getTransactionPhase\"", ",", "observerMethod", ")", ";", "}", "if", "(", "originalObserverMethod", "!=", "null", "&&", "(", "!", "observerMethod", ".", "getBeanClass", "(", ")", ".", "equals", "(", "originalObserverMethod", ".", "getBeanClass", "(", ")", ")", ")", ")", "{", "throw", "EventLogger", ".", "LOG", ".", "beanClassMismatch", "(", "originalObserverMethod", ",", "observerMethod", ")", ";", "}", "if", "(", "!", "(", "observerMethod", "instanceof", "SyntheticObserverMethod", ")", "&&", "!", "hasNotifyOverriden", "(", "observerMethod", ".", "getClass", "(", ")", ",", "observerMethod", ")", ")", "{", "throw", "EventLogger", ".", "LOG", ".", "notifyMethodNotImplemented", "(", "observerMethod", ")", ";", "}", "}" ]

[ "Validates", "given", "external", "observer", "method", "." ]

[ "private", "static", "boolean", "isAssignableFrom", "(", "WildcardType", "type1", ",", "Type", "type2", ")", "{", "if", "(", "!", "isAssignableFrom", "(", "type1", ".", "getUpperBounds", "(", ")", "[", "0", "]", ",", "type2", ")", ")", "{", "return", "false", ";", "}", "if", "(", "type1", ".", "getLowerBounds", "(", ")", ".", "length", ">", "0", "&&", "!", "isAssignableFrom", "(", "type2", ",", "type1", ".", "getLowerBounds", "(", ")", "[", "0", "]", ")", ")", "{", "return", "false", ";", "}", "return", "true", ";", "}" ]

[ "This", "logic", "is", "shared", "for", "all", "actual", "types", "i", ".", "e", ".", "raw", "types", "parameterized", "types", "and", "generic", "array", "types", "." ]

[ "public", "static", "CombinedInterceptorAndDecoratorStackMethodHandler", "peekIfNotEmpty", "(", ")", "{", "Stack", "stack", "=", "interceptionContexts", ".", "get", "(", ")", ";", "if", "(", "stack", "==", "null", ")", "{", "return", "null", ";", "}", "return", "stack", ".", "peek", "(", ")", ";", "}" ]

[ "Peeks", "the", "current", "top", "of", "the", "stack", "or", "returns", "null", "if", "the", "stack", "is", "empty" ]

[ "public", "static", "Stack", "getStack", "(", ")", "{", "Stack", "stack", "=", "interceptionContexts", ".", "get", "(", ")", ";", "if", "(", "stack", "==", "null", ")", "{", "stack", "=", "new", "Stack", "(", "interceptionContexts", ")", ";", "interceptionContexts", ".", "set", "(", "stack", ")", ";", "}", "return", "stack", ";", "}" ]

[ "Gets", "the", "current", "Stack", ".", "If", "the", "stack", "is", "not", "set", "a", "new", "empty", "instance", "is", "created", "and", "set", "." ]

[ "public", "static", "boolean", "isTypesProxyable", "(", "Iterable", "<", "?", "extends", "Type", ">", "types", ",", "ServiceRegistry", "services", ")", "{", "return", "getUnproxyableTypesException", "(", "types", ",", "services", ")", "==", "null", ";", "}" ]

[ "Indicates", "if", "a", "set", "of", "types", "are", "all", "proxyable" ]

[ "public", "static", "<", "T", ">", "boolean", "addAll", "(", "Collection", "<", "T", ">", "target", ",", "Iterator", "<", "?", "extends", "T", ">", "iterator", ")", "{", "Preconditions", ".", "checkArgumentNotNull", "(", "target", ",", "\"target\"", ")", ";", "boolean", "modified", "=", "false", ";", "while", "(", "iterator", ".", "hasNext", "(", ")", ")", "{", "modified", "|=", "target", ".", "add", "(", "iterator", ".", "next", "(", ")", ")", ";", "}", "return", "modified", ";", "}" ]

[ "Add", "all", "elements", "in", "the", "iterator", "to", "the", "collection", "." ]

[ "public", "static", "<", "T", ">", "Iterator", "<", "T", ">", "concat", "(", "Iterator", "<", "?", "extends", "Iterator", "<", "?", "extends", "T", ">", ">", "iterators", ")", "{", "Preconditions", ".", "checkArgumentNotNull", "(", "iterators", ",", "\"iterators\"", ")", ";", "return", "new", "CombinedIterator", "<", "T", ">", "(", "iterators", ")", ";", "}" ]

[ "Combine", "the", "iterators", "into", "a", "single", "one", "." ]

[ "HtmlTag", "attr", "(", "String", "name", ",", "String", "value", ")", "{", "if", "(", "attrs", "==", "null", ")", "{", "attrs", "=", "new", "HashMap", "<>", "(", ")", ";", "}", "attrs", ".", "put", "(", "name", ",", "value", ")", ";", "return", "this", ";", "}" ]

[ "Attribute", "name", "and", "value", "are", "not", "escaped", "or", "modified", "in", "any", "way", "." ]

[ "public", "void", "clearAnnotationData", "(", "Class", "<", "?", "extends", "Annotation", ">", "annotationClass", ")", "{", "stereotypes", ".", "invalidate", "(", "annotationClass", ")", ";", "scopes", ".", "invalidate", "(", "annotationClass", ")", ";", "qualifiers", ".", "invalidate", "(", "annotationClass", ")", ";", "interceptorBindings", ".", "invalidate", "(", "annotationClass", ")", ";", "}" ]

[ "removes", "all", "data", "for", "an", "annotation", "class", ".", "This", "should", "be", "called", "after", "an", "annotation", "has", "been", "modified", "through", "the", "SPI" ]

[ "public", "static", "<", "K", ",", "V", ">", "Map", "<", "K", ",", "V", ">", "immutableMapView", "(", "Map", "<", "K", ",", "V", ">", "map", ")", "{", "if", "(", "map", "instanceof", "ImmutableMap", "<", "?", ",", "?", ">", ")", "{", "return", "map", ";", "}", "return", "Collections", ".", "unmodifiableMap", "(", "map", ")", ";", "}" ]

[ "Returns", "an", "immutable", "view", "of", "a", "given", "map", "." ]

[ "protected", "void", "checkProducerMethod", "(", "EnhancedAnnotatedMethod", "<", "T", ",", "?", "super", "X", ">", "method", ")", "{", "if", "(", "method", ".", "getEnhancedParameters", "(", "Observes", ".", "class", ")", ".", "size", "(", ")", ">", "0", ")", "{", "throw", "BeanLogger", ".", "LOG", ".", "inconsistentAnnotationsOnMethod", "(", "PRODUCER_ANNOTATION", ",", "\"@Observes\"", ",", "this", ".", "method", ",", "Formats", ".", "formatAsStackTraceElement", "(", "method", ".", "getJavaMember", "(", ")", ")", ")", ";", "}", "else", "if", "(", "method", ".", "getEnhancedParameters", "(", "ObservesAsync", ".", "class", ")", ".", "size", "(", ")", ">", "0", ")", "{", "throw", "BeanLogger", ".", "LOG", ".", "inconsistentAnnotationsOnMethod", "(", "PRODUCER_ANNOTATION", ",", "\"@ObservesAsync\"", ",", "this", ".", "method", ",", "Formats", ".", "formatAsStackTraceElement", "(", "method", ".", "getJavaMember", "(", ")", ")", ")", ";", "}", "else", "if", "(", "method", ".", "getEnhancedParameters", "(", "Disposes", ".", "class", ")", ".", "size", "(", ")", ">", "0", ")", "{", "throw", "BeanLogger", ".", "LOG", ".", "inconsistentAnnotationsOnMethod", "(", "PRODUCER_ANNOTATION", ",", "\"@Disposes\"", ",", "this", ".", "method", ",", "Formats", ".", "formatAsStackTraceElement", "(", "method", ".", "getJavaMember", "(", ")", ")", ")", ";", "}", "else", "if", "(", "getDeclaringBean", "(", ")", "instanceof", "SessionBean", "<", "?", ">", "&&", "!", "Modifier", ".", "isStatic", "(", "method", ".", "slim", "(", ")", ".", "getJavaMember", "(", ")", ".", "getModifiers", "(", ")", ")", ")", "{", "boolean", "methodDeclaredOnTypes", "=", "false", ";", "for", "(", "Type", "type", ":", "getDeclaringBean", "(", ")", ".", "getTypes", "(", ")", ")", "{", "Class", "<", "?", ">", "clazz", "=", "Reflections", ".", "getRawType", "(", "type", ")", ";", "try", "{", "AccessController", ".", "doPrivileged", "(", "new", "GetMethodAction", "(", "clazz", ",", "method", ".", "getName", "(", ")", ",", "method", ".", "getParameterTypesAsArray", "(", ")", ")", ")", ";", "methodDeclaredOnTypes", "=", "true", ";", "break", ";", "}", "catch", "(", "PrivilegedActionException", "ignored", ")", "{", "}", "}", "if", "(", "!", "methodDeclaredOnTypes", ")", "{", "throw", "BeanLogger", ".", "LOG", ".", "methodNotBusinessMethod", "(", "\"Producer\"", ",", "this", ",", "getDeclaringBean", "(", ")", ",", "Formats", ".", "formatAsStackTraceElement", "(", "method", ".", "getJavaMember", "(", ")", ")", ")", ";", "}", "}", "}" ]

[ "Validates", "the", "producer", "method" ]

[ "ProtectionDomain", "getProtectionDomainForProxy", "(", "ProtectionDomain", "domain", ")", "{", "if", "(", "domain", ".", "getCodeSource", "(", ")", "==", "null", ")", "{", "// no codesource to cache on", "return", "create", "(", "domain", ")", ";", "}", "ProtectionDomain", "proxyProtectionDomain", "=", "proxyProtectionDomains", ".", "get", "(", "domain", ".", "getCodeSource", "(", ")", ")", ";", "if", "(", "proxyProtectionDomain", "==", "null", ")", "{", "// as this is not atomic create() may be called multiple times for the same domain", "// we ignore that", "proxyProtectionDomain", "=", "create", "(", "domain", ")", ";", "ProtectionDomain", "existing", "=", "proxyProtectionDomains", ".", "putIfAbsent", "(", "domain", ".", "getCodeSource", "(", ")", ",", "proxyProtectionDomain", ")", ";", "if", "(", "existing", "!=", "null", ")", "{", "proxyProtectionDomain", "=", "existing", ";", "}", "}", "return", "proxyProtectionDomain", ";", "}" ]

[ "Gets", "an", "enhanced", "protection", "domain", "for", "a", "proxy", "based", "on", "the", "given", "protection", "domain", "." ]

[ "public", "static", "<", "A", "extends", "Annotation", ">", "EnhancedAnnotation", "<", "A", ">", "create", "(", "SlimAnnotatedType", "<", "A", ">", "annotatedType", ",", "ClassTransformer", "classTransformer", ")", "{", "Class", "<", "A", ">", "annotationType", "=", "annotatedType", ".", "getJavaClass", "(", ")", ";", "Map", "<", "Class", "<", "?", "extends", "Annotation", ">", ",", "Annotation", ">", "annotationMap", "=", "new", "HashMap", "<", "Class", "<", "?", "extends", "Annotation", ">", ",", "Annotation", ">", "(", ")", ";", "annotationMap", ".", "putAll", "(", "buildAnnotationMap", "(", "annotatedType", ".", "getAnnotations", "(", ")", ")", ")", ";", "annotationMap", ".", "putAll", "(", "buildAnnotationMap", "(", "classTransformer", ".", "getTypeStore", "(", ")", ".", "get", "(", "annotationType", ")", ")", ")", ";", "// Annotations and declared annotations are the same for annotation type", "return", "new", "EnhancedAnnotationImpl", "<", "A", ">", "(", "annotatedType", ",", "annotationMap", ",", "annotationMap", ",", "classTransformer", ")", ";", "}" ]

[ "we", "can", "t", "call", "this", "method", "of", "cause", "it", "won", "t", "compile", "on", "JDK7" ]

[ "protected", "void", "init", "(", "EnhancedAnnotation", "<", "T", ">", "annotatedAnnotation", ")", "{", "initType", "(", "annotatedAnnotation", ")", ";", "initValid", "(", "annotatedAnnotation", ")", ";", "check", "(", "annotatedAnnotation", ")", ";", "}" ]

[ "Initializes", "the", "type", "and", "validates", "it" ]

[ "protected", "void", "initValid", "(", "EnhancedAnnotation", "<", "T", ">", "annotatedAnnotation", ")", "{", "this", ".", "valid", "=", "false", ";", "for", "(", "Class", "<", "?", "extends", "Annotation", ">", "annotationType", ":", "getMetaAnnotationTypes", "(", ")", ")", "{", "if", "(", "annotatedAnnotation", ".", "isAnnotationPresent", "(", "annotationType", ")", ")", "{", "this", ".", "valid", "=", "true", ";", "}", "}", "}" ]

[ "Validates", "the", "data", "for", "correct", "annotation" ]

[ "private", "void", "installFastProcessAnnotatedTypeResolver", "(", "ServiceRegistry", "services", ")", "{", "ClassFileServices", "classFileServices", "=", "services", ".", "get", "(", "ClassFileServices", ".", "class", ")", ";", "if", "(", "classFileServices", "!=", "null", ")", "{", "final", "GlobalObserverNotifierService", "observers", "=", "services", ".", "get", "(", "GlobalObserverNotifierService", ".", "class", ")", ";", "try", "{", "final", "FastProcessAnnotatedTypeResolver", "resolver", "=", "new", "FastProcessAnnotatedTypeResolver", "(", "observers", ".", "getAllObserverMethods", "(", ")", ")", ";", "services", ".", "add", "(", "FastProcessAnnotatedTypeResolver", ".", "class", ",", "resolver", ")", ";", "}", "catch", "(", "UnsupportedObserverMethodException", "e", ")", "{", "BootstrapLogger", ".", "LOG", ".", "notUsingFastResolver", "(", "e", ".", "getObserver", "(", ")", ")", ";", "return", ";", "}", "}", "}" ]

[ "needs", "to", "be", "resolved", "once", "extension", "beans", "are", "deployed" ]

[ "public", "String", "load", "(", ")", "{", "this", ".", "paginator", "=", "new", "Paginator", "(", ")", ";", "this", ".", "codes", "=", "null", ";", "// Perform a search", "this", ".", "codes", "=", "codeFragmentManager", ".", "searchCodeFragments", "(", "this", ".", "codeFragmentPrototype", ",", "this", ".", "page", ",", "this", ".", "paginator", ")", ";", "return", "\"history\"", ";", "}" ]

[ "Do", "the", "search", "called", "as", "a", "page", "action" ]

[ "public", "<", "T", ">", "InternalEjbDescriptor", "<", "T", ">", "get", "(", "String", "beanName", ")", "{", "return", "cast", "(", "ejbByName", ".", "get", "(", "beanName", ")", ")", ";", "}" ]

[ "Gets", "an", "iterator", "to", "the", "EJB", "descriptors", "for", "an", "EJB", "implementation", "class" ]

[ "private", "<", "T", ">", "void", "add", "(", "EjbDescriptor", "<", "T", ">", "ejbDescriptor", ")", "{", "InternalEjbDescriptor", "<", "T", ">", "internalEjbDescriptor", "=", "InternalEjbDescriptor", ".", "of", "(", "ejbDescriptor", ")", ";", "ejbByName", ".", "put", "(", "ejbDescriptor", ".", "getEjbName", "(", ")", ",", "internalEjbDescriptor", ")", ";", "ejbByClass", ".", "put", "(", "ejbDescriptor", ".", "getBeanClass", "(", ")", ",", "internalEjbDescriptor", ".", "getEjbName", "(", ")", ")", ";", "}" ]

[ "Adds", "an", "EJB", "descriptor", "to", "the", "maps" ]

[ "private", "void", "fireEventForNonWebModules", "(", "Type", "eventType", ",", "Object", "event", ",", "Annotation", "...", "qualifiers", ")", "{", "try", "{", "BeanDeploymentModules", "modules", "=", "deploymentManager", ".", "getServices", "(", ")", ".", "get", "(", "BeanDeploymentModules", ".", "class", ")", ";", "if", "(", "modules", "!=", "null", ")", "{", "// fire event for non-web modules", "// web modules are handled by HttpContextLifecycle", "for", "(", "BeanDeploymentModule", "module", ":", "modules", ")", "{", "if", "(", "!", "module", ".", "isWebModule", "(", ")", ")", "{", "module", ".", "fireEvent", "(", "eventType", ",", "event", ",", "qualifiers", ")", ";", "}", "}", "}", "}", "catch", "(", "Exception", "ignored", ")", "{", "}", "}" ]

[ "Fires", "given", "event", "for", "non", "-", "web", "modules", ".", "Used", "for" ]

[ "public", "static", "void", "initialize", "(", "BeanManagerImpl", "deploymentManager", ",", "ServiceRegistry", "deploymentServices", ")", "{", "Container", "instance", "=", "new", "Container", "(", "RegistrySingletonProvider", ".", "STATIC_INSTANCE", ",", "deploymentManager", ",", "deploymentServices", ")", ";", "Container", ".", "instance", ".", "set", "(", "RegistrySingletonProvider", ".", "STATIC_INSTANCE", ",", "instance", ")", ";", "}" ]

[ "Initialize", "the", "container", "for", "the", "current", "application", "deployment" ]

[ "public", "void", "cleanup", "(", ")", "{", "managers", ".", "clear", "(", ")", ";", "for", "(", "BeanManagerImpl", "beanManager", ":", "beanDeploymentArchives", ".", "values", "(", ")", ")", "{", "beanManager", ".", "cleanup", "(", ")", ";", "}", "beanDeploymentArchives", ".", "clear", "(", ")", ";", "deploymentServices", ".", "cleanup", "(", ")", ";", "deploymentManager", ".", "cleanup", "(", ")", ";", "instance", ".", "clear", "(", "contextId", ")", ";", "}" ]

[ "Cause", "the", "container", "to", "be", "cleaned", "up", "including", "all", "registered", "bean", "managers", "and", "all", "deployment", "services" ]

[ "public", "void", "putBeanDeployments", "(", "BeanDeploymentArchiveMapping", "bdaMapping", ")", "{", "for", "(", "Entry", "<", "BeanDeploymentArchive", ",", "BeanManagerImpl", ">", "entry", ":", "bdaMapping", ".", "getBdaToBeanManagerMap", "(", ")", ".", "entrySet", "(", ")", ")", "{", "beanDeploymentArchives", ".", "put", "(", "entry", ".", "getKey", "(", ")", ",", "entry", ".", "getValue", "(", ")", ")", ";", "addBeanManager", "(", "entry", ".", "getValue", "(", ")", ")", ";", "}", "}" ]

[ "Add", "sub", "-", "deployment", "units", "to", "the", "container" ]

[ "private", "<", "Y", ">", "void", "checkObserverMethod", "(", "EnhancedAnnotatedMethod", "<", "T", ",", "Y", ">", "annotated", ")", "{", "// Make sure exactly one and only one parameter is annotated with Observes or ObservesAsync", "List", "<", "EnhancedAnnotatedParameter", "<", "?", ",", "Y", ">", ">", "eventObjects", "=", "annotated", ".", "getEnhancedParameters", "(", "Observes", ".", "class", ")", ";", "eventObjects", ".", "addAll", "(", "annotated", ".", "getEnhancedParameters", "(", "ObservesAsync", ".", "class", ")", ")", ";", "if", "(", "this", ".", "reception", ".", "equals", "(", "Reception", ".", "IF_EXISTS", ")", "&&", "declaringBean", ".", "getScope", "(", ")", ".", "equals", "(", "Dependent", ".", "class", ")", ")", "{", "throw", "EventLogger", ".", "LOG", ".", "invalidScopedConditionalObserver", "(", "this", ",", "Formats", ".", "formatAsStackTraceElement", "(", "annotated", ".", "getJavaMember", "(", ")", ")", ")", ";", "}", "if", "(", "eventObjects", ".", "size", "(", ")", ">", "1", ")", "{", "throw", "EventLogger", ".", "LOG", ".", "multipleEventParameters", "(", "this", ",", "Formats", ".", "formatAsStackTraceElement", "(", "annotated", ".", "getJavaMember", "(", ")", ")", ")", ";", "}", "EnhancedAnnotatedParameter", "<", "?", ",", "Y", ">", "eventParameter", "=", "eventObjects", ".", "iterator", "(", ")", ".", "next", "(", ")", ";", "checkRequiredTypeAnnotations", "(", "eventParameter", ")", ";", "// Check for parameters annotated with @Disposes", "List", "<", "?", ">", "disposeParams", "=", "annotated", ".", "getEnhancedParameters", "(", "Disposes", ".", "class", ")", ";", "if", "(", "disposeParams", ".", "size", "(", ")", ">", "0", ")", "{", "throw", "EventLogger", ".", "LOG", ".", "invalidDisposesParameter", "(", "this", ",", "Formats", ".", "formatAsStackTraceElement", "(", "annotated", ".", "getJavaMember", "(", ")", ")", ")", ";", "}", "// Check annotations on the method to make sure this is not a producer", "// method, initializer method, or destructor method.", "if", "(", "this", ".", "observerMethod", ".", "getAnnotated", "(", ")", ".", "isAnnotationPresent", "(", "Produces", ".", "class", ")", ")", "{", "throw", "EventLogger", ".", "LOG", ".", "invalidProducer", "(", "this", ",", "Formats", ".", "formatAsStackTraceElement", "(", "annotated", ".", "getJavaMember", "(", ")", ")", ")", ";", "}", "if", "(", "this", ".", "observerMethod", ".", "getAnnotated", "(", ")", ".", "isAnnotationPresent", "(", "Inject", ".", "class", ")", ")", "{", "throw", "EventLogger", ".", "LOG", ".", "invalidInitializer", "(", "this", ",", "Formats", ".", "formatAsStackTraceElement", "(", "annotated", ".", "getJavaMember", "(", ")", ")", ")", ";", "}", "boolean", "containerLifecycleObserverMethod", "=", "Observers", ".", "isContainerLifecycleObserverMethod", "(", "this", ")", ";", "for", "(", "EnhancedAnnotatedParameter", "<", "?", ",", "?", ">", "parameter", ":", "annotated", ".", "getEnhancedParameters", "(", ")", ")", "{", "// if this is an observer method for container lifecycle event, it must not inject anything besides BeanManager", "if", "(", "containerLifecycleObserverMethod", "&&", "!", "parameter", ".", "isAnnotationPresent", "(", "Observes", ".", "class", ")", "&&", "!", "parameter", ".", "isAnnotationPresent", "(", "ObservesAsync", ".", "class", ")", "&&", "!", "BeanManager", ".", "class", ".", "equals", "(", "parameter", ".", "getBaseType", "(", ")", ")", ")", "{", "throw", "EventLogger", ".", "LOG", ".", "invalidInjectionPoint", "(", "this", ",", "Formats", ".", "formatAsStackTraceElement", "(", "annotated", ".", "getJavaMember", "(", ")", ")", ")", ";", "}", "}", "}" ]

[ "Performs", "validation", "of", "the", "observer", "method", "for", "compliance", "with", "the", "specifications", "." ]

[ "protected", "void", "sendEvent", "(", "final", "T", "event", ")", "{", "if", "(", "isStatic", ")", "{", "sendEvent", "(", "event", ",", "null", ",", "null", ")", ";", "}", "else", "{", "CreationalContext", "<", "X", ">", "creationalContext", "=", "null", ";", "try", "{", "Object", "receiver", "=", "getReceiverIfExists", "(", "null", ")", ";", "if", "(", "receiver", "==", "null", "&&", "reception", "!=", "Reception", ".", "IF_EXISTS", ")", "{", "// creational context is created only if we need it for obtaining receiver", "// ObserverInvocationStrategy takes care of creating CC for parameters, if needed", "creationalContext", "=", "beanManager", ".", "createCreationalContext", "(", "declaringBean", ")", ";", "receiver", "=", "getReceiverIfExists", "(", "creationalContext", ")", ";", "}", "if", "(", "receiver", "!=", "null", ")", "{", "sendEvent", "(", "event", ",", "receiver", ",", "creationalContext", ")", ";", "}", "}", "finally", "{", "if", "(", "creationalContext", "!=", "null", ")", "{", "creationalContext", ".", "release", "(", ")", ";", "}", "}", "}", "}" ]

[ "Invokes", "the", "observer", "method", "immediately", "passing", "the", "event", "." ]

[ "public", "static", "void", "endRequest", "(", ")", "{", "final", "List", "<", "RequestScopedItem", ">", "result", "=", "CACHE", ".", "get", "(", ")", ";", "if", "(", "result", "!=", "null", ")", "{", "CACHE", ".", "remove", "(", ")", ";", "for", "(", "final", "RequestScopedItem", "item", ":", "result", ")", "{", "item", ".", "invalidate", "(", ")", ";", "}", "}", "}" ]

[ "ends", "the", "request", "and", "clears", "the", "cache", ".", "This", "can", "be", "called", "before", "the", "request", "is", "over", "in", "which", "case", "the", "cache", "will", "be", "unavailable", "for", "the", "rest", "of", "the", "request", "." ]

[ "public", "<", "X", ">", "X", "invokeOnInstance", "(", "Object", "instance", ",", "Object", "...", "parameters", ")", "throws", "IllegalArgumentException", ",", "SecurityException", ",", "IllegalAccessException", ",", "InvocationTargetException", ",", "NoSuchMethodException", "{", "final", "Map", "<", "Class", "<", "?", ">", ",", "Method", ">", "methods", "=", "this", ".", "methods", ";", "Method", "method", "=", "methods", ".", "get", "(", "instance", ".", "getClass", "(", ")", ")", ";", "if", "(", "method", "==", "null", ")", "{", "// the same method may be written to the map twice, but that is ok", "// lookupMethod is very slow", "Method", "delegate", "=", "annotatedMethod", ".", "getJavaMember", "(", ")", ";", "method", "=", "SecurityActions", ".", "lookupMethod", "(", "instance", ".", "getClass", "(", ")", ",", "delegate", ".", "getName", "(", ")", ",", "delegate", ".", "getParameterTypes", "(", ")", ")", ";", "SecurityActions", ".", "ensureAccessible", "(", "method", ")", ";", "synchronized", "(", "this", ")", "{", "final", "Map", "<", "Class", "<", "?", ">", ",", "Method", ">", "newMethods", "=", "new", "HashMap", "<", "Class", "<", "?", ">", ",", "Method", ">", "(", "methods", ")", ";", "newMethods", ".", "put", "(", "instance", ".", "getClass", "(", ")", ",", "method", ")", ";", "this", ".", "methods", "=", "WeldCollections", ".", "immutableMapView", "(", "newMethods", ")", ";", "}", "}", "return", "cast", "(", "method", ".", "invoke", "(", "instance", ",", "parameters", ")", ")", ";", "}" ]

[ "Invokes", "the", "method", "on", "the", "class", "of", "the", "passed", "instance", "not", "the", "declaring", "class", ".", "Useful", "with", "proxies" ]

[ "@", "SuppressWarnings", "(", "\"unchecked\"", ")", "protected", "Class", "<", "?", "extends", "Annotation", ">", "annotationTypeForName", "(", "String", "name", ")", "{", "try", "{", "return", "(", "Class", "<", "?", "extends", "Annotation", ">", ")", "resourceLoader", ".", "classForName", "(", "name", ")", ";", "}", "catch", "(", "ResourceLoadingException", "cnfe", ")", "{", "return", "DUMMY_ANNOTATION", ";", "}", "}" ]

[ "Initializes", "an", "annotation", "class" ]

[ "protected", "Class", "<", "?", ">", "classForName", "(", "String", "name", ")", "{", "try", "{", "return", "resourceLoader", ".", "classForName", "(", "name", ")", ";", "}", "catch", "(", "ResourceLoadingException", "cnfe", ")", "{", "return", "DUMMY_CLASS", ";", "}", "}" ]

[ "Initializes", "a", "type" ]

[ "public", "void", "addInterface", "(", "Class", "<", "?", ">", "newInterface", ")", "{", "if", "(", "!", "newInterface", ".", "isInterface", "(", ")", ")", "{", "throw", "new", "IllegalArgumentException", "(", "newInterface", "+", "\" is not an interface\"", ")", ";", "}", "additionalInterfaces", ".", "add", "(", "newInterface", ")", ";", "}" ]

[ "Adds", "an", "additional", "interface", "that", "the", "proxy", "should", "implement", ".", "The", "default", "implementation", "will", "be", "to", "forward", "invocations", "to", "the", "bean", "instance", "." ]

[ "public", "T", "create", "(", "BeanInstance", "beanInstance", ")", "{", "final", "T", "proxy", "=", "(", "System", ".", "getSecurityManager", "(", ")", "==", "null", ")", "?", "run", "(", ")", ":", "AccessController", ".", "doPrivileged", "(", "this", ")", ";", "(", "(", "ProxyObject", ")", "proxy", ")", ".", "weld_setHandler", "(", "new", "ProxyMethodHandler", "(", "contextId", ",", "beanInstance", ",", "bean", ")", ")", ";", "return", "proxy", ";", "}" ]

[ "Method", "to", "create", "a", "new", "proxy", "that", "wraps", "the", "bean", "instance", "." ]

[ "public", "Class", "<", "T", ">", "getProxyClass", "(", ")", "{", "String", "suffix", "=", "\"_$$_Weld\"", "+", "getProxyNameSuffix", "(", ")", ";", "String", "proxyClassName", "=", "getBaseProxyName", "(", ")", ";", "if", "(", "!", "proxyClassName", ".", "endsWith", "(", "suffix", ")", ")", "{", "proxyClassName", "=", "proxyClassName", "+", "suffix", ";", "}", "if", "(", "proxyClassName", ".", "startsWith", "(", "JAVA", ")", ")", "{", "proxyClassName", "=", "proxyClassName", ".", "replaceFirst", "(", "JAVA", ",", "\"org.jboss.weld\"", ")", ";", "}", "Class", "<", "T", ">", "proxyClass", "=", "null", ";", "Class", "<", "?", ">", "originalClass", "=", "bean", "!=", "null", "?", "bean", ".", "getBeanClass", "(", ")", ":", "proxiedBeanType", ";", "BeanLogger", ".", "LOG", ".", "generatingProxyClass", "(", "proxyClassName", ")", ";", "try", "{", "// First check to see if we already have this proxy class", "proxyClass", "=", "cast", "(", "classLoader", "==", "null", "?", "proxyServices", ".", "loadClass", "(", "originalClass", ",", "proxyClassName", ")", ":", "classLoader", ".", "loadClass", "(", "proxyClassName", ")", ")", ";", "}", "catch", "(", "ClassNotFoundException", "e", ")", "{", "// Create the proxy class for this instance", "try", "{", "proxyClass", "=", "createProxyClass", "(", "originalClass", ",", "proxyClassName", ")", ";", "}", "catch", "(", "Throwable", "e1", ")", "{", "//attempt to load the class again, just in case another thread", "//defined it between the check and the create method", "try", "{", "proxyClass", "=", "cast", "(", "classLoader", "==", "null", "?", "proxyServices", ".", "loadClass", "(", "originalClass", ",", "proxyClassName", ")", ":", "classLoader", ".", "loadClass", "(", "proxyClassName", ")", ")", ";", "}", "catch", "(", "ClassNotFoundException", "e2", ")", "{", "BeanLogger", ".", "LOG", ".", "catchingDebug", "(", "e1", ")", ";", "throw", "BeanLogger", ".", "LOG", ".", "unableToLoadProxyClass", "(", "bean", ",", "proxiedBeanType", ",", "e1", ")", ";", "}", "}", "}", "return", "proxyClass", ";", "}" ]

[ "Produces", "or", "returns", "the", "existing", "proxy", "class", ".", "The", "operation", "is", "thread", "-", "safe", "." ]

[ "public", "static", "<", "T", ">", "void", "setBeanInstance", "(", "String", "contextId", ",", "T", "proxy", ",", "BeanInstance", "beanInstance", ",", "Bean", "<", "?", ">", "bean", ")", "{", "if", "(", "proxy", "instanceof", "ProxyObject", ")", "{", "ProxyObject", "proxyView", "=", "(", "ProxyObject", ")", "proxy", ";", "proxyView", ".", "weld_setHandler", "(", "new", "ProxyMethodHandler", "(", "contextId", ",", "beanInstance", ",", "bean", ")", ")", ";", "}", "}" ]

[ "Convenience", "method", "to", "set", "the", "underlying", "bean", "instance", "for", "a", "proxy", "." ]

[ "protected", "void", "addConstructors", "(", "ClassFile", "proxyClassType", ",", "List", "<", "DeferredBytecode", ">", "initialValueBytecode", ")", "{", "try", "{", "if", "(", "getBeanType", "(", ")", ".", "isInterface", "(", ")", ")", "{", "ConstructorUtils", ".", "addDefaultConstructor", "(", "proxyClassType", ",", "initialValueBytecode", ",", "!", "useConstructedFlag", "(", ")", ")", ";", "}", "else", "{", "boolean", "constructorFound", "=", "false", ";", "for", "(", "Constructor", "<", "?", ">", "constructor", ":", "AccessController", ".", "doPrivileged", "(", "new", "GetDeclaredConstructorsAction", "(", "getBeanType", "(", ")", ")", ")", ")", "{", "if", "(", "(", "constructor", ".", "getModifiers", "(", ")", "&", "Modifier", ".", "PRIVATE", ")", "==", "0", ")", "{", "constructorFound", "=", "true", ";", "String", "[", "]", "exceptions", "=", "new", "String", "[", "constructor", ".", "getExceptionTypes", "(", ")", ".", "length", "]", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "exceptions", ".", "length", ";", "++", "i", ")", "{", "exceptions", "[", "i", "]", "=", "constructor", ".", "getExceptionTypes", "(", ")", "[", "i", "]", ".", "getName", "(", ")", ";", "}", "ConstructorUtils", ".", "addConstructor", "(", "BytecodeUtils", ".", "VOID_CLASS_DESCRIPTOR", ",", "DescriptorUtils", ".", "parameterDescriptors", "(", "constructor", ".", "getParameterTypes", "(", ")", ")", ",", "exceptions", ",", "proxyClassType", ",", "initialValueBytecode", ",", "!", "useConstructedFlag", "(", ")", ")", ";", "}", "}", "if", "(", "!", "constructorFound", ")", "{", "// the bean only has private constructors, we need to generate", "// two fake constructors that call each other", "addConstructorsForBeanWithPrivateConstructors", "(", "proxyClassType", ")", ";", "}", "}", "}", "catch", "(", "Exception", "e", ")", "{", "throw", "new", "WeldException", "(", "e", ")", ";", "}", "}" ]

[ "Adds", "a", "constructor", "for", "the", "proxy", "for", "each", "constructor", "declared", "by", "the", "base", "bean", "type", "." ]

[ "public", "static", "ClassLoader", "resolveClassLoaderForBeanProxy", "(", "String", "contextId", ",", "Class", "<", "?", ">", "proxiedType", ",", "TypeInfo", "typeInfo", ",", "ProxyServices", "proxyServices", ")", "{", "Class", "<", "?", ">", "superClass", "=", "typeInfo", ".", "getSuperClass", "(", ")", ";", "if", "(", "superClass", ".", "getName", "(", ")", ".", "startsWith", "(", "JAVA", ")", ")", "{", "ClassLoader", "cl", "=", "proxyServices", ".", "getClassLoader", "(", "proxiedType", ")", ";", "if", "(", "cl", "==", "null", ")", "{", "cl", "=", "Thread", ".", "currentThread", "(", ")", ".", "getContextClassLoader", "(", ")", ";", "}", "return", "cl", ";", "}", "return", "Container", ".", "instance", "(", "contextId", ")", ".", "services", "(", ")", ".", "get", "(", "ProxyServices", ".", "class", ")", ".", "getClassLoader", "(", "superClass", ")", ";", "}" ]

[ "Figures", "out", "the", "correct", "class", "loader", "to", "use", "for", "a", "proxy", "for", "a", "given", "bean" ]

[ "public", "void", "fetchUninitializedAttributes", "(", ")", "{", "for", "(", "String", "prefixedId", ":", "getPrefixedAttributeNames", "(", ")", ")", "{", "BeanIdentifier", "id", "=", "getNamingScheme", "(", ")", ".", "deprefix", "(", "prefixedId", ")", ";", "if", "(", "!", "beanStore", ".", "contains", "(", "id", ")", ")", "{", "ContextualInstance", "<", "?", ">", "instance", "=", "(", "ContextualInstance", "<", "?", ">", ")", "getAttribute", "(", "prefixedId", ")", ";", "beanStore", ".", "put", "(", "id", ",", "instance", ")", ";", "ContextLogger", ".", "LOG", ".", "addingDetachedContextualUnderId", "(", "instance", ",", "id", ")", ";", "}", "}", "}" ]

[ "Fetch", "all", "relevant", "attributes", "from", "the", "backing", "store", "and", "copy", "instances", "which", "are", "not", "present", "in", "the", "local", "bean", "store", "." ]

[ "static", "void", "merge", "(", "Map", "<", "ConfigurationKey", ",", "Object", ">", "original", ",", "Map", "<", "ConfigurationKey", ",", "Object", ">", "toMerge", ",", "String", "mergedSourceDescription", ")", "{", "for", "(", "Entry", "<", "ConfigurationKey", ",", "Object", ">", "entry", ":", "toMerge", ".", "entrySet", "(", ")", ")", "{", "Object", "existing", "=", "original", ".", "get", "(", "entry", ".", "getKey", "(", ")", ")", ";", "if", "(", "existing", "!=", "null", ")", "{", "ConfigurationLogger", ".", "LOG", ".", "configurationKeyAlreadySet", "(", "entry", ".", "getKey", "(", ")", ".", "get", "(", ")", ",", "existing", ",", "entry", ".", "getValue", "(", ")", ",", "mergedSourceDescription", ")", ";", "}", "else", "{", "original", ".", "put", "(", "entry", ".", "getKey", "(", ")", ",", "entry", ".", "getValue", "(", ")", ")", ";", "}", "}", "}" ]

[ "Merge", "two", "maps", "of", "configuration", "properties", ".", "If", "the", "original", "contains", "a", "mapping", "for", "the", "same", "key", "the", "new", "mapping", "is", "ignored", "." ]

[ "private", "Map", "<", "ConfigurationKey", ",", "Object", ">", "getObsoleteSystemProperties", "(", ")", "{", "Map", "<", "ConfigurationKey", ",", "Object", ">", "found", "=", "new", "EnumMap", "<", "ConfigurationKey", ",", "Object", ">", "(", "ConfigurationKey", ".", "class", ")", ";", "String", "concurrentDeployment", "=", "getSystemProperty", "(", "\"org.jboss.weld.bootstrap.properties.concurrentDeployment\"", ")", ";", "if", "(", "concurrentDeployment", "!=", "null", ")", "{", "processKeyValue", "(", "found", ",", "ConfigurationKey", ".", "CONCURRENT_DEPLOYMENT", ",", "concurrentDeployment", ")", ";", "found", ".", "put", "(", "ConfigurationKey", ".", "CONCURRENT_DEPLOYMENT", ",", "ConfigurationKey", ".", "CONCURRENT_DEPLOYMENT", ".", "convertValue", "(", "concurrentDeployment", ")", ")", ";", "}", "String", "preloaderThreadPoolSize", "=", "getSystemProperty", "(", "\"org.jboss.weld.bootstrap.properties.preloaderThreadPoolSize\"", ")", ";", "if", "(", "preloaderThreadPoolSize", "!=", "null", ")", "{", "found", ".", "put", "(", "ConfigurationKey", ".", "PRELOADER_THREAD_POOL_SIZE", ",", "ConfigurationKey", ".", "PRELOADER_THREAD_POOL_SIZE", ".", "convertValue", "(", "preloaderThreadPoolSize", ")", ")", ";", "}", "return", "found", ";", "}" ]

[ "Try", "to", "get", "a", "system", "property", "for", "obsolete", "keys", ".", "The", "value", "is", "automatically", "converted", "-", "a", "runtime", "exception", "may", "be", "thrown", "during", "conversion", "." ]

[ "@", "SuppressFBWarnings", "(", "value", "=", "\"DMI_COLLECTION_OF_URLS\"", ",", "justification", "=", "\"Only local URLs involved\"", ")", "private", "Map", "<", "ConfigurationKey", ",", "Object", ">", "readFileProperties", "(", "Set", "<", "URL", ">", "files", ")", "{", "Map", "<", "ConfigurationKey", ",", "Object", ">", "found", "=", "new", "EnumMap", "<", "ConfigurationKey", ",", "Object", ">", "(", "ConfigurationKey", ".", "class", ")", ";", "for", "(", "URL", "file", ":", "files", ")", "{", "ConfigurationLogger", ".", "LOG", ".", "readingPropertiesFile", "(", "file", ")", ";", "Properties", "fileProperties", "=", "loadProperties", "(", "file", ")", ";", "for", "(", "String", "name", ":", "fileProperties", ".", "stringPropertyNames", "(", ")", ")", "{", "processKeyValue", "(", "found", ",", "name", ",", "fileProperties", ".", "getProperty", "(", "name", ")", ")", ";", "}", "}", "return", "found", ";", "}" ]

[ "Read", "the", "set", "of", "property", "files", ".", "Keys", "and", "Values", "are", "automatically", "validated", "and", "converted", "." ]

[ "private", "void", "processKeyValue", "(", "Map", "<", "ConfigurationKey", ",", "Object", ">", "properties", ",", "ConfigurationKey", "key", ",", "Object", "value", ")", "{", "if", "(", "value", "instanceof", "String", ")", "{", "value", "=", "key", ".", "convertValue", "(", "(", "String", ")", "value", ")", ";", "}", "if", "(", "key", ".", "isValidValue", "(", "value", ")", ")", "{", "Object", "previous", "=", "properties", ".", "put", "(", "key", ",", "value", ")", ";", "if", "(", "previous", "!=", "null", "&&", "!", "previous", ".", "equals", "(", "value", ")", ")", "{", "throw", "ConfigurationLogger", ".", "LOG", ".", "configurationKeyHasDifferentValues", "(", "key", ".", "get", "(", ")", ",", "previous", ",", "value", ")", ";", "}", "}", "else", "{", "throw", "ConfigurationLogger", ".", "LOG", ".", "invalidConfigurationPropertyValue", "(", "value", ",", "key", ".", "get", "(", ")", ")", ";", "}", "}" ]

[ "Process", "the", "given", "key", "and", "value", ".", "First", "validate", "the", "value", "and", "check", "if", "there", "s", "no", "different", "value", "for", "the", "same", "key", "in", "the", "same", "source", "-", "invalid", "and", "different", "values", "are", "treated", "as", "a", "deployment", "problem", "." ]

[ "public", "static", "<", "T", ",", "X", ">", "ObserverMethodImpl", "<", "T", ",", "X", ">", "create", "(", "EnhancedAnnotatedMethod", "<", "T", ",", "?", "super", "X", ">", "method", ",", "RIBean", "<", "X", ">", "declaringBean", ",", "BeanManagerImpl", "manager", ",", "boolean", "isAsync", ")", "{", "if", "(", "declaringBean", "instanceof", "ExtensionBean", ")", "{", "return", "new", "ExtensionObserverMethodImpl", "<", "T", ",", "X", ">", "(", "method", ",", "declaringBean", ",", "manager", ",", "isAsync", ")", ";", "}", "return", "new", "ObserverMethodImpl", "<", "T", ",", "X", ">", "(", "method", ",", "declaringBean", ",", "manager", ",", "isAsync", ")", ";", "}" ]

[ "Creates", "an", "observer" ]

[ "public", "static", "TransactionPhase", "getTransactionalPhase", "(", "EnhancedAnnotatedMethod", "<", "?", ",", "?", ">", "observer", ")", "{", "EnhancedAnnotatedParameter", "<", "?", ",", "?", ">", "parameter", "=", "observer", ".", "getEnhancedParameters", "(", "Observes", ".", "class", ")", ".", "iterator", "(", ")", ".", "next", "(", ")", ";", "return", "parameter", ".", "getAnnotation", "(", "Observes", ".", "class", ")", ".", "during", "(", ")", ";", "}" ]

[ "Tests", "an", "observer", "method", "to", "see", "if", "it", "is", "transactional", "." ]

[ "static", "WeldContainer", "startInitialization", "(", "String", "id", ",", "Deployment", "deployment", ",", "Bootstrap", "bootstrap", ")", "{", "if", "(", "SINGLETON", ".", "isSet", "(", "id", ")", ")", "{", "throw", "WeldSELogger", ".", "LOG", ".", "weldContainerAlreadyRunning", "(", "id", ")", ";", "}", "WeldContainer", "weldContainer", "=", "new", "WeldContainer", "(", "id", ",", "deployment", ",", "bootstrap", ")", ";", "SINGLETON", ".", "set", "(", "id", ",", "weldContainer", ")", ";", "RUNNING_CONTAINER_IDS", ".", "add", "(", "id", ")", ";", "return", "weldContainer", ";", "}" ]

[ "Start", "the", "initialization", "." ]

[ "static", "void", "endInitialization", "(", "WeldContainer", "container", ",", "boolean", "isShutdownHookEnabled", ")", "{", "container", ".", "complete", "(", ")", ";", "// If needed, register one shutdown hook for all containers", "if", "(", "shutdownHook", "==", "null", "&&", "isShutdownHookEnabled", ")", "{", "synchronized", "(", "LOCK", ")", "{", "if", "(", "shutdownHook", "==", "null", ")", "{", "shutdownHook", "=", "new", "ShutdownHook", "(", ")", ";", "SecurityActions", ".", "addShutdownHook", "(", "shutdownHook", ")", ";", "}", "}", "}", "container", ".", "fireContainerInitializedEvent", "(", ")", ";", "}" ]

[ "Finish", "the", "initialization", "." ]

[ "public", "synchronized", "void", "shutdown", "(", ")", "{", "checkIsRunning", "(", ")", ";", "try", "{", "beanManager", "(", ")", ".", "fireEvent", "(", "new", "ContainerBeforeShutdown", "(", "id", ")", ",", "BeforeDestroyed", ".", "Literal", ".", "APPLICATION", ")", ";", "}", "finally", "{", "discard", "(", "id", ")", ";", "// Destroy all the dependent beans correctly", "creationalContext", ".", "release", "(", ")", ";", "beanManager", "(", ")", ".", "fireEvent", "(", "new", "ContainerShutdown", "(", "id", ")", ",", "Destroyed", ".", "Literal", ".", "APPLICATION", ")", ";", "bootstrap", ".", "shutdown", "(", ")", ";", "WeldSELogger", ".", "LOG", ".", "weldContainerShutdown", "(", "id", ")", ";", "}", "}" ]

[ "Shutdown", "the", "container", "." ]

[ "@", "Override", "public", "Collection", "<", "EnhancedAnnotatedConstructor", "<", "T", ">", ">", "getEnhancedConstructors", "(", "Class", "<", "?", "extends", "Annotation", ">", "annotationType", ")", "{", "Set", "<", "EnhancedAnnotatedConstructor", "<", "T", ">>", "ret", "=", "new", "HashSet", "<", "EnhancedAnnotatedConstructor", "<", "T", ">", ">", "(", ")", ";", "for", "(", "EnhancedAnnotatedConstructor", "<", "T", ">", "constructor", ":", "constructors", ")", "{", "if", "(", "constructor", ".", "isAnnotationPresent", "(", "annotationType", ")", ")", "{", "ret", ".", "add", "(", "constructor", ")", ";", "}", "}", "return", "ret", ";", "}" ]

[ "Gets", "constructors", "with", "given", "annotation", "type" ]

[ "protected", "void", "setBeanStore", "(", "BoundBeanStore", "beanStore", ")", "{", "if", "(", "beanStore", "==", "null", ")", "{", "this", ".", "beanStore", ".", "remove", "(", ")", ";", "}", "else", "{", "this", ".", "beanStore", ".", "set", "(", "beanStore", ")", ";", "}", "}" ]

[ "Sets", "the", "bean", "store" ]

[ "public", "void", "setArgs", "(", "String", "[", "]", "args", ")", "{", "if", "(", "args", "==", "null", ")", "{", "args", "=", "new", "String", "[", "]", "{", "}", ";", "}", "this", ".", "args", "=", "args", ";", "this", ".", "argsList", "=", "Collections", ".", "unmodifiableList", "(", "new", "ArrayList", "<", "String", ">", "(", "Arrays", ".", "asList", "(", "args", ")", ")", ")", ";", "}" ]

[ "StartMain", "passes", "in", "the", "command", "line", "args", "here", "." ]

[ "public", "Weld", "addPackages", "(", "boolean", "scanRecursively", ",", "Class", "<", "?", ">", "...", "packageClasses", ")", "{", "for", "(", "Class", "<", "?", ">", "packageClass", ":", "packageClasses", ")", "{", "addPackage", "(", "scanRecursively", ",", "packageClass", ")", ";", "}", "return", "this", ";", "}" ]

[ "Packages", "of", "the", "specified", "classes", "will", "be", "scanned", "and", "found", "classes", "will", "be", "added", "to", "the", "set", "of", "bean", "classes", "for", "the", "synthetic", "bean", "archive", "." ]

[ "public", "Weld", "addPackage", "(", "boolean", "scanRecursively", ",", "Class", "<", "?", ">", "packageClass", ")", "{", "packages", ".", "add", "(", "new", "PackInfo", "(", "packageClass", ",", "scanRecursively", ")", ")", ";", "return", "this", ";", "}" ]

[ "A", "package", "of", "the", "specified", "class", "will", "be", "scanned", "and", "found", "classes", "will", "be", "added", "to", "the", "set", "of", "bean", "classes", "for", "the", "synthetic", "bean", "archive", "." ]

[ "public", "Weld", "extensions", "(", "Extension", "...", "extensions", ")", "{", "this", ".", "extensions", ".", "clear", "(", ")", ";", "for", "(", "Extension", "extension", ":", "extensions", ")", "{", "addExtension", "(", "extension", ")", ";", "}", "return", "this", ";", "}" ]

[ "Define", "the", "set", "of", "extensions", "." ]

[ "public", "Weld", "addExtension", "(", "Extension", "extension", ")", "{", "extensions", ".", "add", "(", "new", "MetadataImpl", "<", "Extension", ">", "(", "extension", ",", "SYNTHETIC_LOCATION_PREFIX", "+", "extension", ".", "getClass", "(", ")", ".", "getName", "(", ")", ")", ")", ";", "return", "this", ";", "}" ]

[ "Add", "an", "extension", "to", "the", "set", "of", "extensions", "." ]

[ "public", "Weld", "property", "(", "String", "key", ",", "Object", "value", ")", "{", "properties", ".", "put", "(", "key", ",", "value", ")", ";", "return", "this", ";", "}" ]

[ "Set", "the", "configuration", "property", "." ]

[ "public", "Weld", "addBeanDefiningAnnotations", "(", "Class", "<", "?", "extends", "Annotation", ">", "...", "annotations", ")", "{", "for", "(", "Class", "<", "?", "extends", "Annotation", ">", "annotation", ":", "annotations", ")", "{", "this", ".", "extendedBeanDefiningAnnotations", ".", "add", "(", "annotation", ")", ";", "}", "return", "this", ";", "}" ]

[ "Registers", "annotations", "which", "will", "be", "considered", "as", "bean", "defining", "annotations", "." ]

[ "private", "static", "void", "checkSensibility", "(", "AnnotatedType", "<", "?", ">", "type", ")", "{", "// check if it has a constructor", "if", "(", "type", ".", "getConstructors", "(", ")", ".", "isEmpty", "(", ")", "&&", "!", "type", ".", "getJavaClass", "(", ")", ".", "isInterface", "(", ")", ")", "{", "MetadataLogger", ".", "LOG", ".", "noConstructor", "(", "type", ")", ";", "}", "Set", "<", "Class", "<", "?", ">", ">", "hierarchy", "=", "new", "HashSet", "<", "Class", "<", "?", ">", ">", "(", ")", ";", "for", "(", "Class", "<", "?", ">", "clazz", "=", "type", ".", "getJavaClass", "(", ")", ";", "clazz", "!=", "null", ";", "clazz", "=", "clazz", ".", "getSuperclass", "(", ")", ")", "{", "hierarchy", ".", "add", "(", "clazz", ")", ";", "hierarchy", ".", "addAll", "(", "Reflections", ".", "getInterfaceClosure", "(", "clazz", ")", ")", ";", "}", "checkMembersBelongToHierarchy", "(", "type", ".", "getConstructors", "(", ")", ",", "hierarchy", ",", "type", ")", ";", "checkMembersBelongToHierarchy", "(", "type", ".", "getMethods", "(", ")", ",", "hierarchy", ",", "type", ")", ";", "checkMembersBelongToHierarchy", "(", "type", ".", "getFields", "(", ")", ",", "hierarchy", ",", "type", ")", ";", "}" ]

[ "Checks", "if", "the", "given", "AnnotatedType", "is", "sensible", "otherwise", "provides", "warnings", "." ]

[ "private", "static", "boolean", "isWideningPrimitive", "(", "Class", "<", "?", ">", "argumentClass", ",", "Class", "<", "?", ">", "targetClass", ")", "{", "return", "WIDENING_TABLE", ".", "containsKey", "(", "argumentClass", ")", "&&", "WIDENING_TABLE", ".", "get", "(", "argumentClass", ")", ".", "contains", "(", "targetClass", ")", ";", "}" ]

[ "Checks", "that", "the", "targetClass", "is", "widening", "the", "argument", "class" ]

[ "public", "static", "<", "X", ">", "String", "createTypeId", "(", "AnnotatedType", "<", "X", ">", "annotatedType", ")", "{", "String", "id", "=", "createTypeId", "(", "annotatedType", ".", "getJavaClass", "(", ")", ",", "annotatedType", ".", "getAnnotations", "(", ")", ",", "annotatedType", ".", "getMethods", "(", ")", ",", "annotatedType", ".", "getFields", "(", ")", ",", "annotatedType", ".", "getConstructors", "(", ")", ")", ";", "String", "hash", "=", "hash", "(", "id", ")", ";", "MetadataLogger", ".", "LOG", ".", "tracef", "(", "\"Generated AnnotatedType id hash for %s: %s\"", ",", "id", ",", "hash", ")", ";", "return", "hash", ";", "}" ]

[ "Generates", "a", "unique", "signature", "for", "an", "annotated", "type", ".", "Members", "without", "annotations", "are", "omitted", "to", "reduce", "the", "length", "of", "the", "signature" ]

[ "public", "static", "boolean", "compareAnnotatedParameters", "(", "AnnotatedParameter", "<", "?", ">", "p1", ",", "AnnotatedParameter", "<", "?", ">", "p2", ")", "{", "return", "compareAnnotatedCallable", "(", "p1", ".", "getDeclaringCallable", "(", ")", ",", "p2", ".", "getDeclaringCallable", "(", ")", ")", "&&", "p1", ".", "getPosition", "(", ")", "==", "p2", ".", "getPosition", "(", ")", "&&", "compareAnnotated", "(", "p1", ",", "p2", ")", ";", "}" ]

[ "Compares", "two", "annotated", "parameters", "and", "returns", "true", "if", "they", "are", "equal" ]

[ "public", "static", "boolean", "compareAnnotatedTypes", "(", "AnnotatedType", "<", "?", ">", "t1", ",", "AnnotatedType", "<", "?", ">", "t2", ")", "{", "if", "(", "!", "t1", ".", "getJavaClass", "(", ")", ".", "equals", "(", "t2", ".", "getJavaClass", "(", ")", ")", ")", "{", "return", "false", ";", "}", "if", "(", "!", "compareAnnotated", "(", "t1", ",", "t2", ")", ")", "{", "return", "false", ";", "}", "if", "(", "t1", ".", "getFields", "(", ")", ".", "size", "(", ")", "!=", "t2", ".", "getFields", "(", ")", ".", "size", "(", ")", ")", "{", "return", "false", ";", "}", "Map", "<", "Field", ",", "AnnotatedField", "<", "?", ">", ">", "fields", "=", "new", "HashMap", "<", "Field", ",", "AnnotatedField", "<", "?", ">", ">", "(", ")", ";", "for", "(", "AnnotatedField", "<", "?", ">", "f", ":", "t2", ".", "getFields", "(", ")", ")", "{", "fields", ".", "put", "(", "f", ".", "getJavaMember", "(", ")", ",", "f", ")", ";", "}", "for", "(", "AnnotatedField", "<", "?", ">", "f", ":", "t1", ".", "getFields", "(", ")", ")", "{", "if", "(", "fields", ".", "containsKey", "(", "f", ".", "getJavaMember", "(", ")", ")", ")", "{", "if", "(", "!", "compareAnnotatedField", "(", "f", ",", "fields", ".", "get", "(", "f", ".", "getJavaMember", "(", ")", ")", ")", ")", "{", "return", "false", ";", "}", "}", "else", "{", "return", "false", ";", "}", "}", "if", "(", "t1", ".", "getMethods", "(", ")", ".", "size", "(", ")", "!=", "t2", ".", "getMethods", "(", ")", ".", "size", "(", ")", ")", "{", "return", "false", ";", "}", "Map", "<", "Method", ",", "AnnotatedMethod", "<", "?", ">", ">", "methods", "=", "new", "HashMap", "<", "Method", ",", "AnnotatedMethod", "<", "?", ">", ">", "(", ")", ";", "for", "(", "AnnotatedMethod", "<", "?", ">", "f", ":", "t2", ".", "getMethods", "(", ")", ")", "{", "methods", ".", "put", "(", "f", ".", "getJavaMember", "(", ")", ",", "f", ")", ";", "}", "for", "(", "AnnotatedMethod", "<", "?", ">", "f", ":", "t1", ".", "getMethods", "(", ")", ")", "{", "if", "(", "methods", ".", "containsKey", "(", "f", ".", "getJavaMember", "(", ")", ")", ")", "{", "if", "(", "!", "compareAnnotatedCallable", "(", "f", ",", "methods", ".", "get", "(", "f", ".", "getJavaMember", "(", ")", ")", ")", ")", "{", "return", "false", ";", "}", "}", "else", "{", "return", "false", ";", "}", "}", "if", "(", "t1", ".", "getConstructors", "(", ")", ".", "size", "(", ")", "!=", "t2", ".", "getConstructors", "(", ")", ".", "size", "(", ")", ")", "{", "return", "false", ";", "}", "Map", "<", "Constructor", "<", "?", ">", ",", "AnnotatedConstructor", "<", "?", ">", ">", "constructors", "=", "new", "HashMap", "<", "Constructor", "<", "?", ">", ",", "AnnotatedConstructor", "<", "?", ">", ">", "(", ")", ";", "for", "(", "AnnotatedConstructor", "<", "?", ">", "f", ":", "t2", ".", "getConstructors", "(", ")", ")", "{", "constructors", ".", "put", "(", "f", ".", "getJavaMember", "(", ")", ",", "f", ")", ";", "}", "for", "(", "AnnotatedConstructor", "<", "?", ">", "f", ":", "t1", ".", "getConstructors", "(", ")", ")", "{", "if", "(", "constructors", ".", "containsKey", "(", "f", ".", "getJavaMember", "(", ")", ")", ")", "{", "if", "(", "!", "compareAnnotatedCallable", "(", "f", ",", "constructors", ".", "get", "(", "f", ".", "getJavaMember", "(", ")", ")", ")", ")", "{", "return", "false", ";", "}", "}", "else", "{", "return", "false", ";", "}", "}", "return", "true", ";", "}" ]

[ "Compares", "two", "annotated", "types", "and", "returns", "true", "if", "they", "are", "the", "same" ]

[ "public", "static", "boolean", "isPassivatingScope", "(", "Bean", "<", "?", ">", "bean", ",", "BeanManagerImpl", "manager", ")", "{", "if", "(", "bean", "==", "null", ")", "{", "return", "false", ";", "}", "else", "{", "return", "manager", ".", "getServices", "(", ")", ".", "get", "(", "MetaAnnotationStore", ".", "class", ")", ".", "getScopeModel", "(", "bean", ".", "getScope", "(", ")", ")", ".", "isPassivating", "(", ")", ";", "}", "}" ]

[ "Indicates", "if", "a", "bean", "s", "scope", "type", "is", "passivating" ]

[ "public", "static", "boolean", "isBeanProxyable", "(", "Bean", "<", "?", ">", "bean", ",", "BeanManagerImpl", "manager", ")", "{", "if", "(", "bean", "instanceof", "RIBean", "<", "?", ">", ")", "{", "return", "(", "(", "RIBean", "<", "?", ">", ")", "bean", ")", ".", "isProxyable", "(", ")", ";", "}", "else", "{", "return", "Proxies", ".", "isTypesProxyable", "(", "bean", ".", "getTypes", "(", ")", ",", "manager", ".", "getServices", "(", ")", ")", ";", "}", "}" ]

[ "Indicates", "if", "a", "bean", "is", "proxyable" ]

[ "public", "static", "boolean", "containsAllQualifiers", "(", "Set", "<", "QualifierInstance", ">", "requiredQualifiers", ",", "Set", "<", "QualifierInstance", ">", "qualifiers", ")", "{", "return", "qualifiers", ".", "containsAll", "(", "requiredQualifiers", ")", ";", "}" ]

[ "Checks", "that", "all", "the", "qualifiers", "in", "the", "set", "requiredQualifiers", "are", "in", "the", "set", "of", "qualifiers", ".", "Qualifier", "equality", "rules", "for", "annotation", "members", "are", "followed", "." ]

[ "public", "static", "<", "T", "extends", "Bean", "<", "?", ">", ">", "Set", "<", "T", ">", "removeDisabledBeans", "(", "Set", "<", "T", ">", "beans", ",", "final", "BeanManagerImpl", "beanManager", ")", "{", "if", "(", "beans", ".", "isEmpty", "(", ")", ")", "{", "return", "beans", ";", "}", "else", "{", "for", "(", "Iterator", "<", "T", ">", "iterator", "=", "beans", ".", "iterator", "(", ")", ";", "iterator", ".", "hasNext", "(", ")", ";", ")", "{", "if", "(", "!", "isBeanEnabled", "(", "iterator", ".", "next", "(", ")", ",", "beanManager", ".", "getEnabled", "(", ")", ")", ")", "{", "iterator", ".", "remove", "(", ")", ";", "}", "}", "return", "beans", ";", "}", "}" ]

[ "Retains", "only", "beans", "which", "are", "enabled", "." ]

[ "public", "static", "boolean", "isAlternative", "(", "EnhancedAnnotated", "<", "?", ",", "?", ">", "annotated", ",", "MergedStereotypes", "<", "?", ",", "?", ">", "mergedStereotypes", ")", "{", "return", "annotated", ".", "isAnnotationPresent", "(", "Alternative", ".", "class", ")", "||", "mergedStereotypes", ".", "isAlternative", "(", ")", ";", "}" ]

[ "Is", "alternative", "." ]

[ "public", "static", "<", "T", ">", "void", "injectEEFields", "(", "Iterable", "<", "Set", "<", "ResourceInjection", "<", "?", ">", ">", ">", "resourceInjectionsHierarchy", ",", "T", "beanInstance", ",", "CreationalContext", "<", "T", ">", "ctx", ")", "{", "for", "(", "Set", "<", "ResourceInjection", "<", "?", ">", ">", "resourceInjections", ":", "resourceInjectionsHierarchy", ")", "{", "for", "(", "ResourceInjection", "<", "?", ">", "resourceInjection", ":", "resourceInjections", ")", "{", "resourceInjection", ".", "injectResourceReference", "(", "beanInstance", ",", "ctx", ")", ";", "}", "}", "}" ]

[ "Injects", "EJBs", "and", "other", "EE", "resources", "." ]

[ "public", "static", "Type", "getDeclaredBeanType", "(", "Class", "<", "?", ">", "clazz", ")", "{", "Type", "[", "]", "actualTypeArguments", "=", "Reflections", ".", "getActualTypeArguments", "(", "clazz", ")", ";", "if", "(", "actualTypeArguments", ".", "length", "==", "1", ")", "{", "return", "actualTypeArguments", "[", "0", "]", ";", "}", "else", "{", "return", "null", ";", "}", "}" ]

[ "Gets", "the", "declared", "bean", "type" ]

[ "public", "static", "<", "T", ">", "void", "injectBoundFields", "(", "T", "instance", ",", "CreationalContext", "<", "T", ">", "creationalContext", ",", "BeanManagerImpl", "manager", ",", "Iterable", "<", "?", "extends", "FieldInjectionPoint", "<", "?", ",", "?", ">", ">", "injectableFields", ")", "{", "for", "(", "FieldInjectionPoint", "<", "?", ",", "?", ">", "injectableField", ":", "injectableFields", ")", "{", "injectableField", ".", "inject", "(", "instance", ",", "manager", ",", "creationalContext", ")", ";", "}", "}" ]

[ "Injects", "bound", "fields" ]

[ "public", "static", "<", "T", ">", "void", "callInitializers", "(", "T", "instance", ",", "CreationalContext", "<", "T", ">", "creationalContext", ",", "BeanManagerImpl", "manager", ",", "Iterable", "<", "?", "extends", "MethodInjectionPoint", "<", "?", ",", "?", ">", ">", "initializerMethods", ")", "{", "for", "(", "MethodInjectionPoint", "<", "?", ",", "?", ">", "initializer", ":", "initializerMethods", ")", "{", "initializer", ".", "invoke", "(", "instance", ",", "null", ",", "manager", ",", "creationalContext", ",", "CreationException", ".", "class", ")", ";", "}", "}" ]

[ "Calls", "all", "initializers", "of", "the", "bean" ]

[ "public", "static", "boolean", "isTypeManagedBeanOrDecoratorOrInterceptor", "(", "AnnotatedType", "<", "?", ">", "annotatedType", ")", "{", "Class", "<", "?", ">", "javaClass", "=", "annotatedType", ".", "getJavaClass", "(", ")", ";", "return", "!", "javaClass", ".", "isEnum", "(", ")", "&&", "!", "Extension", ".", "class", ".", "isAssignableFrom", "(", "javaClass", ")", "&&", "Reflections", ".", "isTopLevelOrStaticNestedClass", "(", "javaClass", ")", "&&", "!", "Reflections", ".", "isParameterizedTypeWithWildcard", "(", "javaClass", ")", "&&", "hasSimpleCdiConstructor", "(", "annotatedType", ")", ";", "}" ]

[ "Indicates", "if", "the", "type", "is", "a", "simple", "Web", "Bean" ]

[ "public", "static", "<", "T", ">", "NewSessionBean", "<", "T", ">", "of", "(", "BeanAttributes", "<", "T", ">", "attributes", ",", "InternalEjbDescriptor", "<", "T", ">", "ejbDescriptor", ",", "BeanManagerImpl", "beanManager", ")", "{", "EnhancedAnnotatedType", "<", "T", ">", "type", "=", "beanManager", ".", "getServices", "(", ")", ".", "get", "(", "ClassTransformer", ".", "class", ")", ".", "getEnhancedAnnotatedType", "(", "ejbDescriptor", ".", "getBeanClass", "(", ")", ",", "beanManager", ".", "getId", "(", ")", ")", ";", "return", "new", "NewSessionBean", "<", "T", ">", "(", "attributes", ",", "type", ",", "ejbDescriptor", ",", "new", "StringBeanIdentifier", "(", "SessionBeans", ".", "createIdentifierForNew", "(", "ejbDescriptor", ")", ")", ",", "beanManager", ")", ";", "}" ]

[ "Creates", "an", "instance", "of", "a", "NewEnterpriseBean", "from", "an", "annotated", "class" ]

[ "public", "static", "<", "X", ",", "T", ">", "ProducerField", "<", "X", ",", "T", ">", "of", "(", "BeanAttributes", "<", "T", ">", "attributes", ",", "EnhancedAnnotatedField", "<", "T", ",", "?", "super", "X", ">", "field", ",", "AbstractClassBean", "<", "X", ">", "declaringBean", ",", "DisposalMethod", "<", "X", ",", "?", ">", "disposalMethod", ",", "BeanManagerImpl", "beanManager", ",", "ServiceRegistry", "services", ")", "{", "return", "new", "ProducerField", "<", "X", ",", "T", ">", "(", "attributes", ",", "field", ",", "declaringBean", ",", "disposalMethod", ",", "beanManager", ",", "services", ")", ";", "}" ]

[ "Creates", "a", "producer", "field" ]

[ "public", "static", "boolean", "hasPermission", "(", "Permission", "permission", ")", "{", "SecurityManager", "security", "=", "System", ".", "getSecurityManager", "(", ")", ";", "if", "(", "security", "!=", "null", ")", "{", "try", "{", "security", ".", "checkPermission", "(", "permission", ")", ";", "}", "catch", "(", "java", ".", "security", ".", "AccessControlException", "e", ")", "{", "return", "false", ";", "}", "}", "return", "true", ";", "}" ]

[ "Determines", "whether", "the", "specified", "permission", "is", "permitted", "." ]

[ "public", "static", "<", "T", ">", "ManagedBean", "<", "T", ">", "of", "(", "BeanAttributes", "<", "T", ">", "attributes", ",", "EnhancedAnnotatedType", "<", "T", ">", "clazz", ",", "BeanManagerImpl", "beanManager", ")", "{", "return", "new", "ManagedBean", "<", "T", ">", "(", "attributes", ",", "clazz", ",", "createId", "(", "attributes", ",", "clazz", ")", ",", "beanManager", ")", ";", "}" ]

[ "Creates", "a", "simple", "annotation", "defined", "Web", "Bean" ]

[ "@", "Override", "public", "void", "destroy", "(", "T", "instance", ",", "CreationalContext", "<", "T", ">", "creationalContext", ")", "{", "super", ".", "destroy", "(", "instance", ",", "creationalContext", ")", ";", "try", "{", "getProducer", "(", ")", ".", "preDestroy", "(", "instance", ")", ";", "// WELD-1010 hack?", "if", "(", "creationalContext", "instanceof", "CreationalContextImpl", ")", "{", "(", "(", "CreationalContextImpl", "<", "T", ">", ")", "creationalContext", ")", ".", "release", "(", "this", ",", "instance", ")", ";", "}", "else", "{", "creationalContext", ".", "release", "(", ")", ";", "}", "}", "catch", "(", "Exception", "e", ")", "{", "BeanLogger", ".", "LOG", ".", "errorDestroying", "(", "instance", ",", "this", ")", ";", "BeanLogger", ".", "LOG", ".", "catchingDebug", "(", "e", ")", ";", "}", "}" ]

[ "Destroys", "an", "instance", "of", "the", "bean" ]

[ "@", "Override", "protected", "void", "checkType", "(", ")", "{", "if", "(", "!", "isDependent", "(", ")", "&&", "getEnhancedAnnotated", "(", ")", ".", "isParameterizedType", "(", ")", ")", "{", "throw", "BeanLogger", ".", "LOG", ".", "managedBeanWithParameterizedBeanClassMustBeDependent", "(", "type", ")", ";", "}", "boolean", "passivating", "=", "beanManager", ".", "isPassivatingScope", "(", "getScope", "(", ")", ")", ";", "if", "(", "passivating", "&&", "!", "isPassivationCapableBean", "(", ")", ")", "{", "if", "(", "!", "getEnhancedAnnotated", "(", ")", ".", "isSerializable", "(", ")", ")", "{", "throw", "BeanLogger", ".", "LOG", ".", "passivatingBeanNeedsSerializableImpl", "(", "this", ")", ";", "}", "else", "if", "(", "hasDecorators", "(", ")", "&&", "!", "allDecoratorsArePassivationCapable", "(", ")", ")", "{", "throw", "BeanLogger", ".", "LOG", ".", "passivatingBeanHasNonPassivationCapableDecorator", "(", "this", ",", "getFirstNonPassivationCapableDecorator", "(", ")", ")", ";", "}", "else", "if", "(", "hasInterceptors", "(", ")", "&&", "!", "allInterceptorsArePassivationCapable", "(", ")", ")", "{", "throw", "BeanLogger", ".", "LOG", ".", "passivatingBeanHasNonPassivationCapableInterceptor", "(", "this", ",", "getFirstNonPassivationCapableInterceptor", "(", ")", ")", ";", "}", "}", "}" ]

[ "Validates", "the", "type" ]

[ "@", "SafeVarargs", "public", "static", "<", "T", ">", "Set", "<", "T", ">", "of", "(", "T", "...", "elements", ")", "{", "Preconditions", ".", "checkNotNull", "(", "elements", ")", ";", "return", "ImmutableSet", ".", "<", "T", ">", "builder", "(", ")", ".", "addAll", "(", "elements", ")", ".", "build", "(", ")", ";", "}" ]

[ "Creates", "a", "new", "immutable", "set", "that", "consists", "of", "given", "elements", "." ]

[ "Object", "readResolve", "(", ")", "throws", "ObjectStreamException", "{", "Bean", "<", "?", ">", "bean", "=", "Container", ".", "instance", "(", "contextId", ")", ".", "services", "(", ")", ".", "get", "(", "ContextualStore", ".", "class", ")", ".", "<", "Bean", "<", "Object", ">", ",", "Object", ">", "getContextual", "(", "beanId", ")", ";", "if", "(", "bean", "==", "null", ")", "{", "throw", "BeanLogger", ".", "LOG", ".", "proxyDeserializationFailure", "(", "beanId", ")", ";", "}", "return", "Container", ".", "instance", "(", "contextId", ")", ".", "deploymentManager", "(", ")", ".", "getClientProxyProvider", "(", ")", ".", "getClientProxy", "(", "bean", ")", ";", "}" ]

[ "Always", "returns", "the", "original", "proxy", "object", "that", "was", "serialized", "." ]

[ "@", "Override", "protected", "String", "getToken", "(", ")", "{", "GetAccessTokenResult", "token", "=", "accessToken", ".", "get", "(", ")", ";", "if", "(", "token", "==", "null", "||", "isExpired", "(", "token", ")", "||", "(", "isAboutToExpire", "(", "token", ")", "&&", "refreshInProgress", ".", "compareAndSet", "(", "false", ",", "true", ")", ")", ")", "{", "lock", ".", "lock", "(", ")", ";", "try", "{", "token", "=", "accessToken", ".", "get", "(", ")", ";", "if", "(", "token", "==", "null", "||", "isAboutToExpire", "(", "token", ")", ")", "{", "token", "=", "accessTokenProvider", ".", "getNewAccessToken", "(", "oauthScopes", ")", ";", "accessToken", ".", "set", "(", "token", ")", ";", "cacheExpirationHeadroom", ".", "set", "(", "getNextCacheExpirationHeadroom", "(", ")", ")", ";", "}", "}", "finally", "{", "refreshInProgress", ".", "set", "(", "false", ")", ";", "lock", ".", "unlock", "(", ")", ";", "}", "}", "return", "token", ".", "getAccessToken", "(", ")", ";", "}" ]

[ "Attempts", "to", "return", "the", "token", "from", "cache", ".", "If", "this", "is", "not", "possible", "because", "it", "is", "expired", "or", "was", "never", "assigned", "a", "new", "token", "is", "requested", "and", "parallel", "requests", "will", "block", "on", "retrieving", "a", "new", "token", ".", "As", "such", "no", "guarantee", "of", "maximum", "latency", "is", "provided", "." ]

[ "private", "void", "waitForOutstandingRequest", "(", ")", "throws", "IOException", "{", "if", "(", "outstandingRequest", "==", "null", ")", "{", "return", ";", "}", "try", "{", "RetryHelper", ".", "runWithRetries", "(", "new", "Callable", "<", "Void", ">", "(", ")", "{", "@", "Override", "public", "Void", "call", "(", ")", "throws", "IOException", ",", "InterruptedException", "{", "if", "(", "RetryHelper", ".", "getContext", "(", ")", ".", "getAttemptNumber", "(", ")", ">", "1", ")", "{", "outstandingRequest", ".", "retry", "(", ")", ";", "}", "token", "=", "outstandingRequest", ".", "waitForNextToken", "(", ")", ";", "outstandingRequest", "=", "null", ";", "return", "null", ";", "}", "}", ",", "retryParams", ",", "GcsServiceImpl", ".", "exceptionHandler", ")", ";", "}", "catch", "(", "RetryInterruptedException", "ex", ")", "{", "token", "=", "null", ";", "throw", "new", "ClosedByInterruptException", "(", ")", ";", "}", "catch", "(", "NonRetriableException", "e", ")", "{", "Throwables", ".", "propagateIfInstanceOf", "(", "e", ".", "getCause", "(", ")", ",", "IOException", ".", "class", ")", ";", "throw", "e", ";", "}", "}" ]

[ "Waits", "for", "the", "current", "outstanding", "request", "retrying", "it", "with", "exponential", "backoff", "if", "it", "fails", "." ]

[ "static", "Date", "parseDate", "(", "String", "dateString", ")", "{", "try", "{", "return", "DATE_FORMAT", ".", "parseDateTime", "(", "dateString", ")", ".", "toDate", "(", ")", ";", "}", "catch", "(", "IllegalArgumentException", "e", ")", "{", "return", "null", ";", "}", "}" ]

[ "Parses", "the", "date", "or", "returns", "null", "if", "it", "fails", "to", "do", "so", "." ]

[ "@", "Override", "public", "Future", "<", "RawGcsCreationToken", ">", "continueObjectCreationAsync", "(", "final", "RawGcsCreationToken", "token", ",", "final", "ByteBuffer", "chunk", ",", "long", "timeoutMillis", ")", "{", "try", "{", "ensureInitialized", "(", ")", ";", "}", "catch", "(", "IOException", "e", ")", "{", "throw", "new", "RuntimeException", "(", "e", ")", ";", "}", "final", "Environment", "environment", "=", "ApiProxy", ".", "getCurrentEnvironment", "(", ")", ";", "return", "writePool", ".", "schedule", "(", "new", "Callable", "<", "RawGcsCreationToken", ">", "(", ")", "{", "@", "Override", "public", "RawGcsCreationToken", "call", "(", ")", "throws", "Exception", "{", "ApiProxy", ".", "setEnvironmentForCurrentThread", "(", "environment", ")", ";", "return", "append", "(", "token", ",", "chunk", ")", ";", "}", "}", ",", "50", ",", "TimeUnit", ".", "MILLISECONDS", ")", ";", "}" ]

[ "Runs", "calls", "in", "a", "background", "thread", "so", "that", "the", "results", "will", "actually", "be", "asynchronous", "." ]

[ "private", "void", "requestBlock", "(", ")", "{", "next", "=", "ByteBuffer", ".", "allocate", "(", "blockSizeBytes", ")", ";", "long", "requestTimeout", "=", "retryParams", ".", "getRequestTimeoutMillisForCurrentAttempt", "(", ")", ";", "pendingFetch", "=", "raw", ".", "readObjectAsync", "(", "next", ",", "filename", ",", "fetchPosition", ",", "requestTimeout", ")", ";", "}" ]

[ "Allocates", "a", "new", "next", "buffer", "and", "pending", "fetch", "." ]

[ "GcsRestCreationToken", "handlePutResponse", "(", "final", "GcsRestCreationToken", "token", ",", "final", "boolean", "isFinalChunk", ",", "final", "int", "length", ",", "final", "HTTPRequestInfo", "reqInfo", ",", "HTTPResponse", "resp", ")", "throws", "Error", ",", "IOException", "{", "switch", "(", "resp", ".", "getResponseCode", "(", ")", ")", "{", "case", "200", ":", "if", "(", "!", "isFinalChunk", ")", "{", "throw", "new", "RuntimeException", "(", "\"Unexpected response code 200 on non-final chunk. Request: \\n\"", "+", "URLFetchUtils", ".", "describeRequestAndResponse", "(", "reqInfo", ",", "resp", ")", ")", ";", "}", "else", "{", "return", "null", ";", "}", "case", "308", ":", "if", "(", "isFinalChunk", ")", "{", "throw", "new", "RuntimeException", "(", "\"Unexpected response code 308 on final chunk: \"", "+", "URLFetchUtils", ".", "describeRequestAndResponse", "(", "reqInfo", ",", "resp", ")", ")", ";", "}", "else", "{", "return", "new", "GcsRestCreationToken", "(", "token", ".", "filename", ",", "token", ".", "uploadId", ",", "token", ".", "offset", "+", "length", ")", ";", "}", "default", ":", "throw", "HttpErrorHandler", ".", "error", "(", "resp", ".", "getResponseCode", "(", ")", ",", "URLFetchUtils", ".", "describeRequestAndResponse", "(", "reqInfo", ",", "resp", ")", ")", ";", "}", "}" ]

[ "Given", "a", "HTTPResponce", "process", "it", "throwing", "an", "error", "if", "needed", "and", "return", "a", "Token", "for", "the", "next", "request", "." ]

[ "private", "RawGcsCreationToken", "put", "(", "final", "GcsRestCreationToken", "token", ",", "ByteBuffer", "chunk", ",", "final", "boolean", "isFinalChunk", ",", "long", "timeoutMillis", ")", "throws", "IOException", "{", "final", "int", "length", "=", "chunk", ".", "remaining", "(", ")", ";", "HTTPRequest", "req", "=", "createPutRequest", "(", "token", ",", "chunk", ",", "isFinalChunk", ",", "timeoutMillis", ",", "length", ")", ";", "HTTPRequestInfo", "info", "=", "new", "HTTPRequestInfo", "(", "req", ")", ";", "HTTPResponse", "response", ";", "try", "{", "response", "=", "urlfetch", ".", "fetch", "(", "req", ")", ";", "}", "catch", "(", "IOException", "e", ")", "{", "throw", "createIOException", "(", "info", ",", "e", ")", ";", "}", "return", "handlePutResponse", "(", "token", ",", "isFinalChunk", ",", "length", ",", "info", ",", "response", ")", ";", "}" ]

[ "Write", "the", "provided", "chunk", "at", "the", "offset", "specified", "in", "the", "token", ".", "If", "finalChunk", "is", "set", "the", "file", "will", "be", "closed", "." ]