rdf/base/src/nsRDFContainerUtils.cpp

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /* ***** BEGIN LICENSE BLOCK *****
   3  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   4  *
   5  * The contents of this file are subject to the Mozilla Public License Version
   6  * 1.1 (the "License"); you may not use this file except in compliance with
   7  * the License. You may obtain a copy of the License at
   8  * http://www.mozilla.org/MPL/
   9  *
  10  * Software distributed under the License is distributed on an "AS IS" basis,
  11  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  12  * for the specific language governing rights and limitations under the
  13  * License.
  14  *
  15  * The Original Code is Mozilla Communicator client code.
  16  *
  17  * The Initial Developer of the Original Code is
  18  * Netscape Communications Corporation.
  19  * Portions created by the Initial Developer are Copyright (C) 1998
  20  * the Initial Developer. All Rights Reserved.
  21  *
  22  * Contributor(s):
  23  *   Pierre Phaneuf <pp@ludusdesign.com>
  24  *
  25  * Alternatively, the contents of this file may be used under the terms of
  26  * either of the GNU General Public License Version 2 or later (the "GPL"),
  27  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  28  * in which case the provisions of the GPL or the LGPL are applicable instead
  29  * of those above. If you wish to allow use of your version of this file only
  30  * under the terms of either the GPL or the LGPL, and not to allow others to
  31  * use your version of this file under the terms of the MPL, indicate your
  32  * decision by deleting the provisions above and replace them with the notice
  33  * and other provisions required by the GPL or the LGPL. If you do not delete
  34  * the provisions above, a recipient may use your version of this file under
  35  * the terms of any one of the MPL, the GPL or the LGPL.
  36  *
  37  * ***** END LICENSE BLOCK ***** */
  38
  39 /*
  40
  41   Implementation for the RDF container utils.
  42
  43  */
  44
  45
  46 #include "nsCOMPtr.h"
  47 #include "nsIServiceManager.h"
  48 #include "nsIRDFContainer.h"
  49 #include "nsIRDFContainerUtils.h"
  50 #include "nsIRDFService.h"
  51 #include "nsRDFCID.h"
  52 #include "nsString.h"
  53 #include "nsXPIDLString.h"
  54 #include "plstr.h"
  55 #include "prprf.h"
  56 #include "rdf.h"
  57 #include "rdfutil.h"
  58
  59 static NS_DEFINE_CID(kRDFServiceCID, NS_RDFSERVICE_CID);
  60 static const char kRDFNameSpaceURI[] = RDF_NAMESPACE_URI;
  61
  62 class RDFContainerUtilsImpl : public nsIRDFContainerUtils
  63 {
  64 public:
  65     // nsISupports interface
  66     NS_DECL_ISUPPORTS
  67
  68     // nsIRDFContainerUtils interface
  69     NS_DECL_NSIRDFCONTAINERUTILS
  70
  71 private:
  72     friend nsresult NS_NewRDFContainerUtils(nsIRDFContainerUtils** aResult);
  73
  74     RDFContainerUtilsImpl();
  75     virtual ~RDFContainerUtilsImpl();
  76
  77     nsresult MakeContainer(nsIRDFDataSource* aDataSource,
  78                            nsIRDFResource* aResource,
  79                            nsIRDFResource* aType,
  80                            nsIRDFContainer** aResult);
  81
  82     PRBool IsA(nsIRDFDataSource* aDataSource, nsIRDFResource* aResource, nsIRDFResource* aType);
  83
  84     // pseudo constants
  85     static PRInt32 gRefCnt;
  86     static nsIRDFService* gRDFService;
  87     static nsIRDFResource* kRDF_instanceOf;
  88     static nsIRDFResource* kRDF_nextVal;
  89     static nsIRDFResource* kRDF_Bag;
  90     static nsIRDFResource* kRDF_Seq;
  91     static nsIRDFResource* kRDF_Alt;
  92     static nsIRDFLiteral* kOne;
  93 };
  94
  95
  96 PRInt32         RDFContainerUtilsImpl::gRefCnt = 0;
  97 nsIRDFService*  RDFContainerUtilsImpl::gRDFService;
  98 nsIRDFResource* RDFContainerUtilsImpl::kRDF_instanceOf;
  99 nsIRDFResource* RDFContainerUtilsImpl::kRDF_nextVal;
 100 nsIRDFResource* RDFContainerUtilsImpl::kRDF_Bag;
 101 nsIRDFResource* RDFContainerUtilsImpl::kRDF_Seq;
 102 nsIRDFResource* RDFContainerUtilsImpl::kRDF_Alt;
 103 nsIRDFLiteral*  RDFContainerUtilsImpl::kOne;
 104
 105 ////////////////////////////////////////////////////////////////////////
 106 // nsISupports interface
 107
 108 NS_IMPL_THREADSAFE_ISUPPORTS1(RDFContainerUtilsImpl, nsIRDFContainerUtils)
 109
 110 ////////////////////////////////////////////////////////////////////////
 111 // nsIRDFContainerUtils interface
 112
 113 NS_IMETHODIMP
 114 RDFContainerUtilsImpl::IsOrdinalProperty(nsIRDFResource *aProperty, PRBool *_retval)
 115 {
 116     NS_PRECONDITION(aProperty != nsnull, "null ptr");
 117     if (! aProperty)
 118         return NS_ERROR_NULL_POINTER;
 119
 120     nsresult rv;
 121
 122     const char  *propertyStr;
 123     rv = aProperty->GetValueConst( &propertyStr );
 124     if (NS_FAILED(rv)) return rv;
 125
 126     if (PL_strncmp(propertyStr, kRDFNameSpaceURI, sizeof(kRDFNameSpaceURI) - 1) != 0) {
 127         *_retval = PR_FALSE;
 128         return NS_OK;
 129     }
 130
 131     const char* s = propertyStr;
 132     s += sizeof(kRDFNameSpaceURI) - 1;
 133     if (*s != '_') {
 134         *_retval = PR_FALSE;
 135         return NS_OK;
 136     }
 137
 138     ++s;
 139     while (*s) {
 140         if (*s < '0' || *s > '9') {
 141             *_retval = PR_FALSE;
 142             return NS_OK;
 143         }
 144
 145         ++s;
 146     }
 147
 148     *_retval = PR_TRUE;
 149     return NS_OK;
 150 }
 151
 152
 153 NS_IMETHODIMP
 154 RDFContainerUtilsImpl::IndexToOrdinalResource(PRInt32 aIndex, nsIRDFResource **aOrdinal)
 155 {
 156     NS_PRECONDITION(aIndex > 0, "illegal value");
 157     if (aIndex <= 0)
 158         return NS_ERROR_ILLEGAL_VALUE;
 159
 160     nsCAutoString uri(kRDFNameSpaceURI);
 161     uri.Append('_');
 162     uri.AppendInt(aIndex);
 163
 164     nsresult rv = gRDFService->GetResource(uri, aOrdinal);
 165     NS_ASSERTION(NS_SUCCEEDED(rv), "unable to get ordinal resource");
 166     if (NS_FAILED(rv)) return rv;
 167
 168     return NS_OK;
 169 }
 170
 171
 172 NS_IMETHODIMP
 173 RDFContainerUtilsImpl::OrdinalResourceToIndex(nsIRDFResource *aOrdinal, PRInt32 *aIndex)
 174 {
 175     NS_PRECONDITION(aOrdinal != nsnull, "null ptr");
 176     if (! aOrdinal)
 177         return NS_ERROR_NULL_POINTER;
 178
 179     const char  *ordinalStr;
 180     if (NS_FAILED(aOrdinal->GetValueConst( &ordinalStr )))
 181         return NS_ERROR_FAILURE;
 182
 183     const char* s = ordinalStr;
 184     if (PL_strncmp(s, kRDFNameSpaceURI, sizeof(kRDFNameSpaceURI) - 1) != 0) {
 185         NS_ERROR("not an ordinal");
 186         return NS_ERROR_UNEXPECTED;
 187     }
 188
 189     s += sizeof(kRDFNameSpaceURI) - 1;
 190     if (*s != '_') {
 191         NS_ERROR("not an ordinal");
 192         return NS_ERROR_UNEXPECTED;
 193     }
 194
 195     PRInt32 idx = 0;
 196
 197     ++s;
 198     while (*s) {
 199         if (*s < '0' || *s > '9') {
 200             NS_ERROR("not an ordinal");
 201             return NS_ERROR_UNEXPECTED;
 202         }
 203
 204         idx *= 10;
 205         idx += (*s - '0');
 206
 207         ++s;
 208     }
 209
 210     *aIndex = idx;
 211     return NS_OK;
 212 }
 213
 214 NS_IMETHODIMP
 215 RDFContainerUtilsImpl::IsContainer(nsIRDFDataSource *aDataSource, nsIRDFResource *aResource, PRBool *_retval)
 216 {
 217     NS_PRECONDITION(aDataSource != nsnull, "null ptr");
 218     if (! aDataSource)
 219         return NS_ERROR_NULL_POINTER;
 220
 221     NS_PRECONDITION(aResource != nsnull, "null ptr");
 222     if (! aResource)
 223         return NS_ERROR_NULL_POINTER;
 224
 225     NS_PRECONDITION(_retval != nsnull, "null ptr");
 226     if (! _retval)
 227         return NS_ERROR_NULL_POINTER;
 228
 229     if (IsA(aDataSource, aResource, kRDF_Seq) ||
 230         IsA(aDataSource, aResource, kRDF_Bag) ||
 231         IsA(aDataSource, aResource, kRDF_Alt)) {
 232         *_retval = PR_TRUE;
 233     }
 234     else {
 235         *_retval = PR_FALSE;
 236     }
 237     return NS_OK;
 238 }
 239
 240
 241 NS_IMETHODIMP
 242 RDFContainerUtilsImpl::IsEmpty(nsIRDFDataSource* aDataSource, nsIRDFResource* aResource, PRBool* _retval)
 243 {
 244     if (! aDataSource)
 245         return NS_ERROR_NULL_POINTER;
 246
 247     nsresult rv;
 248
 249     // By default, say that we're an empty container. Even if we're not
 250     // really even a container.
 251     *_retval = PR_TRUE;
 252
 253     nsCOMPtr<nsIRDFNode> nextValNode;
 254     rv = aDataSource->GetTarget(aResource, kRDF_nextVal, PR_TRUE, getter_AddRefs(nextValNode));
 255     if (NS_FAILED(rv)) return rv;
 256
 257     if (rv == NS_RDF_NO_VALUE)
 258         return NS_OK;
 259
 260     nsCOMPtr<nsIRDFLiteral> nextValLiteral;
 261     rv = nextValNode->QueryInterface(NS_GET_IID(nsIRDFLiteral), getter_AddRefs(nextValLiteral));
 262     if (NS_FAILED(rv)) return rv;
 263
 264     if (nextValLiteral.get() != kOne)
 265         *_retval = PR_FALSE;
 266
 267     return NS_OK;
 268 }
 269
 270
 271 NS_IMETHODIMP
 272 RDFContainerUtilsImpl::IsBag(nsIRDFDataSource *aDataSource, nsIRDFResource *aResource, PRBool *_retval)
 273 {
 274     NS_PRECONDITION(aDataSource != nsnull, "null ptr");
 275     if (! aDataSource)
 276         return NS_ERROR_NULL_POINTER;
 277
 278     NS_PRECONDITION(aResource != nsnull, "null ptr");
 279     if (! aResource)
 280         return NS_ERROR_NULL_POINTER;
 281
 282     NS_PRECONDITION(_retval != nsnull, "null ptr");
 283     if (! _retval)
 284         return NS_ERROR_NULL_POINTER;
 285
 286     *_retval = IsA(aDataSource, aResource, kRDF_Bag);
 287     return NS_OK;
 288 }
 289
 290
 291 NS_IMETHODIMP
 292 RDFContainerUtilsImpl::IsSeq(nsIRDFDataSource *aDataSource, nsIRDFResource *aResource, PRBool *_retval)
 293 {
 294     NS_PRECONDITION(aDataSource != nsnull, "null ptr");
 295     if (! aDataSource)
 296         return NS_ERROR_NULL_POINTER;
 297
 298     NS_PRECONDITION(aResource != nsnull, "null ptr");
 299     if (! aResource)
 300         return NS_ERROR_NULL_POINTER;
 301
 302     NS_PRECONDITION(_retval != nsnull, "null ptr");
 303     if (! _retval)
 304         return NS_ERROR_NULL_POINTER;
 305
 306     *_retval = IsA(aDataSource, aResource, kRDF_Seq);
 307     return NS_OK;
 308 }
 309
 310
 311 NS_IMETHODIMP
 312 RDFContainerUtilsImpl::IsAlt(nsIRDFDataSource *aDataSource, nsIRDFResource *aResource, PRBool *_retval)
 313 {
 314     NS_PRECONDITION(aDataSource != nsnull, "null ptr");
 315     if (! aDataSource)
 316         return NS_ERROR_NULL_POINTER;
 317
 318     NS_PRECONDITION(aResource != nsnull, "null ptr");
 319     if (! aResource)
 320         return NS_ERROR_NULL_POINTER;
 321
 322     NS_PRECONDITION(_retval != nsnull, "null ptr");
 323     if (! _retval)
 324         return NS_ERROR_NULL_POINTER;
 325
 326     *_retval = IsA(aDataSource, aResource, kRDF_Alt);
 327     return NS_OK;
 328 }
 329
 330
 331 NS_IMETHODIMP
 332 RDFContainerUtilsImpl::MakeBag(nsIRDFDataSource *aDataSource, nsIRDFResource *aResource, nsIRDFContainer **_retval)
 333 {
 334     return MakeContainer(aDataSource, aResource, kRDF_Bag, _retval);
 335 }
 336
 337
 338 NS_IMETHODIMP
 339 RDFContainerUtilsImpl::MakeSeq(nsIRDFDataSource *aDataSource, nsIRDFResource *aResource, nsIRDFContainer **_retval)
 340 {
 341     return MakeContainer(aDataSource, aResource, kRDF_Seq, _retval);
 342 }
 343
 344
 345 NS_IMETHODIMP
 346 RDFContainerUtilsImpl::MakeAlt(nsIRDFDataSource *aDataSource, nsIRDFResource *aResource, nsIRDFContainer **_retval)
 347 {
 348     return MakeContainer(aDataSource, aResource, kRDF_Alt, _retval);
 349 }
 350
 351
 352
 353 ////////////////////////////////////////////////////////////////////////
 354
 355
 356 RDFContainerUtilsImpl::RDFContainerUtilsImpl()
 357 {
 358     if (gRefCnt++ == 0) {
 359         nsresult rv;
 360
 361         rv = CallGetService(kRDFServiceCID, &gRDFService);
 362
 363         NS_ASSERTION(NS_SUCCEEDED(rv), "unable to get RDF service");
 364         if (NS_SUCCEEDED(rv)) {
 365             gRDFService->GetResource(NS_LITERAL_CSTRING(RDF_NAMESPACE_URI "instanceOf"),
 366                                      &kRDF_instanceOf);
 367             gRDFService->GetResource(NS_LITERAL_CSTRING(RDF_NAMESPACE_URI "nextVal"),
 368                                      &kRDF_nextVal);
 369             gRDFService->GetResource(NS_LITERAL_CSTRING(RDF_NAMESPACE_URI "Bag"),
 370                                      &kRDF_Bag);
 371             gRDFService->GetResource(NS_LITERAL_CSTRING(RDF_NAMESPACE_URI "Seq"),
 372                                      &kRDF_Seq);
 373             gRDFService->GetResource(NS_LITERAL_CSTRING(RDF_NAMESPACE_URI "Alt"),
 374                                      &kRDF_Alt);
 375             gRDFService->GetLiteral(NS_LITERAL_STRING("1").get(), &kOne);
 376         }
 377     }
 378 }
 379
 380
 381 RDFContainerUtilsImpl::~RDFContainerUtilsImpl()
 382 {
 383 #ifdef DEBUG_REFS
 384     --gInstanceCount;
 385     fprintf(stdout, "%d - RDF: RDFContainerUtilsImpl\n", gInstanceCount);
 386 #endif
 387
 388     if (--gRefCnt == 0) {
 389         NS_IF_RELEASE(gRDFService);
 390         NS_IF_RELEASE(kRDF_instanceOf);
 391         NS_IF_RELEASE(kRDF_nextVal);
 392         NS_IF_RELEASE(kRDF_Bag);
 393         NS_IF_RELEASE(kRDF_Seq);
 394         NS_IF_RELEASE(kRDF_Alt);
 395         NS_IF_RELEASE(kOne);
 396     }
 397 }
 398
 399
 400
 401 nsresult
 402 NS_NewRDFContainerUtils(nsIRDFContainerUtils** aResult)
 403 {
 404     NS_PRECONDITION(aResult != nsnull, "null ptr");
 405     if (! aResult)
 406         return NS_ERROR_NULL_POINTER;
 407
 408     RDFContainerUtilsImpl* result =
 409         new RDFContainerUtilsImpl();
 410
 411     if (! result)
 412         return NS_ERROR_OUT_OF_MEMORY;
 413
 414     NS_ADDREF(result);
 415     *aResult = result;
 416     return NS_OK;
 417 }
 418
 419
 420 nsresult
 421 RDFContainerUtilsImpl::MakeContainer(nsIRDFDataSource* aDataSource, nsIRDFResource* aResource, nsIRDFResource* aType, nsIRDFContainer** aResult)
 422 {
 423     NS_PRECONDITION(aDataSource != nsnull, "null ptr");
 424     if (! aDataSource)  return NS_ERROR_NULL_POINTER;
 425
 426     NS_PRECONDITION(aResource != nsnull, "null ptr");
 427     if (! aResource)    return NS_ERROR_NULL_POINTER;
 428
 429     NS_PRECONDITION(aType != nsnull, "null ptr");
 430     if (! aType)        return NS_ERROR_NULL_POINTER;
 431
 432     if (aResult)        *aResult = nsnull;
 433
 434     nsresult rv;
 435
 436     // Check to see if somebody has already turned it into a container; if so
 437     // don't try to do it again.
 438     PRBool isContainer;
 439     rv = IsContainer(aDataSource, aResource, &isContainer);
 440     if (NS_FAILED(rv)) return rv;
 441
 442     if (isContainer == PR_FALSE)
 443     {
 444         rv = aDataSource->Assert(aResource, kRDF_instanceOf, aType, PR_TRUE);
 445         if (NS_FAILED(rv)) return rv;
 446
 447         rv = aDataSource->Assert(aResource, kRDF_nextVal, kOne, PR_TRUE);
 448         if (NS_FAILED(rv)) return rv;
 449     }
 450
 451     if (aResult) {
 452         rv = NS_NewRDFContainer(aResult);
 453         if (NS_FAILED(rv)) return rv;
 454
 455         rv = (*aResult)->Init(aDataSource, aResource);
 456         if (NS_FAILED(rv)) return rv;
 457     }
 458
 459     return NS_OK;
 460 }
 461
 462 PRBool
 463 RDFContainerUtilsImpl::IsA(nsIRDFDataSource* aDataSource, nsIRDFResource* aResource, nsIRDFResource* aType)
 464 {
 465     if (!aDataSource || !aResource || !aType)
 466         return NS_ERROR_NULL_POINTER;
 467
 468     nsresult rv;
 469
 470     PRBool result;
 471     rv = aDataSource->HasAssertion(aResource, kRDF_instanceOf, aType, PR_TRUE, &result);
 472     if (NS_FAILED(rv)) return PR_FALSE;
 473
 474     return result;
 475 }
 476
 477 NS_IMETHODIMP
 478 RDFContainerUtilsImpl::IndexOf(nsIRDFDataSource* aDataSource, nsIRDFResource* aContainer, nsIRDFNode* aElement, PRInt32* aIndex)
 479 {
 480     if (!aDataSource || !aContainer)
 481         return NS_ERROR_NULL_POINTER;
 482
 483     // Assume we can't find it.
 484     *aIndex = -1;
 485
 486     // If the resource is null, bail quietly
 487     if (! aElement)
 488       return NS_OK;
 489
 490     // We'll assume that fan-out is much higher than fan-in, so grovel
 491     // through the inbound arcs, look for an ordinal resource, and
 492     // decode it.
 493     nsCOMPtr<nsISimpleEnumerator> arcsIn;
 494     aDataSource->ArcLabelsIn(aElement, getter_AddRefs(arcsIn));
 495     if (! arcsIn)
 496         return NS_OK;
 497
 498     while (1) {
 499         PRBool hasMoreArcs = PR_FALSE;
 500         arcsIn->HasMoreElements(&hasMoreArcs);
 501         if (! hasMoreArcs)
 502             break;
 503
 504         nsCOMPtr<nsISupports> isupports;
 505         arcsIn->GetNext(getter_AddRefs(isupports));
 506         if (! isupports)
 507             break;
 508
 509         nsCOMPtr<nsIRDFResource> property =
 510             do_QueryInterface(isupports);
 511
 512         if (! property)
 513             continue;
 514
 515         PRBool isOrdinal;
 516         IsOrdinalProperty(property, &isOrdinal);
 517         if (! isOrdinal)
 518             continue;
 519
 520         nsCOMPtr<nsISimpleEnumerator> sources;
 521         aDataSource->GetSources(property, aElement, PR_TRUE, getter_AddRefs(sources));
 522         if (! sources)
 523             continue;
 524
 525         while (1) {
 526             PRBool hasMoreSources = PR_FALSE;
 527             sources->HasMoreElements(&hasMoreSources);
 528             if (! hasMoreSources)
 529                 break;
 530
 531             nsCOMPtr<nsISupports> isupports2;
 532             sources->GetNext(getter_AddRefs(isupports2));
 533             if (! isupports2)
 534                 break;
 535
 536             nsCOMPtr<nsIRDFResource> source =
 537                 do_QueryInterface(isupports2);
 538
 539             if (source == aContainer)
 540                 // Found it.
 541                 return OrdinalResourceToIndex(property, aIndex);
 542         }
 543     }
 544
 545     return NS_OK;
 546 }