cache_interface.h

Go to the documentation of this file.

/*
 * Copyright 2010 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http:///www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */


#ifndef PAGESPEED_KERNEL_BASE_CACHE_INTERFACE_H_
#define PAGESPEED_KERNEL_BASE_CACHE_INTERFACE_H_

#include <vector>

#include "base/logging.h"
#include "pagespeed/kernel/base/basictypes.h"
#include "pagespeed/kernel/base/string.h"
#include "pagespeed/kernel/base/shared_string.h"

namespace net_instaweb {

class CacheInterface {
 public:
  enum KeyState {
    kAvailable = 0,     
    kNotFound = 1,      
    kOverload = 2,      
    kNetworkError = 3,  
    kTimeout = 4,       
  };

  class Callback {
   public:
    virtual ~Callback();
    void set_value(const SharedString& value) { value_ = value; }
    const SharedString& value() const { return value_; }

    bool DelegatedValidateCandidate(const GoogleString& key, KeyState state) {
      return ValidateCandidate(key, state);
    }

    void DelegatedDone(KeyState state) {
      Done(state);
    }

   protected:
    friend class CacheInterface;

    virtual bool ValidateCandidate(const GoogleString& key,
                                   KeyState state) { return true; }

    virtual void Done(KeyState state) = 0;

   private:
    SharedString value_;
  };

  class SynchronousCallback : public Callback {
   public:
    SynchronousCallback() { Reset(); }

    bool called() const { return called_; }
    KeyState state() const { return state_; }

    void Reset() {
      called_ = false;
      state_ = CacheInterface::kNotFound;
      SharedString empty;
      set_value(empty);
    }

    virtual void Done(CacheInterface::KeyState state) {
      called_ = true;
      state_ = state;
    }

   private:
    bool called_;
    CacheInterface::KeyState state_;

    
  };

  struct KeyCallback {
    KeyCallback(const GoogleString& k, Callback* c) : key(k), callback(c) {}
    GoogleString key;
    Callback* callback;
  };
  typedef std::vector<KeyCallback> MultiGetRequest;

  static const char* KeyStateName(KeyState state);

  CacheInterface();
  virtual ~CacheInterface();

  virtual void Get(const GoogleString& key, Callback* callback) = 0;

  virtual void MultiGet(MultiGetRequest* request);

  virtual void Put(const GoogleString& key, const SharedString& value) = 0;
  virtual void Delete(const GoogleString& key) = 0;

  void PutSwappingString(const GoogleString& key, GoogleString* value) {
    SharedString shared_string;
    shared_string.SwapWithString(value);
    Put(key, shared_string);
  }

  virtual GoogleString Name() const = 0;

  virtual CacheInterface* Backend();

  virtual bool IsBlocking() const = 0;

  virtual bool IsHealthy() const = 0;

  virtual void ShutDown() = 0;

  virtual bool MustEncodeKeyInValueOnPut() const { return false; }

  virtual void PutWithKeyInValue(const GoogleString& key,
                                 const SharedString& key_and_value) {
    CHECK(false);
  }

 protected:
  void ValidateAndReportResult(const GoogleString& key, KeyState state,
                               Callback* callback);

  void ReportMultiGetNotFound(MultiGetRequest* request);
};

}  

#endif