libcore/include/sirikata/core/transfer/CacheLayer.hpp

Go to the documentation of this file.

/*  Sirikata Transfer -- Content Transfer management system
 *  CacheLayer.hpp
 *
 *  Copyright (c) 2008, Patrick Reiter Horn
 *  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are
 *  met:
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *  * Neither the name of Sirikata nor the names of its contributors may
 *    be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
 * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
/*  Created on: Dec 31, 2008 */

#ifndef SIRIKATA_CacheLayer_HPP__
#define SIRIKATA_CacheLayer_HPP__

#include "TransferData.hpp"
#include "URI.hpp"
#include "CachePolicy.hpp"


namespace Sirikata {
namespace Transfer {

typedef std::tr1::function<void(const SparseData*)> TransferCallback;

class CacheLayer : Noncopyable {
private:
    CacheLayer *mRespondTo;
    CacheLayer *mNext;

    friend class CacheMap;

    inline void setResponder(CacheLayer *other) {
        mRespondTo = other;
    }

protected:
    inline void populateParentCaches(const Fingerprint &fileId, const DenseDataPtr &data) {
        if (mRespondTo) {
            mRespondTo->populateCache(fileId, data);
        }
    }

    struct CacheEntry {
    };

    virtual void destroyCacheEntry(const Fingerprint &fileId, CacheEntry *cacheLayerData, cache_usize_type releaseSize) {
    }

    virtual void populateCache(const Fingerprint &fileId, const DenseDataPtr &data) {
        populateParentCaches(fileId, data);
    }

public:

    virtual ~CacheLayer() {
        if (mNext) {
            mNext->setResponder(NULL);
        }
    }

    CacheLayer(CacheLayer *tryNext)
            : mRespondTo(NULL), mNext(tryNext) {
        if (tryNext) {
            tryNext->setResponder(this);
        }
    }

    /* UNSAFE (for testing only)!
       Ensure you set this back to NULL before deallocating either CacheLayer.
    */
    void setRespondTo(CacheLayer *newRespond) {
        mRespondTo = newRespond;
    }

    void setNext(CacheLayer *newNext) {
        if (mNext) {
            mNext->setResponder(NULL);
        }
        mNext = newNext;
        if (mNext) {
            mNext->setResponder(this);
        }
    }

    CacheLayer *getNext() const {
        return mNext;
    }

    CacheLayer *getResponder() const {
        return mRespondTo;
    }

    void addToCache(const Fingerprint &fileId, const DenseDataPtr &data) {
        if (mNext) {
            mNext->addToCache(fileId, data);
        } else {
            populateCache(fileId, data);
        }
    }

    virtual void purgeFromCache(const Fingerprint &fileId) {
        if (mNext) {
            mNext->purgeFromCache(fileId);
        }
    }

    virtual void getData(const Fingerprint &fileId, const Range &requestedRange,
            const TransferCallback&callback) {
        if (mNext) {
            mNext->getData(fileId, requestedRange, callback);
        } else {
            // need some way to signal error
            callback(NULL);
        }
    }

};

}
}

#endif /* SIRIKATA_CacheLayer_HPP__ */