---

IgModuleCache Class Reference

Automatically cached directory of module registrations. More...

#include <Iguana/Framework/interface/IgModuleCache.h>

List of all members.

Public Types
typedef ModuleList::const_iterator	Iterator
	Iterator over IgModule objects in this cache.
Public Member Functions
Iterator	begin (void) const
	Return an iterator to the first Module in the cache.
lat::Filename	directory (void) const
	Return the module cache directory name.
Iterator	end (void) const
	Return an iterator one past the last Module in the cache.
	IgModuleCache (IgPluginManager *manager, const lat::Filename &directory)
	Initialise a module cache in directory.
IgPluginManager *	manager (void) const
void	refresh (void)
	Refresh the module cache.
	~IgModuleCache (void)
	Destroy the module cache.
Protected Member Functions
void	load (void)
	Load the module cache file ".cache".
void	notify (void)
	Update m_modules from the current state of the cache (m_cache).
void	rebuild (void)
	Rebuild the cache comparing it to the actual directory contents.
void	update (void)
	Update the ".cache" file on the disk if it is writable.
Private Types
enum	CacheStatus { CACHE_MISSING = 1, CACHE_OLD = 2, CACHE_VALID = 3 }
	Different cache states. More...
typedef ModuleList::iterator	ModuleIterator
	Iterator over module registations.
typedef std::list< IgModule * >	ModuleList
	Module registrations (each of which maintains its list of modules).
Private Member Functions
bool	parse (const lat::Filename &filename, IgModuleDescriptor *root=0)
	Parse a module cache file (".cache" or one of the "*.reg" files).
void	reconstruct (IgModuleDescriptor *info)
	Validate and reconstruct descriptor proxies from info.
CacheStatus	scanModules (ModuleList &cache)
	Actually scan the module directory, compare it with the current m_cache, and build a new cache that reflects the changes.
void	write (std::ostream &s, IgModuleDescriptor *doc, int level=0)
	Dump the module descriptor doc and all it's children into the stream s.
Static Private Member Functions
static IgModuleDescriptor *	makeBad (const std::string &file, const std::string &time)
	Construct a module descriptor for a bad file with timestamp time.
Private Attributes
ModuleList	m_cache
lat::Filename	m_directory
IgPluginManager *	m_manager
ModuleList	m_modules
ParseContext	m_parse
CacheContext	m_state
Static Private Attributes
static const char	s_cacheFile [] = ".iglets"
static const char	s_cacheTag [] = "cache"
static const char	s_fileTag []
static const char	s_moduleTag []
Friends
struct	CacheContext
class	FileByName
struct	ParseContext
Classes
struct	CacheContext
	Flags that describe the current cache status. More...
class	FileByName
struct	ParseContext
	Structure used as temporary storage and result by parse() and reconstruct(). More...

---

Detailed Description

Automatically cached directory of module registrations.

The IgPluginManager automatically instantiates a IgModuleCache for every module registration directory. The purpose of this class is to maintain an automatically updated cache about all the modules in the directory, including all the plug-ins registered in those modules. The cache object automatically refreshes the cache with respect to the on-disk registrations when it is created. Clients can also force an update by calling refresh(); note however that calling it on already-loaded modules whose library has been updated while the program is running is not a good idea.

The cache maintains information about all the registrations in the directory, including the time-stamp of each file. The cache is updated if the file time stamp is different from what it was when the data was cached. The cache also records time-stamps for bad files: files the cache does not understand or files that describe modules that fail to load for some reason. Such files are ignored until the on-disk file time stamp changes.

The IgModuleCache updates the on-disk cache automatically if it can, i.e. if it has write permissions on the directory. It never modifies the original registration files. If the cache file cannot be written, the errors are silently ignored and class proceeds with just the information in memory; the canonical data it maintains is the part that is in memory, the data on disk is merely an optimisation that avoids having to query all the modules all the time.

Note that if the cache cannot be written but needs to be updated, there is a performance penalty because the client programs will continuously refresh their caches. Thus when new modules are installed, it is important to refresh the cache before the directories are frozen.

The cache data is maintained in string form as IgModuleDescriptor objects. The IgModuleCache automatically creates IgModule objects as needed. When restoring a cache the information is passed as IgModuleDescriptor to the IgModule objects, which passes it to the IgPluginManager, which passes it to the IgPluginFactory categories as necessary. When writing the the IgModule objects are queried for their caches of the IgPluginInfo items registered with them, to produce IgModuleDescriptors for output.

Definition at line 68 of file IgModuleCache.h.

---

Member Typedef Documentation

typedef ModuleList::const_iterator IgModuleCache::Iterator

Iterator over IgModule objects in this cache.

Definition at line 77 of file IgModuleCache.h.

typedef ModuleList::iterator IgModuleCache::ModuleIterator [private]

Iterator over module registations.

Definition at line 73 of file IgModuleCache.h.

typedef std::list<IgModule *> IgModuleCache::ModuleList [private]

Module registrations (each of which maintains its list of modules).

Definition at line 71 of file IgModuleCache.h.

---

Member Enumeration Documentation

enum IgModuleCache::CacheStatus [private]

Different cache states.

The progression goes from first to last.

Enumerator:

CACHE_MISSING
CACHE_OLD
CACHE_VALID

Definition at line 109 of file IgModuleCache.h.

                     {
        CACHE_MISSING   = 1,            //< No cache
        CACHE_OLD       = 2,            //< Cache exists but is outdated
        CACHE_VALID     = 3             //< Cache exists and is up-to-date
    };

---

Constructor & Destructor Documentation

IgModuleCache::IgModuleCache	(	IgPluginManager *	manager,
		const lat::Filename &	directory
	)

Initialise a module cache in directory.

Initialises the cache to clear state and then invokes refresh() to rebuild; this causes for instance Module objects to be created.

Definition at line 103 of file IgModuleCache.cc.

References IgModuleCache::CacheContext::added, ASSERT, CACHE_MISSING, IgModuleCache::CacheContext::changed, lat::Filename::empty(), m_directory, m_parse, m_state, IgModuleCache::ParseContext::module, refresh(), IgModuleCache::CacheContext::removed, IgModuleCache::CacheContext::skipped, and IgModuleCache::CacheContext::status.

    : m_manager (manager),
      m_directory (directory.asDirectory ())
{
    ASSERT (! m_directory.empty ());

    m_state.status = CACHE_MISSING;
    m_state.added  = m_state.removed
                   = m_state.changed
                   = m_state.skipped
                   = false;

    m_parse.module = 0;
    refresh ();
}

IgModuleCache::~IgModuleCache

(

void

)

Destroy the module cache.

Destroys all modules owned by the cache.

Definition at line 120 of file IgModuleCache.cc.

References ASSERT, lat::Filename::empty(), lat::indent(), LFplugin_manager, LOG, m, m_cache, m_directory, GsfMatrixTools::trace(), and lat::undent().

{
    LOG (0, trace, LFplugin_manager,
         "destroying module cache for `" << m_directory << "'\n" << lat::indent);
    ASSERT (! m_directory.empty ());
    for (ModuleIterator m = m_cache.begin (); m != m_cache.end (); ++m)
        delete *m;

    LOG (0, trace, LFplugin_manager, lat::undent);
}

---

Member Function Documentation

IgModuleCache::Iterator IgModuleCache::begin

(

void

)

const

Return an iterator to the first Module in the cache.

Definition at line 138 of file IgModuleCache.cc.

References m_modules.

{ return m_modules.begin (); }

lat::Filename IgModuleCache::directory

(

void

)

const

Return the module cache directory name.

Definition at line 133 of file IgModuleCache.cc.

References m_directory.

Referenced by IgDirectoryByName::operator()().

{ return m_directory; }

IgModuleCache::Iterator IgModuleCache::end

(

void

)

const

Return an iterator one past the last Module in the cache.

Definition at line 143 of file IgModuleCache.cc.

References m_modules.

Referenced by scanModules().

{ return m_modules.end (); }

void IgModuleCache::load

(

void

)

[protected]

Load the module cache file ".cache".

Attempts to load and rebuild the cache from the file. The cache is first set to CACHE_MISSING status and all m_state flags are cleared. If the file exists and can be parsed and reconstructed successfully, m_cache is set to the IgModule list and the cache status is set to CACHE_OLD. Otherwise m_cache is left untouched.

Definition at line 303 of file IgModuleCache.cc.

References IgModuleCache::CacheContext::added, CACHE_MISSING, CACHE_OLD, IgModuleCache::CacheContext::changed, lat::indent(), LFplugin_manager, LOG, m, m_cache, m_directory, m_parse, m_state, parse(), IgModuleCache::CacheContext::removed, IgModuleCache::ParseContext::result, s_cacheFile, IgModuleCache::CacheContext::skipped, IgModuleCache::CacheContext::status, GsfMatrixTools::trace(), and lat::undent().

Referenced by refresh().

{
    LOG (0, trace, LFplugin_manager, "loading cache "
         << lat::Filename (m_directory, s_cacheFile) << '\n' << lat::indent);

    m_state.status = CACHE_MISSING;
    m_state.added  = m_state.removed
                   = m_state.changed
                   = m_state.skipped
                   = false;

    if (parse (s_cacheFile))
    {
        m_state.status = CACHE_OLD;

        // Clear the cache before adding to it (in case we already
        // have something, i.e. refresh() was already invoked).
        for (ModuleIterator m = m_cache.begin (); m != m_cache.end (); ++m)
            delete *m;

        m_cache.clear ();
        m_cache.splice (m_cache.end (), m_parse.result);
    }

    LOG (0, trace, LFplugin_manager, lat::undent << "done\n");
}

IgModuleDescriptor * IgModuleCache::makeBad	(	const std::string &	file,
		const std::string &	time
	)			[static, private]

Construct a module descriptor for a bad file with timestamp time.

Definition at line 332 of file IgModuleCache.cc.

References IgPluginManager::ErrorBadCacheFile, IgPluginManager::feedback(), IgPluginManager::get(), s_cacheTag, and IgModule::tag().

{
    IgPluginManager::get ()->feedback (IgPluginManager::ErrorBadCacheFile, file);
    IgModuleDescriptor *top = new IgModuleDescriptor (0, s_cacheTag);
    new IgModuleDescriptor (top, IgModule::tag (), file, time, "bad");
    return top;
}

IgPluginManager* IgModuleCache::manager

(

void

)

const

void IgModuleCache::notify

(

void

)

[protected]

Update m_modules from the current state of the cache (m_cache).

Definition at line 509 of file IgModuleCache.cc.

References lat::indent(), LFplugin_manager, LOG, m, m_cache, m_modules, GsfMatrixTools::trace(), and lat::undent().

Referenced by refresh().

{
    LOG (0, trace, LFplugin_manager, "collecting modules\n" << lat::indent);
    for (ModuleIterator m = m_cache.begin (); m != m_cache.end (); ++m)
        if (! (*m)->bad ()) m_modules.push_back (*m);
    LOG (0, trace, LFplugin_manager, lat::undent);
}

bool IgModuleCache::parse	(	const lat::Filename &	file,
		IgModuleDescriptor *	root = 0
	)			[private]

Parse a module cache file (".cache" or one of the "*.reg" files).

This both reads the file and reconstructs its contents as children of root; the descriptor tree is destroyed before the method returns. If reading in ".cache", root should be null, if reading in a single registration it should be contain the initial cache structure, otherwise reconstruct will fail. The reconstructed cache will be put into m_parse.result. Returns true if the cache was successfully read and reconstructed, false otherwise.

Definition at line 167 of file IgModuleCache.cc.

References IgModuleDescriptor::addToken(), ASSERT, IgModuleDescriptor::child(), IgModuleDescriptor::children(), decode(), doc, e, error, IgPluginManager::ErrorBadCacheFile, HLT_VtxMuL3::errors, lat::Error::explain(), f, IgPluginManager::feedback(), EgammaValidation_cff::filename, level, LFplugin_manager, LOG, m, m_directory, m_manager, m_parse, IgModuleCache::ParseContext::module, offset, IgPluginManager::Other, reconstruct(), IgModuleCache::ParseContext::result, IgModuleDescriptor::tokens(), and GsfMatrixTools::trace().

Referenced by load().

{
    // FIXME: Use platform independent facilities for all file stuff (actually, registry)
    struct stat         statbuf;
    lat::Filename       filename (m_directory, file);
    bool                errors = false;
    IgModuleDescriptor  *regdata = root;

    if (::stat (filename, &statbuf) == -1)
    {
        delete regdata;
        return true;
    }

    LOG (0, trace, LFplugin_manager, "parsing file: " << file << "\n");

    ASSERT (m_parse.result.empty ());
    ASSERT (! m_parse.module);

    // Parse the registry file
    try {
        // FIXME: use an object so we don't need to fclose() it.
        FILE *f = fopen (filename, "r");
        if (! f)
            throw IgPluginError (new IgPluginParserError ("can't read the file"));

        typedef std::vector<IgModuleDescriptor *> ContextStack;
        ContextStack    stack;
        int             offset = 0;
        int             ch;

        // Bias the stack in case we were give a root preamble.  In
        // that case we simply descend as far as we can into the first
        // children of the preamble, and insert parse results there.
        // `regdata' is assinged
        while (root)
        {
            ++offset;
            stack.push_back (root);
            root = root->children () ? root->child (0) : 0;
        }

        // Process the file
        do {
            std::string token;
            int         level = offset;

            while ((ch = fgetc (f)) != EOF && ch == ' ')
                ++level;

            if (ch == EOF)
                break;

            if (level == 0 && regdata)
            {
                fclose (f);
                throw IgPluginError (new IgPluginParserError ("duplicate top level line"));
            }

            stack.resize (level+1);
            IgModuleDescriptor *doc
                = new IgModuleDescriptor (level ? stack [level-1] : 0);
            stack [level] = doc;
            if (level == 0)
                regdata = doc;

            for ( ; ch != EOF; ch = fgetc (f))
                if (ch == '\n')
                {
                    if (! token.empty ())
                        doc->addToken (decode (token));

                    if (doc->tokens () == 0)
                    {
                        fclose (f);
                        throw IgPluginError (new IgPluginParserError ("empty line"));
                    }

                    break;
                }
                else if (ch == ' ')
                {
                    if (! token.empty ())
                        doc->addToken (decode (token));
                    token = "";
                }
                else
                    token += ch;
        } while (ch != EOF);

        fclose (f);
        reconstruct (regdata);

        ASSERT (! m_parse.module);
    } catch (lat::Error &e) {
        m_manager->feedback (IgPluginManager::ErrorBadCacheFile, file, &e);

        // FIXME: Notify owner
        LOG (0, error, LFplugin_manager,
             file << ": error, file ignored (" << e.explain() << ")\n");

        errors = true;
    } catch (...) {
        m_manager->feedback (IgPluginManager::Other, file);

        // FIXME: Notify owner
        LOG (0, error, LFplugin_manager,
             file << ": unknown error, file ignored\n");

        errors = true;
    }

    delete regdata;

    if (errors)
    {
        delete m_parse.module;
        m_parse.module = 0;

        for (ModuleIterator m = m_parse.result.begin ();
             m != m_parse.result.end (); ++m)
            delete *m;

        m_parse.result.clear ();
    }

    return !errors;
}

void IgModuleCache::rebuild

(

void

)

[protected]

Rebuild the cache comparing it to the actual directory contents.

Assumes any existing cache is already loaded. Scans the directory contents and compares with the cache, updating it to the new state of things. Updates m_state to reflect what happened.

Definition at line 483 of file IgModuleCache.cc.

References IgModuleCache::CacheContext::added, IgModuleCache::CacheContext::changed, lat::indent(), LFplugin_manager, LOG, m, m_cache, m_directory, m_state, IgModuleCache::CacheContext::removed, scanModules(), IgModuleCache::CacheContext::skipped, IgModuleCache::CacheContext::status, GsfMatrixTools::trace(), and lat::undent().

Referenced by refresh().

{
    LOG (0, trace, LFplugin_manager,
         "rebuilding cache in `" << m_directory << "'\n" << lat::indent);

    // Build a new cache and stealing bits from the old one as the new
    // one is rebuilt.  Then replace the cache with the new one and
    // delete whatever was left over from the old cache (creating the
    // new one may steal bits of the old).
    ModuleList cache;
    m_state.status = scanModules (cache);
    m_cache.swap (cache);
    for (ModuleIterator m = cache.begin (); m != cache.end (); ++m)
        delete *m;

    LOG (0, trace, LFplugin_manager,
         lat::undent << "done (" << (int) m_state.status
         << ", added = " << m_state.added
         << ", removed = " << m_state.removed
         << ", changed = " << m_state.changed
         << ", skipped = " << m_state.skipped
         << ")\n");
}

void IgModuleCache::reconstruct

(

IgModuleDescriptor *

info

)

[private]

Validate and reconstruct descriptor proxies from info.

Definition at line 589 of file IgModuleCache.cc.

References ASSERT, IgModuleDescriptor::child(), IgModuleDescriptor::children(), i, LFplugin_manager, LOG, m_directory, m_manager, m_parse, IgModuleCache::ParseContext::module, IgModuleDescriptor::parent(), IgModule::restore(), IgModuleCache::ParseContext::result, s_cacheTag, IgModule::tag(), IgModuleDescriptor::token(), IgModuleDescriptor::tokens(), and GsfMatrixTools::trace().

Referenced by parse(), and scanModules().

{
    // Protect against random junk, e.g. empty files
    if (! info || ! info->tokens ())
        throw IgPluginError (new IgPluginParserError ("empty descriptor"));

    // Make sure the root is either a cache...
    if (info->token (0) == s_cacheTag)
    {
        if (info->tokens () != 1)
            throw IgPluginError (new IgPluginParserError
                                 ("`cache' does not take arguments"));
        else if (info->parent ())
            throw IgPluginError (new IgPluginParserError
                                 ("`cache' must be at the root"));

        for (unsigned i = 0; i < info->children (); ++i)
            reconstruct (info->child (i));

        ASSERT (! m_parse.module);
    }
    // ... or a module itself
    else if (info->token (0) == IgModule::tag ())
    {
        if (info->tokens () != 4)
            throw IgPluginError (new IgPluginParserError
                                 ("`module' must have three arguments"));
        if (! info->parent () || info->parent ()->token (0) != s_cacheTag)
            throw IgPluginError (new IgPluginParserError
                                 ("`module' must be under `cache'"));
        if (info->token (3) != "good" && info->token (3) != "bad")
            throw IgPluginError (new IgPluginParserError
                                 ("`module' last argument must be"
                                  " 'good' or 'bad'"));

        ASSERT (! m_parse.module);
        m_parse.module = new IgModule (m_manager,
                                       lat::Filename (m_directory, info->token (1)),
                                       info->token (2),
                                       info->token (3));

        for (unsigned i = 0; i < info->children (); ++i)
            reconstruct (info->child (i));

        ASSERT (m_parse.module);
        m_parse.result.push_back (m_parse.module);
        m_parse.module = 0;
    }
    // ... or junk we don't understand
    else
    {
        if (! m_parse.module)
            throw IgPluginError (new IgPluginParserError
                                 (info->token (0) + " unexpected"));

        if (info->tokens () >= 2)
            LOG (0, trace, LFplugin_manager, "processing "
                 << info->token(0) << ' ' << info->token(1) << '\n');

        m_parse.module->restore (info);
    }
}

void IgModuleCache::refresh

(

void

)

Refresh the module cache.

This causes the old ".cache" file to be loaded and to be compared with the current state of the directory. If there are any differences, a new cache will be written out.

Definition at line 150 of file IgModuleCache.cc.

References load(), notify(), rebuild(), and update().

Referenced by IgModuleCache().

{
    load ();
    rebuild ();
    notify ();
    update ();
}

IgModuleCache::CacheStatus IgModuleCache::scanModules

(

ModuleList &

cache

)

[private]

Actually scan the module directory, compare it with the current m_cache, and build a new cache that reflects the changes.

Returns a cache status code to reflect the new state.

Definition at line 344 of file IgModuleCache.cc.

References IgModuleCache::CacheContext::added, ASSERT, CACHE_MISSING, CACHE_OLD, CACHE_VALID, IgModuleCache::CacheContext::changed, e, end(), error, IgPluginManager::ErrorBadModule, lat::Error::explain(), IgPluginManager::feedback(), file, FileByName, EgammaValidation_cff::filename, lat::indent(), LFplugin_manager, LOG, m, m_cache, m_directory, m_manager, m_parse, m_state, edm::match(), IgModuleCache::ParseContext::module, reconstruct(), IgModuleCache::CacheContext::removed, HLT_VtxMuL3::result, IgModuleCache::ParseContext::result, s_cacheFile, s_cacheTag, IgModuleCache::CacheContext::skipped, StDecayID::status, IgModule::tag(), GsfMatrixTools::trace(), and lat::undent().

Referenced by rebuild().

{
    LOG (0, trace, LFplugin_manager,
         "scanning `" << m_directory << "'\n" << lat::indent);

    CacheStatus         result = CACHE_MISSING;
    lat::DirIterator    file (m_directory);
    lat::DirIterator    end;

    ASSERT (cache.empty ());
    for (; file != end; ++file)
    {
        // Ignore the cache file.
        if (*file == s_cacheFile)
            continue;

        // Check, read and validate the module definition file.
        // FIXME: Use platform-independent facilities!
        struct stat     statbuf;
        lat::Filename   filename (m_directory, *file);
        if (filename.extension () != "iglet")
            continue;

        // Ignore files we cannot stat
        int status = stat (filename, &statbuf);
        if (status == -1)
        {
            LOG (0, error, LFplugin_manager,
                 "stat() failed with error " << errno << ", ignoring `"
                 << *file << "'\n");
            m_state.skipped = true;
            continue;
        }

        // Check whether the module reg fragment has changed by
        // comparing the file and cached timestamps.
        ModuleIterator match
            = std::find_if (m_cache.begin(), m_cache.end(),
                            FileByName (*file));

        if (match == m_cache.end ())
        {
            LOG (0, trace, LFplugin_manager,
                 "==> new module definition `" << *file << "'\n");
            m_state.added = true;
        }
        else if ((*match)->time () != (unsigned long) statbuf.st_mtime)
        {
            LOG (0, trace, LFplugin_manager,
                 "==> modified module definition `" << *file << "' (file is "
                 << statbuf.st_mtime << ", cached was " << (*match)->time ()
                 << ")\n");
            m_state.changed = true;
        }
        else
        {
            // Copy the old cache to the new cache.  This relies on
            // the knowledge that the old cache will be thrown away
            // and so it is ok to steal the entry from the old one to
            // the new one.
            LOG (0, trace, LFplugin_manager,
                 "==> unchanged definition `" << *file << "'\n");
            cache.splice (cache.end (), m_cache, match);
            continue;
        }

        // Construct a fake registry document root for this file
        std::string time = lat::StringFormat ("%1").arg (statbuf.st_mtime);
        IgModuleDescriptor *top = new IgModuleDescriptor (0, s_cacheTag);
        new IgModuleDescriptor (top, IgModule::tag (), *file, time, "good");
        ASSERT (m_parse.result.empty ());
        ASSERT (! m_parse.module);
        reconstruct (top);
        ASSERT (! m_parse.module);

        // Try loading the modules to check that they are well-formed:
        // ensure that each module loads and resolves the required
        // entry points.  If this fails, mark the whole registration
        // file bad so that it will be ignored until the time-stamp
        // changes.  This leaves the cache always in valid state,
        // remembering anything bad.
        ASSERT (m_parse.result.size () == 1);
        for (ModuleIterator m = m_parse.result.begin () ; m != m_parse.result.end (); ++m)
            try
            {
                (*m)->load (); // checks for entry points
                (*m)->query ();
                (*m)->unload ();
            }
            catch (lat::Error &e)
            {
                m_manager->feedback (IgPluginManager::ErrorBadModule,
                                     (*m)->libraryName (), &e);

                // FIXME: Notify to owner
                LOG (0, error, LFplugin_manager,
                     *file << ": bad module library `"
                     << (*m)->libraryName ()
                     << "', module ignored\n (error was: "
                     << e.explain () << ")\n");
                m_state.skipped = true;
                (*m)->bad (true);
                break;
            }

        // Transfer into cache.
        cache.splice (cache.end (), m_parse.result);
    }

    // See if cache contains info on removed modules.
    for (ModuleIterator m = m_cache.begin (); m != m_cache.end (); ++m)
        if (std::find_if (cache.begin (), cache.end (),
                          FileByName ((*m)->libraryName ().nondirectory ()))
            == cache.end ())
        {
            LOG (0, trace, LFplugin_manager,
                 "==> removed module `" << (*m)->libraryName () << "'\n");
            m_state.removed = true;
        }

    // Update status codes.  Note that CACHE_VALID means .cache is
    // valid, CACHE_OLD means it needs updating.  If directory was
    // empty, mark the cache valid so we don't try to create one.
    result = (m_state.added
              || m_state.removed
              || m_state.changed
              || m_state.skipped)
              ? CACHE_OLD : CACHE_VALID;

    LOG (0, trace, LFplugin_manager,
         lat::undent << "done (" << (int) result << ")\n");
    return result;
}

void IgModuleCache::update

(

void

)

[protected]

Update the ".cache" file on the disk if it is writable.

Definition at line 538 of file IgModuleCache.cc.

References python::cmstools::all(), CACHE_VALID, data, error, file, EgammaValidation_cff::filename, lat::indent(), LFplugin_manager, LOG, m, m_cache, m_directory, m_state, s_cacheFile, s_cacheTag, IgModuleCache::CacheContext::status, GsfMatrixTools::trace(), lat::undent(), and write().

Referenced by refresh().

{
    if (m_state.status == CACHE_VALID)
        return;

    // Regenerate cache file from information we have in memory
    LOG (0, trace, LFplugin_manager,
         "updating cache in `" << m_directory << "'\n" << lat::indent);

    // Build a descriptor tree and dump it out
    IgModuleDescriptor *all = new IgModuleDescriptor (0, s_cacheTag);
    for (ModuleIterator m = m_cache.begin (); m != m_cache.end (); ++m)
        (*m)->cache (all);

    std::ostringstream buf;
    write (buf, all);
    delete all;

    lat::Filename filename (m_directory, s_cacheFile);
    FILE          *file = STDC::fopen (filename, "wb");

    if (! file)
    {
        LOG (0, error, LFplugin_manager,
             filename << ": error " << errno << ", unable to open the cache"
             " for writing -- cache not updated\n" << lat::undent);
        return;
    }

    std::string data (buf.str ());
    if (STDC::fwrite (data.c_str (), 1, data.size (), file) != data.size ())
    {
        LOG (0, error, LFplugin_manager,
             filename << ": error " << errno << " while writing cache out"
             " -- forcing file truncation\n");

        file = STDC::freopen (filename, "wb", file);
    }
    else
        m_state.status = CACHE_VALID;

    STDC::fclose (file);

    LOG (0, trace, LFplugin_manager, lat::undent << "done\n");
}

void IgModuleCache::write	(	std::ostream &	s,
		IgModuleDescriptor *	doc,
		int	level = 0
	)			[private]

Dump the module descriptor doc and all it's children into the stream s.

Output should happen at nesting level; omit this argument on the first call, it is meant to be used only in the internal implementation.

Definition at line 525 of file IgModuleCache.cc.

References IgModuleDescriptor::child(), IgModuleDescriptor::children(), encode(), lat::endl(), i, IgModuleDescriptor::token(), and IgModuleDescriptor::tokens().

Referenced by update().

{
    s << std::string (level, ' ') << encode (doc->token (0));
    for (unsigned i = 1; i < doc->tokens (); ++i)
        s << ' ' << encode (doc->token (i));
    s << std::endl;

    for (unsigned i = 0; i < doc->children (); ++i)
        write (s, doc->child (i), level+1);
}

---

Friends And Related Function Documentation

friend struct CacheContext [friend]

Definition at line 102 of file IgModuleCache.h.

friend class FileByName [friend]

Definition at line 106 of file IgModuleCache.h.

Referenced by scanModules().

friend struct ParseContext [friend]

Definition at line 105 of file IgModuleCache.h.

---

Member Data Documentation

ModuleList IgModuleCache::m_cache [private]

Definition at line 144 of file IgModuleCache.h.

Referenced by load(), notify(), rebuild(), scanModules(), update(), and ~IgModuleCache().

lat::Filename IgModuleCache::m_directory [private]

Definition at line 143 of file IgModuleCache.h.

Referenced by directory(), IgModuleCache(), load(), parse(), rebuild(), reconstruct(), scanModules(), update(), and ~IgModuleCache().

IgPluginManager* IgModuleCache::m_manager [private]

Definition at line 142 of file IgModuleCache.h.

Referenced by parse(), reconstruct(), and scanModules().

ModuleList IgModuleCache::m_modules [private]

Definition at line 147 of file IgModuleCache.h.

Referenced by begin(), end(), and notify().

ParseContext IgModuleCache::m_parse [private]

Definition at line 146 of file IgModuleCache.h.

Referenced by IgModuleCache(), load(), parse(), reconstruct(), and scanModules().

CacheContext IgModuleCache::m_state [private]

Definition at line 145 of file IgModuleCache.h.

Referenced by IgModuleCache(), load(), rebuild(), scanModules(), and update().

const char IgModuleCache::s_cacheFile = ".iglets" [static, private]

Definition at line 149 of file IgModuleCache.h.

Referenced by load(), scanModules(), and update().

const char IgModuleCache::s_cacheTag = "cache" [static, private]

Definition at line 150 of file IgModuleCache.h.

Referenced by makeBad(), reconstruct(), scanModules(), and update().

const char IgModuleCache::s_fileTag[] [static, private]

Definition at line 151 of file IgModuleCache.h.

const char IgModuleCache::s_moduleTag[] [static, private]

Definition at line 152 of file IgModuleCache.h.

---

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

• Iguana/Framework/interface/IgModuleCache.h
• Iguana/Framework/src/IgModuleCache.cc

---