Changeset 184

Timestamp:

1999-03-04T12:26:35+13:00 (25 years ago)

Author:

sjboddie

Message:

Implemented more of the protocol

Location:

trunk/gsdl/src/recpt

Files:

• comproto.asn (modified) (6 diffs)
• comtypes.h (modified) (2 diffs)
• nullproto.cpp (modified) (2 diffs)
• nullproto.h (modified) (1 diff)
• recptproto.cpp (modified) (2 diffs)
• recptproto.h (modified) (1 diff)

trunk/gsdl/src/recpt/comproto.asn

@@ -266 +266 @@
 
 MetadataInfoResponse ::= SEQUENCE {
-  supportedFields StringSet
+  supportedFields    StringSet,
+  supportedLanguages StringSet
 }
 
 MetadataRequest ::= SEQUENCE {
-  docIDs     StringSequence,
-  attributes StringSequence
-}
-
+  OIDs      StringSequence,
+  fields    StringSequence,
+  languages StringSequence
+}
+
+-- for each OID it will return all the fields
+-- in each of the languages
 MetadataResponse ::= SEQUENCE {
-  metadata SEQUENCE OF Metadata
-}
-
-Metadata ::= StringSequence
+  metadata SEQUENCE OF GeneralString
+}
 
 
 DocumentRequest ::= SEQUENCE {
-  docID     GeneralString,
+  OID       GeneralString,
   docType   GeneralString,
   docFormat GeneralString
@@ -297 +299 @@
 
 
--- filter options which might be supported for the query filter
+-- filter options which might be supported for the QueryFilter
 --
 -- onePerQuery StartResults   integer
 -- onePerQuery EndResults     integer
--- onePerQuery InverseOrder   boolean
--- onePerQuery Ordering       enumerated (rank, or metadata field)
+-- onePerQuery QueryType      enumerated (boolean, ranked)
 -- onePerTerm  Term           string ???
--- onePerTerm  MimeType       enumerated
--- onePerTerm  Language       enumerated
--- onePerTerm  MatchOption    enumerated (must match, can match, mustn't match)
 -- onePerTerm  Casefold       boolean
 -- onePerTerm  Stem           boolean
 -- onePerTerm  Index          enumerated
 -- onePerTerm  Subcollection  enumerated
+--
+-- filter options which might be supported for the BrowseFilter
+--
+-- onePerQuery StartResults   integer
+-- onePerQuery EndResults     integer
+-- onePerQuery ParentNode     string ("" will return the browsing available)
 
 InfoFilterOptionsRequest ::= SEQUENCE {
@@ -325 +329 @@
 
 FilterOption ::= SEQUENCE {
-  name        GeneralString,
-  type        ENUMERATED {boolean(0), integer(1), enumerated(2), string(3)},
-  repeatable  ENUMERATED {onePerQuery(0), onePerTerm(1), nPerTerm(2)},
-  default     GeneralString,
+  name         GeneralString,
+  type         ENUMERATED {booleant(0), integert(1), enumeratedt(2), stringt(3)},
+  repeatable   ENUMERATED {onePerQuery(0), onePerTerm(1), nPerTerm(2)},
+  defaultValue GeneralString,
   -- the interpretation of the validValues depends on the type
   -- for boolean: the first value is the false value, the second is true value
@@ -334 +338 @@
   -- for enumerated: all values a listed
   -- for string: this value is ignored
-  validValues StringSequence
+  validValues  StringSequence
 }
 
@@ -348 +352 @@
   filterOptions       [1] IMPLICIT SEQUENCE OF OptionValue,
   docSet              [2] IMPLICIT StringSequence OPTIONAL,
-  filterResultOptions [3] BIT STRING {termFreq(0), matchTerms(1), docID(2), subCol(3),
+  filterResultOptions [3] BIT STRING {termFreq(0), matchTerms(1), OID(2), subCol(3),
                                       ranking(4), docFreq(5)}
 }
@@ -371 +375 @@
 
 ResultDocInfo ::= SEQUENCE {
-  docID    [0] IMPLICIT GeneralString,
+  OID      [0] IMPLICIT GeneralString,
   subCol   [1] IMPLICIT StringSequence OPTIONAL,
   ranking  [2] IMPLICIT REAL OPTIONAL,

trunk/gsdl/src/recpt/comtypes.h

@@ -16 +16 @@
 #include "gsdlconf.h"
 #include "text_t.h"
+
+#if defined(GSDL_USE_OBJECTSPACE)
+#  include <ospace\std\vector>
+#  include <ospace\std\list>
+#  include <ospace\std\set>
+#elif defined(GSDL_USE_STL_H)
+#  include <vector.h>
+#  include <list.h>
+#  include <set.h>
+#else
+#  include <vector>
+#  include <list>
+#  include <set>
+#endif
 
 
@@ -59 +73 @@
 
 
+
+// FilterOption ::= SEQUENCE {
+//   name         GeneralString,
+//   type         ENUMERATED {booleant(0), integert(1), enumeratedt(2), stringt(3)},
+//   repeatable   ENUMERATED {onePerQuery(0), onePerTerm(1), nPerTerm(2)},
+//   defaultValue GeneralString,
+//   -- the interpretation of the validValues depends on the type
+//   -- for boolean: the first value is the false value, the second is true value
+//   -- for integer: the first value is the minimum, the second the maximum
+//   -- for enumerated: all values a listed
+//   -- for string: this value is ignored
+//   validValues  StringSequence
+// }
+struct FilterOption_t {
+  FilterOption_t () {type=booleant; repeatable=onePerQuery;}
+
+  text_t name;
+
+  enum type_t {booleant=0, integert=1, enumeratedt=2, stringt=3};
+  type_t type;
+
+  enum repeatable_t {onePerQuery=0, onePerTerm=1, nPerTerm=2};
+  repeatable_t repeatable;
+
+  text_t defaultValue;
+  text_tarray validValues;
+};
+
+inline bool operator<(const FilterOption_t &f1, const FilterOption_t &f2) {
+  return ((f1.name < f2.name) || 
+      ((f1.name == f2.name) && 
+       ((f1.type < f2.type) || 
+        ((f1.type == f2.type) && 
+         ((f1.repeatable < f2.repeatable) || 
+          ((f1.repeatable == f2.repeatable) && 
+           ((f1.defaultValue < f2.defaultValue) || 
+        ((f1.defaultValue == f2.defaultValue) && 
+         (f1.validValues < f2.validValues)))))))));
+}
+
+
+struct ltFilterOption_t {
+  bool operator()(const FilterOption_t &f1, const FilterOption_t &f2) const
+  { return f1 < f2; }
+};
+
+typedef set<FilterOption_t, ltFilterOption_t> FilterOption_tset;
+
+// FilterDescript ::= SEQUENCE {
+//   filterName GeneralString,
+//   filterOptions SET OF FilterOption
+// }
+struct FilterDescript_t {
+  text_t filterName;
+  FilterOption_tset filterOptions;
+};
+
+struct ltFilterDescript_t {
+  bool operator()(const FilterDescript_t &f1, const FilterDescript_t &f2) const
+  { return ((f1.filterName < f2.filterName) || 
+        ((f1.filterName == f2.filterName) && (f1.filterOptions < f2.filterOptions))); }
+};
+
+typedef set<FilterDescript_t, ltFilterDescript_t> FilterDescript_tset;
+
+// InfoFilterOptionsResponse ::= SEQUENCE {
+//   filterOptions SET OF FilterDescript
+// }
+struct InfoFilterOptionsResponse_t {
+  FilterDescript_tset filterOptions;
+};
+
+
+
+// OptionValue ::= SEQUENCE {
+//   name  GeneralString,
+//   value GeneralString
+// }
+struct OptionValue_t {
+  text_t name;
+  text_t value;
+};
+
+typedef vector<OptionValue_t> OptionValue_tarray;
+
+
+// -- Terms are presented in the same order that they are requested,
+// -- any information relating to the terms is in reference to the
+// -- index specified for that term.
+// -- Metadata is presented in the same order that it is requested.
+// 
+// FilterRequest ::= SEQUENCE {
+//   filterName          [0] GeneralString,
+//   filterOptions       [1] IMPLICIT SEQUENCE OF OptionValue,
+//   docSet              [2] IMPLICIT StringSequence OPTIONAL,
+//   filterResultOptions [3] BIT STRING {termFreq(0), matchTerms(1), OID(2), subCol(3),
+//                                       ranking(4), docFreq(5)}
+// }
+#define FRtermFreq   1
+#define FRmatchTerms 2
+#define FROID        4
+#define FRsubCol     8
+#define FRranking    16
+#define FRdocFreq    32
+
+struct FilterRequest_t {
+  FilterRequest_t () {filterResultOptions=0;}
+
+  text_t filterName;
+  OptionValue_tarray filterOptions;
+  text_tarray docSet;  // empty if not used
+  int filterResultOptions; // use the FR* defines above
+};
+
+
+// TermInfo ::= SEQUENCE {
+//   term       [0] GeneralString,
+//   freq       [0] IMPLICIT INTEGER OPTIONAL,
+//   matchTerms [1] IMPLICIT StringSequence OPTIONAL
+// }
+struct TermInfo_t {
+  TermInfo_t () {freq=0;}
+
+  text_t term;
+  int freq; // 0 if not requested
+  text_tarray matchTerms; // empty if not requested
+};
+
+typedef vector<TermInfo_t> TermInfo_tarray;
+
+// ResultDocInfo ::= SEQUENCE {
+//   OID      [0] IMPLICIT GeneralString,
+//   subCol   [1] IMPLICIT StringSequence OPTIONAL,
+//   ranking  [2] IMPLICIT REAL OPTIONAL,
+//   docFreq  [3] IMPLICIT SEQUENCE OF INTEGER OPTIONAL,
+// }
+struct ResultDocInfo_t {
+  ResultDocInfo_t () {ranking=0.0;}
+
+  text_t OID;
+  text_tarray subCol; // empty if not requested
+  float ranking; // 0.0 if not requested
+  vector<int> docFreq; // empty if not requested
+
+  ResultDocInfo_t &operator=(const ResultDocInfo_t &x) 
+  {OID=x.OID; subCol=x.subCol; ranking=x.ranking; 
+  docFreq=x.docFreq; return *this;}
+};
+
+typedef vector<ResultDocInfo_t> ResultDocInfo_tarray;
+
+// FilterResponse ::= SEQUENCE {
+//   docsFound [0] IMPLICIT INTEGER,
+//   isApprox  [1] IMPLICIT BOOLEAN, -- whether docsFound is approximate
+//   termInfo  [2] IMPLICIT SEQUENCE OF TermInfo OPTIONAL,
+//   docInfo   [3] IMPLICIT SEQUENCE OF ResultDocInfo OPTIONAL
+// }
+struct FilterResponse_t {
+  FilterResponse_t () {docsFound=0; isApprox=false;}
+
+  int docsFound;
+  bool isApprox;
+  TermInfo_tarray termInfo; // empty if not requested
+  ResultDocInfo_tarray docInfo; // empty if not requested
+};
+
+
+
+// MetadataInfoResponse ::= SEQUENCE {
+//   supportedFields    StringSet,
+//   supportedLanguages StringSet
+// }
+struct MetadataInfoResponse_t {
+  text_tset supportedFields;
+  text_tset supportedLanguages;
+};
+
+// MetadataRequest ::= SEQUENCE {
+//   OIDs      StringSequence,
+//   fields    StringSequence,
+//   languages StringSequence
+// }
+struct MetadataRequest_t {
+  text_tarray OIDs;
+  text_tarray fields;
+  text_tarray languages;
+};
+
+
+// -- for each OID it will return all the fields
+// -- in each of the languages
+// MetadataResponse ::= SEQUENCE {
+//   metadata SEQUENCE OF GeneralString
+// }
+struct MetadataResponse_t {
+  text_tarray metadata;
+};
+
+
 #endif

trunk/gsdl/src/recpt/nullproto.cpp

@@ -12 +12 @@
 /*
    $Log$
+   Revision 1.3  1999/03/03 23:26:35  sjboddie
+
+   Implemented more of the protocol
+
    Revision 1.2  1999/02/25 21:58:58  rjmcnab
 
@@ -122 +126 @@
 void nullproto::get_collectinfo (const text_t &collection, 
                  ColInfoResponse_t &collectinfo,
-                 comerror_t &err, ostream &/*logout*/) {
+                 comerror_t &err, ostream &logout) {
   collectserver *cserver = cservers.getcollectserver (collection);
-  if (cserver != NULL) {
-    collectinfo = cserver->get_collectinfo ();
-    err = noError;
+  if (cserver != NULL) cserver->get_collectinfo (collectinfo, err, logout);
+  else err = protocolError;
+}
 
-  } else {
-    err = protocolError;
-  }
+
+void nullproto::get_filteroptions (const text_t &collection,
+                   InfoFilterOptionsResponse_t &response, 
+                   comerror_t &err, ostream &logout) {
+  collectserver *cserver = cservers.getcollectserver (collection);
+  if (cserver != NULL) cserver->get_filteroptions (response, err, logout);
+  else err = protocolError;
 }
+
+void nullproto::filter (const text_t &collection,
+            const FilterRequest_t &request,
+            FilterResponse_t &response,
+            comerror_t &err, ostream &logout) {
+  collectserver *cserver = cservers.getcollectserver (collection);
+  if (cserver != NULL) cserver->filter (request, response, err, logout);
+  else err = protocolError;
+}
+
+void nullproto::get_metadataoptions (const text_t &collection,
+                     MetadataInfoResponse_t &response,
+                     comerror_t &err, ostream &logout) {
+  collectserver *cserver = cservers.getcollectserver (collection);
+  if (cserver != NULL) cserver->get_metadataoptions (response, err, logout);
+  else err = protocolError;
+}
+
+void nullproto::get_metadata (const text_t &collection,
+                  const MetadataRequest_t &request,
+                  MetadataResponse_t &response,
+                  comerror_t &err, ostream &logout) {
+  collectserver *cserver = cservers.getcollectserver (collection);
+  if (cserver != NULL) cserver->get_metadata (request, response, err, logout);
+  else err = protocolError;
+}
+

trunk/gsdl/src/recpt/nullproto.h

@@ -46 +46 @@
             ColInfoResponse_t &collectinfo,
             comerror_t &err, ostream &logout);
+  void get_filteroptions (const text_t &collection,
+              InfoFilterOptionsResponse_t &response, 
+              comerror_t &err, ostream &logout);
+  void filter (const text_t &collection,
+           const FilterRequest_t &request,
+           FilterResponse_t &response,
+           comerror_t &err, ostream &logout);
+  void get_metadataoptions (const text_t &collection,
+                MetadataInfoResponse_t &response,
+                comerror_t &err, ostream &logout);
+  void get_metadata (const text_t &collection,
+             const MetadataRequest_t &request,
+             MetadataResponse_t &response,
+             comerror_t &err, ostream &logout);
 };
 

trunk/gsdl/src/recpt/recptproto.cpp

@@ -12 +12 @@
 /*
    $Log$
+   Revision 1.3  1999/03/03 23:26:35  sjboddie
+
+   Implemented more of the protocol
+
    Revision 1.2  1999/02/25 21:59:01  rjmcnab
 
@@ -79 +83 @@
 }
 
+// gets all the filter options for a collection
+void recptproto::get_filteroptions (const text_t &/*collection*/,
+                    InfoFilterOptionsResponse_t &/*response*/, 
+                    comerror_t &err, ostream &/*logout*/) {
+  err = protocolError;
+}
+
+// filters (search or browse) a result set
+void recptproto::filter (const text_t &/*collection*/,
+             const FilterRequest_t &/*request*/,
+             FilterResponse_t &/*response*/,
+             comerror_t &err, ostream &/*logout*/) {
+  err = protocolError;
+}
+
+// gets all the metadata options for a collection
+void recptproto::get_metadataoptions (const text_t &/*collection*/,
+                      MetadataInfoResponse_t &/*response*/,
+                      comerror_t &err, ostream &/*logout*/) {
+  err = protocolError;
+}
+
+// gets all the metadata for a result set
+void recptproto::get_metadata (const text_t &/*collection*/,
+                   const MetadataRequest_t &/*request*/,
+                   MetadataResponse_t &/*response*/,
+                   comerror_t &err, ostream &/*logout*/) {
+  err = protocolError;
+}
+
+
+
+
 
 

trunk/gsdl/src/recpt/recptproto.h

@@ -74 +74 @@
                 ColInfoResponse_t &collectinfo,
                 comerror_t &err, ostream &logout);
+
+  // gets all the filter options for a collection
+  virtual void get_filteroptions (const text_t &collection,
+                  InfoFilterOptionsResponse_t &response, 
+                  comerror_t &err, ostream &logout);
+
+  // filters (search or browse) a result set
+  virtual void filter (const text_t &collection,
+               const FilterRequest_t &request,
+               FilterResponse_t &response,
+               comerror_t &err, ostream &logout);
+
+  // gets all the metadata options for a collection
+  virtual void get_metadataoptions (const text_t &collection,
+                    MetadataInfoResponse_t &response,
+                    comerror_t &err, ostream &logout);
+
+  // gets all the metadata for a result set
+  virtual void get_metadata (const text_t &collection,
+                 const MetadataRequest_t &request,
+                 MetadataResponse_t &response,
+                 comerror_t &err, ostream &logout);
 };