Datasets:

---

CM

/

codexglue_code2text_java

like 4

[ "private", "void", "configureEPServiceProvider", "(", ")", "throws", "EPException", ",", "IOException", "{", "if", "(", "LOG", ".", "isDebugEnabled", "(", ")", ")", "{", "LOG", ".", "debug", "(", "\"Configuring the Esper Service Provider with name: \"", "+", "name", ")", ";", "}", "if", "(", "this", ".", "configuration", "!=", "null", "&&", "this", ".", "configuration", ".", "exists", "(", ")", ")", "{", "Configuration", "esperConfiguration", "=", "new", "Configuration", "(", ")", ";", "esperConfiguration", "=", "esperConfiguration", ".", "configure", "(", "this", ".", "configuration", ".", "getFile", "(", ")", ")", ";", "epServiceProvider", "=", "EPServiceProviderManager", ".", "getProvider", "(", "name", ",", "esperConfiguration", ")", ";", "LOG", ".", "info", "(", "\"Esper configured with a user-provided configuration\"", ",", "esperConfiguration", ")", ";", "}", "else", "{", "epServiceProvider", "=", "EPServiceProviderManager", ".", "getProvider", "(", "name", ")", ";", "}", "if", "(", "LOG", ".", "isDebugEnabled", "(", ")", ")", "{", "LOG", ".", "debug", "(", "\"Completed configuring the Esper Service Provider with name: \"", "+", "name", ")", ";", "}", "}" ]

[ "Configure", "the", "Esper", "Service", "Provider", "to", "create", "the", "appropriate", "Esper", "Runtime", "." ]

[ "public", "static", "void", "setLogLevels", "(", "final", "int", "aLogLevel", ",", "final", "String", "[", "]", "aLoggerList", ",", "final", "String", "[", "]", "aExcludesList", ",", "final", "String", "...", "aIncludesList", ")", "{", "final", "ArrayList", "<", "String", ">", "loggerList", "=", "new", "ArrayList", "<>", "(", "Arrays", ".", "asList", "(", "aLoggerList", ")", ")", ";", "final", "Class", "<", "?", "extends", "Logger", ">", "simpleLogger", "=", "LoggerFactory", ".", "getLogger", "(", "\"org.slf4j.impl.SimpleLogger\"", ")", ".", "getClass", "(", ")", ";", "if", "(", "aIncludesList", "!=", "null", ")", "{", "loggerList", ".", "addAll", "(", "Arrays", ".", "asList", "(", "aIncludesList", ")", ")", ";", "}", "for", "(", "final", "String", "loggerName", ":", "loggerList", ")", "{", "if", "(", "aExcludesList", "!=", "null", ")", "{", "boolean", "skip", "=", "false", ";", "for", "(", "final", "String", "element", ":", "aExcludesList", ")", "{", "if", "(", "loggerName", ".", "equals", "(", "element", ")", ")", "{", "skip", "=", "true", ";", "break", ";", "}", "}", "if", "(", "skip", ")", "{", "continue", ";", "}", "}", "final", "Logger", "loggerObject", "=", "LoggerFactory", ".", "getLogger", "(", "loggerName", ")", ";", "final", "Class", "<", "?", "extends", "Logger", ">", "loggerClass", "=", "loggerObject", ".", "getClass", "(", ")", ";", "if", "(", "simpleLogger", ".", "equals", "(", "loggerClass", ")", ")", "{", "try", "{", "final", "Field", "field", "=", "loggerClass", ".", "getDeclaredField", "(", "\"currentLogLevel\"", ")", ";", "field", ".", "setAccessible", "(", "true", ")", ";", "field", ".", "setInt", "(", "loggerObject", ",", "aLogLevel", ")", ";", "if", "(", "loggerObject", ".", "isDebugEnabled", "(", ")", ")", "{", "LOGGER", ".", "debug", "(", "MessageCodes", ".", "MVN_012", ",", "loggerName", ",", "getLevelName", "(", "aLogLevel", ")", ")", ";", "}", "}", "catch", "(", "NoSuchFieldException", "|", "IllegalAccessException", "details", ")", "{", "LOGGER", ".", "error", "(", "MessageCodes", ".", "MVN_011", ",", "details", ")", ";", "}", "}", "else", "{", "LOGGER", ".", "warn", "(", "MessageCodes", ".", "MVN_010", ",", "loggerName", ")", ";", "}", "}", "}" ]

[ "Sets", "the", "logging", "level", "of", "the", "supplied", "loggers", "optionally", "excluding", "some", "and", "including", "others", "." ]

[ "public", "static", "int", "getLevelIntCode", "(", "final", "String", "aLogLevelName", ")", "{", "final", "String", "levelName", "=", "aLogLevelName", ".", "trim", "(", ")", ".", "toLowerCase", "(", "Locale", ".", "US", ")", ";", "if", "(", "\"error\"", ".", "equals", "(", "levelName", ")", ")", "{", "return", "ERROR_LOG_LEVEL", ";", "}", "else", "if", "(", "\"warn\"", ".", "equals", "(", "levelName", ")", ")", "{", "return", "WARN_LOG_LEVEL", ";", "}", "else", "if", "(", "\"info\"", ".", "equals", "(", "levelName", ")", ")", "{", "return", "INFO_LOG_LEVEL", ";", "}", "else", "if", "(", "\"debug\"", ".", "equals", "(", "levelName", ")", ")", "{", "return", "DEBUG_LOG_LEVEL", ";", "}", "else", "if", "(", "\"trace\"", ".", "equals", "(", "levelName", ")", ")", "{", "return", "TRACE_LOG_LEVEL", ";", "}", "else", "{", "return", "0", ";", "}", "}" ]

[ "Returns", "the", "int", "of", "the", "supplied", "log", "level", "or", "zero", "if", "the", "supplied", "name", "doesn", "t", "match", "a", "known", "log", "level", "." ]

[ "public", "static", "String", "decode", "(", "final", "String", "aURL", ",", "final", "String", "aEncoding", ")", "{", "String", "urlString", "=", "aURL", ";", "String", "decodedString", ";", "try", "{", "do", "{", "decodedString", "=", "urlString", ";", "// Java's URLDecoder needs a little help with occurrences of '%' that aren't percent escaped values", "urlString", "=", "URLDecoder", ".", "decode", "(", "decodedString", ".", "replaceAll", "(", "\"%(?![0-9a-fA-F]{2})\"", ",", "PERCENT", ")", ",", "aEncoding", ")", ";", "}", "while", "(", "!", "urlString", ".", "equals", "(", "decodedString", ")", ")", ";", "}", "catch", "(", "final", "java", ".", "io", ".", "UnsupportedEncodingException", "details", ")", "{", "throw", "new", "UnsupportedEncodingException", "(", "details", ",", "aEncoding", ")", ";", "}", "if", "(", "LOGGER", ".", "isDebugEnabled", "(", ")", "&&", "!", "aURL", ".", "equals", "(", "decodedString", ")", ")", "{", "LOGGER", ".", "debug", "(", "MessageCodes", ".", "DBG_002", ",", "aURL", ",", "decodedString", ")", ";", "}", "return", "decodedString", ";", "}" ]

[ "Decodes", "an", "encoded", "path", ".", "If", "it", "has", "been", "doubly", "encoded", "it", "is", "doubly", "decoded", "." ]

[ "public", "static", "String", "encode", "(", "final", "String", "aString", ",", "final", "boolean", "aIgnoreSlashFlag", ")", "{", "final", "CharacterIterator", "iterator", "=", "new", "StringCharacterIterator", "(", "decode", "(", "aString", ")", ")", ";", "final", "StringBuilder", "builder", "=", "new", "StringBuilder", "(", ")", ";", "for", "(", "char", "c", "=", "iterator", ".", "first", "(", ")", ";", "c", "!=", "CharacterIterator", ".", "DONE", ";", "c", "=", "iterator", ".", "next", "(", ")", ")", "{", "switch", "(", "c", ")", "{", "case", "'", "'", ":", "builder", ".", "append", "(", "PERCENT", ")", ";", "break", ";", "case", "'", "'", ":", "if", "(", "aIgnoreSlashFlag", ")", "{", "builder", ".", "append", "(", "c", ")", ";", "}", "else", "{", "builder", ".", "append", "(", "\"%2F\"", ")", ";", "}", "break", ";", "case", "'", "'", ":", "builder", ".", "append", "(", "\"%3F\"", ")", ";", "break", ";", "case", "'", "'", ":", "builder", ".", "append", "(", "\"%23\"", ")", ";", "break", ";", "case", "'", "'", ":", "builder", ".", "append", "(", "\"%5B\"", ")", ";", "break", ";", "case", "'", "'", ":", "builder", ".", "append", "(", "\"%5D\"", ")", ";", "break", ";", "case", "'", "'", ":", "builder", ".", "append", "(", "\"%40\"", ")", ";", "break", ";", "default", ":", "builder", ".", "append", "(", "c", ")", ";", "break", ";", "}", "}", "// Must percent-encode any characters outside the US-ASCII set", "return", "URI", ".", "create", "(", "builder", ".", "toString", "(", ")", ")", ".", "toASCIIString", "(", ")", ";", "}" ]

[ "Percent", "-", "encodes", "supplied", "string", "but", "only", "after", "decoding", "it", "completely", "first", "." ]

[ "public", "void", "start", "(", ")", "{", "if", "(", "LOG", ".", "isInfoEnabled", "(", ")", ")", "{", "LOG", ".", "info", "(", "\"Esper statement [\"", "+", "epl", "+", "\"] being started\"", ")", ";", "}", "this", ".", "epStatement", ".", "start", "(", ")", ";", "if", "(", "LOG", ".", "isInfoEnabled", "(", ")", ")", "{", "LOG", ".", "info", "(", "\"Esper statement [\"", "+", "epl", "+", "\"] started\"", ")", ";", "}", "}" ]

[ "Starts", "events", "being", "collated", "according", "to", "the", "statement", "s", "filter", "query" ]

[ "public", "void", "stop", "(", ")", "{", "if", "(", "LOG", ".", "isInfoEnabled", "(", ")", ")", "{", "LOG", ".", "info", "(", "\"Esper statement [\"", "+", "epl", "+", "\"] being stopped\"", ")", ";", "}", "this", ".", "epStatement", ".", "stop", "(", ")", ";", "if", "(", "LOG", ".", "isInfoEnabled", "(", ")", ")", "{", "LOG", ".", "info", "(", "\"Esper statement [\"", "+", "epl", "+", "\"] stopped\"", ")", ";", "}", "}" ]

[ "Stops", "the", "underlying", "native", "statement", "from", "applying", "its", "filter", "query", "." ]

[ "private", "void", "addEPStatementListener", "(", "UpdateListener", "listener", ")", "{", "if", "(", "this", ".", "subscriber", "==", "null", ")", "{", "if", "(", "epStatement", "!=", "null", ")", "{", "epStatement", ".", "addListener", "(", "listener", ")", ";", "}", "}", "}" ]

[ "Adds", "an", "listener", "to", "the", "underlying", "native", "EPStatement", "." ]

[ "void", "setEPStatement", "(", "EPStatement", "epStatement", ")", "{", "this", ".", "epStatement", "=", "epStatement", ";", "if", "(", "this", ".", "subscriber", "!=", "null", ")", "{", "epStatement", ".", "setSubscriber", "(", "this", ".", "subscriber", ")", ";", "}", "else", "{", "for", "(", "UpdateListener", "listener", ":", "listeners", ")", "{", "epStatement", ".", "addListener", "(", "listener", ")", ";", "}", "}", "}" ]

[ "Sets", "the", "native", "Esper", "statement", ".", "Typically", "created", "by", "an", "Esper", "Template", "." ]

[ "public", "boolean", "filters", "(", "final", "String", "aFileExt", ")", "{", "final", "String", "normalizedExt", "=", "normalizeExt", "(", "aFileExt", ")", ";", "for", "(", "final", "String", "extension", ":", "myExtensions", ")", "{", "if", "(", "extension", ".", "equals", "(", "normalizedExt", ")", ")", "{", "return", "true", ";", "}", "}", "return", "false", ";", "}" ]

[ "Returns", "whether", "or", "not", "the", "supplied", "file", "extension", "is", "one", "that", "this", "filter", "matches", "." ]

[ "@", "SuppressWarnings", "(", "\"unchecked\"", ")", "public", "ManagedSet", "parseListeners", "(", "Element", "element", ",", "ParserContext", "parserContext", ")", "{", "ManagedSet", "listeners", "=", "new", "ManagedSet", "(", ")", ";", "NodeList", "childNodes", "=", "element", ".", "getChildNodes", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "childNodes", ".", "getLength", "(", ")", ";", "i", "++", ")", "{", "Node", "child", "=", "childNodes", ".", "item", "(", "i", ")", ";", "if", "(", "child", ".", "getNodeType", "(", ")", "==", "Node", ".", "ELEMENT_NODE", ")", "{", "Element", "childElement", "=", "(", "Element", ")", "child", ";", "String", "localName", "=", "child", ".", "getLocalName", "(", ")", ";", "if", "(", "\"bean\"", ".", "equals", "(", "localName", ")", ")", "{", "BeanDefinitionHolder", "holder", "=", "parserContext", ".", "getDelegate", "(", ")", ".", "parseBeanDefinitionElement", "(", "childElement", ")", ";", "parserContext", ".", "registerBeanComponent", "(", "new", "BeanComponentDefinition", "(", "holder", ")", ")", ";", "listeners", ".", "add", "(", "new", "RuntimeBeanReference", "(", "holder", ".", "getBeanName", "(", ")", ")", ")", ";", "}", "else", "if", "(", "\"ref\"", ".", "equals", "(", "localName", ")", ")", "{", "String", "ref", "=", "childElement", ".", "getAttribute", "(", "\"bean\"", ")", ";", "listeners", ".", "add", "(", "new", "RuntimeBeanReference", "(", "ref", ")", ")", ";", "}", "}", "}", "return", "listeners", ";", "}" ]

[ "Parses", "out", "a", "set", "of", "configured", "esper", "statement", "listeners", "." ]

[ "protected", "String", "getI18n", "(", "final", "String", "aMessageKey", ",", "final", "long", "aLongDetail", ")", "{", "return", "StringUtils", ".", "normalizeWS", "(", "myBundle", ".", "get", "(", "aMessageKey", ",", "Long", ".", "toString", "(", "aLongDetail", ")", ")", ")", ";", "}" ]

[ "Gets", "the", "internationalized", "value", "for", "the", "supplied", "message", "key", "using", "a", "long", "as", "additional", "information", "." ]

[ "protected", "String", "getI18n", "(", "final", "String", "aMessageKey", ",", "final", "int", "aIntDetail", ")", "{", "return", "StringUtils", ".", "normalizeWS", "(", "myBundle", ".", "get", "(", "aMessageKey", ",", "Integer", ".", "toString", "(", "aIntDetail", ")", ")", ")", ";", "}" ]

[ "Gets", "the", "internationalized", "value", "for", "the", "supplied", "message", "key", "using", "an", "int", "as", "additional", "information", "." ]

[ "protected", "String", "getI18n", "(", "final", "String", "aMessageKey", ",", "final", "String", "aDetail", ")", "{", "return", "StringUtils", ".", "normalizeWS", "(", "myBundle", ".", "get", "(", "aMessageKey", ",", "aDetail", ")", ")", ";", "}" ]

[ "Gets", "the", "internationalized", "value", "for", "the", "supplied", "message", "key", "using", "a", "string", "as", "additional", "information", "." ]

[ "protected", "String", "getI18n", "(", "final", "String", "aMessageKey", ",", "final", "String", "...", "aDetailsArray", ")", "{", "return", "StringUtils", ".", "normalizeWS", "(", "myBundle", ".", "get", "(", "aMessageKey", ",", "aDetailsArray", ")", ")", ";", "}" ]

[ "Gets", "the", "internationalized", "value", "for", "the", "supplied", "message", "key", "using", "a", "string", "array", "as", "additional", "information", "." ]

[ "protected", "String", "getI18n", "(", "final", "String", "aMessageKey", ",", "final", "Exception", "aException", ")", "{", "return", "StringUtils", ".", "normalizeWS", "(", "myBundle", ".", "get", "(", "aMessageKey", ",", "aException", ".", "getMessage", "(", ")", ")", ")", ";", "}" ]

[ "Gets", "the", "internationalized", "value", "for", "the", "supplied", "message", "key", "using", "an", "exception", "as", "additional", "information", "." ]

[ "protected", "String", "getI18n", "(", "final", "String", "aMessageKey", ",", "final", "File", "aFile", ")", "{", "return", "StringUtils", ".", "normalizeWS", "(", "myBundle", ".", "get", "(", "aMessageKey", ",", "aFile", ".", "getAbsolutePath", "(", ")", ")", ")", ";", "}" ]

[ "Gets", "the", "internationalized", "value", "for", "the", "supplied", "message", "key", "using", "a", "file", "as", "additional", "information", "." ]

[ "protected", "String", "getI18n", "(", "final", "String", "aMessageKey", ",", "final", "File", "...", "aFileArray", ")", "{", "final", "String", "[", "]", "fileNames", "=", "new", "String", "[", "aFileArray", ".", "length", "]", ";", "for", "(", "int", "index", "=", "0", ";", "index", "<", "fileNames", ".", "length", ";", "index", "++", ")", "{", "fileNames", "[", "index", "]", "=", "aFileArray", "[", "index", "]", ".", "getAbsolutePath", "(", ")", ";", "}", "return", "StringUtils", ".", "normalizeWS", "(", "myBundle", ".", "get", "(", "aMessageKey", ",", "fileNames", ")", ")", ";", "}" ]

[ "Gets", "the", "internationalized", "value", "for", "the", "supplied", "message", "key", "using", "a", "file", "array", "as", "additional", "information", "." ]

[ "protected", "String", "getI18n", "(", "final", "String", "aMessageKey", ",", "final", "Object", "...", "aObjArray", ")", "{", "final", "String", "[", "]", "strings", "=", "new", "String", "[", "aObjArray", ".", "length", "]", ";", "for", "(", "int", "index", "=", "0", ";", "index", "<", "aObjArray", ".", "length", ";", "index", "++", ")", "{", "if", "(", "aObjArray", "[", "index", "]", "instanceof", "File", ")", "{", "strings", "[", "index", "]", "=", "(", "(", "File", ")", "aObjArray", "[", "index", "]", ")", ".", "getAbsolutePath", "(", ")", ";", "}", "else", "{", "strings", "[", "index", "]", "=", "aObjArray", "[", "index", "]", ".", "toString", "(", ")", ";", "}", "}", "return", "StringUtils", ".", "normalizeWS", "(", "myBundle", ".", "get", "(", "aMessageKey", ",", "strings", ")", ")", ";", "}" ]

[ "Gets", "the", "internationalized", "value", "for", "the", "supplied", "message", "key", "using", "an", "object", "array", "as", "additional", "information", "." ]

[ "protected", "boolean", "hasI18nKey", "(", "final", "String", "aMessageKey", ")", "{", "return", "myBundle", "!=", "null", "&&", "aMessageKey", "!=", "null", "&&", "myBundle", ".", "containsKey", "(", "aMessageKey", ")", ";", "}" ]

[ "Returns", "true", "if", "this", "I18N", "object", "contains", "the", "requested", "I18N", "key", ";", "else", "false", "." ]

[ "public", "static", "String", "[", "]", "getDirs", "(", ")", "{", "final", "ArrayList", "<", "String", ">", "list", "=", "new", "ArrayList", "<>", "(", ")", ";", "for", "(", "final", "String", "filename", ":", "System", ".", "getProperty", "(", "CLASSPATH", ")", ".", "split", "(", "DELIMETER", ")", ")", "{", "final", "File", "file", "=", "new", "File", "(", "filename", ")", ";", "LOGGER", ".", "debug", "(", "MessageCodes", ".", "UTIL_003", ",", "file", ",", "file", ".", "isDirectory", "(", ")", "?", "YES", ":", "NO", ")", ";", "if", "(", "file", ".", "isDirectory", "(", ")", ")", "{", "list", ".", "add", "(", "file", ".", "getAbsolutePath", "(", ")", ")", ";", "}", "}", "return", "list", ".", "toArray", "(", "new", "String", "[", "0", "]", ")", ";", "}" ]

[ "Returns", "an", "String", "array", "of", "all", "the", "directory", "names", "in", "the", "system", "classpath" ]

[ "public", "static", "String", "[", "]", "getJars", "(", ")", "{", "final", "ArrayList", "<", "String", ">", "list", "=", "new", "ArrayList", "<>", "(", ")", ";", "final", "FileExtFileFilter", "filter", "=", "new", "FileExtFileFilter", "(", "JAR_EXT", ")", ";", "for", "(", "final", "String", "part", ":", "System", ".", "getProperty", "(", "CLASSPATH", ")", ".", "split", "(", "File", ".", "pathSeparator", ")", ")", "{", "final", "File", "file", "=", "new", "File", "(", "part", ")", ";", "if", "(", "filter", ".", "accept", "(", "file", ".", "getParentFile", "(", ")", ",", "file", ".", "getName", "(", ")", ")", ")", "{", "list", ".", "add", "(", "file", ".", "getAbsolutePath", "(", ")", ")", ";", "}", "}", "return", "list", ".", "toArray", "(", "new", "String", "[", "0", "]", ")", ";", "}" ]

[ "Returns", "an", "String", "array", "of", "all", "the", "names", "of", "the", "jars", "in", "the", "system", "classpath" ]

[ "public", "boolean", "initiateOutgoingMessage", "(", "String", "toUri", ",", "String", "viaNonProxyRoute", ")", "{", "return", "initiateOutgoingMessage", "(", "null", ",", "toUri", ",", "viaNonProxyRoute", ",", "null", ",", "null", ",", "null", ")", ";", "}" ]

[ "This", "basic", "method", "is", "used", "to", "initiate", "an", "outgoing", "MESSAGE", "." ]

[ "public", "SipResponse", "findMostRecentResponse", "(", "int", "statusCode", ")", "{", "List", "<", "SipResponse", ">", "responses", "=", "getAllReceivedResponses", "(", ")", ";", "ListIterator", "<", "SipResponse", ">", "i", "=", "responses", ".", "listIterator", "(", "responses", ".", "size", "(", ")", ")", ";", "while", "(", "i", ".", "hasPrevious", "(", ")", ")", "{", "SipResponse", "resp", "=", "i", ".", "previous", "(", ")", ";", "if", "(", "resp", ".", "getStatusCode", "(", ")", "==", "statusCode", ")", "{", "return", "resp", ";", "}", "}", "return", "null", ";", "}" ]

[ "Finds", "the", "last", "received", "response", "with", "status", "code", "matching", "the", "given", "parameter", "." ]

[ "public", "String", "generateNewTag", "(", ")", "{", "// This scheme of using random numbers to generate a", "// unique tag has a small probability of", "// causing duplicate tags.", "// TODO at some point, we may want to change it.", "int", "r", "=", "parent", ".", "getRandom", "(", ")", ".", "nextInt", "(", ")", ";", "r", "=", "(", "r", "<", "0", ")", "?", "0", "-", "r", ":", "r", ";", "// generate a positive number", "// incorporate registration/session ID (myRegistrationId) into all tags", "// from this", "// client? (for jiplet call identification purposes)", "return", "Integer", ".", "toString", "(", "r", ")", ";", "}" ]

[ "Generates", "a", "newly", "generated", "unique", "tag", "ID", "." ]

[ "public", "SipTransaction", "sendRequestWithTransaction", "(", "String", "reqMessage", ",", "boolean", "viaProxy", ",", "Dialog", "dialog", ")", "throws", "ParseException", "{", "Request", "request", "=", "parent", ".", "getMessageFactory", "(", ")", ".", "createRequest", "(", "reqMessage", ")", ";", "return", "sendRequestWithTransaction", "(", "request", ",", "viaProxy", ",", "dialog", ")", ";", "}" ]

[ "This", "basic", "method", "sends", "out", "a", "request", "message", "as", "part", "of", "a", "transaction", ".", "A", "test", "program", "should", "use", "this", "method", "when", "a", "response", "to", "a", "request", "is", "expected", ".", "A", "Request", "object", "is", "constructed", "from", "the", "string", "passed", "in", "." ]

[ "public", "SipTransaction", "sendRequestWithTransaction", "(", "Request", "request", ",", "boolean", "viaProxy", ",", "Dialog", "dialog", ")", "{", "return", "sendRequestWithTransaction", "(", "request", ",", "viaProxy", ",", "dialog", ",", "null", ")", ";", "}" ]

[ "This", "basic", "method", "sends", "out", "a", "request", "message", "as", "part", "of", "a", "transaction", ".", "A", "test", "program", "should", "use", "this", "method", "when", "a", "response", "to", "a", "request", "is", "expected", ".", "The", "Request", "object", "passed", "in", "must", "be", "a", "fully", "formed", "Request", "with", "all", "required", "content", "EXCEPT", "for", "the", "Via", "header", "branch", "parameter", "which", "cannot", "be", "filled", "in", "until", "a", "client", "transaction", "is", "obtained", ".", "That", "happens", "in", "this", "method", ".", "If", "the", "Via", "branch", "value", "is", "set", "in", "the", "request", "parameter", "passed", "to", "this", "method", "it", "is", "nulled", "out", "by", "this", "method", "so", "that", "a", "new", "client", "transaction", "can", "be", "created", "by", "the", "stack", "." ]

[ "public", "boolean", "sendUnidirectionalResponse", "(", "RequestEvent", "request", ",", "int", "statusCode", ",", "String", "reasonPhrase", ",", "String", "toTag", ",", "Address", "contact", ",", "int", "expires", ")", "{", "initErrorInfo", "(", ")", ";", "if", "(", "(", "request", "==", "null", ")", "||", "(", "request", ".", "getRequest", "(", ")", "==", "null", ")", ")", "{", "setErrorMessage", "(", "\"Cannot send response, request information is null\"", ")", ";", "setReturnCode", "(", "INVALID_ARGUMENT", ")", ";", "return", "false", ";", "}", "Response", "response", ";", "try", "{", "response", "=", "parent", ".", "getMessageFactory", "(", ")", ".", "createResponse", "(", "statusCode", ",", "request", ".", "getRequest", "(", ")", ")", ";", "if", "(", "reasonPhrase", "!=", "null", ")", "{", "response", ".", "setReasonPhrase", "(", "reasonPhrase", ")", ";", "}", "if", "(", "toTag", "!=", "null", ")", "{", "(", "(", "ToHeader", ")", "response", ".", "getHeader", "(", "ToHeader", ".", "NAME", ")", ")", ".", "setTag", "(", "toTag", ")", ";", "}", "if", "(", "contact", "!=", "null", ")", "{", "response", ".", "addHeader", "(", "parent", ".", "getHeaderFactory", "(", ")", ".", "createContactHeader", "(", "contact", ")", ")", ";", "}", "if", "(", "expires", "!=", "-", "1", ")", "{", "response", ".", "addHeader", "(", "parent", ".", "getHeaderFactory", "(", ")", ".", "createExpiresHeader", "(", "expires", ")", ")", ";", "}", "}", "catch", "(", "Exception", "ex", ")", "{", "setException", "(", "ex", ")", ";", "setErrorMessage", "(", "\"Exception: \"", "+", "ex", ".", "getClass", "(", ")", ".", "getName", "(", ")", "+", "\": \"", "+", "ex", ".", "getMessage", "(", ")", ")", ";", "setReturnCode", "(", "EXCEPTION_ENCOUNTERED", ")", ";", "return", "false", ";", "}", "return", "sendUnidirectionalResponse", "(", "response", ")", ";", "}" ]

[ "This", "method", "sends", "out", "a", "stateless", "response", "to", "the", "given", "request", "." ]

[ "public", "Request", "getRequest", "(", ")", "{", "if", "(", "clientTransaction", "!=", "null", ")", "{", "return", "clientTransaction", ".", "getRequest", "(", ")", ";", "}", "if", "(", "serverTransaction", "!=", "null", ")", "{", "return", "serverTransaction", ".", "getRequest", "(", ")", ";", "}", "return", "null", ";", "}" ]

[ "The", "user", "test", "program", "MAY", "call", "this", "method", "to", "view", "the", "javax", ".", "sip", ".", "message", ".", "Request", "object", "that", "created", "this", "transaction", ".", "However", "knowledge", "of", "JAIN", "SIP", "API", "is", "required", "to", "interpret", "the", "Request", "object", "." ]

[ "public", "static", "void", "assertLastOperationSuccess", "(", "String", "msg", ",", "SipActionObject", "op", ")", "{", "assertNotNull", "(", "\"Null assert object passed in\"", ",", "op", ")", ";", "assertTrue", "(", "msg", ",", "op", ".", "getErrorMessage", "(", ")", ".", "length", "(", ")", "==", "0", ")", ";", "}" ]

[ "Asserts", "that", "the", "last", "SIP", "operation", "performed", "by", "the", "given", "object", "was", "successful", ".", "Assertion", "failure", "output", "includes", "the", "given", "message", "text", "." ]

[ "public", "static", "void", "assertHeaderPresent", "(", "String", "msg", ",", "SipMessage", "sipMessage", ",", "String", "header", ")", "{", "assertNotNull", "(", "\"Null assert object passed in\"", ",", "sipMessage", ")", ";", "assertTrue", "(", "msg", ",", "sipMessage", ".", "getHeaders", "(", "header", ")", ".", "hasNext", "(", ")", ")", ";", "}" ]

[ "Asserts", "that", "the", "given", "SIP", "message", "contains", "at", "least", "one", "occurrence", "of", "the", "specified", "header", ".", "Assertion", "failure", "output", "includes", "the", "given", "message", "text", "." ]

[ "public", "static", "void", "assertHeaderNotPresent", "(", "String", "msg", ",", "SipMessage", "sipMessage", ",", "String", "header", ")", "{", "assertNotNull", "(", "\"Null assert object passed in\"", ",", "sipMessage", ")", ";", "assertFalse", "(", "msg", ",", "sipMessage", ".", "getHeaders", "(", "header", ")", ".", "hasNext", "(", ")", ")", ";", "}" ]

[ "Asserts", "that", "the", "given", "SIP", "message", "contains", "no", "occurrence", "of", "the", "specified", "header", ".", "Assertion", "failure", "output", "includes", "the", "given", "message", "text", "." ]

[ "public", "static", "void", "assertHeaderContains", "(", "SipMessage", "sipMessage", ",", "String", "header", ",", "String", "value", ")", "{", "assertHeaderContains", "(", "null", ",", "sipMessage", ",", "header", ",", "value", ")", ";", "// value is case\r", "// sensitive?\r", "}" ]

[ "Asserts", "that", "the", "given", "SIP", "message", "contains", "at", "least", "one", "occurrence", "of", "the", "specified", "header", "and", "that", "at", "least", "one", "occurrence", "of", "this", "header", "contains", "the", "given", "value", ".", "The", "assertion", "fails", "if", "no", "occurrence", "of", "the", "header", "contains", "the", "value", "or", "if", "the", "header", "is", "not", "present", "in", "the", "mesage", "." ]

[ "public", "static", "void", "assertHeaderContains", "(", "String", "msg", ",", "SipMessage", "sipMessage", ",", "String", "header", ",", "String", "value", ")", "{", "assertNotNull", "(", "\"Null assert object passed in\"", ",", "sipMessage", ")", ";", "ListIterator", "<", "Header", ">", "l", "=", "sipMessage", ".", "getHeaders", "(", "header", ")", ";", "while", "(", "l", ".", "hasNext", "(", ")", ")", "{", "String", "h", "=", "(", "(", "Header", ")", "l", ".", "next", "(", ")", ")", ".", "toString", "(", ")", ";", "if", "(", "h", ".", "indexOf", "(", "value", ")", "!=", "-", "1", ")", "{", "assertTrue", "(", "true", ")", ";", "return", ";", "}", "}", "fail", "(", "msg", ")", ";", "}" ]

[ "Asserts", "that", "the", "given", "SIP", "message", "contains", "at", "least", "one", "occurrence", "of", "the", "specified", "header", "and", "that", "at", "least", "one", "occurrence", "of", "this", "header", "contains", "the", "given", "value", ".", "The", "assertion", "fails", "if", "no", "occurrence", "of", "the", "header", "contains", "the", "value", "or", "if", "the", "header", "is", "not", "present", "in", "the", "mesage", ".", "Assertion", "failure", "output", "includes", "the", "given", "message", "text", "." ]

[ "public", "static", "void", "assertHeaderNotContains", "(", "SipMessage", "sipMessage", ",", "String", "header", ",", "String", "value", ")", "{", "assertHeaderNotContains", "(", "null", ",", "sipMessage", ",", "header", ",", "value", ")", ";", "}" ]

[ "Asserts", "that", "the", "given", "SIP", "message", "contains", "no", "occurrence", "of", "the", "specified", "header", "with", "the", "value", "given", "or", "that", "there", "is", "no", "occurrence", "of", "the", "header", "in", "the", "message", ".", "The", "assertion", "fails", "if", "any", "occurrence", "of", "the", "header", "contains", "the", "value", "." ]

[ "public", "static", "void", "assertResponseReceived", "(", "int", "statusCode", ",", "String", "method", ",", "long", "sequenceNumber", ",", "MessageListener", "obj", ")", "{", "assertResponseReceived", "(", "null", ",", "statusCode", ",", "method", ",", "sequenceNumber", ",", "obj", ")", ";", "}" ]

[ "Asserts", "that", "the", "given", "message", "listener", "object", "received", "a", "response", "with", "the", "indicated", "status", "code", "CSeq", "method", "and", "CSeq", "sequence", "number", "." ]

[ "public", "static", "void", "assertResponseReceived", "(", "String", "msg", ",", "int", "statusCode", ",", "MessageListener", "obj", ")", "{", "assertNotNull", "(", "\"Null assert object passed in\"", ",", "obj", ")", ";", "assertTrue", "(", "msg", ",", "responseReceived", "(", "statusCode", ",", "obj", ")", ")", ";", "}" ]

[ "Asserts", "that", "the", "given", "message", "listener", "object", "received", "a", "response", "with", "the", "indicated", "status", "code", ".", "Assertion", "failure", "output", "includes", "the", "given", "message", "text", "." ]

[ "public", "static", "boolean", "responseReceived", "(", "int", "statusCode", ",", "MessageListener", "messageListener", ")", "{", "ArrayList", "<", "SipResponse", ">", "responses", "=", "messageListener", ".", "getAllReceivedResponses", "(", ")", ";", "for", "(", "SipResponse", "r", ":", "responses", ")", "{", "if", "(", "statusCode", "==", "r", ".", "getStatusCode", "(", ")", ")", "{", "return", "true", ";", "}", "}", "return", "false", ";", "}" ]

[ "Check", "the", "given", "message", "listener", "object", "received", "a", "response", "with", "the", "indicated", "status", "code", "." ]

[ "public", "static", "void", "assertResponseNotReceived", "(", "int", "statusCode", ",", "String", "method", ",", "long", "sequenceNumber", ",", "MessageListener", "obj", ")", "{", "assertResponseNotReceived", "(", "null", ",", "statusCode", ",", "method", ",", "sequenceNumber", ",", "obj", ")", ";", "}" ]

[ "Asserts", "that", "the", "given", "message", "listener", "object", "has", "not", "received", "a", "response", "with", "the", "indicated", "status", "code", "CSeq", "method", "and", "sequence", "number", "." ]

[ "public", "static", "void", "assertResponseNotReceived", "(", "String", "msg", ",", "int", "statusCode", ",", "String", "method", ",", "long", "sequenceNumber", ",", "MessageListener", "obj", ")", "{", "assertNotNull", "(", "\"Null assert object passed in\"", ",", "obj", ")", ";", "assertFalse", "(", "msg", ",", "responseReceived", "(", "statusCode", ",", "method", ",", "sequenceNumber", ",", "obj", ")", ")", ";", "}" ]

[ "Asserts", "that", "the", "given", "message", "listener", "object", "has", "not", "received", "a", "response", "with", "the", "indicated", "status", "code", "CSeq", "method", "and", "sequence", "number", ".", "Assertion", "failure", "output", "includes", "the", "given", "message", "text", "." ]

[ "public", "static", "void", "assertRequestReceived", "(", "String", "method", ",", "long", "sequenceNumber", ",", "MessageListener", "obj", ")", "{", "assertRequestReceived", "(", "null", ",", "method", ",", "sequenceNumber", ",", "obj", ")", ";", "}" ]

[ "Asserts", "that", "the", "given", "message", "listener", "object", "received", "a", "request", "with", "the", "indicated", "CSeq", "method", "and", "CSeq", "sequence", "number", "." ]

[ "public", "static", "void", "assertRequestReceived", "(", "String", "msg", ",", "String", "method", ",", "MessageListener", "obj", ")", "{", "assertNotNull", "(", "\"Null assert object passed in\"", ",", "obj", ")", ";", "assertTrue", "(", "msg", ",", "requestReceived", "(", "method", ",", "obj", ")", ")", ";", "}" ]

[ "Asserts", "that", "the", "given", "message", "listener", "object", "received", "a", "request", "with", "the", "indicated", "request", "method", ".", "Assertion", "failure", "output", "includes", "the", "given", "message", "text", "." ]

[ "public", "static", "void", "assertRequestNotReceived", "(", "String", "msg", ",", "String", "method", ",", "MessageListener", "obj", ")", "{", "assertNotNull", "(", "\"Null assert object passed in\"", ",", "obj", ")", ";", "assertFalse", "(", "msg", ",", "requestReceived", "(", "method", ",", "obj", ")", ")", ";", "}" ]

[ "Asserts", "that", "the", "given", "message", "listener", "object", "has", "not", "received", "a", "request", "with", "the", "indicated", "request", "method", ".", "Assertion", "failure", "output", "includes", "the", "given", "message", "text", "." ]

[ "public", "static", "void", "assertRequestNotReceived", "(", "String", "method", ",", "long", "sequenceNumber", ",", "MessageListener", "obj", ")", "{", "assertRequestNotReceived", "(", "null", ",", "method", ",", "sequenceNumber", ",", "obj", ")", ";", "}" ]

[ "Asserts", "that", "the", "given", "message", "listener", "object", "has", "not", "received", "a", "request", "with", "the", "indicated", "CSeq", "method", "and", "sequence", "number", "." ]

[ "public", "static", "void", "assertAnswered", "(", "String", "msg", ",", "SipCall", "call", ")", "{", "assertNotNull", "(", "\"Null assert object passed in\"", ",", "call", ")", ";", "assertTrue", "(", "msg", ",", "call", ".", "isCallAnswered", "(", ")", ")", ";", "}" ]

[ "Asserts", "that", "the", "given", "incoming", "or", "outgoing", "call", "leg", "was", "answered", ".", "Assertion", "failure", "output", "includes", "the", "given", "message", "text", "." ]

[ "public", "static", "void", "awaitAnswered", "(", "final", "String", "msg", ",", "final", "SipCall", "call", ")", "{", "await", "(", ")", ".", "until", "(", "new", "Runnable", "(", ")", "{", "@", "Override", "public", "void", "run", "(", ")", "{", "assertAnswered", "(", "msg", ",", "call", ")", ";", "}", "}", ")", ";", "}" ]

[ "Awaits", "that", "the", "given", "incoming", "or", "outgoing", "call", "leg", "was", "answered", ".", "Assertion", "failure", "output", "includes", "the", "given", "message", "text", "." ]

[ "public", "static", "void", "assertNotAnswered", "(", "String", "msg", ",", "SipCall", "call", ")", "{", "assertNotNull", "(", "\"Null assert object passed in\"", ",", "call", ")", ";", "assertFalse", "(", "msg", ",", "call", ".", "isCallAnswered", "(", ")", ")", ";", "}" ]

[ "Asserts", "that", "the", "given", "incoming", "or", "outgoing", "call", "leg", "has", "not", "been", "answered", ".", "Assertion", "failure", "output", "includes", "the", "given", "message", "text", "." ]

[ "public", "static", "void", "assertBodyPresent", "(", "String", "msg", ",", "SipMessage", "sipMessage", ")", "{", "assertNotNull", "(", "\"Null assert object passed in\"", ",", "sipMessage", ")", ";", "assertTrue", "(", "msg", ",", "sipMessage", ".", "getContentLength", "(", ")", ">", "0", ")", ";", "}" ]

[ "Asserts", "that", "the", "given", "SIP", "message", "contains", "a", "body", ".", "Assertion", "failure", "output", "includes", "the", "given", "message", "text", "." ]

[ "public", "static", "void", "assertBodyNotPresent", "(", "String", "msg", ",", "SipMessage", "sipMessage", ")", "{", "assertNotNull", "(", "\"Null assert object passed in\"", ",", "sipMessage", ")", ";", "assertFalse", "(", "msg", ",", "sipMessage", ".", "getContentLength", "(", ")", ">", "0", ")", ";", "}" ]

[ "Asserts", "that", "the", "given", "SIP", "message", "contains", "no", "body", ".", "Assertion", "failure", "output", "includes", "the", "given", "message", "text", "." ]

[ "public", "static", "void", "assertBodyContains", "(", "String", "msg", ",", "SipMessage", "sipMessage", ",", "String", "value", ")", "{", "assertNotNull", "(", "\"Null assert object passed in\"", ",", "sipMessage", ")", ";", "assertBodyPresent", "(", "msg", ",", "sipMessage", ")", ";", "String", "body", "=", "new", "String", "(", "sipMessage", ".", "getRawContent", "(", ")", ")", ";", "if", "(", "body", ".", "indexOf", "(", "value", ")", "!=", "-", "1", ")", "{", "assertTrue", "(", "true", ")", ";", "return", ";", "}", "fail", "(", "msg", ")", ";", "}" ]

[ "Asserts", "that", "the", "given", "SIP", "message", "contains", "a", "body", "that", "includes", "the", "given", "value", ".", "The", "assertion", "fails", "if", "a", "body", "is", "not", "present", "in", "the", "message", "or", "is", "present", "but", "doesn", "t", "include", "the", "value", ".", "Assertion", "failure", "output", "includes", "the", "given", "message", "text", "." ]

[ "public", "static", "void", "assertBodyNotContains", "(", "String", "msg", ",", "SipMessage", "sipMessage", ",", "String", "value", ")", "{", "assertNotNull", "(", "\"Null assert object passed in\"", ",", "sipMessage", ")", ";", "if", "(", "sipMessage", ".", "getContentLength", "(", ")", ">", "0", ")", "{", "String", "body", "=", "new", "String", "(", "sipMessage", ".", "getRawContent", "(", ")", ")", ";", "if", "(", "body", ".", "indexOf", "(", "value", ")", "!=", "-", "1", ")", "{", "fail", "(", "msg", ")", ";", "}", "}", "assertTrue", "(", "true", ")", ";", "}" ]

[ "Asserts", "that", "the", "body", "in", "the", "given", "SIP", "message", "does", "not", "contain", "the", "value", "given", "or", "that", "there", "is", "no", "body", "in", "the", "message", ".", "The", "assertion", "fails", "if", "the", "body", "is", "present", "and", "contains", "the", "value", ".", "Assertion", "failure", "output", "includes", "the", "given", "message", "text", "." ]

[ "public", "static", "void", "dumpMessage", "(", "String", "informationalHeader", ",", "javax", ".", "sip", ".", "message", ".", "Message", "msg", ")", "{", "LOG", ".", "trace", "(", "informationalHeader", "+", "\"{}.......... \\n {}\"", ",", "informationalHeader", ",", "msg", ")", ";", "ListIterator", "rhdrs", "=", "msg", ".", "getHeaders", "(", "RouteHeader", ".", "NAME", ")", ";", "while", "(", "rhdrs", ".", "hasNext", "(", ")", ")", "{", "RouteHeader", "rhdr", "=", "(", "RouteHeader", ")", "rhdrs", ".", "next", "(", ")", ";", "if", "(", "rhdr", "!=", "null", ")", "{", "LOG", ".", "trace", "(", "\"RouteHeader address: {}\"", ",", "rhdr", ".", "getAddress", "(", ")", ".", "toString", "(", ")", ")", ";", "Iterator", "i", "=", "rhdr", ".", "getParameterNames", "(", ")", ";", "while", "(", "i", ".", "hasNext", "(", ")", ")", "{", "String", "parm", "=", "(", "String", ")", "i", ".", "next", "(", ")", ";", "LOG", ".", "trace", "(", "\"RouteHeader parameter {}: {}\"", ",", "parm", ",", "rhdr", ".", "getParameter", "(", "parm", ")", ")", ";", "}", "}", "}", "ListIterator", "rrhdrs", "=", "msg", ".", "getHeaders", "(", "RecordRouteHeader", ".", "NAME", ")", ";", "while", "(", "rrhdrs", ".", "hasNext", "(", ")", ")", "{", "RecordRouteHeader", "rrhdr", "=", "(", "RecordRouteHeader", ")", "rrhdrs", ".", "next", "(", ")", ";", "if", "(", "rrhdr", "!=", "null", ")", "{", "LOG", ".", "trace", "(", "\"RecordRouteHeader address: {}\"", ",", "rrhdr", ".", "getAddress", "(", ")", ")", ";", "Iterator", "i", "=", "rrhdr", ".", "getParameterNames", "(", ")", ";", "while", "(", "i", ".", "hasNext", "(", ")", ")", "{", "String", "parm", "=", "(", "String", ")", "i", ".", "next", "(", ")", ";", "LOG", ".", "trace", "(", "\"RecordRouteHeader parameter {}: {}\"", ",", "parm", ",", "rrhdr", ".", "getParameter", "(", "parm", ")", ")", ";", "}", "}", "}", "}" ]

[ "Outputs", "to", "console", "the", "provided", "header", "string", "followed", "by", "the", "message", "." ]

[ "protected", "Response", "createNotifyResponse", "(", "RequestEvent", "request", ",", "int", "status", ",", "String", "reason", ",", "List", "<", "Header", ">", "additionalHeaders", ")", "{", "// when used internally - WATCH OUT - retcode, errorMessage initialized here", "initErrorInfo", "(", ")", ";", "if", "(", "(", "request", "==", "null", ")", "||", "(", "request", ".", "getRequest", "(", ")", "==", "null", ")", ")", "{", "setReturnCode", "(", "SipSession", ".", "INVALID_ARGUMENT", ")", ";", "setErrorMessage", "(", "\"Null request given for creating NOTIFY response\"", ")", ";", "return", "null", ";", "}", "Request", "req", "=", "request", ".", "getRequest", "(", ")", ";", "String", "cseqStr", "=", "\"CSEQ \"", "+", "(", "(", "CSeqHeader", ")", "req", ".", "getHeader", "(", "CSeqHeader", ".", "NAME", ")", ")", ".", "getSeqNumber", "(", ")", ";", "LOG", ".", "trace", "(", "\"Creating NOTIFY {} response with status code {}, reason phrase = {}\"", ",", "cseqStr", ",", "status", ",", "reason", ")", ";", "try", "{", "Response", "response", "=", "parent", ".", "getMessageFactory", "(", ")", ".", "createResponse", "(", "status", ",", "req", ")", ";", "if", "(", "reason", "!=", "null", ")", "{", "response", ".", "setReasonPhrase", "(", "reason", ")", ";", "}", "(", "(", "ToHeader", ")", "response", ".", "getHeader", "(", "ToHeader", ".", "NAME", ")", ")", ".", "setTag", "(", "myTag", ")", ";", "response", ".", "addHeader", "(", "(", "ContactHeader", ")", "parent", ".", "getContactInfo", "(", ")", ".", "getContactHeader", "(", ")", ".", "clone", "(", ")", ")", ";", "if", "(", "additionalHeaders", "!=", "null", ")", "{", "Iterator", "<", "Header", ">", "i", "=", "additionalHeaders", ".", "iterator", "(", ")", ";", "while", "(", "i", ".", "hasNext", "(", ")", ")", "{", "response", ".", "addHeader", "(", "i", ".", "next", "(", ")", ")", ";", "}", "}", "return", "response", ";", "}", "catch", "(", "Exception", "e", ")", "{", "setReturnCode", "(", "SipSession", ".", "EXCEPTION_ENCOUNTERED", ")", ";", "setException", "(", "e", ")", ";", "setErrorMessage", "(", "\"Exception: \"", "+", "e", ".", "getClass", "(", ")", ".", "getName", "(", ")", "+", "\": \"", "+", "e", ".", "getMessage", "(", ")", ")", ";", "}", "return", "null", ";", "}" ]

[ "if", "returns", "null", "returnCode", "and", "errorMessage", "already", "set" ]

[ "public", "boolean", "unregister", "(", "String", "contact", ",", "long", "timeout", ")", "{", "initErrorInfo", "(", ")", ";", "// TODO - need to support multiple server(s)/registrations", "// simultaneously?", "// then return registration() object to user (w/lastregrequest) and", "// receive", "// it here, get rid of lastRegistrationRequest", "if", "(", "lastRegistrationRequest", "==", "null", ")", "{", "return", "true", ";", "}", "Request", "msg", "=", "(", "Request", ")", "lastRegistrationRequest", ".", "clone", "(", ")", ";", "try", "{", "ExpiresHeader", "expires", "=", "parent", ".", "getHeaderFactory", "(", ")", ".", "createExpiresHeader", "(", "0", ")", ";", "msg", ".", "setExpires", "(", "expires", ")", ";", "cseq", ".", "setSeqNumber", "(", "cseq", ".", "getSeqNumber", "(", ")", "+", "1", ")", ";", "cseq", ".", "setMethod", "(", "Request", ".", "REGISTER", ")", ";", "msg", ".", "setHeader", "(", "cseq", ")", ";", "// set contact header", "if", "(", "contact", "!=", "null", ")", "{", "ContactHeader", "contact_hdr", ";", "if", "(", "!", "contact", ".", "equals", "(", "\"*\"", ")", ")", "{", "URI", "contact_uri", "=", "parent", ".", "getAddressFactory", "(", ")", ".", "createURI", "(", "contact", ")", ";", "Address", "contact_address", "=", "parent", ".", "getAddressFactory", "(", ")", ".", "createAddress", "(", "contact_uri", ")", ";", "contact_hdr", "=", "parent", ".", "getHeaderFactory", "(", ")", ".", "createContactHeader", "(", "contact_address", ")", ";", "}", "else", "{", "contact_hdr", "=", "parent", ".", "getHeaderFactory", "(", ")", ".", "createContactHeader", "(", ")", ";", "}", "msg", ".", "setHeader", "(", "contact_hdr", ")", ";", "}", "// send the REGISTRATION request and get the response", "Response", "response", "=", "sendRegistrationMessage", "(", "msg", ",", "null", ",", "null", ",", "30000", ")", ";", "if", "(", "response", "==", "null", ")", "{", "return", "false", ";", "}", "// clear out authorizations accumulated for this Call-ID", "clearAuthorizations", "(", "myRegistrationId", ")", ";", "// should we drop any calls in progress?", "lastRegistrationRequest", "=", "null", ";", "return", "true", ";", "}", "catch", "(", "Exception", "ex", ")", "{", "setReturnCode", "(", "EXCEPTION_ENCOUNTERED", ")", ";", "setErrorMessage", "(", "\"Exception: \"", "+", "ex", ".", "getClass", "(", ")", ".", "getName", "(", ")", "+", "\": \"", "+", "ex", ".", "getMessage", "(", ")", ")", ";", "return", "false", ";", "}", "}" ]

[ "This", "method", "performs", "the", "SIP", "unregistration", "process", ".", "It", "returns", "true", "if", "unregistration", "was", "successful", "or", "no", "unregistration", "was", "needed", "and", "false", "otherwise", ".", "Any", "authorization", "headers", "required", "for", "the", "last", "registration", "are", "cleared", "out", ".", "If", "there", "was", "no", "previous", "registration", "this", "method", "does", "not", "send", "any", "messages", "." ]

[ "public", "SipCall", "createSipCall", "(", ")", "{", "initErrorInfo", "(", ")", ";", "SipCall", "call", "=", "new", "SipCall", "(", "this", ",", "myAddress", ")", ";", "callList", ".", "add", "(", "call", ")", ";", "return", "call", ";", "}" ]

[ "This", "method", "is", "used", "to", "create", "a", "SipCall", "object", "for", "handling", "one", "leg", "of", "a", "call", ".", "That", "is", "it", "represents", "an", "outgoing", "call", "leg", "or", "an", "incoming", "call", "leg", ".", "In", "a", "telephone", "call", "there", "are", "two", "call", "legs", ".", "The", "outgoing", "call", "leg", "is", "the", "connection", "from", "the", "phone", "making", "the", "call", "to", "the", "telephone", "network", ".", "The", "incoming", "call", "leg", "is", "a", "connection", "from", "the", "telephone", "network", "to", "the", "phone", "being", "called", ".", "For", "a", "SIP", "call", "the", "outbound", "leg", "is", "the", "user", "agent", "originating", "the", "call", "and", "the", "inbound", "leg", "is", "the", "user", "agent", "receiving", "the", "call", ".", "The", "test", "program", "can", "use", "this", "method", "to", "create", "a", "SipCall", "object", "for", "handling", "an", "incoming", "call", "leg", "or", "an", "outgoing", "call", "leg", ".", "Currently", "only", "one", "SipCall", "object", "is", "supported", "per", "SipPhone", ".", "In", "future", "when", "more", "than", "one", "SipCall", "per", "SipPhone", "is", "supported", "this", "method", "can", "be", "called", "multiple", "times", "to", "create", "multiple", "call", "legs", "on", "the", "same", "SipPhone", "object", "." ]

[ "public", "SipCall", "makeCall", "(", "String", "to", ",", "int", "response", ",", "long", "timeout", ",", "String", "viaNonProxyRoute", ")", "{", "return", "makeCall", "(", "to", ",", "response", ",", "timeout", ",", "viaNonProxyRoute", ",", "null", ",", "null", ",", "null", ")", ";", "}" ]

[ "This", "blocking", "basic", "method", "is", "used", "to", "make", "an", "outgoing", "call", ".", "It", "blocks", "until", "the", "specified", "INVITE", "response", "status", "code", "is", "received", ".", "The", "object", "returned", "is", "a", "SipCall", "object", "representing", "the", "outgoing", "call", "leg", ";", "that", "is", "the", "UAC", "originating", "a", "call", "to", "the", "network", ".", "Then", "you", "can", "take", "subsequent", "action", "on", "the", "call", "by", "making", "method", "calls", "on", "the", "SipCall", "object", "." ]

[ "public", "static", "String", "calculateResponse", "(", "String", "algorithm", ",", "String", "username_value", ",", "String", "realm_value", ",", "String", "passwd", ",", "String", "nonce_value", ",", "String", "nc_value", ",", "String", "cnonce_value", ",", "String", "Method", ",", "String", "digest_uri_value", ",", "String", "entity_body", ",", "String", "qop_value", ")", "{", "if", "(", "username_value", "==", "null", "||", "realm_value", "==", "null", "||", "passwd", "==", "null", "||", "Method", "==", "null", "||", "digest_uri_value", "==", "null", "||", "nonce_value", "==", "null", ")", "throw", "new", "NullPointerException", "(", "\"Null parameter to MessageDigestAlgorithm.calculateResponse()\"", ")", ";", "// The following follows closely the algorithm for generating a response", "// digest as specified by rfc2617", "String", "A1", "=", "null", ";", "if", "(", "algorithm", "==", "null", "||", "algorithm", ".", "trim", "(", ")", ".", "length", "(", ")", "==", "0", "||", "algorithm", ".", "trim", "(", ")", ".", "equalsIgnoreCase", "(", "\"MD5\"", ")", ")", "{", "A1", "=", "username_value", "+", "\":\"", "+", "realm_value", "+", "\":\"", "+", "passwd", ";", "}", "else", "{", "if", "(", "cnonce_value", "==", "null", "||", "cnonce_value", ".", "length", "(", ")", "==", "0", ")", "throw", "new", "NullPointerException", "(", "\"cnonce_value may not be absent for MD5-Sess algorithm.\"", ")", ";", "A1", "=", "H", "(", "username_value", "+", "\":\"", "+", "realm_value", "+", "\":\"", "+", "passwd", ")", "+", "\":\"", "+", "nonce_value", "+", "\":\"", "+", "cnonce_value", ";", "}", "String", "A2", "=", "null", ";", "if", "(", "qop_value", "==", "null", "||", "qop_value", ".", "trim", "(", ")", ".", "length", "(", ")", "==", "0", "||", "qop_value", ".", "trim", "(", ")", ".", "equalsIgnoreCase", "(", "\"auth\"", ")", ")", "{", "A2", "=", "Method", "+", "\":\"", "+", "digest_uri_value", ";", "}", "else", "{", "if", "(", "entity_body", "==", "null", ")", "entity_body", "=", "\"\"", ";", "A2", "=", "Method", "+", "\":\"", "+", "digest_uri_value", "+", "\":\"", "+", "H", "(", "entity_body", ")", ";", "}", "String", "request_digest", "=", "null", ";", "if", "(", "cnonce_value", "!=", "null", "&&", "qop_value", "!=", "null", "&&", "(", "qop_value", ".", "equals", "(", "\"auth\"", ")", "||", "(", "qop_value", ".", "equals", "(", "\"auth-int\"", ")", ")", ")", ")", "{", "request_digest", "=", "KD", "(", "H", "(", "A1", ")", ",", "nonce_value", "+", "\":\"", "+", "nc_value", "+", "\":\"", "+", "cnonce_value", "+", "\":\"", "+", "qop_value", "+", "\":\"", "+", "H", "(", "A2", ")", ")", ";", "}", "else", "{", "request_digest", "=", "KD", "(", "H", "(", "A1", ")", ",", "nonce_value", "+", "\":\"", "+", "H", "(", "A2", ")", ")", ";", "}", "return", "request_digest", ";", "}" ]

[ "Calculates", "a", "response", "an", "http", "authentication", "response", "in", "accordance", "with", "rfc2617", "." ]

[ "public", "String", "getRequestURI", "(", ")", "{", "if", "(", "(", "message", "==", "null", ")", "||", "(", "(", "(", "Request", ")", "message", ")", ".", "getRequestURI", "(", ")", "==", "null", ")", ")", "{", "return", "\"\"", ";", "}", "return", "(", "(", "Request", ")", "message", ")", ".", "getRequestURI", "(", ")", ".", "toString", "(", ")", ";", "}" ]

[ "Returns", "the", "request", "URI", "line", "of", "the", "request", "message", "or", "an", "empty", "string", "if", "there", "isn", "t", "one", ".", "The", "request", "URI", "indicates", "the", "user", "or", "service", "to", "which", "this", "request", "is", "addressed", "." ]

[ "public", "boolean", "isSipURI", "(", ")", "{", "if", "(", "(", "message", "==", "null", ")", "||", "(", "(", "(", "Request", ")", "message", ")", ".", "getRequestURI", "(", ")", "==", "null", ")", ")", "{", "return", "false", ";", "}", "return", "(", "(", "Request", ")", "message", ")", ".", "getRequestURI", "(", ")", ".", "isSipURI", "(", ")", ";", "}" ]

[ "Indicates", "if", "the", "request", "URI", "in", "the", "request", "message", "is", "a", "URI", "with", "a", "scheme", "of", "sip", "or", "sips", "." ]

[ "public", "boolean", "isInvite", "(", ")", "{", "if", "(", "message", "==", "null", ")", "{", "return", "false", ";", "}", "return", "(", "(", "(", "Request", ")", "message", ")", ".", "getMethod", "(", ")", ".", "equals", "(", "Request", ".", "INVITE", ")", ")", ";", "}" ]

[ "Indicates", "if", "the", "request", "method", "is", "INVITE", "or", "not", "." ]

[ "public", "boolean", "isAck", "(", ")", "{", "if", "(", "message", "==", "null", ")", "{", "return", "false", ";", "}", "return", "(", "(", "(", "Request", ")", "message", ")", ".", "getMethod", "(", ")", ".", "equals", "(", "Request", ".", "ACK", ")", ")", ";", "}" ]

[ "Indicates", "if", "the", "request", "method", "is", "ACK", "or", "not", "." ]

[ "public", "boolean", "isBye", "(", ")", "{", "if", "(", "message", "==", "null", ")", "{", "return", "false", ";", "}", "return", "(", "(", "(", "Request", ")", "message", ")", ".", "getMethod", "(", ")", ".", "equals", "(", "Request", ".", "BYE", ")", ")", ";", "}" ]

[ "Indicates", "if", "the", "request", "method", "is", "BYE", "or", "not", "." ]

[ "public", "boolean", "isNotify", "(", ")", "{", "if", "(", "message", "==", "null", ")", "{", "return", "false", ";", "}", "return", "(", "(", "(", "Request", ")", "message", ")", ".", "getMethod", "(", ")", ".", "equals", "(", "Request", ".", "NOTIFY", ")", ")", ";", "}" ]

[ "Indicates", "if", "the", "request", "method", "is", "NOTIFY", "or", "not", "." ]

[ "public", "boolean", "isSubscribe", "(", ")", "{", "if", "(", "message", "==", "null", ")", "{", "return", "false", ";", "}", "return", "(", "(", "(", "Request", ")", "message", ")", ".", "getMethod", "(", ")", ".", "equals", "(", "Request", ".", "SUBSCRIBE", ")", ")", ";", "}" ]

[ "Indicates", "if", "the", "request", "method", "is", "SUBSCRIBE", "or", "not", "." ]

[ "public", "void", "schedule", "(", "TimerTask", "task", ",", "Date", "time", ")", "{", "timer", ".", "schedule", "(", "new", "TimerTaskWrapper", "(", "task", ")", ",", "time", ")", ";", "}" ]

[ "Schedules", "the", "specified", "task", "for", "execution", "at", "the", "specified", "time", ".", "If", "the", "time", "is", "in", "the", "past", "the", "task", "is", "scheduled", "for", "immediate", "execution", "." ]

[ "public", "void", "shutdown", "(", ")", "{", "if", "(", "executor", "!=", "null", ")", "{", "executor", ".", "shutdown", "(", ")", ";", "executor", "=", "null", ";", "}", "if", "(", "timer", "!=", "null", ")", "{", "timer", ".", "cancel", "(", ")", ";", "timer", "=", "null", ";", "}", "instance", "=", "null", ";", "}" ]

[ "Shuts", "down", "the", "task", "engine", "service", "." ]

[ "private", "static", "String", "getColumnNameFromGetter", "(", "Method", "getter", ",", "Field", "f", ")", "{", "String", "columnName", "=", "\"\"", ";", "Column", "columnAnno", "=", "getter", ".", "getAnnotation", "(", "Column", ".", "class", ")", ";", "if", "(", "columnAnno", "!=", "null", ")", "{", "//如果是列注解就读取name属性", "columnName", "=", "columnAnno", ".", "name", "(", ")", ";", "}", "if", "(", "columnName", "==", "null", "||", "\"\"", ".", "equals", "(", "columnName", ")", ")", "{", "//如果没有列注解就用命名方式去猜", "columnName", "=", "IdUtils", ".", "toUnderscore", "(", "f", ".", "getName", "(", ")", ")", ";", "}", "return", "columnName", ";", "}" ]

[ "use", "getter", "to", "guess", "column", "name", "if", "there", "is", "annotation", "then", "use", "annotation", "value", "if", "not", "then", "guess", "from", "field", "name" ]

[ "public", "static", "SqlParamsPairs", "handleIn", "(", "String", "sql", ",", "Object", "[", "]", "params", ")", "{", "//split with question mark placeholder", "String", "[", "]", "sqlPieces", "=", "sql", ".", "split", "(", "\"\\\\?\"", ")", ";", "//question mark placeholder list", "String", "[", "]", "questionPlaceholders", ";", "if", "(", "sql", ".", "endsWith", "(", "\"?\"", ")", ")", "{", "questionPlaceholders", "=", "new", "String", "[", "sqlPieces", ".", "length", "]", ";", "}", "else", "{", "questionPlaceholders", "=", "new", "String", "[", "sqlPieces", ".", "length", "-", "1", "]", ";", "}", "for", "(", "int", "i", "=", "0", ";", "i", "<", "questionPlaceholders", ".", "length", ";", "i", "++", ")", "{", "questionPlaceholders", "[", "i", "]", "=", "\"?\"", ";", "}", "List", "<", "Object", ">", "plist", "=", "new", "ArrayList", "<", "Object", ">", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "params", ".", "length", ";", "i", "++", ")", "{", "Object", "p", "=", "params", "[", "i", "]", ";", "if", "(", "p", ".", "getClass", "(", ")", ".", "equals", "(", "ArrayList", ".", "class", ")", ")", "{", "//change ? => (?,?,?...)", "//change list to objects", "StringBuilder", "sb", "=", "new", "StringBuilder", "(", ")", ";", "sb", ".", "append", "(", "\"(\"", ")", ";", "ArrayList", "inParams", "=", "(", "ArrayList", ")", "p", ";", "for", "(", "int", "j", "=", "0", ";", "j", "<", "inParams", ".", "size", "(", ")", ";", "j", "++", ")", "{", "if", "(", "j", "!=", "0", ")", "{", "sb", ".", "append", "(", "\",\"", ")", ";", "}", "sb", ".", "append", "(", "\"?\"", ")", ";", "//split list to objects", "plist", ".", "add", "(", "inParams", ".", "get", "(", "j", ")", ")", ";", "}", "sb", ".", "append", "(", "\")\"", ")", ";", "questionPlaceholders", "[", "i", "]", "=", "sb", ".", "toString", "(", ")", ";", "}", "else", "{", "plist", ".", "add", "(", "p", ")", ";", "}", "}", "//join sql", "StringBuilder", "sqlsb", "=", "new", "StringBuilder", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "sqlPieces", ".", "length", ";", "i", "++", ")", "{", "sqlsb", ".", "append", "(", "sqlPieces", "[", "i", "]", ")", ";", "if", "(", "i", "<", "questionPlaceholders", ".", "length", ")", "{", "sqlsb", ".", "append", "(", "questionPlaceholders", "[", "i", "]", ")", ";", "}", "}", "SqlParamsPairs", "spPairs", "=", "new", "SqlParamsPairs", "(", "sqlsb", ".", "toString", "(", ")", ",", "plist", ".", "toArray", "(", ")", ")", ";", "return", "spPairs", ";", "}" ]

[ "Change", "sql", "if", "found", "array", "in", "params" ]

[ "public", "static", "String", "toCamel", "(", "String", "name", ")", "{", "return", "CaseFormat", ".", "LOWER_UNDERSCORE", ".", "to", "(", "CaseFormat", ".", "LOWER_CAMEL", ",", "name", ")", ";", "}" ]

[ "Convert", "underscore", "style", "to", "camel", "style" ]

[ "public", "static", "String", "toUnderscore", "(", "String", "name", ")", "{", "return", "CaseFormat", ".", "LOWER_CAMEL", ".", "to", "(", "CaseFormat", ".", "LOWER_UNDERSCORE", ",", "name", ")", ";", "}" ]

[ "Convert", "camel", "style", "to", "underscore", "style" ]

[ "private", "JdbcTemplateProxy", "getProxy", "(", ")", "{", "if", "(", "_proxy", "==", "null", ")", "{", "_proxy", "=", "new", "JdbcTemplateProxy", "(", ")", ";", "_proxy", ".", "setJdbcTemplate", "(", "jdbcTemplate", ")", ";", "}", "return", "_proxy", ";", "}" ]

[ "return", "the", "singleton", "proxy" ]

[ "public", "int", "insert", "(", "String", "sql", ",", "Object", "[", "]", "params", ",", "String", "autoGeneratedColumnName", ")", "throws", "DataAccessException", "{", "//dynamic change catalog name", "sql", "=", "changeCatalog", "(", "sql", ")", ";", "ReturnIdPreparedStatementCreator", "psc", "=", "new", "ReturnIdPreparedStatementCreator", "(", "sql", ",", "params", ",", "autoGeneratedColumnName", ")", ";", "KeyHolder", "keyHolder", "=", "new", "GeneratedKeyHolder", "(", ")", ";", "try", "{", "jdbcTemplate", ".", "update", "(", "psc", ",", "keyHolder", ")", ";", "}", "catch", "(", "DataAccessException", "e", ")", "{", "StringBuilder", "sb", "=", "new", "StringBuilder", "(", ")", ";", "sb", ".", "append", "(", "\"[\"", ")", ";", "for", "(", "Object", "p", ":", "params", ")", "{", "sb", ".", "append", "(", "p", "+", "\" | \"", ")", ";", "}", "sb", ".", "append", "(", "\"]\"", ")", ";", "logger", ".", "error", "(", "\"Error SQL: \"", "+", "sql", "+", "\" Params: \"", "+", "sb", ".", "toString", "(", ")", ")", ";", "throw", "e", ";", "}", "return", "keyHolder", ".", "getKey", "(", ")", ".", "intValue", "(", ")", ";", "}" ]

[ "insert", "a", "row", "with", "auto", "increament", "id" ]

[ "public", "static", "String", "changeCatalog", "(", "String", "sql", ")", "{", "CatalogContext", "catalogContext", "=", "catalogContextHolder", ".", "get", "(", ")", ";", "if", "(", "catalogContext", "!=", "null", "&&", "catalogContext", ".", "getCatalog", "(", ")", "!=", "null", "&&", "catalogContext", ".", "getPlaceHolder", "(", ")", "!=", "null", ")", "{", "sql", "=", "sql", ".", "replace", "(", "catalogContext", ".", "getPlaceHolder", "(", ")", ",", "catalogContext", ".", "getCatalog", "(", ")", ")", ";", "}", "logger", ".", "debug", "(", "\"real sql: \"", "+", "sql", ")", ";", "return", "sql", ";", "}" ]

[ "JdbcTemplateTool", "supports", "mulitiple", "catalog", "query", ".", "You", "can", "put", "a", "placeholder", "before", "your", "table", "name", "JdbcTemplateTool", "will", "change", "this", "placeholder", "to", "real", "catalog", "name", "with", "the", "catalog", "stored", "in", "catalogContext", "." ]

[ "private", "void", "V", "(", "StringBuilder", "buf", ")", "{", "Token", "t", "=", "getNextToken", "(", ")", ";", "if", "(", "t", ".", "tokenType", "!=", "TokenType", ".", "VALUE", ")", "{", "throw", "new", "IllegalStateException", "(", "\"Unexpected token \"", "+", "t", ")", ";", "}", "buf", ".", "append", "(", "t", ".", "getValue", "(", ")", ")", ";", "t", "=", "getNextToken", "(", ")", ";", "if", "(", "t", ".", "tokenType", "==", "TokenType", ".", "EOL", ")", "{", "return", ";", "}", "else", "if", "(", "t", ".", "tokenType", "==", "TokenType", ".", "TRAILING_BACKSLASH", ")", "{", "Vopt", "(", "buf", ")", ";", "}", "}" ]

[ "Vopt", "=", "EOL", "V" ]

[ "public", "List", "<", "Cal10nError", ">", "verifyAllLocales", "(", ")", "{", "List", "<", "Cal10nError", ">", "errorList", "=", "new", "ArrayList", "<", "Cal10nError", ">", "(", ")", ";", "String", "[", "]", "localeNameArray", "=", "getLocaleNames", "(", ")", ";", "ErrorFactory", "errorFactory", "=", "new", "ErrorFactory", "(", "enumTypeAsStr", ",", "null", ",", "getBaseName", "(", ")", ")", ";", "if", "(", "localeNameArray", "==", "null", "||", "localeNameArray", ".", "length", "==", "0", ")", "{", "errorList", ".", "add", "(", "errorFactory", ".", "buildError", "(", "MISSING_LOCALE_DATA_ANNOTATION", ",", "\"*\"", ")", ")", ";", "return", "errorList", ";", "}", "for", "(", "String", "localeName", ":", "localeNameArray", ")", "{", "Locale", "locale", "=", "MiscUtil", ".", "toLocale", "(", "localeName", ")", ";", "List", "<", "Cal10nError", ">", "tmpList", "=", "verify", "(", "locale", ")", ";", "errorList", ".", "addAll", "(", "tmpList", ")", ";", "}", "return", "errorList", ";", "}" ]

[ "Verify", "all", "declared", "locales", "in", "one", "step", "." ]

[ "private", "double", "[", "]", "readListProperty", "(", "final", "ListProperty", "property", ")", "throws", "IOException", "{", "int", "valueCount", "=", "(", "int", ")", "stream", ".", "read", "(", "property", ".", "getCountType", "(", ")", ")", ";", "double", "[", "]", "values", "=", "new", "double", "[", "valueCount", "]", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "values", ".", "length", ";", "i", "++", ")", "{", "values", "[", "i", "]", "=", "stream", ".", "read", "(", "property", ".", "getType", "(", ")", ")", ";", "}", "return", "values", ";", "}" ]

[ "Reads", "the", "values", "of", "a", "list", "-", "property", "." ]

[ "static", "HeaderEntry", "parse", "(", "final", "String", "elementLine", ")", "throws", "IOException", "{", "if", "(", "!", "elementLine", ".", "startsWith", "(", "\"element \"", ")", ")", "{", "throw", "new", "IOException", "(", "\"not an element: '\"", "+", "elementLine", "+", "\"'\"", ")", ";", "}", "String", "definition", "=", "elementLine", ".", "substring", "(", "\"element \"", ".", "length", "(", ")", ")", ";", "String", "[", "]", "parts", "=", "definition", ".", "split", "(", "\" +\"", ",", "2", ")", ";", "if", "(", "parts", ".", "length", "!=", "2", ")", "{", "throw", "new", "IOException", "(", "\"Expected two parts in element definition: '\"", "+", "elementLine", "+", "\"'\"", ")", ";", "}", "String", "name", "=", "parts", "[", "0", "]", ";", "String", "countStr", "=", "parts", "[", "1", "]", ";", "int", "count", ";", "try", "{", "count", "=", "Integer", ".", "parseInt", "(", "countStr", ")", ";", "}", "catch", "(", "NumberFormatException", "e", ")", "{", "throw", "new", "IOException", "(", "\"Invalid element entry. Not an integer: '\"", "+", "countStr", "+", "\"'.\"", ")", ";", "}", "return", "new", "HeaderEntry", "(", "name", ",", "count", ")", ";", "}" ]

[ "Parses", "a", "header", "line", "starting", "an", "element", "description", "." ]

[ "public", "RandomElementReader", "getElementReader", "(", "final", "String", "elementType", ")", "throws", "IOException", "{", "if", "(", "elementType", "==", "null", ")", "{", "throw", "new", "NullPointerException", "(", "\"elementType must not be null.\"", ")", ";", "}", "if", "(", "!", "buffer", ".", "containsKey", "(", "elementType", ")", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"No such element type.\"", ")", ";", "}", "if", "(", "closed", ")", "{", "throw", "new", "IllegalStateException", "(", "\"Reader is closed.\"", ")", ";", "}", "while", "(", "buffer", ".", "get", "(", "elementType", ")", "==", "null", ")", "{", "ElementReader", "eReader", "=", "reader", ".", "nextElementReader", "(", ")", ";", "BufferedElementReader", "bReader", "=", "new", "BufferedElementReader", "(", "eReader", ")", ";", "bReader", ".", "detach", "(", ")", ";", "buffer", ".", "put", "(", "eReader", ".", "getElementType", "(", ")", ".", "getName", "(", ")", ",", "bReader", ")", ";", "}", "return", "buffer", ".", "get", "(", "elementType", ")", ".", "duplicate", "(", ")", ";", "}" ]

[ "Returns", "an", "element", "reader", "for", "the", "given", "element", "type", "." ]

[ "static", "Property", "parse", "(", "final", "String", "propertyLine", ")", "throws", "IOException", "{", "if", "(", "!", "propertyLine", ".", "startsWith", "(", "\"property \"", ")", ")", "{", "throw", "new", "IOException", "(", "\"not a property: '\"", "+", "propertyLine", "+", "\"'\"", ")", ";", "}", "String", "definition", "=", "propertyLine", ".", "substring", "(", "\"property \"", ".", "length", "(", ")", ")", ";", "if", "(", "definition", ".", "startsWith", "(", "\"list\"", ")", ")", "{", "return", "ListProperty", ".", "parse", "(", "propertyLine", ")", ";", "}", "String", "[", "]", "parts", "=", "definition", ".", "split", "(", "\" +\"", ",", "2", ")", ";", "if", "(", "parts", ".", "length", "!=", "2", ")", "{", "throw", "new", "IOException", "(", "\"Expected two parts in property definition: '\"", "+", "propertyLine", "+", "\"'\"", ")", ";", "}", "String", "type", "=", "parts", "[", "0", "]", ";", "String", "name", "=", "parts", "[", "1", "]", ";", "DataType", "dataType", ";", "try", "{", "dataType", "=", "DataType", ".", "parse", "(", "type", ")", ";", "}", "catch", "(", "IllegalArgumentException", "e", ")", "{", "throw", "new", "IOException", "(", "e", ".", "getMessage", "(", ")", ")", ";", "}", "return", "new", "Property", "(", "name", ",", "dataType", ")", ";", "}" ]

[ "Parses", "a", "property", "header", "line", "." ]

[ "private", "String", "getSourceName", "(", "final", "String", "property", ")", "{", "if", "(", "propertyNameMap", ".", "containsKey", "(", "property", ")", ")", "{", "return", "propertyNameMap", ".", "get", "(", "property", ")", ";", "}", "else", "{", "return", "property", ";", "}", "}" ]

[ "Get", "the", "name", "of", "a", "property", "in", "the", "source", "type", "." ]

[ "private", "double", "getValue", "(", "final", "double", "x", ",", "final", "double", "y", ",", "final", "double", "z", ",", "final", "Axis", "axis", ")", "{", "switch", "(", "axis", ")", "{", "case", "X", ":", "return", "x", ";", "case", "X_INVERTED", ":", "return", "-", "x", ";", "case", "Y", ":", "return", "y", ";", "case", "Y_INVERTED", ":", "return", "-", "y", ";", "case", "Z", ":", "return", "z", ";", "case", "Z_INVERTED", ":", "return", "-", "z", ";", "default", ":", "throw", "new", "IllegalArgumentException", "(", "\"Unsupported axis.\"", ")", ";", "}", "}" ]

[ "Returns", "the", "value", "of", "a", "given", "axis", "." ]

[ "public", "void", "generateNormals", "(", "final", "RandomElementReader", "vertexReader", ",", "final", "ElementReader", "faceReader", ")", "throws", "IOException", "{", "if", "(", "vertexReader", "==", "null", ")", "{", "throw", "new", "NullPointerException", "(", "\"vertexReader must not be null.\"", ")", ";", "}", "if", "(", "faceReader", "==", "null", ")", "{", "throw", "new", "NullPointerException", "(", "\"faceReader must not be null.\"", ")", ";", "}", "if", "(", "!", "vertexReader", ".", "getElementType", "(", ")", ".", "getName", "(", ")", ".", "equals", "(", "\"vertex\"", ")", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"vertexReader does not read vertices.\"", ")", ";", "}", "boolean", "foundX", "=", "false", ";", "boolean", "foundY", "=", "false", ";", "boolean", "foundZ", "=", "false", ";", "for", "(", "Property", "p", ":", "vertexReader", ".", "getElementType", "(", ")", ".", "getProperties", "(", ")", ")", "{", "foundX", "|=", "p", ".", "getName", "(", ")", ".", "equals", "(", "\"x\"", ")", "&&", "!", "(", "p", "instanceof", "ListProperty", ")", ";", "foundY", "|=", "p", ".", "getName", "(", ")", ".", "equals", "(", "\"y\"", ")", "&&", "!", "(", "p", "instanceof", "ListProperty", ")", ";", "foundZ", "|=", "p", ".", "getName", "(", ")", ".", "equals", "(", "\"z\"", ")", "&&", "!", "(", "p", "instanceof", "ListProperty", ")", ";", "}", "if", "(", "!", "foundX", "||", "!", "foundY", "||", "!", "foundZ", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"Vertex type does not include\"", "+", "\" the three non-list properties x y and z.\"", ")", ";", "}", "if", "(", "!", "faceReader", ".", "getElementType", "(", ")", ".", "getName", "(", ")", ".", "equals", "(", "\"face\"", ")", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"faceReader does not read faces.\"", ")", ";", "}", "boolean", "foundVertexIndex", "=", "false", ";", "for", "(", "Property", "p", ":", "faceReader", ".", "getElementType", "(", ")", ".", "getProperties", "(", ")", ")", "{", "foundVertexIndex", "|=", "p", ".", "getName", "(", ")", ".", "equals", "(", "\"vertex_index\"", ")", "&&", "(", "p", "instanceof", "ListProperty", ")", ";", "}", "if", "(", "!", "foundVertexIndex", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"Face type does not include a list property named \"", "+", "\"vertex_index.\"", ")", ";", "}", "// Phase 1: accumulate weighted normals", "for", "(", "Element", "face", "=", "faceReader", ".", "readElement", "(", ")", ";", "face", "!=", "null", ";", "face", "=", "faceReader", ".", "readElement", "(", ")", ")", "{", "accumulateNormals", "(", "vertexReader", ",", "face", ")", ";", "}", "// Phase 2: normalize the normal vectors", "for", "(", "Element", "vertex", "=", "vertexReader", ".", "readElement", "(", ")", ";", "vertex", "!=", "null", ";", "vertex", "=", "vertexReader", ".", "readElement", "(", ")", ")", "{", "normalize", "(", "vertex", ")", ";", "}", "}" ]

[ "Performs", "the", "normal", "generation", "." ]

[ "private", "void", "normalize", "(", "final", "Element", "vertex", ")", "{", "double", "nx", "=", "vertex", ".", "getDouble", "(", "\"nx\"", ")", ";", "double", "ny", "=", "vertex", ".", "getDouble", "(", "\"ny\"", ")", ";", "double", "nz", "=", "vertex", ".", "getDouble", "(", "\"nz\"", ")", ";", "double", "n", "=", "Math", ".", "sqrt", "(", "nx", "*", "nx", "+", "ny", "*", "ny", "+", "nz", "*", "nz", ")", ";", "if", "(", "n", "<", "EPSILON", ")", "{", "vertex", ".", "setDouble", "(", "\"nx\"", ",", "0", ")", ";", "vertex", ".", "setDouble", "(", "\"ny\"", ",", "0", ")", ";", "vertex", ".", "setDouble", "(", "\"nz\"", ",", "0", ")", ";", "}", "vertex", ".", "setDouble", "(", "\"nx\"", ",", "nx", "/", "n", ")", ";", "vertex", ".", "setDouble", "(", "\"ny\"", ",", "ny", "/", "n", ")", ";", "vertex", ".", "setDouble", "(", "\"nz\"", ",", "nz", "/", "n", ")", ";", "}" ]

[ "Normalizes", "the", "normal", "vector", "of", "a", "vertex", "." ]

[ "private", "void", "accumulateNormals", "(", "final", "RandomElementReader", "vertices", ",", "final", "Element", "face", ")", "throws", "IOException", "{", "int", "[", "]", "indices", "=", "face", ".", "getIntList", "(", "\"vertex_index\"", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "indices", ".", "length", ";", "i", "++", ")", "{", "int", "pre", ";", "int", "post", ";", "if", "(", "counterClockwise", ")", "{", "pre", "=", "(", "i", "+", "indices", ".", "length", "-", "1", ")", "%", "indices", ".", "length", ";", "post", "=", "(", "i", "+", "1", ")", "%", "indices", ".", "length", ";", "}", "else", "{", "pre", "=", "(", "i", "+", "1", ")", "%", "indices", ".", "length", ";", "post", "=", "(", "i", "+", "indices", ".", "length", "-", "1", ")", "%", "indices", ".", "length", ";", "}", "Element", "centerVertex", ";", "Element", "preVertex", ";", "Element", "postVertex", ";", "try", "{", "centerVertex", "=", "vertices", ".", "readElement", "(", "indices", "[", "i", "]", ")", ";", "preVertex", "=", "vertices", ".", "readElement", "(", "indices", "[", "pre", "]", ")", ";", "postVertex", "=", "vertices", ".", "readElement", "(", "indices", "[", "post", "]", ")", ";", "accumulateNormal", "(", "centerVertex", ",", "preVertex", ",", "postVertex", ")", ";", "}", "catch", "(", "IndexOutOfBoundsException", "e", ")", "{", "// we ignore defects in the normals.", "}", "}", "}" ]

[ "Calculate", "the", "face", "normal", "weight", "by", "angle", "and", "add", "them", "to", "the", "vertices", "." ]

[ "private", "void", "accumulateNormal", "(", "final", "Element", "center", ",", "final", "Element", "pre", ",", "final", "Element", "post", ")", "{", "double", "cx", "=", "center", ".", "getDouble", "(", "\"x\"", ")", ";", "double", "cy", "=", "center", ".", "getDouble", "(", "\"y\"", ")", ";", "double", "cz", "=", "center", ".", "getDouble", "(", "\"z\"", ")", ";", "double", "ax", "=", "post", ".", "getDouble", "(", "\"x\"", ")", "-", "cx", ";", "double", "ay", "=", "post", ".", "getDouble", "(", "\"y\"", ")", "-", "cy", ";", "double", "az", "=", "post", ".", "getDouble", "(", "\"z\"", ")", "-", "cz", ";", "double", "a", "=", "Math", ".", "sqrt", "(", "ax", "*", "ax", "+", "ay", "*", "ay", "+", "az", "*", "az", ")", ";", "if", "(", "a", "<", "EPSILON", ")", "{", "return", ";", "}", "double", "bx", "=", "pre", ".", "getDouble", "(", "\"x\"", ")", "-", "cx", ";", "double", "by", "=", "pre", ".", "getDouble", "(", "\"y\"", ")", "-", "cy", ";", "double", "bz", "=", "pre", ".", "getDouble", "(", "\"z\"", ")", "-", "cz", ";", "double", "b", "=", "Math", ".", "sqrt", "(", "bx", "*", "bx", "+", "by", "*", "by", "+", "bz", "*", "bz", ")", ";", "if", "(", "b", "<", "EPSILON", ")", "{", "return", ";", "}", "double", "nx", "=", "ay", "*", "bz", "-", "az", "*", "by", ";", "double", "ny", "=", "az", "*", "bx", "-", "ax", "*", "bz", ";", "double", "nz", "=", "ax", "*", "by", "-", "ay", "*", "bx", ";", "double", "n", "=", "Math", ".", "sqrt", "(", "nx", "*", "nx", "+", "ny", "*", "ny", "+", "nz", "*", "nz", ")", ";", "if", "(", "n", "<", "EPSILON", ")", "{", "return", ";", "}", "double", "sin", "=", "n", "/", "(", "a", "*", "b", ")", ";", "double", "dot", "=", "ax", "*", "bx", "+", "ay", "*", "by", "+", "az", "*", "bz", ";", "double", "angle", ";", "if", "(", "dot", "<", "0", ")", "{", "angle", "=", "Math", ".", "PI", "-", "Math", ".", "asin", "(", "sin", ")", ";", "}", "else", "{", "angle", "=", "Math", ".", "asin", "(", "sin", ")", ";", "}", "double", "factor", "=", "angle", "/", "n", ";", "nx", "*=", "factor", ";", "ny", "*=", "factor", ";", "nz", "*=", "factor", ";", "center", ".", "setDouble", "(", "\"nx\"", ",", "center", ".", "getDouble", "(", "\"nx\"", ")", "+", "nx", ")", ";", "center", ".", "setDouble", "(", "\"ny\"", ",", "center", ".", "getDouble", "(", "\"ny\"", ")", "+", "ny", ")", ";", "center", ".", "setDouble", "(", "\"nz\"", ",", "center", ".", "getDouble", "(", "\"nz\"", ")", "+", "nz", ")", ";", "}" ]

[ "Calculate", "the", "face", "normal", "weight", "by", "angle", "and", "add", "them", "to", "the", "vertex", "." ]

[ "private", "static", "RectBounds", "fillBuffers", "(", "PlyReader", "plyReader", ",", "FloatBuffer", "vertexBuffer", ",", "IntBuffer", "indexBuffer", ")", "throws", "IOException", "{", "// Get all element readers and find the two providing ", "// the vertices and triangles.", "ElementReader", "reader", "=", "plyReader", ".", "nextElementReader", "(", ")", ";", "RectBounds", "bounds", "=", "null", ";", "while", "(", "reader", "!=", "null", ")", "{", "if", "(", "reader", ".", "getElementType", "(", ")", ".", "getName", "(", ")", ".", "equals", "(", "\"vertex\"", ")", ")", "{", "bounds", "=", "fillVertexBuffer", "(", "reader", ",", "vertexBuffer", ")", ";", "}", "else", "if", "(", "reader", ".", "getElementType", "(", ")", ".", "getName", "(", ")", ".", "equals", "(", "\"face\"", ")", ")", "{", "fillIndexBuffer", "(", "reader", ",", "indexBuffer", ")", ";", "}", "reader", ".", "close", "(", ")", ";", "reader", "=", "plyReader", ".", "nextElementReader", "(", ")", ";", "}", "return", "bounds", ";", "}" ]

[ "Loads", "the", "data", "from", "the", "PLY", "file", "into", "the", "buffers", "." ]

[ "private", "static", "RectBounds", "fillVertexBuffer", "(", "ElementReader", "reader", ",", "FloatBuffer", "vertexBuffer", ")", "throws", "IOException", "{", "// Just go though the vertices and store the coordinates in the buffer.", "Element", "vertex", "=", "reader", ".", "readElement", "(", ")", ";", "RectBounds", "bounds", "=", "new", "RectBounds", "(", ")", ";", "while", "(", "vertex", "!=", "null", ")", "{", "double", "x", "=", "vertex", ".", "getDouble", "(", "\"x\"", ")", ";", "double", "y", "=", "vertex", ".", "getDouble", "(", "\"y\"", ")", ";", "double", "z", "=", "vertex", ".", "getDouble", "(", "\"z\"", ")", ";", "double", "nx", "=", "vertex", ".", "getDouble", "(", "\"nx\"", ")", ";", "double", "ny", "=", "vertex", ".", "getDouble", "(", "\"ny\"", ")", ";", "double", "nz", "=", "vertex", ".", "getDouble", "(", "\"nz\"", ")", ";", "vertexBuffer", ".", "put", "(", "(", "float", ")", "x", ")", ";", "vertexBuffer", ".", "put", "(", "(", "float", ")", "y", ")", ";", "vertexBuffer", ".", "put", "(", "(", "float", ")", "z", ")", ";", "vertexBuffer", ".", "put", "(", "(", "float", ")", "nx", ")", ";", "vertexBuffer", ".", "put", "(", "(", "float", ")", "ny", ")", ";", "vertexBuffer", ".", "put", "(", "(", "float", ")", "nz", ")", ";", "bounds", ".", "addPoint", "(", "x", ",", "y", ",", "z", ")", ";", "vertex", "=", "reader", ".", "readElement", "(", ")", ";", "}", "return", "bounds", ";", "}" ]

[ "Fill", "the", "vertex", "buffer", "with", "the", "data", "from", "the", "PLY", "file", "." ]

[ "private", "static", "void", "fillIndexBuffer", "(", "ElementReader", "reader", ",", "IntBuffer", "indexBuffer", ")", "throws", "IOException", "{", "// Just go though the triangles and store the indices in the buffer.", "Element", "triangle", "=", "reader", ".", "readElement", "(", ")", ";", "while", "(", "triangle", "!=", "null", ")", "{", "int", "[", "]", "indices", "=", "triangle", ".", "getIntList", "(", "\"vertex_index\"", ")", ";", "for", "(", "int", "index", ":", "indices", ")", "{", "indexBuffer", ".", "put", "(", "index", ")", ";", "}", "triangle", "=", "reader", ".", "readElement", "(", ")", ";", "}", "}" ]

[ "Fill", "the", "index", "buffer", "with", "the", "data", "from", "the", "PLY", "file", "." ]

[ "private", "static", "int", "createShaders", "(", ")", "throws", "IOException", "{", "// load and compile the vertex shader.", "String", "vertexShaderCode", "=", "IOUtils", ".", "toString", "(", "ClassLoader", ".", "getSystemResourceAsStream", "(", "\"vertexShader.glsl\"", ")", ")", ";", "int", "vertexShaderId", "=", "glCreateShaderObjectARB", "(", "GL_VERTEX_SHADER_ARB", ")", ";", "glShaderSourceARB", "(", "vertexShaderId", ",", "vertexShaderCode", ")", ";", "glCompileShaderARB", "(", "vertexShaderId", ")", ";", "printLogInfo", "(", "vertexShaderId", ")", ";", "// load and compile the fragment shader.", "String", "fragmentShaderCode", "=", "IOUtils", ".", "toString", "(", "ClassLoader", ".", "getSystemResourceAsStream", "(", "\"fragmentShader.glsl\"", ")", ")", ";", "int", "fragmentShaderId", "=", "glCreateShaderObjectARB", "(", "GL_FRAGMENT_SHADER_ARB", ")", ";", "glShaderSourceARB", "(", "fragmentShaderId", ",", "fragmentShaderCode", ")", ";", "glCompileShaderARB", "(", "fragmentShaderId", ")", ";", "printLogInfo", "(", "fragmentShaderId", ")", ";", "// combine the two into a program.", "int", "programId", "=", "ARBShaderObjects", ".", "glCreateProgramObjectARB", "(", ")", ";", "glAttachObjectARB", "(", "programId", ",", "vertexShaderId", ")", ";", "glAttachObjectARB", "(", "programId", ",", "fragmentShaderId", ")", ";", "glValidateProgramARB", "(", "programId", ")", ";", "glLinkProgramARB", "(", "programId", ")", ";", "printLogInfo", "(", "programId", ")", ";", "return", "programId", ";", "}" ]

[ "Loads", "the", "vertex", "and", "fragment", "shader", "." ]

[ "private", "static", "boolean", "printLogInfo", "(", "int", "obj", ")", "{", "IntBuffer", "iVal", "=", "BufferUtils", ".", "createIntBuffer", "(", "1", ")", ";", "ARBShaderObjects", ".", "glGetObjectParameterARB", "(", "obj", ",", "ARBShaderObjects", ".", "GL_OBJECT_INFO_LOG_LENGTH_ARB", ",", "iVal", ")", ";", "int", "length", "=", "iVal", ".", "get", "(", ")", ";", "if", "(", "length", ">", "1", ")", "{", "// We have some info we need to output.", "ByteBuffer", "infoLog", "=", "BufferUtils", ".", "createByteBuffer", "(", "length", ")", ";", "iVal", ".", "flip", "(", ")", ";", "ARBShaderObjects", ".", "glGetInfoLogARB", "(", "obj", ",", "iVal", ",", "infoLog", ")", ";", "byte", "[", "]", "infoBytes", "=", "new", "byte", "[", "length", "]", ";", "infoLog", ".", "get", "(", "infoBytes", ")", ";", "String", "out", "=", "new", "String", "(", "infoBytes", ")", ";", "System", ".", "out", ".", "println", "(", "\"Info log:\\n\"", "+", "out", ")", ";", "}", "else", "{", "return", "true", ";", "}", "return", "false", ";", "}" ]

[ "Helper", "to", "get", "the", "log", "messages", "from", "the", "shader", "compiler", "." ]

[ "public", "String", "readLine", "(", ")", "throws", "IOException", "{", "StringBuilder", "str", "=", "new", "StringBuilder", "(", ")", ";", "while", "(", "true", ")", "{", "int", "c", "=", "read", "(", ")", ";", "if", "(", "c", "<", "0", ")", "{", "break", ";", "}", "if", "(", "c", "==", "'", "'", ")", "{", "// if possible consume another '\\r'", "int", "peek", "=", "stream", ".", "read", "(", ")", ";", "if", "(", "peek", "!=", "'", "'", "&&", "peek", ">=", "0", ")", "{", "stream", ".", "unread", "(", "peek", ")", ";", "}", "break", ";", "}", "if", "(", "c", "==", "'", "'", ")", "{", "// if possible consume another '\\n'", "int", "peek", "=", "stream", ".", "read", "(", ")", ";", "if", "(", "peek", "!=", "'", "'", "&&", "peek", ">=", "0", ")", "{", "stream", ".", "unread", "(", "peek", ")", ";", "}", "break", ";", "}", "str", ".", "append", "(", "(", "char", ")", "c", ")", ";", "}", "return", "str", ".", "toString", "(", ")", ";", "}" ]

[ "Reads", "the", "next", "line", "." ]

[ "public", "double", "getScaleToUnityBox", "(", ")", "{", "double", "largestEdge", "=", "0", ";", "largestEdge", "=", "Math", ".", "max", "(", "largestEdge", ",", "maxX", "-", "minX", ")", ";", "largestEdge", "=", "Math", ".", "max", "(", "largestEdge", ",", "maxY", "-", "minY", ")", ";", "largestEdge", "=", "Math", ".", "max", "(", "largestEdge", ",", "maxZ", "-", "minZ", ")", ";", "return", "1.0", "/", "largestEdge", ";", "}" ]

[ "Gets", "the", "scale", "factor", "by", "which", "the", "box", "needs", "to", "be", "multiplied", "that", "it", "fits", "into", "a", "cube", "with", "edge", "length", "1", "." ]

[ "private", "static", "ElementType", "addNormalProps", "(", "final", "ElementType", "sourceType", ")", "{", "List", "<", "Property", ">", "properties", "=", "new", "ArrayList", "<", "Property", ">", "(", ")", ";", "boolean", "foundNX", "=", "false", ";", "boolean", "foundNY", "=", "false", ";", "boolean", "foundNZ", "=", "false", ";", "for", "(", "Property", "property", ":", "sourceType", ".", "getProperties", "(", ")", ")", "{", "if", "(", "property", ".", "getName", "(", ")", ".", "equals", "(", "\"nx\"", ")", ")", "{", "foundNX", "=", "true", ";", "}", "if", "(", "property", ".", "getName", "(", ")", ".", "equals", "(", "\"ny\"", ")", ")", "{", "foundNY", "=", "true", ";", "}", "if", "(", "property", ".", "getName", "(", ")", ".", "equals", "(", "\"nz\"", ")", ")", "{", "foundNZ", "=", "true", ";", "}", "properties", ".", "add", "(", "property", ")", ";", "}", "if", "(", "foundNX", "&&", "foundNY", "&&", "foundNZ", ")", "{", "return", "sourceType", ";", "}", "if", "(", "!", "foundNX", ")", "{", "properties", ".", "add", "(", "new", "Property", "(", "\"nx\"", ",", "DataType", ".", "DOUBLE", ")", ")", ";", "}", "if", "(", "!", "foundNY", ")", "{", "properties", ".", "add", "(", "new", "Property", "(", "\"ny\"", ",", "DataType", ".", "DOUBLE", ")", ")", ";", "}", "if", "(", "!", "foundNZ", ")", "{", "properties", ".", "add", "(", "new", "Property", "(", "\"nz\"", ",", "DataType", ".", "DOUBLE", ")", ")", ";", "}", "return", "new", "ElementType", "(", "\"vertex\"", ",", "properties", ")", ";", "}" ]

[ "Adds", "properties", "for", "nx", "ny", "and", "nz", "if", "they", "don", "t", "already", "exist", "." ]

[ "private", "static", "ElementType", "addTextureProps", "(", "final", "ElementType", "sourceType", ")", "{", "List", "<", "Property", ">", "properties", "=", "new", "ArrayList", "<", "Property", ">", "(", ")", ";", "boolean", "foundU", "=", "false", ";", "boolean", "foundV", "=", "false", ";", "for", "(", "Property", "property", ":", "sourceType", ".", "getProperties", "(", ")", ")", "{", "if", "(", "property", ".", "getName", "(", ")", ".", "equals", "(", "\"u\"", ")", ")", "{", "foundU", "=", "true", ";", "}", "if", "(", "property", ".", "getName", "(", ")", ".", "equals", "(", "\"v\"", ")", ")", "{", "foundV", "=", "true", ";", "}", "properties", ".", "add", "(", "property", ")", ";", "}", "if", "(", "foundU", "&&", "foundV", ")", "{", "return", "sourceType", ";", "}", "if", "(", "!", "foundU", ")", "{", "properties", ".", "add", "(", "new", "Property", "(", "\"u\"", ",", "DataType", ".", "DOUBLE", ")", ")", ";", "}", "if", "(", "!", "foundV", ")", "{", "properties", ".", "add", "(", "new", "Property", "(", "\"v\"", ",", "DataType", ".", "DOUBLE", ")", ")", ";", "}", "return", "new", "ElementType", "(", "\"vertex\"", ",", "properties", ")", ";", "}" ]

[ "Adds", "properties", "for", "u", "and", "v", "if", "they", "don", "t", "already", "exist", "." ]

[ "public", "void", "setDouble", "(", "final", "String", "propertyName", ",", "final", "double", "value", ")", "{", "if", "(", "propertyName", "==", "null", ")", "{", "throw", "new", "NullPointerException", "(", "\"propertyName must not be null.\"", ")", ";", "}", "Integer", "index", "=", "propertyMap", ".", "get", "(", "propertyName", ")", ";", "if", "(", "index", "==", "null", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"non existent property: '\"", "+", "propertyName", "+", "\"'.\"", ")", ";", "}", "this", ".", "data", "[", "index", "]", "=", "new", "double", "[", "]", "{", "value", "}", ";", "}" ]

[ "Sets", "the", "value", "of", "a", "property", "-", "list", ".", "If", "the", "property", "is", "a", "list", "the", "list", "will", "be", "set", "to", "a", "single", "entry", "." ]

[ "static", "Property", "parse", "(", "final", "String", "line", ")", "throws", "IOException", "{", "if", "(", "!", "line", ".", "startsWith", "(", "\"property \"", ")", ")", "{", "throw", "new", "IOException", "(", "\"not a property: '\"", "+", "line", "+", "\"'\"", ")", ";", "}", "String", "definition", "=", "line", ".", "substring", "(", "\"property \"", ".", "length", "(", ")", ")", ";", "definition", "=", "definition", ".", "trim", "(", ")", ";", "if", "(", "!", "definition", ".", "startsWith", "(", "\"list \"", ")", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"not a list property: '\"", "+", "line", "+", "\"'\"", ")", ";", "}", "definition", "=", "definition", ".", "substring", "(", "\"list \"", ".", "length", "(", ")", ")", ";", "definition", "=", "definition", ".", "trim", "(", ")", ";", "String", "[", "]", "parts", "=", "definition", ".", "split", "(", "\" +\"", ",", "3", ")", ";", "if", "(", "parts", ".", "length", "!=", "3", ")", "{", "throw", "new", "IOException", "(", "\"Expected three parts in list property \"", "+", "\"definition: '\"", "+", "line", "+", "\"'\"", ")", ";", "}", "String", "countType", "=", "parts", "[", "0", "]", ";", "String", "type", "=", "parts", "[", "1", "]", ";", "String", "name", "=", "parts", "[", "2", "]", ";", "DataType", "dataType", ";", "DataType", "countDataType", ";", "try", "{", "dataType", "=", "DataType", ".", "parse", "(", "type", ")", ";", "countDataType", "=", "DataType", ".", "parse", "(", "countType", ")", ";", "}", "catch", "(", "IllegalArgumentException", "e", ")", "{", "throw", "new", "IOException", "(", "e", ".", "getMessage", "(", ")", ")", ";", "}", "return", "new", "ListProperty", "(", "countDataType", ",", "name", ",", "dataType", ")", ";", "}" ]

[ "Parses", "a", "list", "-", "property", "header", "line", "." ]

[ "@", "Override", "public", "int", "getElementCount", "(", "final", "String", "elementType", ")", "{", "if", "(", "elementType", "==", "null", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"elementType must not be null.\"", ")", ";", "}", "Integer", "count", "=", "elementCounts", ".", "get", "(", "elementType", ")", ";", "if", "(", "count", "==", "null", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"Type does not exist in this file.\"", ")", ";", "}", "else", "{", "return", "count", ";", "}", "}" ]

[ "Gets", "the", "number", "of", "elements", "for", "a", "given", "element", "type", "." ]

[ "private", "ElementReader", "nextElementReaderInternal", "(", ")", "{", "if", "(", "nextElement", ">=", "elements", ".", "size", "(", ")", ")", "{", "return", "null", ";", "}", "try", "{", "ElementType", "type", "=", "elements", ".", "get", "(", "nextElement", ")", ";", "switch", "(", "format", ")", "{", "case", "ASCII", ":", "return", "new", "AsciiElementReader", "(", "type", ",", "getElementCount", "(", "type", ".", "getName", "(", ")", ")", ",", "asciiReader", ")", ";", "case", "BINARY_BIG_ENDIAN", ":", "case", "BINARY_LITTLE_ENDIAN", ":", "return", "new", "BinaryElementReader", "(", "type", ",", "getElementCount", "(", "type", ".", "getName", "(", ")", ")", ",", "binaryStream", ")", ";", "default", ":", "throw", "new", "UnsupportedOperationException", "(", "\"PLY format \"", "+", "format", "+", "\" is currently not supported.\"", ")", ";", "}", "}", "finally", "{", "nextElement", "++", ";", "}", "}" ]

[ "Creates", "the", "next", "element", "reader", "." ]

[ "public", "double", "read", "(", "final", "DataType", "type", ")", "throws", "IOException", "{", "if", "(", "type", "==", "null", ")", "{", "throw", "new", "NullPointerException", "(", "\"type must not be null.\"", ")", ";", "}", "switch", "(", "type", ")", "{", "case", "CHAR", ":", "ensureAvailable", "(", "1", ")", ";", "return", "buffer", ".", "get", "(", ")", ";", "case", "UCHAR", ":", "ensureAvailable", "(", "1", ")", ";", "return", "(", "(", "int", ")", "buffer", ".", "get", "(", ")", ")", "&", "0x000000FF", ";", "case", "SHORT", ":", "ensureAvailable", "(", "2", ")", ";", "return", "buffer", ".", "getShort", "(", ")", ";", "case", "USHORT", ":", "ensureAvailable", "(", "2", ")", ";", "return", "(", "(", "int", ")", "buffer", ".", "getShort", "(", ")", ")", "&", "0x0000FFFF", ";", "case", "INT", ":", "ensureAvailable", "(", "4", ")", ";", "return", "buffer", ".", "getInt", "(", ")", ";", "case", "UINT", ":", "ensureAvailable", "(", "4", ")", ";", "return", "(", "(", "long", ")", "buffer", ".", "getShort", "(", ")", ")", "&", "0x00000000FFFFFFFF", ";", "case", "FLOAT", ":", "ensureAvailable", "(", "4", ")", ";", "return", "buffer", ".", "getFloat", "(", ")", ";", "case", "DOUBLE", ":", "ensureAvailable", "(", "8", ")", ";", "return", "buffer", ".", "getDouble", "(", ")", ";", "default", ":", "throw", "new", "IllegalArgumentException", "(", "\"Unsupported type: \"", "+", "type", ")", ";", "}", "}" ]

[ "Reads", "a", "value", "from", "the", "stream", "." ]

[ "private", "void", "ensureAvailable", "(", "final", "int", "bytes", ")", "throws", "IOException", "{", "while", "(", "buffer", ".", "remaining", "(", ")", "<", "bytes", ")", "{", "buffer", ".", "compact", "(", ")", ";", "if", "(", "channel", ".", "read", "(", "buffer", ")", "<", "0", ")", "{", "throw", "new", "EOFException", "(", ")", ";", "}", "buffer", ".", "flip", "(", ")", ";", "}", "}" ]

[ "Ensures", "that", "a", "certain", "amount", "of", "bytes", "are", "in", "the", "buffer", "ready", "to", "be", "read", "." ]