From 5f8de423f190bbb79a62f804151bc24824fa32d8 Mon Sep 17 00:00:00 2001 From: "Matt A. Tobin" Date: Fri, 2 Feb 2018 04:16:08 -0500 Subject: Add m-esr52 at 52.6.0 --- rdf/base/nsRDFXMLSerializer.cpp | 1127 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 1127 insertions(+) create mode 100644 rdf/base/nsRDFXMLSerializer.cpp (limited to 'rdf/base/nsRDFXMLSerializer.cpp') diff --git a/rdf/base/nsRDFXMLSerializer.cpp b/rdf/base/nsRDFXMLSerializer.cpp new file mode 100644 index 000000000..677f58ca3 --- /dev/null +++ b/rdf/base/nsRDFXMLSerializer.cpp @@ -0,0 +1,1127 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * vim: set ts=4 sw=4 et tw=80: + * + * 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/. */ + +#include "nsRDFXMLSerializer.h" + +#include "nsIAtom.h" +#include "nsIOutputStream.h" +#include "nsIRDFService.h" +#include "nsIRDFContainerUtils.h" +#include "nsIServiceManager.h" +#include "nsString.h" +#include "nsXPIDLString.h" +#include "nsTArray.h" +#include "rdf.h" +#include "rdfutil.h" +#include "mozilla/Attributes.h" + +#include "rdfIDataSource.h" + +int32_t nsRDFXMLSerializer::gRefCnt = 0; +nsIRDFContainerUtils* nsRDFXMLSerializer::gRDFC; +nsIRDFResource* nsRDFXMLSerializer::kRDF_instanceOf; +nsIRDFResource* nsRDFXMLSerializer::kRDF_type; +nsIRDFResource* nsRDFXMLSerializer::kRDF_nextVal; +nsIRDFResource* nsRDFXMLSerializer::kRDF_Bag; +nsIRDFResource* nsRDFXMLSerializer::kRDF_Seq; +nsIRDFResource* nsRDFXMLSerializer::kRDF_Alt; + +static const char kRDFDescriptionOpen[] = " \n"; +static const char kRDFParseTypeInteger[] = " NC:parseType=\"Integer\">"; +static const char kRDFParseTypeDate[] = " NC:parseType=\"Date\">"; +static const char kRDFUnknown[] = ">"; + +nsresult +nsRDFXMLSerializer::Create(nsISupports* aOuter, REFNSIID aIID, void** aResult) +{ + if (aOuter) + return NS_ERROR_NO_AGGREGATION; + + nsCOMPtr result = new nsRDFXMLSerializer(); + if (! result) + return NS_ERROR_OUT_OF_MEMORY; + // The serializer object is here, addref gRefCnt so that the + // destructor can safely release it. + gRefCnt++; + + nsresult rv; + rv = result->QueryInterface(aIID, aResult); + + if (NS_FAILED(rv)) return rv; + + if (gRefCnt == 1) do { + nsCOMPtr rdf = do_GetService("@mozilla.org/rdf/rdf-service;1", &rv); + if (NS_FAILED(rv)) break; + + rv = rdf->GetResource(NS_LITERAL_CSTRING(RDF_NAMESPACE_URI "instanceOf"), + &kRDF_instanceOf); + if (NS_FAILED(rv)) break; + + rv = rdf->GetResource(NS_LITERAL_CSTRING(RDF_NAMESPACE_URI "type"), + &kRDF_type); + if (NS_FAILED(rv)) break; + + rv = rdf->GetResource(NS_LITERAL_CSTRING(RDF_NAMESPACE_URI "nextVal"), + &kRDF_nextVal); + if (NS_FAILED(rv)) break; + + rv = rdf->GetResource(NS_LITERAL_CSTRING(RDF_NAMESPACE_URI "Bag"), + &kRDF_Bag); + if (NS_FAILED(rv)) break; + + rv = rdf->GetResource(NS_LITERAL_CSTRING(RDF_NAMESPACE_URI "Seq"), + &kRDF_Seq); + if (NS_FAILED(rv)) break; + + rv = rdf->GetResource(NS_LITERAL_CSTRING(RDF_NAMESPACE_URI "Alt"), + &kRDF_Alt); + if (NS_FAILED(rv)) break; + + rv = CallGetService("@mozilla.org/rdf/container-utils;1", &gRDFC); + if (NS_FAILED(rv)) break; + } while (0); + + return rv; +} + +nsRDFXMLSerializer::nsRDFXMLSerializer() +{ + MOZ_COUNT_CTOR(nsRDFXMLSerializer); +} + +nsRDFXMLSerializer::~nsRDFXMLSerializer() +{ + MOZ_COUNT_DTOR(nsRDFXMLSerializer); + + if (--gRefCnt == 0) { + NS_IF_RELEASE(kRDF_Bag); + NS_IF_RELEASE(kRDF_Seq); + NS_IF_RELEASE(kRDF_Alt); + NS_IF_RELEASE(kRDF_instanceOf); + NS_IF_RELEASE(kRDF_type); + NS_IF_RELEASE(kRDF_nextVal); + NS_IF_RELEASE(gRDFC); + } +} + +NS_IMPL_ISUPPORTS(nsRDFXMLSerializer, nsIRDFXMLSerializer, nsIRDFXMLSource) + +NS_IMETHODIMP +nsRDFXMLSerializer::Init(nsIRDFDataSource* aDataSource) +{ + if (! aDataSource) + return NS_ERROR_NULL_POINTER; + + mDataSource = aDataSource; + mDataSource->GetURI(getter_Copies(mBaseURLSpec)); + + // Add the ``RDF'' prefix, by default. + nsCOMPtr prefix; + + prefix = NS_Atomize("RDF"); + AddNameSpace(prefix, NS_LITERAL_STRING("http://www.w3.org/1999/02/22-rdf-syntax-ns#")); + + prefix = NS_Atomize("NC"); + AddNameSpace(prefix, NS_LITERAL_STRING("http://home.netscape.com/NC-rdf#")); + + mPrefixID = 0; + + return NS_OK; +} + +NS_IMETHODIMP +nsRDFXMLSerializer::AddNameSpace(nsIAtom* aPrefix, const nsAString& aURI) +{ + nsCOMPtr prefix = aPrefix; + if (!prefix) { + // Make up a prefix, we don't want default namespaces, so + // that we can use QNames for elements and attributes alike. + prefix = EnsureNewPrefix(); + } + mNameSpaces.Put(aURI, prefix); + return NS_OK; +} + +static nsresult +rdf_BlockingWrite(nsIOutputStream* stream, const char* buf, uint32_t size) +{ + uint32_t written = 0; + uint32_t remaining = size; + while (remaining > 0) { + nsresult rv; + uint32_t cb; + + if (NS_FAILED(rv = stream->Write(buf + written, remaining, &cb))) + return rv; + + written += cb; + remaining -= cb; + } + return NS_OK; +} + +static nsresult +rdf_BlockingWrite(nsIOutputStream* stream, const nsCSubstring& s) +{ + return rdf_BlockingWrite(stream, s.BeginReading(), s.Length()); +} + +static nsresult +rdf_BlockingWrite(nsIOutputStream* stream, const nsAString& s) +{ + NS_ConvertUTF16toUTF8 utf8(s); + return rdf_BlockingWrite(stream, utf8.get(), utf8.Length()); +} + +already_AddRefed +nsRDFXMLSerializer::EnsureNewPrefix() +{ + nsAutoString qname; + nsCOMPtr prefix; + bool isNewPrefix; + do { + isNewPrefix = true; + qname.AssignLiteral("NS"); + qname.AppendInt(++mPrefixID, 10); + prefix = NS_Atomize(qname); + nsNameSpaceMap::const_iterator iter = mNameSpaces.first(); + while (iter != mNameSpaces.last() && isNewPrefix) { + isNewPrefix = (iter->mPrefix != prefix); + ++iter; + } + } while (!isNewPrefix); + return prefix.forget(); +} + +// This converts a property resource (like +// "http://www.w3.org/TR/WD-rdf-syntax#Description") into a QName +// ("RDF:Description"), and registers the namespace, if it's made up. + +nsresult +nsRDFXMLSerializer::RegisterQName(nsIRDFResource* aResource) +{ + nsAutoCString uri, qname; + aResource->GetValueUTF8(uri); + + nsNameSpaceMap::const_iterator iter = mNameSpaces.GetNameSpaceOf(uri); + if (iter != mNameSpaces.last()) { + NS_ENSURE_TRUE(iter->mPrefix, NS_ERROR_UNEXPECTED); + iter->mPrefix->ToUTF8String(qname); + qname.Append(':'); + qname += StringTail(uri, uri.Length() - iter->mURI.Length()); + mQNames.Put(aResource, qname); + return NS_OK; + } + + // Okay, so we don't have it in our map. Try to make one up. This + // is very bogus. + int32_t i = uri.RFindChar('#'); // first try a '#' + if (i == -1) { + i = uri.RFindChar('/'); + if (i == -1) { + // Okay, just punt and assume there is _no_ namespace on + // this thing... + mQNames.Put(aResource, uri); + return NS_OK; + } + } + + // Take whatever is to the right of the '#' or '/' and call it the + // local name, make up a prefix. + nsCOMPtr prefix = EnsureNewPrefix(); + mNameSpaces.Put(StringHead(uri, i+1), prefix); + prefix->ToUTF8String(qname); + qname.Append(':'); + qname += StringTail(uri, uri.Length() - (i + 1)); + + mQNames.Put(aResource, qname); + return NS_OK; +} + +nsresult +nsRDFXMLSerializer::GetQName(nsIRDFResource* aResource, nsCString& aQName) +{ + return mQNames.Get(aResource, &aQName) ? NS_OK : NS_ERROR_UNEXPECTED; +} + +bool +nsRDFXMLSerializer::IsContainerProperty(nsIRDFResource* aProperty) +{ + // Return `true' if the property is an internal property related + // to being a container. + if (aProperty == kRDF_instanceOf) + return true; + + if (aProperty == kRDF_nextVal) + return true; + + bool isOrdinal = false; + gRDFC->IsOrdinalProperty(aProperty, &isOrdinal); + if (isOrdinal) + return true; + + return false; +} + + +// convert '&', '<', and '>' into "&", "<", and ">", respectively. +static const char amp[] = "&"; +static const char lt[] = "<"; +static const char gt[] = ">"; +static const char quot[] = """; + +static void +rdf_EscapeAmpersandsAndAngleBrackets(nsCString& s) +{ + uint32_t newLength, origLength; + newLength = origLength = s.Length(); + + // Compute the length of the result string. + const char* start = s.BeginReading(); + const char* end = s.EndReading(); + const char* c = start; + while (c != end) { + switch (*c) { + case '&' : + newLength += sizeof(amp) - 2; + break; + case '<': + case '>': + newLength += sizeof(gt) - 2; + break; + default: + break; + } + ++c; + } + if (newLength == origLength) { + // nothing to escape + return; + } + + // escape the chars from the end back to the front. + s.SetLength(newLength); + + // Buffer might have changed, get the pointers again + start = s.BeginReading(); // begin of string + c = start + origLength - 1; // last char in original string + char* w = s.EndWriting() - 1; // last char in grown buffer + while (c >= start) { + switch (*c) { + case '&' : + w -= 4; + nsCharTraits::copy(w, amp, sizeof(amp) - 1); + break; + case '<': + w -= 3; + nsCharTraits::copy(w, lt, sizeof(lt) - 1); + break; + case '>': + w -= 3; + nsCharTraits::copy(w, gt, sizeof(gt) - 1); + break; + default: + *w = *c; + } + --w; + --c; + } +} + +// convert '"' to """ +static void +rdf_EscapeQuotes(nsCString& s) +{ + int32_t i = 0; + while ((i = s.FindChar('"', i)) != -1) { + s.Replace(i, 1, quot, sizeof(quot) - 1); + i += sizeof(quot) - 2; + } +} + +static void +rdf_EscapeAttributeValue(nsCString& s) +{ + rdf_EscapeAmpersandsAndAngleBrackets(s); + rdf_EscapeQuotes(s); +} + + +nsresult +nsRDFXMLSerializer::SerializeInlineAssertion(nsIOutputStream* aStream, + nsIRDFResource* aResource, + nsIRDFResource* aProperty, + nsIRDFLiteral* aValue) +{ + nsresult rv; + nsCString qname; + rv = GetQName(aProperty, qname); + NS_ENSURE_SUCCESS(rv, rv); + + rv = rdf_BlockingWrite(aStream, + NS_LITERAL_CSTRING("\n ")); + if (NS_FAILED(rv)) return rv; + + const char16_t* value; + aValue->GetValueConst(&value); + NS_ConvertUTF16toUTF8 s(value); + + rdf_EscapeAttributeValue(s); + + rv = rdf_BlockingWrite(aStream, qname); + if (NS_FAILED(rv)) return rv; + rv = rdf_BlockingWrite(aStream, "=\"", 2); + if (NS_FAILED(rv)) return rv; + s.Append('"'); + return rdf_BlockingWrite(aStream, s); +} + +nsresult +nsRDFXMLSerializer::SerializeChildAssertion(nsIOutputStream* aStream, + nsIRDFResource* aResource, + nsIRDFResource* aProperty, + nsIRDFNode* aValue) +{ + nsCString qname; + nsresult rv = GetQName(aProperty, qname); + NS_ENSURE_SUCCESS(rv, rv); + + rv = rdf_BlockingWrite(aStream, " <", 5); + if (NS_FAILED(rv)) return rv; + rv = rdf_BlockingWrite(aStream, qname); + if (NS_FAILED(rv)) return rv; + + nsCOMPtr resource; + nsCOMPtr literal; + nsCOMPtr number; + nsCOMPtr date; + + if ((resource = do_QueryInterface(aValue)) != nullptr) { + nsAutoCString uri; + resource->GetValueUTF8(uri); + + rdf_MakeRelativeRef(mBaseURLSpec, uri); + rdf_EscapeAttributeValue(uri); + + rv = rdf_BlockingWrite(aStream, kRDFResource1, + sizeof(kRDFResource1) - 1); + if (NS_FAILED(rv)) return rv; + rv = rdf_BlockingWrite(aStream, uri); + if (NS_FAILED(rv)) return rv; + rv = rdf_BlockingWrite(aStream, kRDFResource2, + sizeof(kRDFResource2) - 1); + if (NS_FAILED(rv)) return rv; + + goto no_close_tag; + } + else if ((literal = do_QueryInterface(aValue)) != nullptr) { + const char16_t *value; + literal->GetValueConst(&value); + NS_ConvertUTF16toUTF8 s(value); + + rdf_EscapeAmpersandsAndAngleBrackets(s); + + rv = rdf_BlockingWrite(aStream, ">", 1); + if (NS_FAILED(rv)) return rv; + rv = rdf_BlockingWrite(aStream, s); + if (NS_FAILED(rv)) return rv; + } + else if ((number = do_QueryInterface(aValue)) != nullptr) { + int32_t value; + number->GetValue(&value); + + nsAutoCString n; + n.AppendInt(value); + + rv = rdf_BlockingWrite(aStream, kRDFParseTypeInteger, + sizeof(kRDFParseTypeInteger) - 1); + if (NS_FAILED(rv)) return rv; + rv = rdf_BlockingWrite(aStream, n); + if (NS_FAILED(rv)) return rv; + } + else if ((date = do_QueryInterface(aValue)) != nullptr) { + PRTime value; + date->GetValue(&value); + + nsAutoCString s; + rdf_FormatDate(value, s); + + rv = rdf_BlockingWrite(aStream, kRDFParseTypeDate, + sizeof(kRDFParseTypeDate) - 1); + if (NS_FAILED(rv)) return rv; + rv = rdf_BlockingWrite(aStream, s); + if (NS_FAILED(rv)) return rv; + } + else { + // XXX it doesn't support nsIRDFResource _or_ nsIRDFLiteral??? + // We should serialize nsIRDFInt, nsIRDFDate, etc... + NS_WARNING("unknown RDF node type"); + + rv = rdf_BlockingWrite(aStream, kRDFUnknown, sizeof(kRDFUnknown) - 1); + if (NS_FAILED(rv)) return rv; + } + + rv = rdf_BlockingWrite(aStream, "\n", 2); + + no_close_tag: + return NS_OK; +} + +nsresult +nsRDFXMLSerializer::SerializeProperty(nsIOutputStream* aStream, + nsIRDFResource* aResource, + nsIRDFResource* aProperty, + bool aInline, + int32_t* aSkipped) +{ + nsresult rv = NS_OK; + + int32_t skipped = 0; + + nsCOMPtr assertions; + mDataSource->GetTargets(aResource, aProperty, true, getter_AddRefs(assertions)); + if (! assertions) + return NS_ERROR_FAILURE; + + // Serializing the assertion inline is ok as long as the property has + // only one target value, and it is a literal that doesn't include line + // breaks. + bool needsChild = false; + + while (1) { + bool hasMore = false; + assertions->HasMoreElements(&hasMore); + if (! hasMore) + break; + + nsCOMPtr isupports; + assertions->GetNext(getter_AddRefs(isupports)); + nsCOMPtr literal = do_QueryInterface(isupports); + needsChild |= (!literal); + + if (!needsChild) { + assertions->HasMoreElements(&needsChild); + if (!needsChild) { + const char16_t* literalVal = nullptr; + literal->GetValueConst(&literalVal); + if (literalVal) { + for (; *literalVal; literalVal++) { + if (*literalVal == char16_t('\n') || + *literalVal == char16_t('\r')) { + needsChild = true; + break; + } + } + } + } + } + + if (aInline && !needsChild) { + rv = SerializeInlineAssertion(aStream, aResource, aProperty, literal); + } + else if (!aInline && needsChild) { + nsCOMPtr value = do_QueryInterface(isupports); + rv = SerializeChildAssertion(aStream, aResource, aProperty, value); + } + else { + ++skipped; + rv = NS_OK; + } + + if (NS_FAILED(rv)) + break; + } + + *aSkipped += skipped; + return rv; +} + + +nsresult +nsRDFXMLSerializer::SerializeDescription(nsIOutputStream* aStream, + nsIRDFResource* aResource) +{ + nsresult rv; + + bool isTypedNode = false; + nsCString typeQName; + + nsCOMPtr typeNode; + mDataSource->GetTarget(aResource, kRDF_type, true, getter_AddRefs(typeNode)); + if (typeNode) { + nsCOMPtr type = do_QueryInterface(typeNode, &rv); + if (type) { + // Try to get a namespace prefix. If none is available, + // just treat the description as if it weren't a typed node + // after all and emit rdf:type as a normal property. This + // seems preferable to using a bogus (invented) prefix. + isTypedNode = NS_SUCCEEDED(GetQName(type, typeQName)); + } + } + + nsAutoCString uri; + rv = aResource->GetValueUTF8(uri); + if (NS_FAILED(rv)) return rv; + + rdf_MakeRelativeRef(mBaseURLSpec, uri); + rdf_EscapeAttributeValue(uri); + + // Emit an open tag and the subject + if (isTypedNode) { + rv = rdf_BlockingWrite(aStream, NS_LITERAL_STRING(" <")); + if (NS_FAILED(rv)) return rv; + // Watch out for the default namespace! + rv = rdf_BlockingWrite(aStream, typeQName); + if (NS_FAILED(rv)) return rv; + } + else { + rv = rdf_BlockingWrite(aStream, kRDFDescriptionOpen, + sizeof(kRDFDescriptionOpen) - 1); + if (NS_FAILED(rv)) return rv; + } + if (uri[0] == char16_t('#')) { + uri.Cut(0, 1); + rv = rdf_BlockingWrite(aStream, kIDAttr, sizeof(kIDAttr) - 1); + } + else { + rv = rdf_BlockingWrite(aStream, kAboutAttr, sizeof(kAboutAttr) - 1); + } + if (NS_FAILED(rv)) return rv; + + uri.Append('"'); + rv = rdf_BlockingWrite(aStream, uri); + if (NS_FAILED(rv)) return rv; + + // Any value that's a literal we can write out as an inline + // attribute on the RDF:Description + AutoTArray visited; + int32_t skipped = 0; + + nsCOMPtr arcs; + mDataSource->ArcLabelsOut(aResource, getter_AddRefs(arcs)); + + if (arcs) { + // Don't re-serialize rdf:type later on + if (isTypedNode) + visited.AppendElement(kRDF_type); + + while (1) { + bool hasMore = false; + arcs->HasMoreElements(&hasMore); + if (! hasMore) + break; + + nsCOMPtr isupports; + arcs->GetNext(getter_AddRefs(isupports)); + + nsCOMPtr property = do_QueryInterface(isupports); + if (! property) + continue; + + // Ignore properties that pertain to containers; we may be + // called from SerializeContainer() if the container resource + // has been assigned non-container properties. + if (IsContainerProperty(property)) + continue; + + // Only serialize values for the property once. + if (visited.Contains(property.get())) + continue; + + visited.AppendElement(property.get()); + + SerializeProperty(aStream, aResource, property, true, &skipped); + } + } + + if (skipped) { + // Close the RDF:Description tag. + rv = rdf_BlockingWrite(aStream, NS_LITERAL_CSTRING(">\n")); + if (NS_FAILED(rv)) return rv; + + // Now write out resources (which might have their own + // substructure) as children. + mDataSource->ArcLabelsOut(aResource, getter_AddRefs(arcs)); + + if (arcs) { + // Forget that we've visited anything + visited.Clear(); + // ... except for rdf:type + if (isTypedNode) + visited.AppendElement(kRDF_type); + + while (1) { + bool hasMore = false; + arcs->HasMoreElements(&hasMore); + if (! hasMore) + break; + + nsCOMPtr isupports; + arcs->GetNext(getter_AddRefs(isupports)); + + nsCOMPtr property = do_QueryInterface(isupports); + if (! property) + continue; + + // Ignore properties that pertain to containers; we may be + // called from SerializeContainer() if the container + // resource has been assigned non-container properties. + if (IsContainerProperty(property)) + continue; + + // have we already seen this property? If so, don't write it + // out again; serialize property will write each instance. + if (visited.Contains(property.get())) + continue; + + visited.AppendElement(property.get()); + + SerializeProperty(aStream, aResource, property, false, &skipped); + } + } + + // Emit a proper close-tag. + if (isTypedNode) { + rv = rdf_BlockingWrite(aStream, NS_LITERAL_CSTRING(" \n", 2); + if (NS_FAILED(rv)) return rv; + } + else { + rv = rdf_BlockingWrite(aStream, kRDFDescriptionClose, + sizeof(kRDFDescriptionClose) - 1); + if (NS_FAILED(rv)) return rv; + } + } + else { + // If we saw _no_ child properties, then we can don't need a + // close-tag. + rv = rdf_BlockingWrite(aStream, NS_LITERAL_CSTRING(" />\n")); + if (NS_FAILED(rv)) return rv; + } + + return NS_OK; +} + +nsresult +nsRDFXMLSerializer::SerializeMember(nsIOutputStream* aStream, + nsIRDFResource* aContainer, + nsIRDFNode* aMember) +{ + // If it's a resource, then output a "" + // tag, because we'll be dumping the resource separately. (We + // iterate thru all the resources in the datasource, + // remember?) Otherwise, output the literal value. + + nsCOMPtr resource; + nsCOMPtr literal; + nsCOMPtr number; + nsCOMPtr date; + +static const char kRDFLIOpen[] = " GetValueUTF8(uri); + + rdf_MakeRelativeRef(mBaseURLSpec, uri); + rdf_EscapeAttributeValue(uri); + + rv = rdf_BlockingWrite(aStream, kRDFResource1, + sizeof(kRDFResource1) - 1); + if (NS_FAILED(rv)) return rv; + rv = rdf_BlockingWrite(aStream, uri); + if (NS_FAILED(rv)) return rv; + rv = rdf_BlockingWrite(aStream, kRDFResource2, + sizeof(kRDFResource2) - 1); + if (NS_FAILED(rv)) return rv; + + goto no_close_tag; + } + else if ((literal = do_QueryInterface(aMember)) != nullptr) { + const char16_t *value; + literal->GetValueConst(&value); +static const char kRDFLIOpenGT[] = ">"; + // close the 'GetValue(&value); + + nsAutoCString n; + n.AppendInt(value); + + rv = rdf_BlockingWrite(aStream, kRDFParseTypeInteger, + sizeof(kRDFParseTypeInteger) - 1); + if (NS_FAILED(rv)) return rv; + rv = rdf_BlockingWrite(aStream, n); + if (NS_FAILED(rv)) return rv; + } + else if ((date = do_QueryInterface(aMember)) != nullptr) { + PRTime value; + date->GetValue(&value); + + nsAutoCString s; + rdf_FormatDate(value, s); + + rv = rdf_BlockingWrite(aStream, kRDFParseTypeDate, + sizeof(kRDFParseTypeDate) - 1); + if (NS_FAILED(rv)) return rv; + rv = rdf_BlockingWrite(aStream, s); + if (NS_FAILED(rv)) return rv; + } + else { + // XXX it doesn't support nsIRDFResource _or_ nsIRDFLiteral??? + // We should serialize nsIRDFInt, nsIRDFDate, etc... + NS_WARNING("unknown RDF node type"); + + rv = rdf_BlockingWrite(aStream, kRDFUnknown, sizeof(kRDFUnknown) - 1); + if (NS_FAILED(rv)) return rv; + } + + { +static const char kRDFLIClose[] = "\n"; + rv = rdf_BlockingWrite(aStream, kRDFLIClose, sizeof(kRDFLIClose) - 1); + if (NS_FAILED(rv)) return rv; + } + + no_close_tag: + return NS_OK; +} + + +nsresult +nsRDFXMLSerializer::SerializeContainer(nsIOutputStream* aStream, + nsIRDFResource* aContainer) +{ + nsresult rv; + nsAutoCString tag; + + // Decide if it's a sequence, bag, or alternation, and print the + // appropriate tag-open sequence + + if (IsA(mDataSource, aContainer, kRDF_Bag)) { + tag.AssignLiteral("RDF:Bag"); + } + else if (IsA(mDataSource, aContainer, kRDF_Seq)) { + tag.AssignLiteral("RDF:Seq"); + } + else if (IsA(mDataSource, aContainer, kRDF_Alt)) { + tag.AssignLiteral("RDF:Alt"); + } + else { + NS_ASSERTION(false, "huh? this is _not_ a container."); + return NS_ERROR_UNEXPECTED; + } + + rv = rdf_BlockingWrite(aStream, " <", 3); + if (NS_FAILED(rv)) return rv; + rv = rdf_BlockingWrite(aStream, tag); + if (NS_FAILED(rv)) return rv; + + + // Unfortunately, we always need to print out the identity of the + // resource, even if was constructed "anonymously". We need to do + // this because we never really know who else might be referring + // to it... + + nsAutoCString uri; + if (NS_SUCCEEDED(aContainer->GetValueUTF8(uri))) { + rdf_MakeRelativeRef(mBaseURLSpec, uri); + + rdf_EscapeAttributeValue(uri); + + if (uri.First() == '#') { + // Okay, it's actually identified as an element in the + // current document, not trying to decorate some absolute + // URI. We can use the 'ID=' attribute... + + uri.Cut(0, 1); // chop the '#' + rv = rdf_BlockingWrite(aStream, kIDAttr, sizeof(kIDAttr) - 1); + if (NS_FAILED(rv)) return rv; + } + else { + // We need to cheat and spit out an illegal 'about=' on + // the sequence. + rv = rdf_BlockingWrite(aStream, kAboutAttr, + sizeof(kAboutAttr) - 1); + if (NS_FAILED(rv)) return rv; + } + + rv = rdf_BlockingWrite(aStream, uri); + if (NS_FAILED(rv)) return rv; + rv = rdf_BlockingWrite(aStream, "\"", 1); + if (NS_FAILED(rv)) return rv; + } + + rv = rdf_BlockingWrite(aStream, ">\n", 2); + if (NS_FAILED(rv)) return rv; + + // First iterate through each of the ordinal elements (the RDF/XML + // syntax doesn't allow us to place properties on RDF container + // elements). + nsCOMPtr elements; + rv = NS_NewContainerEnumerator(mDataSource, aContainer, getter_AddRefs(elements)); + + if (NS_SUCCEEDED(rv)) { + while (1) { + bool hasMore; + rv = elements->HasMoreElements(&hasMore); + if (NS_FAILED(rv)) break; + + if (! hasMore) + break; + + nsCOMPtr isupports; + elements->GetNext(getter_AddRefs(isupports)); + + nsCOMPtr element = do_QueryInterface(isupports); + NS_ASSERTION(element != nullptr, "not an nsIRDFNode"); + if (! element) + continue; + + SerializeMember(aStream, aContainer, element); + } + } + + // close the container tag + rv = rdf_BlockingWrite(aStream, " \n", 2); + rv = rdf_BlockingWrite(aStream, tag); + if (NS_FAILED(rv)) return rv; + + // Now, we iterate through _all_ of the arcs, in case someone has + // applied properties to the bag itself. These'll be placed in a + // separate RDF:Description element. + nsCOMPtr arcs; + mDataSource->ArcLabelsOut(aContainer, getter_AddRefs(arcs)); + + bool wroteDescription = false; + while (! wroteDescription) { + bool hasMore = false; + rv = arcs->HasMoreElements(&hasMore); + if (NS_FAILED(rv)) break; + + if (! hasMore) + break; + + nsIRDFResource* property; + rv = arcs->GetNext((nsISupports**) &property); + if (NS_FAILED(rv)) break; + + // If it's a membership property, then output a "LI" + // tag. Otherwise, output a property. + if (! IsContainerProperty(property)) { + rv = SerializeDescription(aStream, aContainer); + wroteDescription = true; + } + + NS_RELEASE(property); + if (NS_FAILED(rv)) + break; + } + + return NS_OK; +} + + +nsresult +nsRDFXMLSerializer::SerializePrologue(nsIOutputStream* aStream) +{ +static const char kXMLVersion[] = "\n"; + + nsresult rv; + rv = rdf_BlockingWrite(aStream, kXMLVersion, sizeof(kXMLVersion) - 1); + if (NS_FAILED(rv)) return rv; + + // global name space declarations + rv = rdf_BlockingWrite(aStream, NS_LITERAL_CSTRING("mPrefix) { + rv = rdf_BlockingWrite(aStream, NS_LITERAL_CSTRING(":")); + if (NS_FAILED(rv)) return rv; + nsAutoCString prefix; + entry->mPrefix->ToUTF8String(prefix); + rv = rdf_BlockingWrite(aStream, prefix); + if (NS_FAILED(rv)) return rv; + } + + rv = rdf_BlockingWrite(aStream, NS_LITERAL_CSTRING("=\"")); + if (NS_FAILED(rv)) return rv; + nsAutoCString uri(entry->mURI); + rdf_EscapeAttributeValue(uri); + rv = rdf_BlockingWrite(aStream, uri); + if (NS_FAILED(rv)) return rv; + rv = rdf_BlockingWrite(aStream, NS_LITERAL_CSTRING("\"")); + if (NS_FAILED(rv)) return rv; + } + + return rdf_BlockingWrite(aStream, NS_LITERAL_CSTRING(">\n")); +} + + +nsresult +nsRDFXMLSerializer::SerializeEpilogue(nsIOutputStream* aStream) +{ + return rdf_BlockingWrite(aStream, NS_LITERAL_CSTRING("\n")); +} + +class QNameCollector final : public rdfITripleVisitor { +public: + NS_DECL_ISUPPORTS + NS_DECL_RDFITRIPLEVISITOR + explicit QNameCollector(nsRDFXMLSerializer* aParent) + : mParent(aParent){} +private: + ~QNameCollector() {} + nsRDFXMLSerializer* mParent; +}; + +NS_IMPL_ISUPPORTS(QNameCollector, rdfITripleVisitor) +nsresult +QNameCollector::Visit(nsIRDFNode* aSubject, nsIRDFResource* aPredicate, + nsIRDFNode* aObject, bool aTruthValue) +{ + if (aPredicate == mParent->kRDF_type) { + // try to get a type QName for aObject, should be a resource + nsCOMPtr resType = do_QueryInterface(aObject); + if (!resType) { + // ignore error + return NS_OK; + } + if (mParent->mQNames.Get(resType, nullptr)) { + return NS_OK; + } + mParent->RegisterQName(resType); + return NS_OK; + } + + if (mParent->mQNames.Get(aPredicate, nullptr)) { + return NS_OK; + } + if (aPredicate == mParent->kRDF_instanceOf || + aPredicate == mParent->kRDF_nextVal) + return NS_OK; + bool isOrdinal = false; + mParent->gRDFC->IsOrdinalProperty(aPredicate, &isOrdinal); + if (isOrdinal) + return NS_OK; + + mParent->RegisterQName(aPredicate); + + return NS_OK; +} + +nsresult +nsRDFXMLSerializer::CollectNamespaces() +{ + // Iterate over all Triples to get namespaces for subject resource types + // and Predicates and cache all the QNames we want to use. + nsCOMPtr collector = + new QNameCollector(this); + nsCOMPtr ds = do_QueryInterface(mDataSource); // XXX API + NS_ENSURE_TRUE(collector && ds, NS_ERROR_FAILURE); + return ds->VisitAllTriples(collector); +} + +//---------------------------------------------------------------------- + +NS_IMETHODIMP +nsRDFXMLSerializer::Serialize(nsIOutputStream* aStream) +{ + nsresult rv; + + rv = CollectNamespaces(); + if (NS_FAILED(rv)) return rv; + + nsCOMPtr resources; + rv = mDataSource->GetAllResources(getter_AddRefs(resources)); + if (NS_FAILED(rv)) return rv; + + rv = SerializePrologue(aStream); + if (NS_FAILED(rv)) + return rv; + + while (1) { + bool hasMore = false; + resources->HasMoreElements(&hasMore); + if (! hasMore) + break; + + nsCOMPtr isupports; + resources->GetNext(getter_AddRefs(isupports)); + + nsCOMPtr resource = do_QueryInterface(isupports); + if (! resource) + continue; + + if (IsA(mDataSource, resource, kRDF_Bag) || + IsA(mDataSource, resource, kRDF_Seq) || + IsA(mDataSource, resource, kRDF_Alt)) { + rv = SerializeContainer(aStream, resource); + } + else { + rv = SerializeDescription(aStream, resource); + } + + if (NS_FAILED(rv)) + break; + } + + rv = SerializeEpilogue(aStream); + + return rv; +} + + +bool +nsRDFXMLSerializer::IsA(nsIRDFDataSource* aDataSource, nsIRDFResource* aResource, nsIRDFResource* aType) +{ + nsresult rv; + + bool result; + rv = aDataSource->HasAssertion(aResource, kRDF_instanceOf, aType, true, &result); + if (NS_FAILED(rv)) return false; + + return result; +} -- cgit v1.2.3