/** * 生成mongoClientFacotryBean * * @param mythMongoConfig 配置信息 * @return bean */ private MongoClientFactoryBean buildMongoClientFactoryBean(MythMongoConfig mythMongoConfig) { MongoClientFactoryBean clientFactoryBean = new MongoClientFactoryBean(); MongoCredential credential = MongoCredential.createScramSha1Credential(mythMongoConfig.getMongoUserName(), mythMongoConfig.getMongoDbName(), mythMongoConfig.getMongoUserPwd().toCharArray()); clientFactoryBean.setCredentials(new MongoCredential[]{ credential }); List<String> urls = Splitter.on(",").trimResults().splitToList(mythMongoConfig.getMongoDbUrl()); final ServerAddress[] sds = urls.stream().map(url -> { List<String> adds = Splitter.on(":").trimResults().splitToList(url); InetSocketAddress address = new InetSocketAddress(adds.get(0), Integer.parseInt(adds.get(1))); return new ServerAddress(address); }).collect(Collectors.toList()).toArray(new ServerAddress[]{}); clientFactoryBean.setReplicaSetSeeds(sds); return clientFactoryBean; }
@Override public String getTopic(String uuid) { HierarchyTopic ht = null; boolean isDynamicTopic = false; for( String uuidValue : Splitter.on(',').omitEmptyStrings().split(uuid) ) { final String[] uv = uuidValue.split(":", 2); ht = hierarchyService.getHierarchyTopicByUuid(uv[0]); if( uv.length > 1 ) { isDynamicTopic = true; } } PropBagEx xml = new PropBagEx(); buildXmlFromTopic(xml, ht, isDynamicTopic, uuid); return xml.getSubtree("topic").toString(); }
/** * Unpack the querystring from the given url * Returns an empty map if there is no querystring * * @param url The url to parse * @param isPureQueryString Supply true if the url is just the query string or false for complete urls * @return A Map containing the key-value pairs */ public static Map<String, String> unpackQueryString(String url, boolean isPureQueryString) { if (url != null) { String query = null; if (isPureQueryString) { query = url; } else { int qidIndex = url.indexOf(QUERY_IDENTIFIER); if (qidIndex > -1) { query = url.substring(qidIndex + 1); } } if (query != null) { return Splitter .on(QUERY_PAIR_SEPARATOR) .trimResults() .withKeyValueSeparator(QUERY_KEY_VALUE_SEPARATOR) .split(query); } } return new HashMap<>(); }
@Nullable public static GraphiteMetric decode(@Nullable final String metric) { if (metric == null || metric.isEmpty()) { return null; } final List<String> parts = Splitter.on(CharMatcher.BREAKING_WHITESPACE) .trimResults().omitEmptyStrings().splitToList(metric); if (parts.isEmpty() || parts.size() != 3) { return null; } final double value = Double.parseDouble(parts.get(1)); final long timestamp = Long.parseUnsignedLong(parts.get(2)); return new GraphiteMetric(parts.get(0), value, timestamp); }
@Override public String getPath(Charset charset) { StringBuilder path = new StringBuilder(); boolean slash = false; for (String segment : getSegments()) { if (slash) { path.append('/'); } if (segment.indexOf('/') != -1) { Url url = new Url(Splitter.on('/').splitToList(segment), Charsets.UTF_8); path.append(url.getPath()); } else { path.append(UrlEncoder.PATH_INSTANCE.encode(segment, charset)); } slash = true; } return path.toString(); }
public void handleRequest(LogRequest logRequest, LogParams logParams) { List<String> entries = Lists.newArrayList(); entries.add(logRequest.uri); if (logRequest.clientApplication != null) { entries.add("Client: " + logRequest.clientApplication); } if (logRequest.user != null) { entries.add("User: " + logRequest.user); } if (logParams.logHeaders && logRequest.headers != null) { entries.add("Headers: " + getHeaders(logRequest.headers, logParams) ); } if (logParams.logResponseEntity && ! Strings.isNullOrEmpty(logRequest.entity)) { List<String> lines = Splitter.on('\n').splitToList(logRequest.entity) .stream() .map(String::trim) .collect(Collectors.toList()); String compactedEntity = Joiner.on(' ').join(lines); entries.add("Entity: " + compactedEntity); } String logString = Joiner.on(", ").join(entries); LogUtil.doLog(logString, logParams.logLevel, log); }
@Override public CompletableFuture<Long> onLogin(ChannelHandlerContext ctx, SocketASK ask) { // 整个消息就是 token ByteString tokenArg = ask.getBody().getArgs(0); if (tokenArg == null) { logger.info("Token arg must be input."); return null; } String token = tokenArg.toStringUtf8(); if (Strings.isNullOrEmpty(token)) { logger.info("Token arg must be input."); return null; } return CompletableFuture.supplyAsync(() -> { String parseToken = new String(BaseEncoding.base64Url().decode(token)); List<String> tokenChars = Splitter.on('|').splitToList(parseToken); Long userId = Long.valueOf(tokenArg.toStringUtf8()); RoomGroup.getRoomManger().onOnline(ctx, userId); return userId; }); }
/** * 1.0.0 -> 1 00 00 * 2.3.4 -> 2 03 04 * 2.3.40 -> 2 03 40 * 2.4.40 -> 2 04 40 * 20.3.40 -> 20 03 40 * * @param version * @return */ public static int create(String version) { List<String> items = Splitter.on('.').splitToList(version); if (items.size() > 3 || items.size() < 1) { throw new RuntimeException("仅支持99.99.99为最大版本号"); } StringBuffer buffer = new StringBuffer(); for (int i = 0; i < items.size(); i++) { if (items.get(i).length() > 2) { throw new RuntimeException("仅支持99.99.99为最大版本号"); } if (i > 0 && items.get(i).length() == 1) { buffer.append('0'); } buffer.append(items.get(i)); } return Integer.valueOf(buffer.toString()); }
/** * Handles tools: namespace attributes presence in both documents. * @param higherPriority the higherPriority attribute */ private void handleBothToolsAttributePresent( XmlAttribute higherPriority) { // do not merge tools:node attributes, the higher priority one wins. if (getName().getLocalName().equals(NodeOperationType.NODE_LOCAL_NAME)) { return; } // everything else should be merged, duplicates should be eliminated. Splitter splitter = Splitter.on(','); ImmutableSet.Builder<String> targetValues = ImmutableSet.builder(); targetValues.addAll(splitter.split(higherPriority.getValue())); targetValues.addAll(splitter.split(getValue())); higherPriority.getXml().setValue(Joiner.on(',').join(targetValues.build())); }
public static void print(Object toJson) { if (!ENABLED) return; synchronized (sGson) { String json = sGson.toJson(toJson); Iterable<String> lines = Splitter.on(CharMatcher.anyOf("\r\n")).omitEmptyStrings().split(json); int count = 0; Log.v(TAG, "┏"); for (String line : lines) { Log.v(TAG, "┃ " + line); /** * delay the log output to avoid exceeding kernel log buffer size */ if (count++ % 64 == 0) { try { Thread.sleep(1); } catch (InterruptedException ignored) { } } } Log.v(TAG, "┗"); } }
public void deseralise(String sceneData) { String[] data = sceneData.split(deliminator); //careful for regex SceneName = data[0]; PosX = Integer.parseInt(data[1]); PosY = Integer.parseInt(data[2]); NumOfTimesPlayerHasBeenHere = Integer.parseInt(data[3]); currentBackground= data[4]; DynamicOverlayCSS= data[5]; StaticOverlayCSS = data[6]; hasNotBeenCurrentYet=Boolean.parseBoolean(data[7]); //add dependantSceneNames! String sequence = data[8]; if (sequence!=null && !sequence.isEmpty()){ dependantSceneNames = Sets.newHashSet(Splitter.on(',').trimResults().split(sequence)); //convert coma seperated strings to a hashset. Thanks guava! } }
public void read(String path, String prefix) { LogInfo.begin_track("Reading parameters from %s", path); try { BufferedReader in = IOUtils.openIn(path); String line; while ((line = in.readLine()) != null) { String[] pair = Lists.newArrayList(Splitter.on('\t').split(line)).toArray(new String[2]); weights.put(pair[0], Double.parseDouble(pair[1])); weights.put(prefix + pair[0], Double.parseDouble(pair[1])); } in.close(); } catch (IOException e) { throw new RuntimeException(e); } LogInfo.logs("Read %s weights", weights.size()); LogInfo.end_track(); }
public Filter getGroupSearchFilter(String query) { SingleFilter groupClass = new SingleFilter(OBJECTCLASS, groupObject); groupClass.setLimit(config.getSearchLimit()); query = checkQuery(query); if( isSearchAllQuery(query) ) { return groupClass; } AndFilter and = new AndFilter(groupClass); for( String token : Splitter.onPattern("\\s").omitEmptyStrings().trimResults(CharMatcher.is('*')).split(query) ) { token = (config.isWildcards() ? "*" : "") + token + '*'; OrFilter or = new OrFilter(); or.addFilter(new SingleFilter(groupNameField, token, false)); or.addFilter(new SingleFilter(groupIdField, token, false)); and.addFilter(or); } return and; }
private PropertyTree process(PropertyTree meta, SiteConfig siteConfig, ImmutableList<Category> categories) { Builder builder = FixedPropertyTree.builder() .copyOf(meta); for (PostProcessing.Category cat : categories) { Optional<Tree> tree = siteConfig.tree(cat.tree()); tree.ifPresent(t -> { ImmutableList<String> sourceVal = meta.findList(String.class, Splitter.on(".").split(cat.source())); ImmutableSet<String> allParents = t.allParentsOf(sourceVal); ImmutableSet<String> allCategories = Sets.union(allParents, Sets.newHashSet(sourceVal)).immutableCopy(); allCategories.forEach(c -> { builder.put(cat.name(), c); }); }); } return builder.build(); }
public Map<Enchantment, Integer> parseEnchantments(Element el, String name) throws InvalidXMLException { Map<Enchantment, Integer> enchantments = Maps.newHashMap(); Node attr = Node.fromAttr(el, name, StringUtils.pluralize(name)); if(attr != null) { Iterable<String> enchantmentTexts = Splitter.on(";").split(attr.getValue()); for(String enchantmentText : enchantmentTexts) { int level = 1; List<String> parts = Lists.newArrayList(Splitter.on(":").limit(2).split(enchantmentText)); Enchantment enchant = XMLUtils.parseEnchantment(attr, parts.get(0)); if(parts.size() > 1) { level = XMLUtils.parseNumber(attr, parts.get(1), Integer.class); } enchantments.put(enchant, level); } } for(Element elEnchantment : el.getChildren(name)) { Pair<Enchantment, Integer> entry = parseEnchantment(elEnchantment); enchantments.put(entry.first, entry.second); } return enchantments; }
/** * 生成mongoClientFacotryBean * * @param tccMongoConfig 配置信息 * @return bean */ private MongoClientFactoryBean buildMongoClientFactoryBean(TccMongoConfig tccMongoConfig) { MongoClientFactoryBean clientFactoryBean = new MongoClientFactoryBean(); MongoCredential credential = MongoCredential.createScramSha1Credential(tccMongoConfig.getMongoUserName(), tccMongoConfig.getMongoDbName(), tccMongoConfig.getMongoUserPwd().toCharArray()); clientFactoryBean.setCredentials(new MongoCredential[]{ credential }); List<String> urls = Splitter.on(",").trimResults().splitToList(tccMongoConfig.getMongoDbUrl()); ServerAddress[] sds = new ServerAddress[urls.size()]; for (int i = 0; i < sds.length; i++) { List<String> adds = Splitter.on(":").trimResults().splitToList(urls.get(i)); InetSocketAddress address = new InetSocketAddress(adds.get(0), Integer.parseInt(adds.get(1))); sds[i] = new ServerAddress(address); } clientFactoryBean.setReplicaSetSeeds(sds); return clientFactoryBean; }
private static <T> List<T> getList( Map<?, ?> map, Object key, List<T> defaultValue, Function<Object, T> transformation) { Object value = map.get(key); if (value == null) { return defaultValue; } if (value instanceof String) { value = Splitter.on(',').splitToList(value.toString()); } if (!(value instanceof Collection)) { return Collections.singletonList(transformation.apply(value)); } return FluentIterable.from((Collection<?>) value).transform(transformation).toList(); }
private static TreeMultimap<Integer, AlternateName> alternateNames(String path) { Stopwatch stopwatch = Stopwatch.createStarted(); TreeMultimap<Integer, AlternateName> multimap = TreeMultimap.create(); try (BufferedReader br = new BufferedReader(new FileReader(path))) { for (String line = br.readLine(); line != null; line = br.readLine()) { List<String> list = Splitter.on('\t').splitToList(line); if ("fr".equals(list.get(2))) { AlternateName name = new AlternateName(list.get(3), "1".equals(list.get(4)), "1".equals(list.get(5)), "1".equals(list.get(6)), "1".equals(list.get(7))); multimap.put(parseInt(list.get(1)), name); } } } catch (IOException e) { throw propagate(e); } log.info("Alternate names loaded: {}s", stopwatch.elapsed(SECONDS)); return multimap; }
private void readCsv(File file, Map<String, String> map) throws IOException { GradleStartCommon.LOGGER.log(Level.DEBUG, "Reading CSV file: {}", file); Splitter split = Splitter.on(',').trimResults().limit(3); for (String line : Files.readLines(file, Charsets.UTF_8)) { if (line.startsWith("searge")) // header line continue; List<String> splits = split.splitToList(line); map.put(splits.get(0), splits.get(1)); } }
@Override public ServerResponse<CartVo> deleteProduct(Integer userId, String productIds) { List<String> productList = Splitter.on(",").splitToList(productIds); if (CollectionUtils.isEmpty(productList)) { return ServerResponse.createByErrorCodeMessage(ResponseCode.ILLEGAL_ARGUMENT.getCode(), ResponseCode.ILLEGAL_ARGUMENT.getDesc()); } cartMapper.deleteByUserIdProductIds(userId, productList); return this.list(userId); }
public int projectId() { if (projectSlug == null) return 0; List<String> slugParts = Splitter.on('-').limit(2).splitToList(projectSlug); return Integer.parseInt(slugParts.get(0)); }
public String getURL() { if (url == null) { url = Constants.LIBRARIES_BASE; } String[] pts = Iterables.toArray(Splitter.on(':').split(name), String.class); String domain = pts[0]; String libNamename = pts[1]; int last = pts.length - 1; int idx = pts[last].indexOf('@'); if (idx != -1) { pts[last] = pts[last].substring(0, idx); } String version = pts[2]; String classifier = null; String ext = "jar"; if (pts.length > 3) { classifier = pts[3]; } if (domain.equals("net.minecraftforge") && libNamename.equals("forge")) { classifier = "universal"; } String file = libNamename + '-' + version; if (classifier != null) file += '-' + classifier; file += '.' + ext; String path = domain.replace('.', '/') + '/' + libNamename + '/' + version + '/' + file; return url + path; }
public void ensureParsed() { if( topic != null || Check.isEmpty(topicId) || ROOT_TOPICS.equals(topicId) ) { return; } for( String uuidValue : Splitter.on(',').omitEmptyStrings().split(topicId) ) { final String[] uv = uuidValue.split(":", 2); // First UUID is the topic to view if( topic == null ) { topic = hierarchyService.getHierarchyTopicByUuid(uv[0]); topicValue = uv.length > 1 ? URLUtils.basicUrlDecode(uv[1]) : null; if( topic == null ) { throw new IllegalArgumentException("Could not find topic " + uv[0]); } } if( uv.length > 1 ) { if( values == null ) { values = Maps.newHashMap(); } values.put(uv[0], URLUtils.basicUrlDecode(uv[1])); } } }
/** * Draws the screen and all the components in it. */ public void drawScreen(int mouseX, int mouseY, float partialTicks) { this.hoveringText = null; this.drawDefaultBackground(); this.serverListSelector.drawScreen(mouseX, mouseY, partialTicks); this.drawCenteredString(this.fontRendererObj, I18n.format("multiplayer.title", new Object[0]), this.width / 2, 20, 16777215); super.drawScreen(mouseX, mouseY, partialTicks); if (this.hoveringText != null) { this.drawHoveringText(Lists.newArrayList(Splitter.on("\n").split(this.hoveringText)), mouseX, mouseY); } }
public List<String> getApplicationIds() { if (!isDone()) { return Collections.EMPTY_LIST; } else { Optional<ApduSessionParameter> aids = getSession().getParameter( AIDS_KEY + "_" + getIndex()); if (!aids.isPresent()) { return Collections.EMPTY_LIST; } else { Iterable<String> aidIterable = Splitter.on(';') .split(aids.get().getValue()); return Lists.newArrayList(aidIterable); } } }
private void set(Properties properties) { resolveMissingDependenciesFromClassPath = Boolean.valueOf( propertyOrDefault(properties, RESOLVE_MISSING_DEPENDENCIES_FROM_CLASS_PATH)); classResolver = Optional.fromNullable(properties.getProperty(CLASS_RESOLVER)); classResolverArguments = Splitter.on(",").trimResults().omitEmptyStrings() .splitToList(properties.getProperty(CLASS_RESOLVER_ARGS, "")); enableMd5InClassSources = Boolean.valueOf( propertyOrDefault(properties, ENABLE_MD5_IN_CLASS_SOURCES)); parseExtensionProperties(properties); }
public List<String> getMetaFilters() { String metaFilters = EMPTY; if(isDefined(METAFILTER)) { metaFilters = getProperty(METAFILTER); } return Lists.newArrayList(Splitter.on(Pattern.compile(",")) .trimResults().omitEmptyStrings().split(metaFilters)); }
private ImmutableMap<String, String> parseUrlEncodedParams(String input) throws UnsupportedEncodingException { input = URLDecoder.decode(input, "utf8"); if (input.startsWith("?")) { input = input.substring(1); } return ImmutableMap.copyOf(Splitter.on("&").withKeyValueSeparator("=").split(input)); }
/** * Creates commands for calling Node.js on command line. Data wrapped in passed parameter is used to configure node * itself, and to generate file that will be executed by Node. */ public String[] createCmds(NodeRunOptions nodeRunOptions) throws IOException { final ArrayList<String> commands = new ArrayList<>(); commands.add(nodeJsBinary.get().getBinaryAbsolutePath()); // allow user flags final String nodeOptions = nodeRunOptions.getEngineOptions(); if (nodeOptions != null) { for (String nodeOption : Splitter.on(BREAKING_WHITESPACE).omitEmptyStrings().split(nodeOptions)) { commands.add(nodeOption); } } final StringBuilder elfData = getELFCode(nodeRunOptions.getInitModules(), nodeRunOptions.getExecModule(), nodeRunOptions.getExecutionData()); final File elf = createTempFileFor(elfData.toString()); commands.add(elf.getCanonicalPath()); if (nodeRunOptions.getSystemLoader() == SystemLoaderInfo.COMMON_JS) { commands.add(CJS_COMMAND); } return commands.toArray(new String[] {}); }
@AndroidIncompatible // problem with equality of Type objects? public void testFreshInstance() { assertFreshInstances( String.class, CharSequence.class, Appendable.class, StringBuffer.class, StringBuilder.class, Pattern.class, MatchResult.class, Number.class, int.class, Integer.class, long.class, Long.class, short.class, Short.class, byte.class, Byte.class, boolean.class, Boolean.class, char.class, Character.class, int[].class, Object[].class, UnsignedInteger.class, UnsignedLong.class, BigInteger.class, BigDecimal.class, Throwable.class, Error.class, Exception.class, RuntimeException.class, Charset.class, Locale.class, Currency.class, List.class, Map.Entry.class, Object.class, Equivalence.class, Predicate.class, Function.class, Comparable.class, Comparator.class, Ordering.class, Class.class, Type.class, TypeToken.class, TimeUnit.class, Ticker.class, Joiner.class, Splitter.class, CharMatcher.class, InputStream.class, ByteArrayInputStream.class, Reader.class, Readable.class, StringReader.class, OutputStream.class, ByteArrayOutputStream.class, Writer.class, StringWriter.class, File.class, Buffer.class, ByteBuffer.class, CharBuffer.class, ShortBuffer.class, IntBuffer.class, LongBuffer.class, FloatBuffer.class, DoubleBuffer.class, String[].class, Object[].class, int[].class); }
private void applyText(Team team, String text, OfflinePlayer result) { Iterator<String> iterator = Splitter.fixedLength(16).split(text).iterator(); String prefix = iterator.next(); team.setPrefix(prefix); if (!team.hasEntry(result.getName())) team.addEntry(result.getName()); if (text.length() > 16) { String prefixColor = ChatColor.getLastColors(prefix); String suffix = iterator.next(); //TODO Change to the symbols if (prefix.endsWith("nn")) { prefix = prefix.substring(0, prefix.length() - 1); team.setPrefix(prefix); prefixColor = ChatColor.getByChar(suffix.charAt(0)).toString(); suffix = suffix.substring(1); } if (prefixColor == null) prefixColor = ""; if (suffix.length() > 16) { suffix = suffix.substring(0, (13 - prefixColor.length())); // cut off suffix, done if text is over 30 characters } team.setSuffix((prefixColor.equals("") ? ChatColor.RESET : prefixColor) + suffix); } }
public static String getName(String name) { if (!name.contains(".")) { return name; } else { List<String> parts = Splitter.on('.').splitToList(name); return parts.get(parts.size() - 1); } }
@Override public boolean accept(Player receiver, ByteArrayDataInput in) { in.readUTF(); String csv = in.readUTF(); if (csv.isEmpty()) { callback.accept(ImmutableList.of()); return true; } callback.accept(ImmutableList.copyOf(Splitter.on(", ").splitToList(csv))); return true; }
@Override public boolean accept(Player receiver, ByteArrayDataInput in) { String csv = in.readUTF(); if (csv.isEmpty()) { callback.accept(ImmutableList.of()); return true; } callback.accept(ImmutableList.copyOf(Splitter.on(", ").splitToList(csv))); return true; }
@Override public FunctionalCommandBuilder<T> assertUsage(String usage, String failureMessage) { Preconditions.checkNotNull(usage, "usage"); Preconditions.checkNotNull(failureMessage, "failureMessage"); List<String> usageParts = Splitter.on(" ").splitToList(usage); int requiredArgs = 0; for (String usagePart : usageParts) { if (!usagePart.startsWith("[") && !usagePart.endsWith("]")) { // assume it's a required argument requiredArgs++; } } int finalRequiredArgs = requiredArgs; predicates.add(context -> { if (context.args().size() >= finalRequiredArgs) { return true; } context.reply(failureMessage.replace("{usage}", "/" + context.label() + " " + usage)); return false; }); return this; }
public OutputConfiguration(String id, Config config) { this.id = id; if (config.hasPath("inputs")) { this.inputs = Sets.newHashSet(Splitter.on(",").omitEmptyStrings().trimResults().split(config.getString("inputs"))); } }
public InputConfiguration(String id, Config config) { this.id = id; if (config.hasPath("outputs")) { this.outputs = Sets.newHashSet(Splitter.on(",").omitEmptyStrings().trimResults().split(config.getString("outputs"))); } if (config.hasPath("message-fields")) { final Config messageFieldsConfig = config.getConfig("message-fields"); for (Map.Entry<String, ConfigValue> entry : messageFieldsConfig.entrySet()) { final String key = entry.getKey(); final ConfigValue value = entry.getValue(); switch (value.valueType()) { case NUMBER: this.messageFields.put(key, messageFieldsConfig.getNumber(key)); break; case BOOLEAN: this.messageFields.put(key, messageFieldsConfig.getBoolean(key)); break; case STRING: this.messageFields.put(key, messageFieldsConfig.getString(key)); break; default: log.warn("{}[{}] Message field value of type \"{}\" is not supported for key \"{}\" (value: {})", getClass().getSimpleName(), getId(), value.valueType(), key, value.toString()); break; } } } }
/** * Returns a parsed list of the --invoke-with command and its * arguments, or an empty list if no --invoke-with was provided. */ public Iterable<String> invokeWith() { if (invokeWith == null) { return Collections.emptyList(); } return Splitter.onPattern("\\s+").omitEmptyStrings().split(invokeWith); }
public Map<String, String> doAnalysis(String log) { Map<String, String> result = new HashMap<String, String>(); String temp3area = log.substring(15).trim(); Splitter s = Splitter.onPattern("\\p{Space}").trimResults(); List<String> it = Lists.newArrayList(s.limit(3).split(temp3area)); result.put("date", log.substring(0, 15)); result.put("host", it.get(0)); result.put("pid", it.get(1)); result.put("message", it.get(2)); return result; }
public static String createJavaPackage(String nativeNamespace, String packagePrefix) { String cleanedTsNamespace = maybeRemoveClutzNamespace(nativeNamespace); // ensure all package are in lower case to avoid clash with type name cleanedTsNamespace = Joiner.on('.') .join(transform(Splitter.on('.').split(cleanedTsNamespace), String::toLowerCase)); return maybeAppendPrefix(packagePrefix, cleanedTsNamespace); }