401 lines
14 KiB
C++
401 lines
14 KiB
C++
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
|
|
/*
|
|
* 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 .
|
|
*/
|
|
|
|
#include <sal/config.h>
|
|
|
|
#include <boost/property_tree/json_parser.hpp>
|
|
|
|
#include <com/sun/star/beans/NamedValue.hpp>
|
|
#include <com/sun/star/beans/PropertyValue.hpp>
|
|
#include <com/sun/star/lang/IllegalArgumentException.hpp>
|
|
#include <com/sun/star/reflection/XIdlField.hpp>
|
|
#include <com/sun/star/reflection/theCoreReflection.hpp>
|
|
#include <comphelper/sequenceashashmap.hxx>
|
|
#include <comphelper/processfactory.hxx>
|
|
#include <comphelper/propertysequence.hxx>
|
|
#include <sal/log.hxx>
|
|
#include <o3tl/string_view.hxx>
|
|
#include <comphelper/sequence.hxx>
|
|
|
|
using namespace com::sun::star;
|
|
|
|
namespace
|
|
{
|
|
uno::Any jsonToUnoAny(const boost::property_tree::ptree& aTree)
|
|
{
|
|
uno::Any aAny;
|
|
uno::Any aValue;
|
|
sal_Int32 nFields;
|
|
uno::Reference<reflection::XIdlField> aField;
|
|
boost::property_tree::ptree aNodeNull, aNodeValue, aNodeField;
|
|
const std::string aType = aTree.get<std::string>("type", "");
|
|
const std::string aValueStr = aTree.get<std::string>("value", "");
|
|
uno::Sequence<uno::Reference<reflection::XIdlField>> aFields;
|
|
uno::Reference<reflection::XIdlClass> xIdlClass
|
|
= css::reflection::theCoreReflection::get(comphelper::getProcessComponentContext())
|
|
->forName(OUString::fromUtf8(aType));
|
|
if (xIdlClass.is())
|
|
{
|
|
uno::TypeClass aTypeClass = xIdlClass->getTypeClass();
|
|
xIdlClass->createObject(aAny);
|
|
aFields = xIdlClass->getFields();
|
|
nFields = aFields.getLength();
|
|
aNodeValue = aTree.get_child("value", aNodeNull);
|
|
if (nFields > 0 && aNodeValue != aNodeNull)
|
|
{
|
|
for (sal_Int32 itField = 0; itField < nFields; ++itField)
|
|
{
|
|
aField = aFields[itField];
|
|
aNodeField = aNodeValue.get_child(aField->getName().toUtf8().getStr(), aNodeNull);
|
|
if (aNodeField != aNodeNull)
|
|
{
|
|
aValue = jsonToUnoAny(aNodeField);
|
|
aField->set(aAny, aValue);
|
|
}
|
|
}
|
|
}
|
|
else if (!aValueStr.empty())
|
|
{
|
|
if (aTypeClass == uno::TypeClass_VOID)
|
|
aAny.clear();
|
|
else if (aTypeClass == uno::TypeClass_BYTE)
|
|
aAny <<= static_cast<sal_Int8>(o3tl::toInt32(aValueStr));
|
|
else if (aTypeClass == uno::TypeClass_BOOLEAN)
|
|
aAny <<= rtl_str_toBoolean(aValueStr.c_str());
|
|
else if (aTypeClass == uno::TypeClass_SHORT)
|
|
aAny <<= static_cast<sal_Int16>(o3tl::toInt32(aValueStr));
|
|
else if (aTypeClass == uno::TypeClass_UNSIGNED_SHORT)
|
|
aAny <<= static_cast<sal_uInt16>(o3tl::toUInt32(aValueStr));
|
|
else if (aTypeClass == uno::TypeClass_LONG)
|
|
aAny <<= o3tl::toInt32(aValueStr);
|
|
else if (aTypeClass == uno::TypeClass_UNSIGNED_LONG)
|
|
aAny <<= static_cast<sal_uInt32>(o3tl::toInt32(aValueStr));
|
|
else if (aTypeClass == uno::TypeClass_FLOAT)
|
|
aAny <<= rtl_str_toFloat(aValueStr.c_str());
|
|
else if (aTypeClass == uno::TypeClass_DOUBLE)
|
|
aAny <<= o3tl::toDouble(aValueStr);
|
|
else if (aTypeClass == uno::TypeClass_STRING)
|
|
aAny <<= OUString::fromUtf8(aValueStr);
|
|
}
|
|
}
|
|
return aAny;
|
|
}
|
|
}
|
|
|
|
namespace comphelper{
|
|
|
|
SequenceAsHashMap::SequenceAsHashMap()
|
|
{
|
|
}
|
|
|
|
SequenceAsHashMap::SequenceAsHashMap(const css::uno::Any& aSource)
|
|
{
|
|
(*this) << aSource;
|
|
}
|
|
|
|
|
|
SequenceAsHashMap::SequenceAsHashMap(const css::uno::Sequence< css::uno::Any >& lSource)
|
|
{
|
|
(*this) << lSource;
|
|
}
|
|
|
|
SequenceAsHashMap::SequenceAsHashMap(const css::uno::Sequence< css::beans::PropertyValue >& lSource)
|
|
{
|
|
(*this) << lSource;
|
|
}
|
|
|
|
SequenceAsHashMap::SequenceAsHashMap(const css::uno::Sequence< css::beans::NamedValue >& lSource)
|
|
{
|
|
(*this) << lSource;
|
|
}
|
|
|
|
void SequenceAsHashMap::operator<<(const css::uno::Any& aSource)
|
|
{
|
|
// An empty Any reset this instance!
|
|
if (!aSource.hasValue())
|
|
{
|
|
clear();
|
|
return;
|
|
}
|
|
|
|
css::uno::Sequence< css::beans::NamedValue > lN;
|
|
if (aSource >>= lN)
|
|
{
|
|
(*this) << lN;
|
|
return;
|
|
}
|
|
|
|
css::uno::Sequence< css::beans::PropertyValue > lP;
|
|
if (aSource >>= lP)
|
|
{
|
|
(*this) << lP;
|
|
return;
|
|
}
|
|
|
|
throw css::lang::IllegalArgumentException(
|
|
u"Any contains wrong type."_ustr, css::uno::Reference<css::uno::XInterface>(),
|
|
-1);
|
|
}
|
|
|
|
|
|
void SequenceAsHashMap::operator<<(const css::uno::Sequence< css::uno::Any >& lSource)
|
|
{
|
|
sal_Int32 c = lSource.getLength();
|
|
sal_Int32 i = 0;
|
|
|
|
m_aMap.reserve(c);
|
|
for (i=0; i<c; ++i)
|
|
{
|
|
css::beans::PropertyValue lP;
|
|
if (lSource[i] >>= lP)
|
|
{
|
|
if (
|
|
(lP.Name.isEmpty()) ||
|
|
(!lP.Value.hasValue())
|
|
)
|
|
throw css::lang::IllegalArgumentException(
|
|
u"PropertyValue struct contains no useful information."_ustr,
|
|
css::uno::Reference<css::uno::XInterface>(), -1);
|
|
(*this)[lP.Name] = lP.Value;
|
|
continue;
|
|
}
|
|
|
|
css::beans::NamedValue lN;
|
|
if (lSource[i] >>= lN)
|
|
{
|
|
if (
|
|
(lN.Name.isEmpty()) ||
|
|
(!lN.Value.hasValue())
|
|
)
|
|
throw css::lang::IllegalArgumentException(
|
|
u"NamedValue struct contains no useful information."_ustr,
|
|
css::uno::Reference<css::uno::XInterface>(), -1);
|
|
(*this)[lN.Name] = lN.Value;
|
|
continue;
|
|
}
|
|
|
|
// ignore VOID Any ... but reject wrong filled ones!
|
|
if (lSource[i].hasValue())
|
|
throw css::lang::IllegalArgumentException(
|
|
u"Any contains wrong type."_ustr,
|
|
css::uno::Reference<css::uno::XInterface>(), -1);
|
|
}
|
|
}
|
|
|
|
void SequenceAsHashMap::operator<<(const css::uno::Sequence< css::beans::PropertyValue >& lSource)
|
|
{
|
|
clear();
|
|
|
|
m_aMap.reserve(lSource.getLength());
|
|
for (auto& rSource : lSource)
|
|
(*this)[rSource.Name] = rSource.Value;
|
|
}
|
|
|
|
void SequenceAsHashMap::operator<<(const css::uno::Sequence< css::beans::NamedValue >& lSource)
|
|
{
|
|
clear();
|
|
|
|
m_aMap.reserve(lSource.getLength());
|
|
for (auto& rSource : lSource)
|
|
(*this)[rSource.Name] = rSource.Value;
|
|
}
|
|
|
|
void SequenceAsHashMap::operator>>(css::uno::Sequence< css::beans::PropertyValue >& lDestination) const
|
|
{
|
|
sal_Int32 c = static_cast<sal_Int32>(size());
|
|
lDestination.realloc(c);
|
|
css::beans::PropertyValue* pDestination = lDestination.getArray();
|
|
|
|
sal_Int32 i = 0;
|
|
for (const_iterator pThis = begin();
|
|
pThis != end() ;
|
|
++pThis )
|
|
{
|
|
pDestination[i].Name = pThis->first.maString;
|
|
pDestination[i].Value = pThis->second;
|
|
++i;
|
|
}
|
|
}
|
|
|
|
void SequenceAsHashMap::operator>>(css::uno::Sequence< css::beans::NamedValue >& lDestination) const
|
|
{
|
|
sal_Int32 c = static_cast<sal_Int32>(size());
|
|
lDestination.realloc(c);
|
|
css::beans::NamedValue* pDestination = lDestination.getArray();
|
|
|
|
sal_Int32 i = 0;
|
|
for (const_iterator pThis = begin();
|
|
pThis != end() ;
|
|
++pThis )
|
|
{
|
|
pDestination[i].Name = pThis->first.maString;
|
|
pDestination[i].Value = pThis->second;
|
|
++i;
|
|
}
|
|
}
|
|
|
|
css::uno::Any SequenceAsHashMap::getAsConstAny(bool bAsPropertyValueList) const
|
|
{
|
|
css::uno::Any aDestination;
|
|
if (bAsPropertyValueList)
|
|
aDestination <<= getAsConstPropertyValueList();
|
|
else
|
|
aDestination <<= getAsConstNamedValueList();
|
|
return aDestination;
|
|
}
|
|
|
|
css::uno::Sequence< css::beans::NamedValue > SequenceAsHashMap::getAsConstNamedValueList() const
|
|
{
|
|
css::uno::Sequence< css::beans::NamedValue > lReturn;
|
|
(*this) >> lReturn;
|
|
return lReturn;
|
|
}
|
|
|
|
css::uno::Sequence< css::beans::PropertyValue > SequenceAsHashMap::getAsConstPropertyValueList() const
|
|
{
|
|
css::uno::Sequence< css::beans::PropertyValue > lReturn;
|
|
(*this) >> lReturn;
|
|
return lReturn;
|
|
}
|
|
|
|
bool SequenceAsHashMap::match(const SequenceAsHashMap& rCheck) const
|
|
{
|
|
for (auto const& elem : rCheck)
|
|
{
|
|
const OUString& sCheckName = elem.first.maString;
|
|
const css::uno::Any& aCheckValue = elem.second;
|
|
const_iterator pFound = find(sCheckName);
|
|
|
|
if (pFound == end())
|
|
return false;
|
|
|
|
const css::uno::Any& aFoundValue = pFound->second;
|
|
if (aFoundValue != aCheckValue)
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void SequenceAsHashMap::update(const SequenceAsHashMap& rUpdate)
|
|
{
|
|
m_aMap.reserve(std::max(size(), rUpdate.size()));
|
|
for (auto const& elem : rUpdate.m_aMap)
|
|
{
|
|
m_aMap[elem.first] = elem.second;
|
|
}
|
|
}
|
|
|
|
static std::vector<css::beans::PropertyValue> JsonToPropertyValues(const boost::property_tree::ptree& aTree)
|
|
{
|
|
std::vector<beans::PropertyValue> aArguments;
|
|
boost::property_tree::ptree aNodeNull, aNodeValue;
|
|
for (const auto& rPair : aTree)
|
|
{
|
|
const std::string aType = rPair.second.get<std::string>("type", "");
|
|
const std::string aValueStr = rPair.second.get<std::string>("value", "");
|
|
|
|
beans::PropertyValue aValue;
|
|
aValue.Name = OUString::fromUtf8(rPair.first);
|
|
if (aType == "string")
|
|
aValue.Value <<= OUString::fromUtf8(aValueStr);
|
|
else if (aType == "boolean")
|
|
aValue.Value <<= rtl_str_toBoolean(aValueStr.c_str());
|
|
else if (aType == "float")
|
|
aValue.Value <<= rtl_str_toFloat(aValueStr.c_str());
|
|
else if (aType == "long")
|
|
aValue.Value <<= o3tl::toInt32(aValueStr);
|
|
else if (aType == "short")
|
|
aValue.Value <<= sal_Int16(o3tl::toInt32(aValueStr));
|
|
else if (aType == "unsigned short")
|
|
aValue.Value <<= sal_uInt16(o3tl::toUInt32(aValueStr));
|
|
else if (aType == "int64")
|
|
aValue.Value <<= o3tl::toInt64(aValueStr);
|
|
else if (aType == "int32")
|
|
aValue.Value <<= o3tl::toInt32(aValueStr);
|
|
else if (aType == "int16")
|
|
aValue.Value <<= sal_Int16(o3tl::toInt32(aValueStr));
|
|
else if (aType == "uint64")
|
|
aValue.Value <<= rtl_str_toUInt64(aValueStr.c_str(), 10);
|
|
else if (aType == "uint32")
|
|
aValue.Value <<= o3tl::toUInt32(aValueStr);
|
|
else if (aType == "uint16")
|
|
aValue.Value <<= sal_uInt16(o3tl::toUInt32(aValueStr));
|
|
else if (aType == "[]byte")
|
|
{
|
|
aNodeValue = rPair.second.get_child("value", aNodeNull);
|
|
if (aNodeValue != aNodeNull && aNodeValue.size() == 0)
|
|
{
|
|
uno::Sequence<sal_Int8> aSeqByte(reinterpret_cast<const sal_Int8*>(aValueStr.c_str()),
|
|
aValueStr.size());
|
|
aValue.Value <<= aSeqByte;
|
|
}
|
|
}
|
|
else if (aType == "any")
|
|
{
|
|
aNodeValue = rPair.second.get_child("value", aNodeNull);
|
|
if (aNodeValue != aNodeNull && !aNodeValue.empty())
|
|
{
|
|
aValue.Value = jsonToUnoAny(aNodeValue);
|
|
}
|
|
}
|
|
else if (aType == "[]any")
|
|
{
|
|
aNodeValue = rPair.second.get_child("value", aNodeNull);
|
|
if (aNodeValue != aNodeNull && !aNodeValue.empty())
|
|
{
|
|
uno::Sequence<uno::Any> aSeq(aNodeValue.size());
|
|
std::transform(aNodeValue.begin(), aNodeValue.end(), aSeq.getArray(),
|
|
[](const auto& rSeqPair) { return jsonToUnoAny(rSeqPair.second); });
|
|
aValue.Value <<= aSeq;
|
|
}
|
|
}
|
|
else if (aType == "[]com.sun.star.beans.PropertyValue")
|
|
{
|
|
aNodeValue = rPair.second.get_child("value", aNodeNull);
|
|
aValue.Value <<= comphelper::containerToSequence(JsonToPropertyValues(aNodeValue));
|
|
}
|
|
else if (aType == "[][]com.sun.star.beans.PropertyValue")
|
|
{
|
|
aNodeValue = rPair.second.get_child("value", aNodeNull);
|
|
std::vector<uno::Sequence<beans::PropertyValue>> aSeqs;
|
|
for (const auto& rItem : aNodeValue)
|
|
{
|
|
aSeqs.push_back(comphelper::containerToSequence(JsonToPropertyValues(rItem.second)));
|
|
}
|
|
aValue.Value <<= comphelper::containerToSequence(aSeqs);
|
|
}
|
|
else
|
|
SAL_WARN("comphelper", "JsonToPropertyValues: unhandled type '" << aType << "'");
|
|
aArguments.push_back(aValue);
|
|
}
|
|
return aArguments;
|
|
}
|
|
|
|
std::vector<css::beans::PropertyValue> JsonToPropertyValues(std::string_view rJson)
|
|
{
|
|
boost::property_tree::ptree aTree;
|
|
std::stringstream aStream((std::string(rJson)));
|
|
boost::property_tree::read_json(aStream, aTree);
|
|
return JsonToPropertyValues(aTree);
|
|
}
|
|
|
|
} // namespace comphelper
|
|
|
|
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|