Beesnest/DcFileCacher.cpp

Go to the documentation of this file.

/*
Copyright 2007 Erez Bibi (erezbibi@users.sourceforge.net)
This file is part of Beesnest.

Beesnest is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

Beesnest is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Beesnest; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*/


/**
 * DcFilecacher.cpp: implementation of the CdcFilecacher class.
 * for documentation see the header file.
 */

#include "DcFilecacher.h"


CdcFileCacher::CdcFileCacher ()
: nAccessCounter (0), isLimitThreadGo (true)
{ }

CdcFileCacher::~CdcFileCacher()
{
    /* Signal the limit thread to exit. */
    if (nCacheLimit > 0)
    {
        isLimitThreadGo = false;
        oStartThread.Call ();
        while (oThread.IsStillActive ()) Sleep (1);
    }
}

void CdcFileCacher::Init ()
{
    nCacheLimit = CdcParameters::ToInt (CdcParameters::GetParam
        ("Server->Cache-Limit"));

    /* Create the limiter thread. */
    if (nCacheLimit > 0)
    {
        oThread.MakeThread (DcLimit, (void*) this);
        oThread.SetPriority (DC_TP_LOW);
    }
}


bool CdcFileCacher::GetFile (const CdcString& name, const CdcHttpTime& time,
                             CdcBuffer& data)
{
    if (nCacheLimit <= 0) return false;
    CdcFile* pfile = NULL;
    pfile = oMap [name];
    if (pfile != NULL)
    {   /* If file is in the map - lock it. */
        pfile->oMutex.Lock ();
        /* If file was not modified. */
        int is_true = pfile->oModifiedTime == time;
        if (is_true != 0)
        {   /* Get the data and update access number. */
            data = pfile->aData;
            pfile->nAccessNumber = ++nAccessCounter;
        }
        pfile->oMutex.Unlock ();
        return is_true != 0;
    }
    return false;
}


bool CdcFileCacher::PutFile (const CdcString& name, const CdcHttpTime& time,
                             const CdcBuffer& data)
{
    if (nCacheLimit <= 0) return false;
    CdcFile* pfile = NULL;
    pfile = oMap [name];
    if (pfile != NULL)
    {   /* If file is already in map - lock it. */
        pfile->oMutex.Lock ();
        /* If new file modified after existing one. */
        int is_true = pfile->oModifiedTime < time;
        if (is_true != 0)
        {   /* Set new data, time and access counter. */
            pfile->aData = data;
            pfile->oModifiedTime = time;
            pfile->nAccessNumber = ++nAccessCounter;
        }
        pfile->oMutex.Unlock ();
        return is_true != 0;
    }
    else
    {   /* Create new file. */
        pfile = new CdcFile (name, time, data, ++nAccessCounter);
        if (pfile != NULL)
        {   /* Insert to map. */
            oMap [name] = pfile;
            /* Signal to the limiter thread. */
            oStartThread.Call ();
            return true;
        }
    }
    return false;
}


void CdcFileCacher::DeleteLast ()
{
    unsigned int min = nAccessCounter;
    CdcString name;
    CdcFile *pfile, *plast_file;
    /* Find the last accessed file in the map. */
    for (CdcFileCacher::t_file_map::const_iterator pos = oMap.begin ();
         pos != oMap.end (); ++pos)
    {
        pfile = (*pos).second;
        if (pfile == NULL) /* Some bug... */
            return;
        if (min >= pfile->nAccessNumber)
        {
            min = pfile->nAccessNumber;
            plast_file = pfile;
        }
    }
    /* Lock the file. */
    plast_file->oMutex.Lock ();
    /* If file was accessed since - unlock and return. */
    if (plast_file->nAccessNumber == min)
    {   /* Remove the file from map and delete it. */
        oMap.erase (plast_file->sFileName);
        delete plast_file;
    }
    else
        plast_file->oMutex.Unlock ();
}


int DcLimit (void* pParam)
{
    CdcFileCacher* pThis = (CdcFileCacher*)pParam;
    if (pThis == NULL) return 1;   /* if pParam is not valid. */

    while (pThis->isLimitThreadGo)
    {   /* Wait for event. */
        pThis->oStartThread.Wait ();
        if (pThis->isLimitThreadGo == false) return 0;
        /* If more file than the limit - delete the last one. */
        while (pThis->oMap.size () > pThis->nCacheLimit)
            pThis->DeleteLast ();
    }

    return 0;
}