URLCache Struct Reference

#include <URLCache.h>

Overview

A cache for HTTP responses.

Definition at line 44 of file URLCache.h.

Inheritance diagram for URLCache:

Properties
size_t	currentSize
	The current cached body size.
Lock *	lock
	The lock protecting this cache.
size_t	maxSize
	The maximum cached body size.
Object	object
	The superclass.
Dictionary *	responses
	The cached responses, keyed by URLRequest.
Properties inherited from Object
Class *	clazz
	Every instance of Object begins with a pointer to its Class.
unsigned int	magic
	A header to allow introspection of Object types.

Methods
Class *	_URLCache (void)
	The URLCache archetype.
URLCachedResponse *	cachedResponseForRequest (URLCache *self, const URLRequest *request)
	Returns the cached response for the given request.
URLCache *	init (URLCache *self)
	Initializes this URLCache.
void	removeAllCachedResponses (URLCache *self)
	Removes all cached responses.
void	removeCachedResponseForRequest (URLCache *self, const URLRequest *request)
	Removes the cached response for the given request.
void	setMaxSize (URLCache *self, size_t maxSize)
	Sets the maximum cached body size.
void	storeCachedResponseForRequest (URLCache *self, const URLRequest *request, const URLResponse *response, const Data *data)
	Stores a cached response for the given request.
Methods inherited from Object
Class *	_Object (void)
	The Object archetype.
Object *	copy (const Object *self)
	Creates a shallow copy of this Object.
void	dealloc (Object *self)
	Frees all resources held by this Object.
String *	description (const Object *self)
int	hash (const Object *self)
Object *	init (Object *self)
	Initializes this Object.
bool	isEqual (const Object *self, const Object *other)
	Tests equality of the other Object.
bool	isKindOfClass (const Object *self, const Class *clazz)
	Tests for Class hierarchy membership.

Protected Attributes
URLCacheInterface *	interface
	The interface.
Protected Attributes inherited from Object
ObjectInterface *	interface
	The interface.

Property Details

currentSize

size_t URLCache::currentSize

The current cached body size.

Definition at line 70 of file URLCache.h.

interface

URLCacheInterface* URLCache::interface

protected

The interface.

Definition at line 55 of file URLCache.h.

lock

Lock* URLCache::lock

The lock protecting this cache.

Definition at line 60 of file URLCache.h.

maxSize

size_t URLCache::maxSize

The maximum cached body size.

Definition at line 75 of file URLCache.h.

object

Object URLCache::object

The superclass.

Definition at line 49 of file URLCache.h.

responses

Dictionary* URLCache::responses

The cached responses, keyed by URLRequest.

Definition at line 65 of file URLCache.h.

Method Details

_URLCache()

Class * _URLCache

(

void

)

The URLCache archetype.

Returns

The URLCache Class.

Definition at line 411 of file URLCache.c.

                       {
  static Class *clazz;
  static Once once;
 
  do_once(&once, {
    clazz = _initialize(&(const ClassDef) {
      .name = "URLCache",
      .superclass = _Object(),
      .instanceSize = sizeof(URLCache),
      .interfaceOffset = offsetof(URLCache, interface),
      .interfaceSize = sizeof(URLCacheInterface),
      .initialize = initialize,
    });
  });
 
  return clazz;
}

cachedResponseForRequest()

URLCachedResponse * cachedResponseForRequest	(	URLCache *	self,
		const URLRequest *	request
	)

Returns the cached response for the given request.

Parameters

self	The URLCache.
request	The URLRequest.

Returns

The cached response, retained, or NULL if none is cached.

Definition at line 268 of file URLCache.c.

                                                                                              {
 
  if (requestIsCacheable(request) == false) {
    return NULL;
  }
 
  URLCachedResponse *cachedResponse = NULL;
  const Dictionary *dictionary = (Dictionary *) self->responses;
  synchronized(self->lock, {
    cachedResponse = $(dictionary, objectForKey, (ident) request);
    if (cachedResponse) {
      retain(cachedResponse);
    }
  });
 
  return cachedResponse;
}

init()

URLCache * init

(

URLCache *

self

)

Initializes this URLCache.

Parameters

self	The URLCache.

Returns

The initialized URLCache, or NULL on error.

Definition at line 290 of file URLCache.c.

                                      {
 
  self = (URLCache *) super(Object, self, init);
  if (self) {
    self->lock = $(alloc(Lock), init);
    assert(self->lock);
 
    self->responses = $(alloc(Dictionary), init);
    assert(self->responses);
 
    self->maxSize = URLCACHE_DEFAULT_MAX_SIZE;
  }
 
  return self;
}

removeAllCachedResponses()

void removeAllCachedResponses

(

URLCache *

self

)

Removes all cached responses.

Parameters

self	The URLCache.

Definition at line 310 of file URLCache.c.

                                                     {
 
  synchronized(self->lock, {
    $(self->responses, removeAllObjects);
    self->currentSize = 0;
  });
}

removeCachedResponseForRequest()

void removeCachedResponseForRequest	(	URLCache *	self,
		const URLRequest *	request
	)

Removes the cached response for the given request.

Parameters

self	The URLCache.
request	The URLRequest.

Definition at line 322 of file URLCache.c.

                                                                                      {
 
  synchronized(self->lock, {
    const Dictionary *dictionary = (Dictionary *) self->responses;
    URLCachedResponse *cachedResponse = $(dictionary, objectForKey, (ident) request);
    if (cachedResponse) {
      self->currentSize -= cachedResponse->size;
      $(self->responses, removeObjectForKey, (ident) request);
    }
  });
}

setMaxSize()

void setMaxSize	(	URLCache *	self,
		size_t	maxSize
	)

Sets the maximum cached body size.

Parameters

self	The URLCache.
maxSize	The maximum cache size.

Definition at line 338 of file URLCache.c.

                                                       {
 
  synchronized(self->lock, {
    self->maxSize = maxSize;
 
    if (self->maxSize == 0) {
      $(self->responses, removeAllObjects);
      self->currentSize = 0;
    } else {
      evictIfNeeded(self);
    }
  });
}

storeCachedResponseForRequest()

void storeCachedResponseForRequest	(	URLCache *	self,
		const URLRequest *	request,
		const URLResponse *	response,
		const Data *	data
	)

Stores a cached response for the given request.

Parameters

self	The URLCache.
request	The URLRequest.
response	The HTTP response.
data	The response body.

Definition at line 356 of file URLCache.c.

                                                   {
 
  if (requestIsCacheable(request) == false || responseIsCacheable(response) == false) {
    return;
  }
 
  URLCachedResponse *cachedResponse = $(alloc(URLCachedResponse), initWithResponseData, response, data);
  if (cachedResponse == NULL) {
    return;
  }
 
  synchronized(self->lock, {
    if (cachedResponse->size <= self->maxSize && self->maxSize > 0) {
 
      const Dictionary *dictionary = (Dictionary *) self->responses;
      URLCachedResponse *existing = $(dictionary, objectForKey, (ident) request);
      if (existing) {
        self->currentSize -= existing->size;
        $(self->responses, removeObjectForKey, (ident) request);
      }
 
      URLRequest *key = (URLRequest *) $((Object *) request, copy);
      $(self->responses, setObjectForKey, cachedResponse, key);
      release(key);
 
      self->currentSize += cachedResponse->size;
      evictIfNeeded(self);
    }
  });
 
  release(cachedResponse);
}

---

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

• Sources/Objectively/URLCache.h
• Sources/Objectively/URLCache.c