Inproved parsing of value-nodes (needed for localization)

4 files changed, 575 insertions, 97 deletions

diff --git a/configmgr/source/inc/strdecl.hxx b/configmgr/source/inc/strdecl.hxx
index ccf652adbeaf..bbb9f63bdf64 100644
--- a/configmgr/source/inc/strdecl.hxx
+++ b/configmgr/source/inc/strdecl.hxx
@@ -2,9 +2,9 @@
  *
  *  $RCSfile: strdecl.hxx,v $
  *
- *  $Revision: 1.7 $
+ *  $Revision: 1.8 $
  *
- *  last change: $Author: lla $ $Date: 2000-11-29 13:59:48 $
+ *  last change: $Author: jb $ $Date: 2001-03-16 17:28:49 $
  *
  *  The Contents of this file are made available subject to the terms of
  *  either of the following licenses
@@ -71,61 +71,78 @@ namespace configmgr
 //.........................................................................
 
 // extern declaration for predefined strings, uncompleted
+    // tag names
+    // <name>...</name>
     DECLARE_CONSTASCII_USTRING(TAG_VALUE);
-    DECLARE_CONSTASCII_USTRING(TAG_USERVALUE);
-    DECLARE_CONSTASCII_USTRING(TAG_VALUE_ITEM);
-    DECLARE_CONSTASCII_USTRING(TAG_DEFAULT_ITEM);
-    DECLARE_CONSTASCII_USTRING(TAG_NODEFAULT);
-    DECLARE_CONSTASCII_USTRING(TAG_DEFAULT);
-    DECLARE_CONSTASCII_USTRING(TAG_DEFAULTVALUE);
-    DECLARE_CONSTASCII_USTRING(TAG_DATA);
-
-    DECLARE_CONSTASCII_USTRING(TYPE_BOOLEAN);
-    DECLARE_CONSTASCII_USTRING(TYPE_SHORT);
-    DECLARE_CONSTASCII_USTRING(TYPE_INT);
-    DECLARE_CONSTASCII_USTRING(TYPE_LONG);
-    DECLARE_CONSTASCII_USTRING(TYPE_DOUBLE);
-    DECLARE_CONSTASCII_USTRING(TYPE_STRING);
-    DECLARE_CONSTASCII_USTRING(TYPE_BINARY);
-    DECLARE_CONSTASCII_USTRING(TYPE_ANY);
-    DECLARE_CONSTASCII_USTRING(TYPE_SET);
-    DECLARE_CONSTASCII_USTRING(TYPE_GROUP);
 
-    DECLARE_CONSTASCII_USTRING(ATTR_ENCODING_HEX);
+    // Attributes name="..."
     DECLARE_CONSTASCII_USTRING(ATTR_NAME);
     DECLARE_CONSTASCII_USTRING(ATTR_TYPE);
-    DECLARE_CONSTASCII_USTRING(ATTR_GROUP);
-    DECLARE_CONSTASCII_USTRING(ATTR_DERIVED);
+    DECLARE_CONSTASCII_USTRING(ATTR_TYPE_MODIFIER);
     DECLARE_CONSTASCII_USTRING(ATTR_INSTANCE);
+    DECLARE_CONSTASCII_USTRING(ATTR_MODULE);
     DECLARE_CONSTASCII_USTRING(ATTR_ENCODING);
-    DECLARE_CONSTASCII_USTRING(ATTR_MODE);
-    DECLARE_CONSTASCII_USTRING(ATTR_PATH);
-    DECLARE_CONSTASCII_USTRING(ATTR_DERIVED_LIST);
-    DECLARE_CONSTASCII_USTRING(ATTR_VALUE_ADD);
-    DECLARE_CONSTASCII_USTRING(ATTR_VALUE_REMOVE);
-    DECLARE_CONSTASCII_USTRING(ATTR_LOCALIZE);
-    DECLARE_CONSTASCII_USTRING(ATTR_LANG);
     DECLARE_CONSTASCII_USTRING(ATTR_SEPARATOR);
     DECLARE_CONSTASCII_USTRING(ATTR_NULL);
+    DECLARE_CONSTASCII_USTRING(ATTR_LANG);
+    DECLARE_CONSTASCII_USTRING(ATTR_LOCALIZE);
     DECLARE_CONSTASCII_USTRING(ATTR_NULLABLE);
-    DECLARE_CONSTASCII_USTRING(ATTR_STATE);
     DECLARE_CONSTASCII_USTRING(ATTR_WRITABLE);
-    DECLARE_CONSTASCII_USTRING(ATTR_VALUE_DEFAULT);
+    DECLARE_CONSTASCII_USTRING(ATTR_STATE);
 
+    // boolean constants
     DECLARE_CONSTASCII_USTRING(ATTR_VALUE_TRUE);
     DECLARE_CONSTASCII_USTRING(ATTR_VALUE_FALSE);
 
-    DECLARE_CONSTASCII_USTRING(PARAM_OBJECT);
-    DECLARE_CONSTASCII_USTRING(PARAM_NAME);
-    DECLARE_CONSTASCII_USTRING(PARAM_ISNEWOBJECT);
+    // simple types names
+    DECLARE_CONSTASCII_USTRING(TYPE_BOOLEAN);
+    DECLARE_CONSTASCII_USTRING(TYPE_SHORT);
+    DECLARE_CONSTASCII_USTRING(TYPE_INT);
+    DECLARE_CONSTASCII_USTRING(TYPE_LONG);
+    DECLARE_CONSTASCII_USTRING(TYPE_DOUBLE);
+    DECLARE_CONSTASCII_USTRING(TYPE_STRING);
+    // Type: Sequence<bytes>
+    DECLARE_CONSTASCII_USTRING(TYPE_BINARY);
+    // Universal type: Any
+    DECLARE_CONSTASCII_USTRING(TYPE_ANY);
+    // special non-value types
+    DECLARE_CONSTASCII_USTRING(TYPE_SET);
+    DECLARE_CONSTASCII_USTRING(TYPE_GROUP);
 
+    // type modifier values
+    DECLARE_CONSTASCII_USTRING(TYPE_MODIFIER_LIST);
+
+    // States for update actions
     DECLARE_CONSTASCII_USTRING(STATE_MODIFIED);
     DECLARE_CONSTASCII_USTRING(STATE_REPLACED);
     DECLARE_CONSTASCII_USTRING(STATE_DELETED);
+    DECLARE_CONSTASCII_USTRING(STATE_DEFAULT);
 
-    DECLARE_CONSTASCII_USTRING(DEFAULT_SEPARATOR);
+    // the encoding for binary values
+    DECLARE_CONSTASCII_USTRING(ENCODING_HEX);
+    DECLARE_CONSTASCII_USTRING(ENCODING_BASE64);
 
     DECLARE_CONSTASCII_USTRING(XML_CDATA);
+
+    // special template names for native/localized value types
+    DECLARE_CONSTASCII_USTRING(TEMPLATE_MODULE_NATIVE_PREFIX);
+    DECLARE_CONSTASCII_USTRING(TEMPLATE_MODULE_NATIVE_VALUE);
+    DECLARE_CONSTASCII_USTRING(TEMPLATE_MODULE_LOCALIZED_VALUE);
+
+    DECLARE_CONSTASCII_USTRING(TEMPLATE_LIST_SUFFIX);
+
+    // the default separator for strings
+    DECLARE_CONSTASCII_USTRING(DEFAULT_SEPARATOR);
+
+    // specials for im-/export
+    DECLARE_CONSTASCII_USTRING(TAG_DATA);
+    DECLARE_CONSTASCII_USTRING(ATTR_PATH);
+
+    // Parameter (?)
+    DECLARE_CONSTASCII_USTRING(PARAM_OBJECT);
+    DECLARE_CONSTASCII_USTRING(PARAM_NAME);
+    DECLARE_CONSTASCII_USTRING(PARAM_ISNEWOBJECT);
+
 } // namespace configmgr
 #endif
 
diff --git a/configmgr/source/inc/typeconverter.hxx b/configmgr/source/inc/typeconverter.hxx
index 589d5e989523..42b2fc284724 100644
--- a/configmgr/source/inc/typeconverter.hxx
+++ b/configmgr/source/inc/typeconverter.hxx
@@ -2,9 +2,9 @@
  *
  *  $RCSfile: typeconverter.hxx,v $
  *
- *  $Revision: 1.3 $
+ *  $Revision: 1.4 $
  *
- *  last change: $Author: lla $ $Date: 2000-11-03 08:51:03 $
+ *  last change: $Author: jb $ $Date: 2001-03-16 17:28:49 $
  *
  *  The Contents of this file are made available subject to the terms of
  *  either of the following licenses
@@ -107,6 +107,14 @@ namespace configmgr
     inline uno::Type getBinaryType()    { return ::getCppuType(static_cast<uno::Sequence<sal_Int8> const*>(0)); }
     inline uno::Type getAnyType()       { return ::getCppuType(static_cast<uno::Any const*>(0)); }
 
+    // template names
+    ::rtl::OUString toTemplateName(const uno::Type& _rType);
+    ::rtl::OUString toTemplateName(const uno::TypeClass& _rBasicType, bool bList = false);
+    ::rtl::OUString toTemplateName(const ::rtl::OUString& _rBasicTypeName, bool bList = false);
+
+     uno::Type parseTemplateName(::rtl::OUString const& sTypeName);
+     void parseTemplateName(::rtl::OUString const& sTypeName, uno::TypeClass& _rType, bool& bList);
+     void parseTemplateName(::rtl::OUString const& sTypeName, ::rtl::OUString& _rBasicName, bool& bList);
 
 } // namespace configmgr
 
diff --git a/configmgr/source/misc/strimpl.cxx b/configmgr/source/misc/strimpl.cxx
index e7fb7dd8c9a9..71e531c227d7 100644
--- a/configmgr/source/misc/strimpl.cxx
+++ b/configmgr/source/misc/strimpl.cxx
@@ -2,9 +2,9 @@
  *
  *  $RCSfile: strimpl.cxx,v $
  *
- *  $Revision: 1.7 $
+ *  $Revision: 1.8 $
  *
- *  last change: $Author: lla $ $Date: 2000-11-29 13:59:51 $
+ *  last change: $Author: jb $ $Date: 2001-03-16 17:28:49 $
  *
  *  The Contents of this file are made available subject to the terms of
  *  either of the following licenses
@@ -67,77 +67,76 @@ namespace configmgr
 {
     // tag names
     // <name>...</name>
-    IMPLEMENT_CONSTASCII_USTRING(TAG_VALUE,        "cfg:value");
-    IMPLEMENT_CONSTASCII_USTRING(TAG_USERVALUE,    "uservalue");
-    IMPLEMENT_CONSTASCII_USTRING(TAG_VALUE_ITEM,   "value_item");
-    IMPLEMENT_CONSTASCII_USTRING(TAG_DEFAULT_ITEM, "default_item");
-    IMPLEMENT_CONSTASCII_USTRING(TAG_NODEFAULT,    "nodefault");
-    IMPLEMENT_CONSTASCII_USTRING(TAG_DEFAULT,      "default");
-    IMPLEMENT_CONSTASCII_USTRING(TAG_DEFAULTVALUE, "defaultvalue");
-    IMPLEMENT_CONSTASCII_USTRING(TAG_DATA,         "data");
-
-    // simple types Attribut params
-    IMPLEMENT_CONSTASCII_USTRING(TYPE_BOOLEAN, "boolean");
-    IMPLEMENT_CONSTASCII_USTRING(TYPE_SHORT,   "short");
-    IMPLEMENT_CONSTASCII_USTRING(TYPE_INT,     "int");
-    IMPLEMENT_CONSTASCII_USTRING(TYPE_LONG,    "long");
-    IMPLEMENT_CONSTASCII_USTRING(TYPE_DOUBLE,  "double");
-    IMPLEMENT_CONSTASCII_USTRING(TYPE_STRING,  "string");
-    IMPLEMENT_CONSTASCII_USTRING(TYPE_ANY,     "any");
+    IMPLEMENT_CONSTASCII_USTRING(TAG_VALUE,     "cfg:value");
 
-    // Type: Sequence<bytes>
-    IMPLEMENT_CONSTASCII_USTRING(TYPE_BINARY,  "binary");
+    // Attributes name="..."
+    IMPLEMENT_CONSTASCII_USTRING(ATTR_NAME,         "cfg:name");
+    IMPLEMENT_CONSTASCII_USTRING(ATTR_TYPE,         "cfg:type");
+    IMPLEMENT_CONSTASCII_USTRING(ATTR_TYPE_MODIFIER,"cfg:derivedBy");
+    IMPLEMENT_CONSTASCII_USTRING(ATTR_INSTANCE,     "cfg:element-type");
+    IMPLEMENT_CONSTASCII_USTRING(ATTR_MODULE,       "cfg:component");
+    IMPLEMENT_CONSTASCII_USTRING(ATTR_ENCODING,     "cfg:encoding");
+    IMPLEMENT_CONSTASCII_USTRING(ATTR_SEPARATOR,    "cfg:separator");
+    IMPLEMENT_CONSTASCII_USTRING(ATTR_NULL,         "xsi:null");
+    IMPLEMENT_CONSTASCII_USTRING(ATTR_LANG,         "xml:lang");
+    IMPLEMENT_CONSTASCII_USTRING(ATTR_LOCALIZE,     "cfg:localized");
+    IMPLEMENT_CONSTASCII_USTRING(ATTR_NULLABLE,     "cfg:nullable");
+    IMPLEMENT_CONSTASCII_USTRING(ATTR_WRITABLE,     "cfg:writable");
+    IMPLEMENT_CONSTASCII_USTRING(ATTR_STATE,        "state");
 
-    // special types
+    // boolean constants
+    IMPLEMENT_CONSTASCII_USTRING(ATTR_VALUE_TRUE,   "true");
+    IMPLEMENT_CONSTASCII_USTRING(ATTR_VALUE_FALSE,  "false");
+
+    // simple types names
+    IMPLEMENT_CONSTASCII_USTRING(TYPE_BOOLEAN,  "boolean");
+    IMPLEMENT_CONSTASCII_USTRING(TYPE_SHORT,    "short");
+    IMPLEMENT_CONSTASCII_USTRING(TYPE_INT,      "int");
+    IMPLEMENT_CONSTASCII_USTRING(TYPE_LONG,     "long");
+    IMPLEMENT_CONSTASCII_USTRING(TYPE_DOUBLE,   "double");
+    IMPLEMENT_CONSTASCII_USTRING(TYPE_STRING,   "string");
+    // Type: Sequence<bytes>
+    IMPLEMENT_CONSTASCII_USTRING(TYPE_BINARY,   "binary");
+    // Universal type: Any
+    IMPLEMENT_CONSTASCII_USTRING(TYPE_ANY,      "any");
+    // special non-value types
     IMPLEMENT_CONSTASCII_USTRING(TYPE_SET,      "set");
     IMPLEMENT_CONSTASCII_USTRING(TYPE_GROUP,    "group");
 
+    // type modifier values
+    IMPLEMENT_CONSTASCII_USTRING(TYPE_MODIFIER_LIST, "list");
 
-    // Attributes name="..."
-    IMPLEMENT_CONSTASCII_USTRING(ATTR_ENCODING_HEX, "hex");
-    IMPLEMENT_CONSTASCII_USTRING(ATTR_NAME,     "name");
-    IMPLEMENT_CONSTASCII_USTRING(ATTR_TYPE,     "cfg:type");
-
-    IMPLEMENT_CONSTASCII_USTRING(ATTR_GROUP,    "group");
-    IMPLEMENT_CONSTASCII_USTRING(ATTR_DERIVED,  "cfg:derivedBy");
-    IMPLEMENT_CONSTASCII_USTRING(ATTR_INSTANCE, "cfg:element-type");
-    IMPLEMENT_CONSTASCII_USTRING(ATTR_STATE,    "state");
-    IMPLEMENT_CONSTASCII_USTRING(ATTR_ENCODING, "cfg:encoding");
-    IMPLEMENT_CONSTASCII_USTRING(ATTR_WRITABLE, "cfg:writable");
-    IMPLEMENT_CONSTASCII_USTRING(ATTR_MODE,     "mode");
-    IMPLEMENT_CONSTASCII_USTRING(ATTR_PATH,     "path");
-
-    // some Attribute params
-    IMPLEMENT_CONSTASCII_USTRING(ATTR_DERIVED_LIST, "list");
-    IMPLEMENT_CONSTASCII_USTRING(ATTR_VALUE_ADD,    "add");
-    IMPLEMENT_CONSTASCII_USTRING(ATTR_VALUE_REMOVE, "remove");
-
-    IMPLEMENT_CONSTASCII_USTRING(ATTR_LANG,      "xml:lang");
-    IMPLEMENT_CONSTASCII_USTRING(ATTR_LOCALIZE,  "cfg:localized");
-    IMPLEMENT_CONSTASCII_USTRING(ATTR_SEPARATOR, "cfg:separator");
-    IMPLEMENT_CONSTASCII_USTRING(ATTR_NULL,      "xsi:null");
-    IMPLEMENT_CONSTASCII_USTRING(ATTR_NULLABLE,  "cfg:nullable");
-    IMPLEMENT_CONSTASCII_USTRING(ATTR_VALUE_DEFAULT,   "default");
-
-    // boolean constants
-    IMPLEMENT_CONSTASCII_USTRING(ATTR_VALUE_TRUE,"true");
-    IMPLEMENT_CONSTASCII_USTRING(ATTR_VALUE_FALSE,"false");
+    // States for update actions
+    IMPLEMENT_CONSTASCII_USTRING(STATE_MODIFIED, "modified");
+    IMPLEMENT_CONSTASCII_USTRING(STATE_REPLACED, "replaced");
+    IMPLEMENT_CONSTASCII_USTRING(STATE_DELETED,  "deleted");
+    IMPLEMENT_CONSTASCII_USTRING(STATE_DEFAULT,  "default");
 
-    // Parameter
-    IMPLEMENT_CONSTASCII_USTRING(PARAM_OBJECT, "Object");
-    IMPLEMENT_CONSTASCII_USTRING(PARAM_NAME, "Name");
-    IMPLEMENT_CONSTASCII_USTRING(PARAM_ISNEWOBJECT, "IsNewObject");
+    // the encoding for binary values
+    IMPLEMENT_CONSTASCII_USTRING(ENCODING_HEX,      "hex");
+    IMPLEMENT_CONSTASCII_USTRING(ENCODING_BASE64,   "base64");
 
     IMPLEMENT_CONSTASCII_USTRING(XML_CDATA, "CDATA");
 
-    // States for update actions
-    IMPLEMENT_CONSTASCII_USTRING(STATE_MODIFIED,     "modified");
-    IMPLEMENT_CONSTASCII_USTRING(STATE_REPLACED,     "replaced");
-    IMPLEMENT_CONSTASCII_USTRING(STATE_DELETED,      "deleted");
+    // special template names for native/localized value types
+    IMPLEMENT_CONSTASCII_USTRING(TEMPLATE_MODULE_NATIVE_PREFIX,     "cfg:");
+    IMPLEMENT_CONSTASCII_USTRING(TEMPLATE_MODULE_NATIVE_VALUE,      "cfg:value");
+    IMPLEMENT_CONSTASCII_USTRING(TEMPLATE_MODULE_LOCALIZED_VALUE,   "cfg:localized");
+
+    IMPLEMENT_CONSTASCII_USTRING(TEMPLATE_LIST_SUFFIX, "-list");
 
     // the default separator for strings
     IMPLEMENT_CONSTASCII_USTRING(DEFAULT_SEPARATOR,  " ");
 
+    // im-/export specific
+    IMPLEMENT_CONSTASCII_USTRING(TAG_DATA,  "data");
+    IMPLEMENT_CONSTASCII_USTRING(ATTR_PATH, "path");
+
+    // Parameter (?)
+    IMPLEMENT_CONSTASCII_USTRING(PARAM_OBJECT, "Object");
+    IMPLEMENT_CONSTASCII_USTRING(PARAM_NAME, "Name");
+    IMPLEMENT_CONSTASCII_USTRING(PARAM_ISNEWOBJECT, "IsNewObject");
+
 // emacs:
 // create the declare from the implement
 // (fset 'create-declare-from-implement
diff --git a/configmgr/source/xml/valueconverter.cxx b/configmgr/source/xml/valueconverter.cxx
new file mode 100644
index 000000000000..afdc1fbea5e4
--- /dev/null
+++ b/configmgr/source/xml/valueconverter.cxx
@@ -0,0 +1,454 @@
+/*************************************************************************
+ *
+ *  $RCSfile: valueconverter.cxx,v $
+ *
+ *  $Revision: 1.1 $
+ *
+ *  last change: $Author: jb $ $Date: 2001-03-16 17:28:50 $
+ *
+ *  The Contents of this file are made available subject to the terms of
+ *  either of the following licenses
+ *
+ *         - GNU Lesser General Public License Version 2.1
+ *         - Sun Industry Standards Source License Version 1.1
+ *
+ *  Sun Microsystems Inc., October, 2000
+ *
+ *  GNU Lesser General Public License Version 2.1
+ *  =============================================
+ *  Copyright 2000 by Sun Microsystems, Inc.
+ *  901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License version 2.1, as published by the Free Software Foundation.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ *  MA  02111-1307  USA
+ *
+ *
+ *  Sun Industry Standards Source License Version 1.1
+ *  =================================================
+ *  The contents of this file are subject to the Sun Industry Standards
+ *  Source License Version 1.1 (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.openoffice.org/license.html.
+ *
+ *  Software provided under this License is provided on an "AS IS" basis,
+ *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+ *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
+ *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
+ *  See the License for the specific provisions governing your rights and
+ *  obligations concerning the Software.
+ *
+ *  The Initial Developer of the Original Code is: Sun Microsystems, Inc.
+ *
+ *  Copyright: 2000 by Sun Microsystems, Inc.
+ *
+ *  All Rights Reserved.
+ *
+ *  Contributor(s): _______________________________________
+ *
+ *
+ ************************************************************************/
+
+#include "valueconverter.hxx"
+
+#include "strdecl.hxx"
+#include "typeconverter.hxx"
+
+// #define ASCII(x) OUString::createFromAscii(x)
+namespace configmgr
+{
+    using rtl::OUString;
+    using namespace com::sun::star::uno;
+    using namespace std;
+
+// -----------------------------------------------------------------------------
+static
+void throwConversionError(sal_Char const* pErrorMsg) CFG_THROW( ( script::CannotConvertException) )
+{
+    OSL_ENSURE(false, pErrorMsg);
+
+    script::CannotConvertException error;
+    error.Message = OUString::createFromAscii(pErrorMsg);
+    throw error;
+}
+// -----------------------------------------------------------------------------
+template <class Char>
+inline
+bool charInRange(Char ch, char from, char to) throw()
+{
+    return Char(from) <= ch && ch <= Char(to);
+}
+
+// -----------------------------------------------------------------------------
+static
+inline
+unsigned makeHexNibble(unsigned char ch) CFG_THROW( ( script::CannotConvertException) )
+{
+    unsigned nRet;
+
+         if (charInRange(ch, '0', '9')) nRet = ch - unsigned('0');
+
+    else if (charInRange(ch, 'a', 'f')) nRet = ch - unsigned('a' - 10u);
+
+    else if (charInRange(ch, 'A', 'F')) nRet = ch - unsigned('A' - 10u);
+
+    else throwConversionError("Invalid Hex Character in binary value");
+
+    return nRet; // not reachable
+}
+
+// -----------------------------------------------------------------------------
+static
+inline
+unsigned readHexNibble(sal_Unicode ch) CFG_THROW( ( script::CannotConvertException) )
+{
+    if (!charInRange(ch, 0, 127)) throwConversionError("Non-Ascii Character in binary value");
+
+    return makeHexNibble(static_cast<unsigned char>(ch));
+}
+
+// -----------------------------------------------------------------------------
+static
+inline
+unsigned int readHexByte(sal_Unicode const*& pStr) CFG_THROW( ( script::CannotConvertException) )
+{
+    register unsigned int nHigh = readHexNibble(*pStr++);
+    register unsigned int nLow =  readHexNibble(*pStr++);
+    return (nHigh << 4) | nLow;
+}
+
+// -----------------------------------------------------------------------------
+static
+void parseHexBinary(OUString const& aHexString_, uno::Sequence<sal_Int8>& rBinarySeq_)
+        CFG_THROW( ( script::CannotConvertException, uno::RuntimeException ) )
+{
+    // PRE: aBinaryString with HexCode
+    // POST: rBinarySeq with the to Hex converted String
+
+    sal_uInt32 nCount = aHexString_.getLength();
+    sal_Unicode const * pHex = aHexString_.getStr();
+
+    if (nCount % 2) throwConversionError("Hex string has odd number of characters");
+    nCount /= 2;
+
+    rBinarySeq_.realloc(nCount);
+    sal_Int8 * pBinary = rBinarySeq_.getArray();
+
+    while (nCount--)
+    {
+        *pBinary++ = readHexByte(pHex);
+    }
+}
+
+// -----------------------------------------------------------------------------
+
+namespace Encoding {
+    enum Type { unknown, hex, base64, DEFAULT = hex };
+
+    static
+    inline
+    Type parse(OUString const& sEncoding)
+    {
+        Type eEncoding;
+
+        if (sEncoding.getLength() == 0)
+        {
+            eEncoding = Encoding::DEFAULT;
+        }
+
+        else if (sEncoding.equalsIgnoreCase(ENCODING_HEX))
+        {
+            eEncoding = Encoding::hex;
+        }
+
+        else if (sEncoding.equalsIgnoreCase(ENCODING_BASE64))
+        {
+            eEncoding = Encoding::base64;
+        }
+
+        else
+        {
+            eEncoding = Encoding::unknown;
+        }
+
+        return eEncoding;
+    }
+}
+
+// -----------------------------------------------------------------------------
+uno::Sequence<sal_Int8> OValueConverter::parseBinary(OUString const& aBinaryString_) const
+        CFG_THROW( ( script::CannotConvertException, uno::RuntimeException ) )
+{
+    uno::Sequence<sal_Int8> aResultSeq;
+
+    switch (Encoding::parse(m_aValueDesc.sEncoding))
+    {
+    case Encoding::hex:
+        parseHexBinary(aBinaryString_,aResultSeq);
+        break;
+
+    case Encoding::base64:
+        OSL_ENSURE(false, "Base64 encoding for binary value is currently not supported");
+        break;
+
+    case Encoding::unknown:
+        OSL_ENSURE(false, "Unknown encoding found for binary value");
+        break;
+
+    default:
+        OSL_ASSERT(false);// Unreachable code
+        break;
+    }
+
+    return aResultSeq;
+}
+
+// -----------------------------------------------------------------------------
+
+uno::Type OValueConverter::getType() const
+{
+    if (m_aValueDesc.sType.getLength() == 0)
+        return getVoidCppuType();
+
+    return toType(m_aValueDesc.sType, m_aValueDesc.isList);
+}
+// -----------------------------------------------------------------------------
+bool OValueConverter::convertToAny(OUString const& aContent, uno::Any& rValue) const
+        CFG_THROW( ( script::CannotConvertException, uno::RuntimeException ) )
+{
+    // PRE: filled content and ValueInfo and an existing Any Object
+    // POST: Any contain the Data from the content
+
+    if (m_aValueDesc.isNull)
+    {
+        OSL_ENSURE(aContent.trim().getLength() == 0, "OValueConverter: Non-empty Null Value - ignoring content");
+        rValue.clear();
+        return false;
+    }
+
+    else if (m_aValueDesc.isList)
+    {
+        StringList aContentList;
+        splitListData(aContent, aContentList);
+        return convertListToAny(aContentList, rValue);
+    }
+
+    else
+    {
+        return convertScalarToAny(aContent, rValue);
+    }
+}
+
+// -----------------------------------------------------------------------------
+bool OValueConverter::convertScalarToAny(OUString const& aContent, uno::Any& rValue) const
+        CFG_THROW( ( script::CannotConvertException, uno::RuntimeException ) )
+{
+    OSL_PRECOND(!m_aValueDesc.isNull,"OValueConverter::convertScalarToAny - check for NULL before calling");
+    OSL_ENSURE(!m_aValueDesc.sType.equalsIgnoreCase(TYPE_ANY),"'Any' values must be NULL");
+
+    bool bResult = false;
+
+    // check for Binary
+    if (m_aValueDesc.sType.equalsIgnoreCase(TYPE_BINARY))
+    {
+        Sequence<sal_Int8> aBinarySeq = parseBinary(aContent);
+        rValue <<= aBinarySeq;
+        bResult = true;
+    }
+
+    else if (m_xTypeConverter.is())
+    {
+        rValue = toAny(m_xTypeConverter, aContent, toTypeClass(m_aValueDesc.sType));
+        bResult = !! rValue.hasValue();
+    }
+
+    if (!bResult)
+    {
+        if (m_aValueDesc.sType.equalsIgnoreCase(TYPE_STRING))
+        {
+            OSL_ENSHURE(m_xTypeConverter.is(), "Warning: OValueConverter has no TypeConverter");
+            rValue <<= aContent;
+            bResult = true;
+        }
+
+        else if (m_aValueDesc.sType.equalsIgnoreCase(TYPE_ANY))
+        {
+            rValue.clear();
+            bResult = false;
+        }
+
+        else
+        {
+            OSL_ENSHURE(m_xTypeConverter.is(), "ERROR: OValueConverter has no TypeConverter");
+
+            script::CannotConvertException aError;
+            aError.Message = OUString::createFromAscii("No type converter available to translate value \"");
+            aError.Message += aContent;
+            aError.Message += OUString::createFromAscii("\" to type");
+            aError.Message += m_aValueDesc.sType;
+            throw aError;
+        }
+    }
+    return bResult;
+}
+
+// -----------------------------------------------------------------------------
+template <class Type>
+bool convertListToSequence(StringList const& aStringList, uno::Sequence< Type >& rSequence, OValueConverter const& rConverter)
+        CFG_THROW( ( script::CannotConvertException, uno::RuntimeException ) )
+{
+    uno::TypeClass const aElementTypeClass = rSequence.getElementType().getTypeClass();
+
+    rSequence.realloc(aStringList.size());
+
+    sal_uInt32 nPos = 0;
+
+    for(StringList::const_iterator it = aStringList.begin();
+        it != aStringList.end();
+        ++it)
+    {
+        uno::Any aValueAny = toAny(rConverter.getTypeConverter(), *it, aElementTypeClass);
+
+        if (aValueAny >>= rSequence[nPos])
+            ++nPos;
+
+        else if (!aValueAny.hasValue())
+            OSL_ENSURE(false,"UNEXPECTED: Found NULL value in List - ignoring value !");
+
+        else
+            OSL_ENSURE(false,"ERROR: Cannot extract converted value into List - skipping value !");
+    }
+
+    bool bOK = (nPos == aStringList.size());
+
+    if (!bOK)
+    {
+        OSL_ASSERT(nPos < aStringList.size());
+        rSequence.realloc(nPos);
+    }
+    return bOK;
+}
+
+// -----------------------------------------------------------------------------
+// special overload for binary sequence
+
+// template<> // use an explicit specialization
+bool convertListToSequence(StringList const& aStringList, uno::Sequence< uno::Sequence<sal_Int8> >& rSequence, OValueConverter const& rParser )
+        CFG_THROW( ( script::CannotConvertException, uno::RuntimeException ) )
+{
+    rSequence.realloc(aStringList.size());
+
+    sal_uInt32 nPos = 0;
+
+    for(StringList::const_iterator it = aStringList.begin();
+        it != aStringList.end();
+        ++it)
+    {
+        rSequence[nPos++] = rParser.parseBinary(*it);
+    }
+    return true;
+}
+
+// -----------------------------------------------------------------------------
+
+bool OValueConverter::convertListToAny(StringList const& aContentList, uno::Any& rValue) const
+        CFG_THROW( ( script::CannotConvertException, uno::RuntimeException ) )
+{
+    OSL_PRECOND(!m_aValueDesc.isNull,"OValueConverter::convertListToAny - check for NULL before calling");
+    OSL_ENSURE(!m_aValueDesc.sType.equalsIgnoreCase(TYPE_ANY),"'Any' not allowed for lists");
+
+    if (m_aValueDesc.sType.equalsIgnoreCase(TYPE_STRING))
+    {
+        Sequence< OUString > aSequence;
+        convertListToSequence(aContentList,aSequence,*this);
+        rValue <<= aSequence;
+    }
+    else if (m_aValueDesc.sType.equalsIgnoreCase(TYPE_BOOLEAN))
+    {
+        Sequence< sal_Bool > aSequence;
+        convertListToSequence(aContentList,aSequence,*this);
+        rValue <<= aSequence;
+    }
+    else if (m_aValueDesc.sType.equalsIgnoreCase(TYPE_SHORT))
+    {
+        Sequence< sal_Int16 > aSequence;
+        convertListToSequence(aContentList,aSequence,*this);
+        rValue <<= aSequence;
+    }
+    else if (m_aValueDesc.sType.equalsIgnoreCase(TYPE_INT))
+    {
+        Sequence< sal_Int32 > aSequence;
+        convertListToSequence(aContentList,aSequence,*this);
+        rValue <<= aSequence;
+    }
+    else if (m_aValueDesc.sType.equalsIgnoreCase(TYPE_LONG))
+    {
+        Sequence< sal_Int64 > aSequence;
+        convertListToSequence(aContentList,aSequence,*this);
+        rValue <<= aSequence;
+    }
+    else if (m_aValueDesc.sType.equalsIgnoreCase(TYPE_DOUBLE))
+    {
+        Sequence< double > aSequence;
+        convertListToSequence(aContentList,aSequence,*this);
+        rValue <<= aSequence;
+    }
+    else if (m_aValueDesc.sType.equalsIgnoreCase(TYPE_BINARY))
+    {
+        Sequence< Sequence<sal_Int8> > aSequence;
+        convertListToSequence(aContentList,aSequence,*this);
+        rValue <<= aSequence;
+    }
+    else
+    {
+        OSL_ENSURE(false, "Unknown element type in list");
+        throwConversionError("Invalid value-type found in list value");
+    }
+    return !! rValue.hasValue();
+}
+
+// -----------------------------------------------------------------------------
+void OValueConverter::splitListData(OUString const& aContent, StringList& rContentList) const
+        CFG_THROW( ( uno::RuntimeException ) )
+{
+    OUString sSeparator = m_aValueDesc.sSeparator;
+
+    sal_Int32 nSeparatorLength = sSeparator.getLength();
+    if (nSeparatorLength == 0)
+    {
+        sSeparator = DEFAULT_SEPARATOR;
+        nSeparatorLength = sSeparator.getLength();
+    }
+    OSL_ASSERT(nSeparatorLength > 0);
+
+    sal_Int32 nPos = 0;
+
+    for(;;)
+    {
+        sal_Int32 nEnd = aContent.indexOf(sSeparator, nPos);
+
+        if (nEnd < 0) break;
+
+        rContentList.push_back( aContent.copy(nPos, nEnd-nPos) );
+
+        nPos = nEnd + nSeparatorLength;
+    }
+
+    if (nPos < aContent.getLength())
+    {
+        rContentList.push_back( aContent.copy(nPos) );
+    }
+}
+// -----------------------------------------------------------------------------
+
+} // namespace