CacheManager.cs

using System;
using System.Text;
using System.Collections;
using System.Collections.Specialized;

namespace Common
{
        public class CacheManager {
                protected Cache cache; // the underlying cache
                protected long cacheSize; // size of the underlying cache;
                public URIMapper uriMapper; // contains all of the URI <-> CHK mappings, along with the response headers to issue.
                protected Object SyncRoot; // synchronisation root





                public CacheManager(long cacheSize) {
                        this.cacheSize = cacheSize;
                        cache = new Cache(cacheSize, this);
                        uriMapper = new URIMapper();
                        SyncRoot = new Object();
                }









                public bool CanService(HTTPRequest request) {
                        return (uriMapper.Contains(request.URI));
                }

                public HTTPResponse Get(HTTPRequest request) {
                        lock (SyncRoot) {
                                // we're assuming here that the we do have a URI entry here.
                                HTTPResponse result = null;
                                HTTPBody resultBody = null;
                                lock (uriMapper.SyncRoot) {
                                        URIMappingEntry mappingEntry = (URIMappingEntry)uriMapper[request.URI];
                                        // only get the body if there is one.
                                        if (mappingEntry.CHK != null) {
                                                resultBody = cache.Get(mappingEntry.CHK);
                                        } 
                                        HTTPResponseHeader resultHeader = new HTTPResponseHeader(mappingEntry.Headers);
                                        result = new HTTPResponse(resultHeader);
                                        if (resultBody != null) {
                                                result.AppendBody(resultBody);
                                        }
                                        // update URI <-> CHK mapper LRU information (Do this outside this method if you have to)
                                        //mappingEntry.Freshen();
                                }
                                return result;
                        }
                }

                public void UpdateURIMapping(Uri URI, byte[] chk, string headers) {
                        if (uriMapper.Contains(URI)) {
                                ((URIMappingEntry)uriMapper[URI]).Freshen(chk, headers);
                        } else {
                                uriMapper.Add(URI, new URIMappingEntry(URI, chk, headers));
                        }
                }

                public bool CacheContains(byte[] chk) {
                        return cache.Contains(chk);
                }

                public void UpdateCache(HTTPResponse response, Uri requestURI) {
                        if (response != null) {
                                lock (SyncRoot) {
                                        lock(uriMapper.SyncRoot) {
                                                // step 1: Add data to the cache. Put will noop if already there.
                                                byte[] responseChk = cache.Put(response.Body);
                                                UpdateURIMapping(requestURI, responseChk, response.Headers);
                                        }
                                }
                        }
                }

                public HTTPBody GetByChk(byte[] chk) {
                        return cache.Get(chk);
                }
                public static byte[] Patch(byte[] originalDocument, ArrayList changeHunks) {
                        /*      if (no more hunks) {
                         *              append remainder of source to destination
                         *      } else { // hunks remaining
                         *      identify 1st line in hunk (alpha 1, 2nd in range is alpha2)
                         *              copy everything from src up to (not including) src[alpha1] in hunk, to destination
                         *              switch (hunk.Type) {
                         *                      add: {
                         *                      copy line alpha1 from src
                         *                      append to destination the complete lines content of current hunk
                         *                      advance to line alpha1 + 1
                         *                      break;
                         *                      }
                         *                      change: {
                         *                      append to destination the entire line contents of current hunk
                         *                      advance to alpha2 + 1
                         *                      break;
                         *                      }
                         *                      delete: {
                         *                      advance to alpha2 + 1
                         *                      }
                         *              }
                         *      }
                         * */
                        Console.WriteLine("- Beginning Patch process");
                        string original = Encoding.ASCII.GetString(originalDocument);
                        StringCollection source = new StringCollection();
                        StringCollection target = new StringCollection();
                        StringBuilder result = new StringBuilder();
                        int currentSrcLine = 0;
                        IEnumerator hunkEnum = changeHunks.GetEnumerator();

                        source.AddRange(original.Split(new char[] {'\n'}));
                        
                        while(currentSrcLine < source.Count) {
                                if (!hunkEnum.MoveNext()) { // advances to next hunk. False if no more hunks
                                        while (currentSrcLine < source.Count) {
                                                target.Add(source[currentSrcLine] + '\n');
                                                currentSrcLine++;
                                        }
                                } else { // there are more hunks to process
                                        JLibDiff.Hunk currentHunk = (JLibDiff.Hunk)hunkEnum.Current;
                                        int firstLineSrc = currentHunk.lowLine(0) - 1;
                                        // advance until hunk begins to influence
                                        while (currentSrcLine < firstLineSrc) {
                                                target.Add(source[currentSrcLine] + '\n');
                                                currentSrcLine++;
                                        }
                                        switch(currentHunk.GetType().Name) {
                                                case "HunkAdd" : {
                                                        if (currentHunk.lowLine(0) != 0) {
                                                                target.Add(source[currentSrcLine]); // copy 1st line
                                                        }
                                                        for (int i = 0; i < currentHunk.numLines(1); i++) {
                                                                target.Add(currentHunk.relNum(1, i));
                                                        }
                                                        currentSrcLine++;
                                                        break; 
                                                }
                                                case "HunkChange": { 
                                                        for (int i = 0; i < currentHunk.numLines(1); i++) {
                                                                target.Add(currentHunk.relNum(1, i));
                                                        }
                                                        currentSrcLine = currentHunk.highLine(0); // +1 canceled by -1 for zero based counting
                                                        break; 
                                                }
                                                case "HunkDel" : { 
                                                        currentSrcLine = currentHunk.highLine(0); // +1 canceled by -1 for zero based counting
                                                        break; }
                                                default: { throw new Exception("Unknown Hunk type"); }
                                        } // end switch
                                } // end if then else
                        } // end while
                        
                        foreach (string s in target) {
                                result.Append(s);
                        }
                        Console.WriteLine("- Patch Process Complete");
                        return Encoding.ASCII.GetBytes(result.ToString());
                }

                public static ArrayList Diff(System.IO.Stream oldDocStream, System.IO.Stream newDocStream) {
                        JLibDiff.diff myDiff = new JLibDiff.diff();
                        myDiff.diffBuffer(new System.IO.StreamReader(oldDocStream), new System.IO.StreamReader(newDocStream));
                        myDiff.print();
                        return myDiff.getHunk();
                }
        }
}

---