#include <map>

#include <map>

#ifndef NO_NAMESPACES

#ifndef NO_NAMESPACES

using namespace std;

using namespace std;

#endif /* NO_NAMESPACES */

#endif /* NO_NAMESPACES */

#include "internfile.h"

#include "internfile.h"

#include "rcldoc.h"

#include "rcldoc.h"

#include "mimetype.h"

#include "mimetype.h"

#include "debuglog.h"

#include "debuglog.h"

#include "mimehandler.h"

#include "mimehandler.h"

#ifdef RCL_USE_XATTR

#ifdef RCL_USE_XATTR

#include "pxattr.h"

#include "pxattr.h"

#endif // RCL_USE_XATTR

#endif // RCL_USE_XATTR

// The internal path element separator. This can't be the same as the rcldb 

// The internal path element separator. This can't be the same as the rcldb 

// file to ipath separator : "|"

// file to ipath separator : "|"

// We replace it with a control char if it comes out of a filter (ie:

// We replace it with a control char if it comes out of a filter (ie:

// rclzip or rclchm can do this). If you want the SOH control char

// rclzip or rclchm can do this). If you want the SOH control char

    // This is used by filters which manage some kind of cache.

    // This is used by filters which manage some kind of cache.

    // Indexing by udi makes things easier (because they sometimes get a temp 

    // Indexing by udi makes things easier (because they sometimes get a temp 

    // as input

    // as input

    string udi;

    string udi;

    cnf->setKeyDir(path_getfather(m_fn));

    cnf->setKeyDir(path_getfather(m_fn));

    string l_mime;

    string l_mime;

    bool usfci = false;

    bool usfci = false;

    m_forPreview = ((flags & FIF_forPreview) != 0);

    m_forPreview = ((flags & FIF_forPreview) != 0);

    // Initialize handler stack.

    // Initialize handler stack.

    m_handlers.reserve(MAXHANDLERS);

    m_handlers.reserve(MAXHANDLERS);

    for (unsigned int i = 0; i < MAXHANDLERS; i++)

    for (unsigned int i = 0; i < MAXHANDLERS; i++)

    m_tmpflgs[i] = false;

    m_tmpflgs[i] = false;

}

}

// We used a single beagle cache object to access beagle data. We protect it 

// We used a single beagle cache object to access beagle data. We protect it 

// against multiple thread access.

// against multiple thread access.

static PTMutexInit o_beagler_mutex;

static PTMutexInit o_beagler_mutex;

        backend = it->second;

        backend = it->second;

    if (backend.empty() || !backend.compare("FS")) {

    if (backend.empty() || !backend.compare("FS")) {

        // Filesystem document. Intern from file.

        // Filesystem document. Intern from file.

        // The url has to be like file://

        // The url has to be like file://

            LOGERR(("FileInterner: FS backend and non fs url: [%s]\n",

            LOGERR(("FileInterner: FS backend and non fs url: [%s]\n",

                    idoc.url.c_str()));

                    idoc.url.c_str()));

            return;

            return;

        }

        }

        string fn = idoc.url.substr(7, string::npos);

        string fn = idoc.url.substr(7, string::npos);

}

}

// These defs are for the Dijon meta array. Rcl::Doc predefined field

// These defs are for the Dijon meta array. Rcl::Doc predefined field

// names are used where appropriate. In some cases, Rcl::Doc names are

// names are used where appropriate. In some cases, Rcl::Doc names are

// used inside the Dijon metadata (ex: origcharset)

// used inside the Dijon metadata (ex: origcharset)

static const string cstr_keyds("description");

static const string cstr_keyds("description");

static const string cstr_keyfn("filename");

static const string cstr_keyfn("filename");

static const string cstr_keymd("modificationdate");

static const string cstr_keymd("modificationdate");

static const string cstr_keytt("title");

static const string cstr_keytt("title");

bool FileInterner::dijontorcl(Rcl::Doc& doc)

bool FileInterner::dijontorcl(Rcl::Doc& doc)

{

{

    Dijon::Filter *df = m_handlers.back();

    Dijon::Filter *df = m_handlers.back();

    }

    }

    const map<string, string>& docdata = df->get_meta_data();

    const map<string, string>& docdata = df->get_meta_data();

    for (map<string,string>::const_iterator it = docdata.begin(); 

    for (map<string,string>::const_iterator it = docdata.begin(); 

     it != docdata.end(); it++) {

     it != docdata.end(); it++) {

        doc.text = it->second;

        doc.text = it->second;

    } else if (it->first == cstr_keymd) {

    } else if (it->first == cstr_keymd) {

        doc.dmtime = it->second;

        doc.dmtime = it->second;

    } else if (it->first == Rcl::Doc::keyoc) {

    } else if (it->first == Rcl::Doc::keyoc) {

        doc.origcharset = it->second;

        doc.origcharset = it->second;

        // don't need/want these.

        // don't need/want these.

    } else {

    } else {

        doc.meta[it->first] = it->second;

        doc.meta[it->first] = it->second;

    }

    }

    }

    }

    string ipathel;

    string ipathel;

    for (vector<Dijon::Filter*>::const_iterator hit = m_handlers.begin();

    for (vector<Dijon::Filter*>::const_iterator hit = m_handlers.begin();

     hit != m_handlers.end(); hit++) {

     hit != m_handlers.end(); hit++) {

    const map<string, string>& docdata = (*hit)->get_meta_data();

    const map<string, string>& docdata = (*hit)->get_meta_data();

        if (!ipathel.empty()) {

        if (!ipathel.empty()) {

        // We have a non-empty ipath

        // We have a non-empty ipath

        hasipath = true;

        hasipath = true;

        getKeyValue(docdata, cstr_keyfn, doc.utf8fn);

        getKeyValue(docdata, cstr_keyfn, doc.utf8fn);

        }

        }

        doc.ipath += colon_hide(ipathel) + cstr_isep;

        doc.ipath += colon_hide(ipathel) + cstr_isep;

    } else {

    } else {

        doc.ipath += cstr_isep;

        doc.ipath += cstr_isep;

    }

    }

    getKeyValue(docdata, cstr_keymd, doc.dmtime);

    getKeyValue(docdata, cstr_keymd, doc.dmtime);

    }

    }

    // Trim empty tail elements in ipath.

    // Trim empty tail elements in ipath.

    if (hasipath) {

    if (hasipath) {

// and possibly add a filter/handler to the stack

// and possibly add a filter/handler to the stack

int FileInterner::addHandler()

int FileInterner::addHandler()

{

{

    const map<string, string>& docdata = m_handlers.back()->get_meta_data();

    const map<string, string>& docdata = m_handlers.back()->get_meta_data();

    string charset, mimetype;

    string charset, mimetype;

    LOGDEB(("FileInterner::addHandler: next_doc is %s\n", mimetype.c_str()));

    LOGDEB(("FileInterner::addHandler: next_doc is %s\n", mimetype.c_str()));

    // If we find a document of the target type (text/plain in

    // If we find a document of the target type (text/plain in

    // general), we're done decoding. If we hit text/plain, we're done

    // general), we're done decoding. If we hit text/plain, we're done

    // in any case

    // in any case

    if (!stringicmp(mimetype, m_targetMType) || 

    if (!stringicmp(mimetype, m_targetMType) || 

    m_reachedMType = mimetype;

    m_reachedMType = mimetype;

    LOGDEB1(("FileInterner::addHandler: target reached\n"));

    LOGDEB1(("FileInterner::addHandler: target reached\n"));

    return ADD_BREAK;

    return ADD_BREAK;

    }

    }

    // copying the text, which may be big.

    // copying the text, which may be big.

    string ns;

    string ns;

    const string *txt = &ns;

    const string *txt = &ns;

    {

    {

    map<string,string>::const_iterator it;

    map<string,string>::const_iterator it;

    if (it != docdata.end())

    if (it != docdata.end())

        txt = &it->second;

        txt = &it->second;

    }

    }

    bool setres = false;

    bool setres = false;

    if (newflt->is_data_input_ok(Dijon::Filter::DOCUMENT_STRING)) {

    if (newflt->is_data_input_ok(Dijon::Filter::DOCUMENT_STRING)) {