зеркало из https://github.com/mozilla/gecko-dev.git
346 строки
7.4 KiB
C++
346 строки
7.4 KiB
C++
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
|
|
*
|
|
* The contents of this file are subject to the Netscape Public License
|
|
* Version 1.0 (the "NPL"); you may not use this file except in
|
|
* compliance with the NPL. You may obtain a copy of the NPL at
|
|
* http://www.mozilla.org/NPL/
|
|
*
|
|
* Software distributed under the NPL is distributed on an "AS IS" basis,
|
|
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
|
|
* for the specific language governing rights and limitations under the
|
|
* NPL.
|
|
*
|
|
* The Initial Developer of this code under the NPL is Netscape
|
|
* Communications Corporation. Portions created by Netscape are
|
|
* Copyright (C) 1998 Netscape Communications Corporation. All Rights
|
|
* Reserved.
|
|
*/
|
|
|
|
/* nsCacheObject is the class that holds the basic definition of the
|
|
* cache object. A lot of changes are likely to occur before this
|
|
* goes on stage.
|
|
*
|
|
* -Gagan Saksena 09/15/98
|
|
*/
|
|
#ifndef nsCacheObject_h__
|
|
#define nsCacheObject_h__
|
|
|
|
#if 0
|
|
#include "nsISupports.h"
|
|
#endif
|
|
|
|
#include "prtypes.h"
|
|
#include "prinrval.h"
|
|
|
|
static const PRUint32 kCACHE_VERSION = 5;
|
|
|
|
class nsStream;
|
|
|
|
class nsCacheObject //: public nsISupports
|
|
{
|
|
|
|
public:
|
|
|
|
enum state_flags
|
|
{
|
|
INIT=0,
|
|
PARTIAL=1,
|
|
COMPLETE=2,
|
|
ABORTED=3,
|
|
EXPIRED=4,
|
|
CORRUPT=5
|
|
};
|
|
|
|
nsCacheObject();
|
|
nsCacheObject(const nsCacheObject& another);
|
|
nsCacheObject(const char* i_url);
|
|
|
|
virtual ~nsCacheObject();
|
|
|
|
/*
|
|
NS_IMETHOD QueryInterface(const nsIID& aIID,
|
|
void** aInstancePtr);
|
|
NS_IMETHOD_(nsrefcnt) AddRef(void);
|
|
NS_IMETHOD_(nsrefcnt) Release(void);
|
|
|
|
*/
|
|
|
|
void Address(const char* i_url);
|
|
const char* Address(void) const;
|
|
|
|
void Charset(const char* i_Charset);
|
|
const char* Charset(void) const;
|
|
|
|
void ContentEncoding(const char* i_Encoding);
|
|
const char* ContentEncoding(void) const;
|
|
|
|
void ContentLength(PRUint32 i_len);
|
|
PRUint32 ContentLength(void) const;
|
|
|
|
void ContentType(const char* i_Type);
|
|
const char* ContentType(void) const;
|
|
|
|
void Etag(const char* i_etag);
|
|
const char* Etag(void) const;
|
|
|
|
void Expires(PRIntervalTime i_Expires);
|
|
PRIntervalTime Expires(void) const;
|
|
|
|
void Filename(const char* i_Filename);
|
|
const char* Filename(void) const;
|
|
|
|
PRUint16 Hits(void) const;
|
|
|
|
/* Read and write info about this cache object */
|
|
void* Info(void) const;
|
|
PRBool Info(void* /*, PRUint32 len */);
|
|
|
|
PRUint32 InfoSize(void) const;
|
|
|
|
PRBool IsCompleted(void) const;
|
|
void IsCompleted(PRBool bComplete);
|
|
|
|
PRBool IsExpired(void) const;
|
|
|
|
PRBool IsPartial(void) const;
|
|
|
|
PRIntervalTime LastAccessed(void) const;
|
|
|
|
PRIntervalTime LastModified(void) const;
|
|
void LastModified(const PRIntervalTime i_lastModified);
|
|
|
|
PRInt16 Module(void) const;
|
|
void Module(PRUint16 i_m);
|
|
|
|
void PageServicesURL(const char* i_Url);
|
|
const char* PageServicesURL(void) const;
|
|
|
|
const char* PostData(void) const;
|
|
void PostData(const char* i_data, const PRUint32 i_Len);
|
|
|
|
PRUint32 PostDataLen(void) const;
|
|
|
|
PRUint32 Read(char* o_Buffer, PRUint32 len);
|
|
|
|
/* Reset the streams/state, read/write locks, etc. */
|
|
void Reset(void);
|
|
|
|
/* Accessor functions for the size of the cache object */
|
|
PRUint32 Size(void) const;
|
|
void Size(PRUint32 i_Size);
|
|
|
|
/* Accessor functions for the state of the cache object.
|
|
* Some states are changed internally.
|
|
*/
|
|
PRUint32 State(void) const;
|
|
void State(PRUint32 i_State);
|
|
|
|
nsStream* Stream(void) const;
|
|
|
|
const char* Trace() const;
|
|
|
|
PRUint32 Write(const char* i_Buffer, const PRUint32 len);
|
|
|
|
protected:
|
|
|
|
void Init();
|
|
|
|
char* m_Charset;
|
|
char* m_ContentEncoding;
|
|
PRUint32 m_ContentLength;
|
|
char* m_ContentType;
|
|
char* m_Etag;
|
|
PRIntervalTime m_Expires;
|
|
char* m_Filename;
|
|
PRUint16 m_Hits;
|
|
PRUint32 m_info_size;
|
|
PRBool m_bIsCompleted; /* Marked when the stream complete is called */
|
|
PRIntervalTime m_LastAccessed, m_LastModified;
|
|
void* m_pInfo;
|
|
char* m_PageServicesURL;
|
|
char* m_PostData;
|
|
PRUint32 m_PostDataLen;
|
|
PRInt16 m_Module;
|
|
PRUint32 m_Size;
|
|
PRUint32 m_State;
|
|
nsStream* m_pStream;
|
|
char* m_URL;
|
|
|
|
private:
|
|
nsCacheObject& operator=(const nsCacheObject& x);
|
|
};
|
|
|
|
inline
|
|
const char* nsCacheObject::Address(void) const
|
|
{
|
|
return m_URL;
|
|
};
|
|
|
|
inline
|
|
const char* nsCacheObject::Charset(void) const
|
|
{
|
|
return m_Charset;
|
|
}
|
|
|
|
inline
|
|
const char* nsCacheObject::ContentEncoding(void) const
|
|
{
|
|
return m_ContentEncoding;
|
|
}
|
|
|
|
inline
|
|
PRUint32 nsCacheObject::ContentLength(void) const
|
|
{
|
|
return m_ContentLength;
|
|
};
|
|
|
|
inline
|
|
void nsCacheObject::ContentLength(PRUint32 i_Size)
|
|
{
|
|
m_ContentLength = i_Size;
|
|
};
|
|
|
|
inline
|
|
const char* nsCacheObject::ContentType(void) const
|
|
{
|
|
return m_ContentType;
|
|
};
|
|
|
|
inline
|
|
const char* nsCacheObject::Etag(void) const
|
|
{
|
|
return m_Etag;
|
|
};
|
|
|
|
inline
|
|
PRIntervalTime nsCacheObject::Expires(void) const
|
|
{
|
|
return m_Expires;
|
|
};
|
|
|
|
inline
|
|
void nsCacheObject::Expires(PRIntervalTime i_Expires)
|
|
{
|
|
m_Expires = i_Expires;
|
|
};
|
|
|
|
inline
|
|
const char* nsCacheObject::Filename(void) const
|
|
{
|
|
return m_Filename;
|
|
}
|
|
|
|
inline
|
|
PRUint16 nsCacheObject::Hits(void) const
|
|
{
|
|
return m_Hits;
|
|
};
|
|
|
|
inline
|
|
PRBool nsCacheObject::IsCompleted(void) const
|
|
{
|
|
return m_bIsCompleted;
|
|
}
|
|
|
|
inline
|
|
void nsCacheObject::IsCompleted(PRBool bComplete)
|
|
{
|
|
m_bIsCompleted = bComplete;
|
|
}
|
|
|
|
inline
|
|
PRBool nsCacheObject::IsExpired(void) const
|
|
{
|
|
if (nsCacheObject::EXPIRED==m_State)
|
|
return PR_TRUE;
|
|
if (m_Expires <= PR_IntervalNow())
|
|
((nsCacheObject*)this)->m_State = nsCacheObject::EXPIRED;
|
|
return (nsCacheObject::EXPIRED==m_State);
|
|
};
|
|
|
|
inline
|
|
PRBool nsCacheObject::IsPartial(void) const
|
|
{
|
|
return (m_ContentLength != m_Size) ? PR_TRUE : PR_FALSE;
|
|
};
|
|
|
|
inline
|
|
PRIntervalTime nsCacheObject::LastAccessed(void) const
|
|
{
|
|
return m_LastAccessed;
|
|
};
|
|
|
|
inline
|
|
PRIntervalTime nsCacheObject::LastModified(void) const
|
|
{
|
|
return m_LastModified;
|
|
};
|
|
|
|
inline
|
|
void nsCacheObject::LastModified(const PRIntervalTime i_LastModified)
|
|
{
|
|
m_LastModified = i_LastModified;
|
|
};
|
|
|
|
inline
|
|
PRInt16 nsCacheObject::Module(void) const
|
|
{
|
|
return m_Module;
|
|
};
|
|
|
|
inline
|
|
void nsCacheObject::Module(PRUint16 i_Module)
|
|
{
|
|
m_Module = i_Module;
|
|
};
|
|
|
|
inline
|
|
const char* nsCacheObject::PageServicesURL(void) const
|
|
{
|
|
return m_PageServicesURL;
|
|
}
|
|
|
|
inline
|
|
const char* nsCacheObject::PostData(void) const
|
|
{
|
|
return m_PostData;
|
|
}
|
|
|
|
inline
|
|
PRUint32 nsCacheObject::PostDataLen(void) const
|
|
{
|
|
return m_PostDataLen;
|
|
}
|
|
|
|
inline
|
|
PRUint32 nsCacheObject::Size(void) const
|
|
{
|
|
return m_Size;
|
|
};
|
|
|
|
inline
|
|
void nsCacheObject::Size(PRUint32 i_Size)
|
|
{
|
|
m_Size = i_Size;
|
|
};
|
|
|
|
inline
|
|
PRUint32 nsCacheObject::State(void) const
|
|
{
|
|
return m_State;
|
|
};
|
|
|
|
inline
|
|
void nsCacheObject::State(PRUint32 i_State)
|
|
{
|
|
m_State = i_State;
|
|
};
|
|
|
|
inline
|
|
nsStream* nsCacheObject::Stream(void) const
|
|
{
|
|
return m_pStream;
|
|
}
|
|
#endif // nsCacheObject_h__
|
|
|