summaryrefslogtreecommitdiffstats
path: root/qadevOOo/runner/util/RegistryTools.java
diff options
context:
space:
mode:
Diffstat (limited to 'qadevOOo/runner/util/RegistryTools.java')
-rw-r--r--qadevOOo/runner/util/RegistryTools.java359
1 files changed, 359 insertions, 0 deletions
diff --git a/qadevOOo/runner/util/RegistryTools.java b/qadevOOo/runner/util/RegistryTools.java
new file mode 100644
index 000000000..72ef5e743
--- /dev/null
+++ b/qadevOOo/runner/util/RegistryTools.java
@@ -0,0 +1,359 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you under the Apache
+ * License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+package util;
+
+// access the implementations via names
+import com.sun.star.uno.UnoRuntime;
+import java.io.PrintWriter ;
+
+import com.sun.star.registry.XRegistryKey ;
+import com.sun.star.registry.XSimpleRegistry ;
+import com.sun.star.registry.RegistryKeyType ;
+import com.sun.star.registry.RegistryValueType ;
+import com.sun.star.registry.InvalidRegistryException ;
+import com.sun.star.lang.XMultiServiceFactory ;
+import com.sun.star.uno.Exception;
+
+public class RegistryTools {
+
+ /**
+ * Creates 'com.sun.star.registry.SimpleRegistry'
+ * service.
+ * @param xMSF Multiservice factory.
+ * @return Service created.
+ */
+ public static XSimpleRegistry createRegistryService
+ (XMultiServiceFactory xMSF) throws com.sun.star.uno.Exception {
+
+ Object oInterface = xMSF.createInstance
+ ("com.sun.star.registry.SimpleRegistry");
+ return UnoRuntime.queryInterface (
+ XSimpleRegistry.class, oInterface) ;
+ }
+
+ /**
+ * Opens registry file for reading/writing. If file doesn't
+ * exist a new one created.
+ * @param file Registry file name.
+ * @param xMSF Multiservice factory.
+ * @return Opened registry.
+ */
+ public static XSimpleRegistry openRegistry
+ (String file, XMultiServiceFactory xMSF)
+ throws com.sun.star.uno.Exception {
+
+ XSimpleRegistry reg = createRegistryService(xMSF) ;
+
+ reg.open(file, false, true) ;
+
+ return reg ;
+ }
+
+ /**
+ * Compares two registry keys, their names, value
+ * types and values.
+ * return <code>true</code> if key names, value types
+ * and values are equal, else returns <code>false</code>.
+ */
+ private static boolean compareKeys
+ (XRegistryKey key1, XRegistryKey key2) {
+
+ if (key1 == null || key2 == null ||
+ !key1.isValid() || !key2.isValid())
+
+ return false ;
+
+ String keyName1 = getShortKeyName(key1.getKeyName()) ;
+ String keyName2 = getShortKeyName(key2.getKeyName()) ;
+
+ if (!keyName1.equals(keyName2)) return false ;
+
+ try {
+ if (key1.getValueType() != key2.getValueType()) return false ;
+ } catch (InvalidRegistryException e) {
+ return false ;
+ }
+
+ RegistryValueType type ;
+ try {
+ type = key1.getValueType() ;
+
+ if (type.equals(RegistryValueType.ASCII)) {
+ if (!key1.getAsciiValue().equals(key2.getAsciiValue()))
+ return false ;
+ } else
+ if (type.equals(RegistryValueType.STRING)) {
+ if (!key1.getStringValue().equals(key2.getStringValue()))
+ return false ;
+ } else
+ if (type.equals(RegistryValueType.LONG)) {
+ if (key1.getLongValue() != key2.getLongValue())
+ return false ;
+ } else
+ if (type.equals(RegistryValueType.BINARY)) {
+ byte[] bin1 = key1.getBinaryValue() ;
+ byte[] bin2 = key2.getBinaryValue() ;
+ if (bin1.length != bin2.length)
+ return false ;
+ for (int i = 0; i < bin1.length; i++)
+ if (bin1[i] != bin2[i]) return false ;
+ } else
+ if (type.equals(RegistryValueType.ASCIILIST)) {
+ String[] list1 = key1.getAsciiListValue() ;
+ String[] list2 = key2.getAsciiListValue() ;
+ if (list1.length != list2.length)
+ return false ;
+ for (int i = 0; i < list1.length; i++)
+ if (!list1[i].equals(list2[i])) return false ;
+ } else
+ if (type.equals(RegistryValueType.STRINGLIST)) {
+ String[] list1 = key1.getStringListValue() ;
+ String[] list2 = key2.getStringListValue() ;
+ if (list1.length != list2.length)
+ return false ;
+ for (int i = 0; i < list1.length; i++)
+ if (!list1[i].equals(list2[i])) return false ;
+ } else
+ if (type.equals(RegistryValueType.LONGLIST)) {
+ int[] list1 = key1.getLongListValue() ;
+ int[] list2 = key2.getLongListValue() ;
+ if (list1.length != list2.length)
+ return false ;
+ for (int i = 0; i < list1.length; i++)
+ if (list1[i] != list2[i]) return false ;
+ }
+ } catch (Exception e) {
+ return false ;
+ }
+
+ return true ;
+ }
+
+ /**
+ * Gets name of the key relative to its parent.
+ * For example if full name of key is '/key1/subkey'
+ * short key name is 'subkey'
+ * @param keyName Full key name.
+ * @return Short key name.
+ */
+ private static String getShortKeyName(String keyName) {
+ if (keyName == null) return null ;
+ int idx = keyName.lastIndexOf('/') ;
+ if (idx < 0) return keyName ;
+ else return keyName.substring(idx + 1) ;
+ }
+
+ /**
+ * Compare all child keys.
+ * @param compareRoot If <code>true</code> method also
+ * compare root keys, if <code>false</code> it begins recursive
+ * comparing from children of root keys.
+ * @return <code>true</code> if keys and their sub keys are equal.
+ */
+ private static boolean compareKeyTrees
+ (XRegistryKey tree1, XRegistryKey tree2, boolean compareRoot) {
+
+ if (compareRoot && !compareKeys(tree1, tree2)) return false ;
+
+ try {
+ String[] keyNames1 = tree1.getKeyNames() ;
+ String[] keyNames2 = tree2.getKeyNames() ;
+
+ if (keyNames1 == null && keyNames2 == null) return true ;
+
+ if (keyNames1 == null || keyNames2 == null ||
+ keyNames2.length != keyNames1.length)
+ return false ;
+
+ for (int i = 0; i < keyNames1.length; i++) {
+
+ String keyName = getShortKeyName(keyNames1[i]) ;
+ XRegistryKey key2 = tree2.openKey(keyName) ;
+
+ if (key2 == null)
+ // key with the same name doesn't exist in the second tree
+ return false ;
+
+ if (!tree1.getKeyType(keyName).equals(
+ tree2.getKeyType(keyName)))
+ return false ;
+
+ if (tree1.getKeyType(keyName).equals(
+ RegistryKeyType.LINK)) {
+
+ if (!getShortKeyName(tree1.getLinkTarget(keyName)).equals(
+ getShortKeyName(tree2.getLinkTarget(keyName))))
+
+ return false ;
+ } else {
+
+ if (!compareKeyTrees(tree1.openKey(keyName),
+ tree2.openKey(keyName), true)) return false ;
+ }
+ }
+ } catch (InvalidRegistryException e) {
+ return false ;
+ }
+
+ return true ;
+ }
+
+ /**
+ * Compare keys specified and all their child keys.
+ * @return <code>true</code> if keys and their sub keys are equal.
+ */
+ public static boolean compareKeyTrees
+ (XRegistryKey tree1, XRegistryKey tree2) {
+
+ return compareKeyTrees(tree1, tree2, false) ;
+ }
+
+ /**
+ * Prints to a specified output about all keys and subkeys information
+ * (key name, type, value, link target, attributes) recursively.
+ * @param reg Registry for which information is needed.
+ * @param out Output stream.
+ */
+ public static void printRegistryInfo(XSimpleRegistry reg, PrintWriter out) {
+ try {
+ printRegistryInfo(reg.getRootKey(), out) ;
+ } catch (com.sun.star.registry.InvalidRegistryException e) {
+ out.println("!!! Can't open root registry key for info printing") ;
+ }
+ }
+
+ /**
+ * Prints to a specified output about all keys and subkeys information
+ * (key name, type, value, link target, attributes) recursively.
+ * @param root Key for which subkeys (and further) information is required.
+ * @param out Output stream.
+ */
+ public static void printRegistryInfo(XRegistryKey root, PrintWriter out) {
+ if (root == null) {
+ out.println("/(null)") ;
+ return ;
+ }
+
+ out.println("/") ;
+ try {
+ printTreeInfo(root, out, " ") ;
+ } catch (com.sun.star.registry.InvalidRegistryException e) {
+ out.println("Exception accessing registry :") ;
+ e.printStackTrace(out) ;
+ }
+ }
+
+ private static void printTreeInfo(XRegistryKey key,
+ PrintWriter out, String margin)
+ throws com.sun.star.registry.InvalidRegistryException {
+
+ String[] subKeys = key.getKeyNames() ;
+
+ if (subKeys == null || subKeys.length == 0) return ;
+
+ for (int i = 0; i < subKeys.length; i++) {
+ printKeyInfo(key, subKeys[i], out, margin) ;
+ XRegistryKey subKey = key.openKey
+ (getShortKeyName(subKeys[i])) ;
+ printTreeInfo(subKey, out, margin + " ") ;
+ subKey.closeKey() ;
+ }
+ }
+
+ private static void printKeyInfo(XRegistryKey parentKey,
+ String keyName, PrintWriter out, String margin)
+ throws com.sun.star.registry.InvalidRegistryException {
+
+ out.print(margin) ;
+ keyName = getShortKeyName(keyName) ;
+ XRegistryKey key = parentKey.openKey(keyName) ;
+ if (key != null)
+ out.print("/" + getShortKeyName(key.getKeyName()) + " ") ;
+ else {
+ out.println("(null)") ;
+ return ;
+ }
+
+ if (!key.isValid()) {
+ out.println("(not valid)") ;
+ return ;
+ }
+
+ if (key.isReadOnly()) {
+ out.print("(read only) ") ;
+ }
+
+ if (parentKey.getKeyType(keyName) == RegistryKeyType.LINK) {
+ out.println("(link to " + parentKey.getLinkTarget(keyName) + ")") ;
+ return ;
+ }
+
+ RegistryValueType type ;
+ try {
+ type = key.getValueType() ;
+
+ if (type.equals(RegistryValueType.ASCII)) {
+ out.println("[ASCII] = '" + key.getAsciiValue() + "'") ;
+ } else
+ if (type.equals(RegistryValueType.STRING)) {
+ out.println("[STRING] = '" + key.getStringValue() + "'") ;
+ } else
+ if (type.equals(RegistryValueType.LONG)) {
+ out.println("[LONG] = " + key.getLongValue()) ;
+ } else
+ if (type.equals(RegistryValueType.BINARY)) {
+ out.print("[BINARY] = {") ;
+ byte[] bin = key.getBinaryValue() ;
+ for (int i = 0; i < bin.length; i++)
+ out.print(bin[i] + ",") ;
+ out.println("}") ;
+ } else
+ if (type.equals(RegistryValueType.ASCIILIST)) {
+ out.print("[ASCIILIST] = {") ;
+ String[] list = key.getAsciiListValue() ;
+ for (int i = 0; i < list.length; i++)
+ out.print("'" + list[i] + "',") ;
+ out.println("}") ;
+ } else
+ if (type.equals(RegistryValueType.STRINGLIST)) {
+ out.print("[STRINGLIST] = {") ;
+ String[] list = key.getStringListValue() ;
+ for (int i = 0; i < list.length; i++)
+ out.print("'" + list[i] + "',") ;
+ out.println("}") ;
+ } else
+ if (type.equals(RegistryValueType.LONGLIST)) {
+ out.print("[LONGLIST] = {") ;
+ int[] list = key.getLongListValue() ;
+ for (int i = 0; i < list.length; i++)
+ out.print(list[i] + ",") ;
+ out.println("}") ;
+ } else {
+ out.println("") ;
+ }
+ } catch (com.sun.star.uno.Exception e) {
+ out.println("Exception occurred : ") ;
+ e.printStackTrace(out) ;
+ } finally {
+ key.closeKey() ;
+ }
+ }
+
+
+}