Collaboration diagram for metaproxy_1::filter::RecordTransform::Impl:

Public Member Functions
	Impl ()

	~Impl ()

void	process (metaproxy_1::Package &package) const

void	configure (const xmlNode xml_node, const char path)

Private Attributes
yaz_retrieval_t	m_retrieval

Detailed Description

Definition at line 45 of file filter_record_transform.cpp.

Constructor & Destructor Documentation

◆ Impl()

mp::filter::RecordTransform::Impl::Impl ( )

Definition at line 195 of file filter_record_transform.cpp.

 {
     m_retrieval = yaz_retrieval_create();
     assert(m_retrieval);
 }

◆ ~Impl()

mp::filter::RecordTransform::Impl::~Impl ( )

Definition at line 201 of file filter_record_transform.cpp.

 {
     if (m_retrieval)
         yaz_retrieval_destroy(m_retrieval);
 }

Member Function Documentation

◆ configure()

void mp::filter::RecordTransform::Impl::configure	(	const xmlNode *	xml_node,
		const char *	path
	)

Definition at line 207 of file filter_record_transform.cpp.

 {
     yaz_retrieval_set_path(m_retrieval, path);
  
     if (!xml_node)
         throw mp::XMLError("RecordTransform filter config: empty XML DOM");
  
     // parsing down to retrieval node, which can be any of the children nodes
     xmlNode *retrieval_node;
     for (retrieval_node = xml_node->children;
          retrieval_node;
          retrieval_node = retrieval_node->next)
     {
         if (retrieval_node->type != XML_ELEMENT_NODE)
             continue;
         if (0 == strcmp((const char *) retrieval_node->name, "retrievalinfo"))
             break;
     }
  
 #if HAVE_USEMARCON
     struct yaz_record_conv_type mt;
     type_usemarcon(&mt);
     struct yaz_record_conv_type *t = &mt;
 #else
     struct yaz_record_conv_type *t = 0;
 #endif
  
     // read configuration
     if (0 != yaz_retrieval_configure_t(m_retrieval, retrieval_node, t))
     {
         std::string msg("RecordTransform filter config: ");
         msg += yaz_retrieval_get_error(m_retrieval);
         throw mp::XMLError(msg);
     }
 }

◆ process()

void mp::filter::RecordTransform::Impl::process ( metaproxy_1::Package & package ) const

Definition at line 323 of file filter_record_transform.cpp.

 {
  
     Z_GDU *gdu_req = package.request().get();
     Z_PresentRequest *pr_req = 0;
     Z_SearchRequest *sr_req = 0;
  
     const char *input_schema = 0;
     Odr_oid *input_syntax = 0;
  
     if (gdu_req && gdu_req->which == Z_GDU_Z3950 &&
         gdu_req->u.z3950->which == Z_APDU_presentRequest)
     {
         pr_req = gdu_req->u.z3950->u.presentRequest;
  
         input_schema =
             mp_util::record_composition_to_esn(pr_req->recordComposition);
         input_syntax = pr_req->preferredRecordSyntax;
     }
     else if (gdu_req && gdu_req->which == Z_GDU_Z3950 &&
              gdu_req->u.z3950->which == Z_APDU_searchRequest)
     {
         sr_req = gdu_req->u.z3950->u.searchRequest;
  
         input_syntax = sr_req->preferredRecordSyntax;
  
         // we don't know how many hits we're going to get and therefore
         // the effective element set name.. Therefore we can only allow
         // two cases.. Both equal or absent.. If not, we'll just have to
         // disable the piggyback!
         if (sr_req->smallSetElementSetNames
             &&
             sr_req->mediumSetElementSetNames
             &&
             sr_req->smallSetElementSetNames->which == Z_ElementSetNames_generic
             &&
             sr_req->mediumSetElementSetNames->which == Z_ElementSetNames_generic
             &&
             !strcmp(sr_req->smallSetElementSetNames->u.generic,
                     sr_req->mediumSetElementSetNames->u.generic))
         {
             input_schema = sr_req->smallSetElementSetNames->u.generic;
         }
         else if (*sr_req->largeSetLowerBound > 1
                  && !sr_req->smallSetElementSetNames && !sr_req->mediumSetElementSetNames)
             ; // input_schema is 0 already
         else
         {
             // disable piggyback (perhaps it was disabled already)
             *sr_req->smallSetUpperBound = 0;
             *sr_req->largeSetLowerBound = 1;
             *sr_req->mediumSetPresentNumber = 0;
             package.move();
             return;
         }
         // we can handle it in record_transform.
     }
     else
     {
         package.move();
         return;
     }
  
     mp::odr odr_en(ODR_ENCODE);
  
     // setting up variables for conversion state
     yaz_record_conv_t rc = 0;
  
     const char *match_schema = 0;
     Odr_oid *match_syntax = 0;
  
     const char *backend_schema = 0;
     Odr_oid *backend_syntax = 0;
  
     int ret_code
         = yaz_retrieval_request(m_retrieval,
                                 input_schema, input_syntax,
                                 &match_schema, &match_syntax,
                                 &rc,
                                 &backend_schema, &backend_syntax);
     // error handling
     if (ret_code != 0)
     {
         int error_code;
         const char *details = 0;
  
         if (ret_code == -1) /* error ? */
         {
             details = yaz_retrieval_get_error(m_retrieval);
             error_code = YAZ_BIB1_SYSTEM_ERROR_IN_PRESENTING_RECORDS;
         }
         else if (ret_code == 1 || ret_code == 3)
         {
             details = input_schema;
             error_code = YAZ_BIB1_ELEMENT_SET_NAMES_UNSUPP;
         }
         else if (ret_code == 2)
         {
             char oidbuf[OID_STR_MAX];
             oid_oid_to_dotstring(input_syntax, oidbuf);
             details = odr_strdup(odr_en, oidbuf);
             error_code = YAZ_BIB1_RECORD_SYNTAX_UNSUPP;
         }
         else
         {
             char *tmp = (char*) odr_malloc(odr_en, 80);
             sprintf(tmp,
                     "record_transform: yaz_retrieval_get_error returned %d",
                     ret_code);
             details = tmp;
             error_code = YAZ_BIB1_UNSPECIFIED_ERROR;
         }
         Z_APDU *apdu;
         if (sr_req)
         {
             apdu = odr_en.create_searchResponse(
                 gdu_req->u.z3950, error_code, details);
         }
         else
         {
             apdu = odr_en.create_presentResponse(
                 gdu_req->u.z3950, error_code, details);
         }
         package.response() = apdu;
         return;
     }
  
     if (sr_req)
     {
         if (backend_syntax)
             sr_req->preferredRecordSyntax = odr_oiddup(odr_en, backend_syntax);
         else
             sr_req->preferredRecordSyntax = 0;
  
         if (backend_schema)
         {
             sr_req->smallSetElementSetNames
                 = (Z_ElementSetNames *)
                 odr_malloc(odr_en, sizeof(Z_ElementSetNames));
             sr_req->smallSetElementSetNames->which = Z_ElementSetNames_generic;
             sr_req->smallSetElementSetNames->u.generic
                 = odr_strdup(odr_en, backend_schema);
             sr_req->mediumSetElementSetNames = sr_req->smallSetElementSetNames;
         }
         else
         {
             sr_req->smallSetElementSetNames = 0;
             sr_req->mediumSetElementSetNames = 0;
         }
     }
     else if (pr_req)
     {
         if (backend_syntax)
             pr_req->preferredRecordSyntax = odr_oiddup(odr_en, backend_syntax);
         else
             pr_req->preferredRecordSyntax = 0;
  
         if (backend_schema)
         {
             pr_req->recordComposition
                 = (Z_RecordComposition *)
                 odr_malloc(odr_en, sizeof(Z_RecordComposition));
             pr_req->recordComposition->which
                 = Z_RecordComp_simple;
             pr_req->recordComposition->u.simple
                 = (Z_ElementSetNames *)
                 odr_malloc(odr_en, sizeof(Z_ElementSetNames));
             pr_req->recordComposition->u.simple->which = Z_ElementSetNames_generic;
             pr_req->recordComposition->u.simple->u.generic
                 = odr_strdup(odr_en, backend_schema);
         }
         else
             pr_req->recordComposition = 0;
     }
  
     // attaching Z3950 package to filter chain
     package.request() = gdu_req;
  
     package.move();
  
     Z_GDU *gdu_res = package.response().get();
  
     // see if we have a records list to patch!
     Z_NamePlusRecordList *records = 0;
     if (gdu_res && gdu_res->which == Z_GDU_Z3950 &&
         gdu_res->u.z3950->which == Z_APDU_presentResponse)
     {
         Z_PresentResponse * pr_res = gdu_res->u.z3950->u.presentResponse;
  
         if (rc && pr_res
             && pr_res->numberOfRecordsReturned
             && *(pr_res->numberOfRecordsReturned) > 0
             && pr_res->records
             && pr_res->records->which == Z_Records_DBOSD)
         {
             records = pr_res->records->u.databaseOrSurDiagnostics;
         }
     }
     if (gdu_res && gdu_res->which == Z_GDU_Z3950 &&
         gdu_res->u.z3950->which == Z_APDU_searchResponse)
     {
         Z_SearchResponse *sr_res = gdu_res->u.z3950->u.searchResponse;
  
         if (rc && sr_res
             && sr_res->numberOfRecordsReturned
             && *(sr_res->numberOfRecordsReturned) > 0
             && sr_res->records
             && sr_res->records->which == Z_Records_DBOSD)
         {
             records = sr_res->records->u.databaseOrSurDiagnostics;
         }
     }
  
     if (records)
     {
         int i;
         for (i = 0; i < records->num_records; i++)
             convert_npr(rc, match_syntax, odr_en, records, i);
         package.response() = gdu_res;
     }
     return;
 }