metaproxy_1::filter::QueryRewrite::Rep Class Reference

Collaboration diagram for metaproxy_1::filter::QueryRewrite::Rep:

Public Member Functions
	Rep ()
	~Rep ()
void	process (mp::Package &package) const
void	configure (const xmlNode *ptr, bool test_only, const char *path)

Private Attributes
xsltStylesheetPtr	m_stylesheet
std::string	charset_from
std::string	charset_to

Detailed Description

Definition at line 41 of file filter_query_rewrite.cpp.

Constructor & Destructor Documentation

Rep()

mp::filter::QueryRewrite::Rep::Rep

(

)

Definition at line 56 of file filter_query_rewrite.cpp.

                       : m_stylesheet(0), charset_from("UTF-8")
{
}

~Rep()

mp::filter::QueryRewrite::Rep::~Rep

(

)

Definition at line 60 of file filter_query_rewrite.cpp.

{
    if (m_stylesheet)
        xsltFreeStylesheet(m_stylesheet);
}

Member Function Documentation

configure()

void mp::filter::QueryRewrite::Rep::configure	(	const xmlNode *	ptr,
		bool	test_only,
		const char *	path
	)

Definition at line 154 of file filter_query_rewrite.cpp.

{
    for (ptr = ptr->children; ptr; ptr = ptr->next)
    {
        if (ptr->type != XML_ELEMENT_NODE)
            continue;
 
        if (mp::xml::is_element_mp(ptr, "xslt"))
        {
            if (m_stylesheet)
            {
                throw mp::filter::FilterException
                    ("Only one xslt element allowed in query_rewrite filter");
            }
 
            std::string fname;
 
            for (struct _xmlAttr *attr = ptr->properties;
                 attr; attr = attr->next)
            {
                mp::xml::check_attribute(attr, "", "stylesheet");
                fname = mp::xml::get_text(attr);
            }
 
            if (0 == fname.size())
                throw mp::filter::FilterException
                    ("Attribute <xslt stylesheet=\""
                     + fname
                     + "\"> needs XSLT stylesheet path content"
                     + " in query_rewrite filter");
 
            char fullpath[1024];
            char *cp = yaz_filepath_resolve(fname.c_str(), path, 0, fullpath);
            if (!cp)
            {
                throw mp::filter::FilterException("Cannot read XSLT " + fname);
            }
 
            m_stylesheet = xsltParseStylesheetFile(BAD_CAST cp);
            if (!m_stylesheet)
            {
                throw mp::filter::FilterException
                    ("Failed to read XSLT stylesheet '"
                     + fname
                     + "' in query_rewrite filter");
            }
        }
        else if (mp::xml::is_element_mp(ptr, "charset"))
        {
            for (struct _xmlAttr *attr = ptr->properties;
                 attr; attr = attr->next)
            {
                if (!strcmp((const char *) attr->name, "from"))
                {
                    charset_from = mp::xml::get_text(attr);
                }
                else if (!strcmp((const char *) attr->name, "to"))
                {
                    charset_to = mp::xml::get_text(attr);
                }
                else
                    throw mp::filter::FilterException
                        ("Invalid attribute inside charset inside "
                         "query_rewrite filter");
            }
        }
        else
        {
            throw mp::filter::FilterException
                ("Bad element "
                 + std::string((const char *) ptr->name)
                 + " in query_rewrite filter");
        }
    }
}

process()

void mp::filter::QueryRewrite::Rep::process

(

mp::Package &

package

)

const

Definition at line 85 of file filter_query_rewrite.cpp.

{
    Z_GDU *gdu = package.request().get();
 
    if (gdu && gdu->which == Z_GDU_Z3950)
    {
        Z_APDU *apdu_req = gdu->u.z3950;
        if (apdu_req->which == Z_APDU_searchRequest)
        {
            int error_code = 0;
            const char *addinfo = 0;
            mp::odr odr;
            Z_SearchRequest *req = apdu_req->u.searchRequest;
 
            if (m_stylesheet)
            {
                xmlDocPtr doc_input = 0;
                yaz_query2xml(req->query, &doc_input);
 
                if (doc_input)
                {
                    xmlDocPtr doc_res = xsltApplyStylesheet(m_stylesheet,
                                                            doc_input, 0);
                    if (!doc_res)
                    {
                        error_code = YAZ_BIB1_MALFORMED_QUERY;
                        addinfo = "XSLT transform failed for query";
                    }
                    else
                    {
                        const xmlNode *root_element = xmlDocGetRootElement(doc_res);
                        yaz_xml2query(root_element, &req->query, odr,
                                      &error_code, &addinfo);
                        xmlFreeDoc(doc_res);
                    }
                    xmlFreeDoc(doc_input);
                }
            }
            if (!error_code && charset_to.length() && charset_from.length() &&
                (req->query->which == Z_Query_type_1
                 || req->query->which == Z_Query_type_101))
            {
                yaz_iconv_t cd = yaz_iconv_open(charset_to.c_str(),
                                                charset_from.c_str());
                if (cd)
                {
                    int r = yaz_query_charset_convert_rpnquery_check(
                        req->query->u.type_1, odr, cd);
                    yaz_iconv_close(cd);
                    if (r)
                    {  /* query could not be char converted */
                        error_code = YAZ_BIB1_MALFORMED_QUERY;
                        addinfo = "could not convert query to target charset";
                    }
                }
            }
            if (error_code)
            {
                Z_APDU *f_apdu =
                    odr.create_searchResponse(apdu_req, error_code, addinfo);
                package.response() = f_apdu;
                return;
            }
            package.request() = gdu;
        }
    }
    package.move();
}

Member Data Documentation

charset_from

std::string metaproxy_1::filter::QueryRewrite::Rep::charset_from

private

Definition at line 50 of file filter_query_rewrite.cpp.

charset_to

std::string metaproxy_1::filter::QueryRewrite::Rep::charset_to

private

Definition at line 51 of file filter_query_rewrite.cpp.

m_stylesheet

xsltStylesheetPtr metaproxy_1::filter::QueryRewrite::Rep::m_stylesheet

private

Definition at line 49 of file filter_query_rewrite.cpp.

---

The documentation for this class was generated from the following file:

• filter_query_rewrite.cpp