home *** CD-ROM | disk | FTP | other *** search
/ Tools / WinSN5.0Ver.iso / NETSCAP.50 / WIN1998.ZIP / ns / modules / rdf / src / mcf.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-04-08  |  21.4 KB  |  877 lines
  1. /* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
  2.  *
  3.  * The contents of this file are subject to the Netscape Public License
  4.  * Version 1.0 (the "NPL"); you may not use this file except in
  5.  * compliance with the NPL.  You may obtain a copy of the NPL at
  6.  * http://www.mozilla.org/NPL/
  7.  *
  8.  * Software distributed under the NPL is distributed on an "AS IS" basis,
  9.  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
  10.  * for the specific language governing rights and limitations under the
  11.  * NPL.
  12.  *
  13.  * The Initial Developer of this code under the NPL is Netscape
  14.  * Communications Corporation.  Portions created by Netscape are
  15.  * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
  16.  * Reserved.
  17.  */
  18.  
  19. /* 
  20.    This file (which should probably be called rdf.c) implements the
  21.    core rdf query mechanism.
  22.    For more information on this file, contact rjc or guha 
  23.    For more information on RDF, look at the RDF section of www.mozilla.org
  24. */
  25.  
  26. #include "mcf.h"
  27. #include "columns.h"
  28. #include "fs2rdf.h"
  29. #include "hist2rdf.h"
  30. #include "nlcstore.h"
  31. #include "remstore.h"
  32. #include "es2mcf.h"
  33. #include "pm2rdf.h"
  34. #include "scook.h"
  35.  
  36.  
  37.     /* globals */
  38. RDFL        gAllDBs = 0;
  39.  
  40.  
  41.  
  42. RDFT
  43. getTranslator (char* url)
  44. {
  45.   if (startsWith(url, "rdf:localStore")) {
  46.     return MakeLocalStore(url);
  47.   } else if (startsWith(url, "rdf:remoteStore")) {
  48.     return MakeRemoteStore(url);
  49.   } else if (startsWith(url, "rdf:history")) {
  50.     return MakeHistoryStore(url);
  51.   } else if (startsWith(url, "rdf:esftp")) {
  52.     return MakeESFTPStore(url);
  53.     /*  } else if (startsWith(url, "rdf:mail")) {
  54.     return MakeMailStore(url); */
  55.   } else if (startsWith(url, "rdf:lfs")) {
  56.     return MakeLFSStore(url);
  57.   } else if (endsWith(".rdf", url) || (endsWith(".mcf", url))) {
  58.     return MakeFileDB(url);
  59.   } else if (startsWith("rdf:columns", url)) {
  60.     return MakeColumnStore (url);
  61.   } else if (startsWith("rdf:ht", url) || startsWith("rdf:scook", url)) {
  62.     return MakeSCookDB(url);
  63.   } else  return NULL;
  64. }
  65.  
  66.  
  67.  
  68. PR_PUBLIC_API(RDF)
  69. RDF_GetDB (const char** dataSources)
  70. {
  71.   uint16 n = 0;
  72.   uint16 m = 0;
  73.   char* next ;
  74.   RDF r = (RDF) getMem(sizeof(struct RDF_DBStruct)) ;
  75.   RDFL nrl = (RDFL)getMem(sizeof(struct RDF_ListStruct));
  76.   while (*(dataSources + n++)) {} 
  77.   r->translators = (RDFT*)getMem((n-1) * sizeof(RDFT));
  78.   n = 0;
  79.   while (next = (char*) *(dataSources + n)) {
  80.     RDFL rl = (RDFL)getMem(sizeof(struct RDF_ListStruct));
  81.     r->translators[m] = getTranslator(next);
  82.     if (r->translators[m] != NULL) { 
  83.         rl->rdf = r;
  84.         rl->next = r->translators[m]->rdf;
  85.         r->translators[m]->rdf = rl;
  86.         m++;
  87.     } else {
  88.         freeMem(rl);
  89.     }
  90.     n++;
  91.   }
  92.   r->numTranslators = m;
  93.   nrl->rdf = r;
  94.   nrl->next = gAllDBs;
  95.   gAllDBs = nrl;
  96.   return r;
  97. }
  98.  
  99.  
  100.  
  101. RDFL
  102. deleteFromRDFList (RDFL xrl, RDF db)
  103. {
  104.   RDFL rl = xrl;
  105.   RDFL prev = rl;
  106.   while (rl) {
  107.       if (rl->rdf == db) {
  108.         if (prev == rl) {
  109.           RDFL ans = rl->next;
  110.           freeMem(rl);
  111.           return ans;
  112.         } else {
  113.           prev->next = rl->next;
  114.           freeMem(rl);
  115.           return xrl;
  116.         }
  117.       }
  118.       prev = rl;
  119.       rl   = rl->next;
  120.   }
  121.   return xrl;
  122. }
  123.  
  124.  
  125.  
  126. void
  127. disposeAllDBs ()
  128. {
  129.   while (gAllDBs) {
  130.     RDF_ReleaseDB(gAllDBs->rdf);
  131.   }
  132. }
  133.  
  134.  
  135.  
  136. PR_PUBLIC_API(RDF_Error) 
  137. RDF_ReleaseDB(RDF rdf)
  138. {
  139.   if (rdf != NULL) {
  140.     uint16 n = 0;
  141.     uint16 size = rdf->numTranslators;
  142.     while (n < size) {
  143.       RDFL rlx = (*((RDFT*)rdf->translators + n))->rdf;
  144.       (*((RDFT*)rdf->translators + n))->rdf =  deleteFromRDFList(rlx, rdf); 
  145.       callExitRoutine(n, rdf);
  146.       n++;
  147.     }
  148.     gAllDBs = deleteFromRDFList(gAllDBs, rdf);
  149.   }
  150.   freeMem(rdf);
  151.   return noRDFErr;
  152. }
  153.  
  154.  
  155.  
  156. RDF_Resource
  157. addDep (RDF db, RDF_Resource u)
  158. {
  159.  
  160.   if (db) {
  161.     RDFL rl = u->rdf;
  162.     while (rl) {
  163.       if (rl->rdf == db) return u;
  164.       rl = rl->next;
  165.     }
  166.     rl = (RDFL) getMem(sizeof(struct RDF_ListStruct));
  167.     rl->rdf = db;
  168.     rl->next = u->rdf;
  169.     u->rdf = rl;
  170.     return u;
  171.   }
  172.   return u;
  173. }
  174.  
  175.  
  176.  
  177. PRBool
  178. rdfassert(RDF rdf, RDF_Resource u, RDF_Resource  s, void* value, 
  179.           RDF_ValueType type,  PRBool tv)
  180. {
  181.    uint16 size =  rdf->numTranslators;
  182.    int16 n = size -1;
  183.    
  184.    /* XXX - what happens here if there is no local store? */     
  185.    if ((size > 1) && (callHasAssertions(0, rdf, u, s, value, type, (!tv)))) {
  186.      setLockedp(u, 1);
  187.      callUnassert(0, rdf, u, s, value, type); 
  188.      setLockedp(u, 0);
  189.      if (RDF_HasAssertion(rdf, u, s, value, type, tv)) return 1;
  190.    }
  191.    while (n > -1) {
  192.      if (callAssert(n, rdf, u, s, value, type, tv)) return 1; 
  193.      n--; 
  194.    }  
  195.    return 0;
  196. }
  197.  
  198.  
  199.  
  200. PR_PUBLIC_API(PRBool)
  201. RDF_Assert (RDF rdf, RDF_Resource u, RDF_Resource  s, void* value, RDF_ValueType type)
  202. {
  203.     return rdfassert(rdf, u, s, value, type, 1);
  204. }
  205.  
  206.  
  207.  
  208. PR_PUBLIC_API(PRBool)
  209. RDF_AssertFalse (RDF rdf, RDF_Resource u, RDF_Resource  s, void* value, RDF_ValueType type)
  210. {
  211.     return rdfassert(rdf, u, s, value, type, 0);
  212. }
  213.  
  214.  
  215.  
  216. PR_PUBLIC_API(PRBool)
  217. RDF_Unassert (RDF rdf, RDF_Resource u, RDF_Resource s, void* value, RDF_ValueType type)
  218. {
  219.   PRBool allok = 1;
  220.   uint16 size =  rdf->numTranslators;
  221.   uint16 n = 0;
  222.   
  223.   setLockedp(u, 1);
  224.   while (allok && (n < size)) {
  225.     if (callHasAssertions(n, rdf, u, s, value, type, 1)) {
  226.       allok = callUnassert(n, rdf, u, s, value, type);
  227.     }
  228.     n++;
  229.   }
  230.   if (!allok) allok = callAssert(0, rdf, u, s, value, type, 0); 
  231.   setLockedp(u, 0);
  232.   return allok;
  233. }
  234.  
  235.  
  236.  
  237. PRBool
  238. containerIDp(char* id)
  239. {
  240.   return (endsWith(".rdf", id) || (endsWith(".mco", id)) || (endsWith(".mcf", id)) || 
  241.            strstr(id, ".rdf#"));
  242. }
  243.  
  244.  
  245.  
  246. char *
  247. makeNewID ()
  248. {
  249.  
  250.   PRTime tm = PR_Now();
  251.  
  252. #ifndef HAVE_LONG_LONG
  253.   double doubletm;
  254. #endif /* !HAVE_LONG_LONG */
  255.  
  256.   char* id = (char*)getMem(ID_BUF_SIZE);
  257.  
  258.  #ifdef HAVE_LONG_LONG
  259.   PR_snprintf(id, ID_BUF_SIZE, "%u", (double)tm);
  260.  #else
  261.   LL_L2D(doubletm, tm);
  262.   PR_snprintf(id, ID_BUF_SIZE, "%d", doubletm);
  263.  #endif /* HAVE_LONG_LONG */
  264.  
  265.   /* prevent collisions by checking hash. */
  266.   while (PL_HashTableLookup(resourceHash, id) != NULL) {
  267.      #ifdef HAVE_LONG_LONG
  268.       tm = tm + (PR_MSEC_PER_SEC * 60); /* fix me - not sure what the increment should be */
  269.       PR_snprintf(id, ID_BUF_SIZE, "%u", (double)tm);
  270.     #else
  271.       int64 incr;
  272.       LL_I2L(incr, (PR_MSEC_PER_SEC * 60));
  273.       LL_ADD(tm, tm, incr);
  274.       LL_L2D(doubletm, tm);
  275.       PR_snprintf(id, ID_BUF_SIZE, "%d", doubletm);
  276.     #endif /* HAVE_LONG_LONG */
  277.   }
  278.  
  279.   return id;
  280. }
  281.  
  282.  
  283.  
  284. PRBool
  285. iscontainerp (RDF_Resource u)
  286. {
  287.   char* id = resourceID(u);
  288.   if (containerIDp(id)) {
  289.     return 1;
  290.   } else if (startsWith("file:", id)) {
  291.     return fileDirectoryp(u);
  292.   } else if (startsWith("ftp:", id) && (endsWith("/", id))) {
  293.     return 1;
  294.   } else if (startsWith("cache:container", id)) {
  295.     return 1;
  296.   } else  return 0; 
  297. } 
  298.  
  299.  
  300.  
  301. RDF_BT
  302. resourceTypeFromID (char* id)
  303. {
  304.   if (endsWith(".rdf", id) || (strstr(id, ".rdf#"))) {
  305.     return RDF_RT;
  306.   } else if (endsWith(".mcf", id) || (strstr(id, ".mcf#"))) {
  307.     return RDF_RT;
  308.   } else if (endsWith(".mco", id)) {
  309.     return RDF_RT;
  310.   } else if (startsWith("file:", id) || (startsWith("NC:LocalFiles", id))) {
  311.     return LFS_RT;
  312.   } else if (startsWith("nes:", id)) {
  313.     return ES_RT;
  314.   } else if (startsWith("ftp:", id)) {
  315.     return FTP_RT;
  316.   } else if (startsWith("cache:", id)) {
  317.     return CACHE_RT;
  318.   } else return 0;
  319. }
  320.  
  321.  
  322.  
  323. PR_PUBLIC_API(RDF_Resource)
  324. RDF_GetResource (RDF db, char* id, PRBool createp)
  325. {
  326.   char* nid;
  327.   RDF_Resource existing;
  328.   if (id != NULL) {
  329.     existing = (RDF_Resource)PL_HashTableLookup(resourceHash, id);
  330.     if (existing != null) return addDep(db, existing);
  331.     if (!createp) {
  332.       return null;
  333.     } else {
  334.       nid = copyString(id);
  335.     }
  336.   } else if (createp != false) {
  337.     nid = makeNewID();
  338.   }
  339.   existing = (RDF_Resource)getMem(sizeof(struct RDF_ResourceStruct)); 
  340.   existing->url = nid;
  341.   PL_HashTableAdd(resourceHash, nid, existing);
  342.   setResourceType(existing, resourceTypeFromID(nid));
  343.   setContainerp(existing, iscontainerp(existing));
  344.   return addDep(db, existing);
  345.   
  346. }
  347.  
  348.  
  349.   
  350. PR_PUBLIC_API (RDF_Error)
  351. RDF_DeleteAllArcs (RDF rdf, RDF_Resource u)
  352. {
  353.   Assertion as, next;
  354.   /*  if (u->locked) return -1; */
  355.   as = u->rarg1;
  356.   while (as != NULL) {
  357.     next = as->next;
  358.     remoteStoreRemove(gRemoteStore, as->u, as->s, as->value, as->type);
  359.     as = next;
  360.   }
  361.   as = u->rarg2;
  362.   while (as != NULL) {
  363.     next = as->invNext;
  364.     remoteStoreRemove(gRemoteStore, as->u, as->s, as->value, as->type);
  365.     as = next;
  366.   }
  367. #ifdef DBMTEST
  368.  nlclStoreKill(gLocalStore, u);
  369. #endif
  370.   return 0;
  371. }
  372.  
  373.  
  374.  
  375. PR_PUBLIC_API(PRBool)
  376. RDF_HasAssertion (RDF rdf, RDF_Resource u, RDF_Resource s, 
  377.              void* v, RDF_ValueType type, PRBool tv)
  378. {
  379.   uint16 size = rdf->numTranslators;
  380.   uint16 n = 0;
  381.   if (callHasAssertions(0, rdf, u, s, v, type, !tv)) return 0;
  382.   while (n < size) {
  383.     if (callHasAssertions(n, rdf, u, s, v, type, tv)) return 1;
  384.     n++;
  385.   }
  386.   return 0; 
  387. }
  388.  
  389.  
  390.  
  391. PR_PUBLIC_API(void *)
  392. RDF_GetSlotValue (RDF rdf, RDF_Resource u, RDF_Resource s, 
  393.             RDF_ValueType type, PRBool inversep, PRBool tv)
  394. {
  395.   uint16 size =  rdf->numTranslators; 
  396.   uint16 n = 0;
  397.   if (s == gWebData->RDF_URL && tv && !inversep && type == RDF_STRING_TYPE) 
  398.     return  copyString(resourceID(u));         
  399.   while (n < size) {
  400.     void*  ans = callGetSlotValue(n, rdf, u, s, type, inversep, tv);
  401.     if ((ans != NULL) && ((n == 0)||(!callHasAssertions(0, rdf, u, s, ans, type, !tv))))
  402.     if (type == RDF_RESOURCE_TYPE) {
  403.       return addDep(rdf, ans) ;
  404.       } else return ans;
  405.     n++;
  406.   }
  407.   if (s == gCoreVocab->RDF_name && tv && !inversep && type == RDF_STRING_TYPE) 
  408.     return makeResourceName(u);
  409.   return NULL; 
  410. }
  411.  
  412.  
  413.  
  414. RDF_Cursor
  415. getSlotValues (RDF rdf, RDF_Resource u, RDF_Resource s, 
  416.               RDF_ValueType type, PRBool inversep, PRBool tv)
  417. {
  418.   RDF_Cursor c = (RDF_Cursor) getMem(sizeof(struct RDF_CursorStruct));
  419.   if (c == NULL)    return(NULL);
  420.   c->u = u;
  421.   c->s = s;
  422.   c->queryType =  RDF_GET_SLOT_VALUES_QUERY;
  423.   c->tv = tv;
  424.   c->inversep = inversep;
  425.   c->type = type;
  426.   c->count = -1;
  427.   c->rdf = rdf;
  428.   c->current = NULL;
  429.   while ((c->count < rdf->numTranslators-1) && (!c->current)) {
  430.     c->count++;
  431.     c->current = callGetSlotValues(c->count, rdf, u, s, type, inversep, tv);
  432.   }
  433.   if (!c->current) {
  434.     freeMem(c);
  435.     return NULL;
  436.   } else {
  437.     return c;
  438.   }
  439. }
  440.  
  441.  
  442.  
  443. PR_PUBLIC_API(RDF_Cursor)
  444. RDF_GetTargets (RDF rdfDB, RDF_Resource source, RDF_Resource arcLabel, 
  445.                       RDF_ValueType targetType,  PRBool tv)
  446. {
  447.     return getSlotValues(rdfDB, source, arcLabel, targetType, 0, tv);
  448. }
  449.  
  450.  
  451.  
  452. PR_PUBLIC_API(RDF_Cursor)
  453. RDF_GetSources (RDF rdfDB, RDF_Resource target, RDF_Resource arcLabel, 
  454.                       RDF_ValueType sourceType,  PRBool tv)
  455. {
  456.   if (sourceType != RDF_RESOURCE_TYPE) return NULL;
  457.   return getSlotValues(rdfDB, target, arcLabel, sourceType, 1, tv);
  458. }
  459.  
  460.  
  461.  
  462. PR_PUBLIC_API(RDF_ValueType)
  463. RDF_CursorValueType(RDF_Cursor c)
  464. {
  465.   if (c == NULL) {
  466.     return 0;
  467.   } else {
  468.     return c->type;
  469.   }
  470. }
  471.  
  472.  
  473.  
  474. PR_PUBLIC_API(char*)
  475. RDF_ValueDataSource(RDF_Cursor c)
  476. {
  477.   if (c == NULL) {
  478.     return NULL;
  479.   } else {
  480.     RDF rdf = c->rdf;
  481.     RDFT rdft;
  482.     if (rdf == NULL) return NULL;
  483.     rdft = rdf->translators[c->count];
  484.     if (rdft) {
  485.       return rdft->url;
  486.     } else {
  487.       return NULL;
  488.     }
  489.   }
  490. }
  491.  
  492.  
  493.  
  494. PR_PUBLIC_API(RDF_Cursor)
  495. RDF_ArcLabelsOut (RDF rdfDB, RDF_Resource u)
  496. {
  497.   RDF_Cursor c = (RDF_Cursor) getMem(sizeof(struct RDF_CursorStruct));
  498.   if (c == NULL)   return(NULL);
  499.   c->u = u;
  500.   c->queryType =  RDF_ARC_LABELS_OUT_QUERY;
  501.   c->type = RDF_RESOURCE_TYPE;
  502.   c->count = -1;
  503.   c->rdf = rdfDB;
  504.   c->current = NULL;
  505.   while ((c->count < rdfDB->numTranslators-1) && (!c->current)) {
  506.     c->count++;
  507.     c->current = callArcLabelsOut(c->count, rdfDB, u);
  508.   } 
  509.   if (!c->current) {
  510.     freeMem(c);
  511.     return NULL;
  512.   } else {
  513.     return c;
  514.   }
  515. }
  516.  
  517.  
  518.  
  519. PR_PUBLIC_API(RDF_Cursor)
  520. RDF_ArcLabelsIn (RDF rdfDB, RDF_Resource u)
  521. {
  522.   RDF_Cursor c = (RDF_Cursor) getMem(sizeof(struct RDF_CursorStruct));
  523.   if (c == NULL)   return(NULL);
  524.   c->u = u;
  525.   c->queryType =  RDF_ARC_LABELS_IN_QUERY;
  526.   c->type = RDF_RESOURCE_TYPE;
  527.   c->count = -1;
  528.   c->rdf = rdfDB;
  529.   c->current = NULL;
  530.   while ((c->count < rdfDB->numTranslators-1) && (!c->current)) {
  531.     c->count++;
  532.     c->current = callArcLabelsIn(c->count, rdfDB, u);
  533.   }
  534.   if (!c->current) {
  535.     freeMem(c);
  536.     return NULL;
  537.   } else {
  538.     return c;
  539.   }
  540. }
  541.  
  542.  
  543.  
  544. PR_PUBLIC_API(void *)
  545. RDF_NextValue (RDF_Cursor c)
  546. {
  547.   void* ans;
  548.   RDF rdf;  
  549.   if (c == NULL) return NULL;
  550.   if (c->queryType == RDF_FIND_QUERY) return nextFindValue(c);
  551.   rdf =  c->rdf;
  552.   ans = (*rdf->translators[c->count]->nextValue)(rdf->translators[c->count], c->current);
  553.   while (ans != NULL) {
  554.     if (c->count == 0) return addDep(c->rdf, ans);
  555.     if (((!c->inversep) && 
  556.     (!(callHasAssertions(0, rdf, c->u, c->s, ans, c->type, !c->tv)))) ||
  557.     ((c->inversep) && 
  558.      (!(callHasAssertions(0, rdf, (RDF_Resource)ans, c->s, c->u, 
  559.                   c->type, !c->tv))))) {
  560.       if (c->type == RDF_RESOURCE_TYPE) {
  561.     return addDep(c->rdf, (RDF_Resource)ans);
  562.       } else return ans;
  563.     }
  564.     ans = (*rdf->translators[c->count]->nextValue)(rdf->translators[c->count], c->current);
  565.   }
  566.   (*rdf->translators[c->count]->disposeCursor)(rdf->translators[c->count], c->current);
  567.   c->current = NULL;
  568.   while ((c->count < rdf->numTranslators - 1) && (!c->current)) {
  569.     c->count++;
  570.     c->current = callGetSlotValues(c->count,rdf, c->u, c->s, c->type, 
  571.                    c->inversep, c->tv);
  572.   }
  573.   if (c->current == NULL) return NULL;
  574.   return RDF_NextValue(c);
  575. }
  576.  
  577.  
  578.  
  579. void 
  580. disposeResourceInt (RDF rdf, RDF_Resource u)
  581. {
  582.   uint16 size = rdf->numTranslators;
  583.   uint16 n = 0;
  584.   PRBool ok = 1;
  585.   while (n < size && ok) {
  586.     ok = (callDisposeResource(n, rdf, u));
  587.     n++;
  588.   } 
  589.   if (ok && (!lockedp(u))) possiblyGCResource(u);
  590. }
  591.     
  592.   
  593.  
  594. PR_PUBLIC_API(RDF_Error) 
  595. RDF_ReleaseResource (RDF db, RDF_Resource u)
  596. {
  597.   if (db && u) {    
  598.     
  599.     u->rdf = deleteFromRDFList(u->rdf, db);
  600.     if (u->rdf == NULL)  disposeResourceInt(db, u);
  601.   }
  602.   return 0;
  603. }
  604.  
  605.  
  606.  
  607. PR_PUBLIC_API(RDF_Error)
  608. RDF_DisposeCursor (RDF_Cursor c)
  609. {
  610.   if ((c != NULL) && (c->queryType == RDF_FIND_QUERY) && (c->pdata)) freeMem(c->pdata);
  611.   if (c != NULL) freeMem(c);
  612.   return 0;
  613. }
  614.  
  615.  
  616.  
  617. PRIntn
  618. findEnumerator (PLHashEntry *he, PRIntn i, void *arg)
  619. {
  620.   RDF_Cursor c = (RDF_Cursor) arg;
  621.   RDF_Resource u = (RDF_Resource)he->value;
  622.   if (itemMatchesFind(c->rdf, u, c->s, c->value, c->type)) {
  623.     c->count++;
  624.     if (c->size <= c->count) {
  625.       RDF_Resource* newBlock = getMem(c->size+5);
  626.       if (newBlock == NULL) return  HT_ENUMERATE_STOP;
  627.       if (c->size > 0) {
  628.     memcpy(newBlock, c->pdata, c->size * sizeof(RDF_Resource*));
  629.     freeMem(c->pdata);
  630.       }
  631.       c->pdata = newBlock;
  632.     }
  633.     *((RDF_Resource*)c->pdata + c->count) = u;
  634.   }
  635.   return  HT_ENUMERATE_NEXT;
  636. }
  637.  
  638.  
  639.  
  640. PR_PUBLIC_API(RDF_Cursor)
  641. RDF_Find (RDF_Resource s, void* v, RDF_ValueType type)
  642. {
  643.   RDF_Cursor c = (RDF_Cursor) getMem(sizeof(struct RDF_CursorStruct));
  644.   c->s = s;
  645.   c->value = v;
  646.   c->type = type;
  647.   c->queryType =  RDF_FIND_QUERY;
  648.   c->count = 0;
  649.   PL_HashTableEnumerateEntries(resourceHash, findEnumerator, c);
  650.   c->count = 0;
  651.   return c;
  652. }
  653.  
  654.  
  655.  
  656. PRBool
  657. itemMatchesFind (RDF r, RDF_Resource u, RDF_Resource s, void* v, RDF_ValueType type)
  658. {
  659.   RDF_Cursor c = RDF_GetTargets(r, u, s, type, 1);
  660.   void* val;
  661.   while (val = RDF_NextValue(c)) {
  662.     PRBool ok = 0;
  663.     if (type == RDF_RESOURCE_TYPE) {
  664.       ok = (u == v);
  665.     } else if (type == RDF_STRING_TYPE) {
  666.       ok = (strstr(val, v) != NULL);
  667.     }
  668.     if (ok) {
  669.       RDF_DisposeCursor(c);
  670.       return 1;
  671.     }
  672.   }
  673.   return 0;
  674. }
  675.  
  676.  
  677.  
  678. RDF_Resource
  679. nextFindValue (RDF_Cursor c)
  680. {
  681.   if (c->count < c->size && (*((RDF_Resource*)c->pdata + c->count) != NULL)) {
  682.     RDF_Resource ans = (RDF_Resource)*((RDF_Resource*)c->pdata + c->count);
  683.     c->count++;
  684.     return ans;
  685.   } else   return NULL;
  686. }
  687.  
  688.  
  689.  
  690. void
  691. possiblyGCResource (RDF_Resource u)
  692. {
  693.   if ((nullp(u->rarg1)) && (nullp(u->rarg2))) {
  694.     PL_HashTableRemove(resourceHash,  resourceID(u));
  695.     freeMem(u->url);
  696.     freeMem(u);  
  697.   }
  698. }
  699.  
  700.  
  701.  
  702. PR_PUBLIC_API(RDF_Notification)
  703. RDF_AddNotifiable (RDF rdfDB, RDF_NotificationProc callBack, 
  704.                          RDF_Event ev, void* pdata)
  705. {
  706.   RDF_Notification ns = (RDF_Notification)getMem(sizeof(struct RDF_NotificationStruct));
  707.   RDF_Event        nev = (RDF_Event)getMem(sizeof(struct RDF_EventStruct));
  708.   memcpy((char*)nev, ev, sizeof(struct RDF_EventStruct));
  709.   ns->theEvent = nev;
  710.   ns->notifFunction = callBack;
  711.   ns->pdata = pdata;
  712.   ns->next = rdfDB->notifs;
  713.   rdfDB->notifs = ns;
  714.   ns->rdf = rdfDB;
  715.   return ns;
  716. }
  717.  
  718.  
  719.  
  720. PR_PUBLIC_API(RDF_Error)
  721. RDF_DeleteNotifiable (RDF_Notification ns)
  722. {
  723.   RDF rdf = ns->rdf;
  724.   RDF_Notification pr = rdf->notifs;
  725.   RDF_Notification not;
  726.   if (pr == ns) {
  727.     rdf->notifs = pr->next; 
  728.   } else {
  729.     for (not = rdf->notifs; (not != NULL) ; not = not->next) {
  730.       if (ns == not) {
  731.     pr->next = not->next; 
  732.     return 0;
  733.       }
  734.       pr = not;
  735.     }
  736.   }
  737.   freeMem(ns->theEvent);
  738.   freeMem(ns);
  739.   return 0;
  740. }
  741.  
  742.  
  743.  
  744. void
  745. assertNotify (RDF rdf, RDF_Notification not, RDF_Resource u, RDF_Resource s, void* v, RDF_ValueType type, PRBool tv, char* ds)
  746.  {
  747.   RDF_Event nev = not->theEvent;
  748.   RDF_AssertEvent ev = &(not->theEvent->event.assert);
  749.   PRBool opTypeFixed = not->theEvent->eventType;
  750.   PRBool uFixed      = (ev->u != NULL);
  751.   PRBool sFixed        = (ev->s != NULL);
  752.   PRBool vFixed        = (ev->v != NULL);
  753.   RDF_EventType  oldEventType   = not->theEvent->eventType;
  754.   if ((!opTypeFixed ||(not->theEvent->eventType & RDF_ASSERT_NOTIFY)) &&
  755.       (!uFixed      || (ev->u      == u))      &&
  756.       (!vFixed    || (ev->v      == v))       &&
  757.       (!sFixed      || (ev->s      == s))) {
  758.     /*   if     (callHasAssertions(0, rdf, u, s, v, type, !tv)) return; */
  759.     nev->eventType = RDF_ASSERT_NOTIFY;
  760.     ev->u      = u;
  761.     ev->s      = s;
  762.     ev->v      = v;
  763.     ev->type   = type;
  764.     ev->tv     = tv;
  765.     ev->dataSource = ds;
  766.     (*(not->notifFunction))(nev, not->pdata);
  767.        nev->eventType = oldEventType;
  768.     if (!uFixed)      ev->u = NULL;
  769.     if (!sFixed)      ev->s = NULL;
  770.     if (!vFixed)      ev->v = NULL;
  771.     }
  772. }
  773.  
  774.  
  775.  
  776. void
  777. insertNotify (RDF rdf, RDF_Notification not, RDF_Resource u, RDF_Resource s, void* v, RDF_ValueType type, PRBool tv, char* ds)
  778. {
  779.   RDF_Event nev = not->theEvent;
  780.   RDF_AssertEvent ev = &(not->theEvent->event.assert);
  781.   PRBool opTypeFixed = not->theEvent->eventType;
  782.   PRBool uFixed      = (ev->u != NULL);
  783.   PRBool sFixed        = (ev->s != NULL);
  784.   PRBool vFixed        = (ev->v != NULL);
  785.   RDF_EventType  oldEventType   = not->theEvent->eventType;
  786.   if ((!opTypeFixed ||(not->theEvent->eventType & RDF_INSERT_NOTIFY)) &&
  787.       (!uFixed      || (ev->u      == u))      &&
  788.       (!vFixed    || (ev->v      == v))       &&
  789.       (!sFixed      || (ev->s      == s))) {
  790.     /*   if     (callHasAssertions(0, rdf, u, s, v, type, !tv)) return; */
  791.     nev->eventType = RDF_INSERT_NOTIFY;
  792.     ev->u      = u;
  793.     ev->s      = s;
  794.     ev->v      = v;
  795.     ev->type   = type;
  796.     ev->tv     = tv;
  797.     ev->dataSource = ds;
  798.     (*(not->notifFunction))(nev, not->pdata);
  799.         nev->eventType = oldEventType;
  800.     if (!uFixed)      ev->u = NULL;
  801.     if (!sFixed)      ev->s = NULL;
  802.     if (!vFixed)      ev->v = NULL;
  803.     }
  804. }
  805.  
  806.  
  807.  
  808. void
  809. unassertNotify (RDF_Notification not, RDF_Resource u, RDF_Resource s, void* v, RDF_ValueType type, char* ds)
  810. {
  811.   RDF_Event nev = not->theEvent;
  812.   RDF_UnassertEvent ev = &(not->theEvent->event.unassert);
  813.   PRBool opTypeFixed = not->theEvent->eventType;
  814.   PRBool uFixed      = (ev->u != NULL);
  815.   PRBool sFixed        = (ev->s != NULL);
  816.   PRBool vFixed        = (ev->v != NULL);
  817.   RDF_EventType  oldEventType   = not->theEvent->eventType;
  818.   if ((!opTypeFixed ||(not->theEvent->eventType & RDF_DELETE_NOTIFY)) &&
  819.       (!uFixed      || (ev->u      == u))      &&
  820.       (!vFixed    || (ev->v      == v))       &&
  821.       (!sFixed      || (ev->s      == s))) {
  822.     nev->eventType = RDF_DELETE_NOTIFY;
  823.     ev->u      = u;
  824.     ev->s      = s;
  825.     ev->v      = v;
  826.     ev->type   = type;
  827.     ev->dataSource = ds;
  828.     (*(not->notifFunction))(nev, not->pdata);
  829.     nev->eventType = oldEventType;
  830.     if (!uFixed)      ev->u = NULL;
  831.     if (!sFixed)      ev->s = NULL;
  832.     if (!vFixed)      ev->v = NULL;
  833.     }
  834. }
  835.  
  836.  
  837.  
  838. void
  839. sendNotifications2 (RDFT r, RDF_EventType opType, RDF_Resource u, RDF_Resource s, void* v, RDF_ValueType type, PRBool tv)
  840. {
  841.   RDFL rl = r->rdf;
  842.   while (rl) {
  843.     sendNotifications(rl->rdf, opType, u, s, v, type, tv, r->url);
  844.     rl = rl->next;
  845.   }
  846. }
  847.  
  848.  
  849.  
  850. void
  851. sendNotifications (RDF rdf, RDF_EventType opType, RDF_Resource u, RDF_Resource s, void* v, RDF_ValueType type, PRBool tv, char* ds)
  852. {
  853.   RDF_Notification not;
  854.   if (rdf == NULL) return;
  855.   for (not = rdf->notifs; (not != NULL) ; not = not->next) {
  856.     if (!not->theEvent || (not->theEvent->eventType & opType)) {
  857.         RDF_EventType otype = not->theEvent->eventType;
  858.       switch (opType) 
  859.     {
  860.     case RDF_ASSERT_NOTIFY :
  861.       assertNotify(rdf, not, u, s, v, type, tv, ds);
  862.       break;
  863.     case RDF_INSERT_NOTIFY :
  864.       insertNotify(rdf, not, u, s, v, type, tv, ds);
  865.       break;
  866.     case RDF_DELETE_NOTIFY :
  867.       unassertNotify(not, u, s, v, type, ds);
  868.       break;
  869.     case RDF_KILL_NOTIFY :
  870.       break;
  871.       /*      killNotify(not, u); */
  872.     }
  873.       not->theEvent->eventType = otype;
  874.     }
  875.   }
  876. }
  877.