gnustep/libs-gsweb
0
0
Fork 0
mirror of https://github.com/gnustep/libs-gsweb.git synced 2025-02-21 02:41:04 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
libs-gsweb/GSWeb.framework/GSWMessage.m
Manuel Guesdon b43719c330 o added methods for element/component caching 
git-svn-id: svn+ssh://svn.gna.org/svn/gnustep/libs/gsweb/trunk@18748 72102866-910b-0410-8b05-ffd578937521
2004-03-01 16:55:09 +00:00

1223 lines
34 KiB
Objective-C
Raw Blame History

/** GSWMessage.m - <title>GSWeb: Class GSWMessage</title>
Copyright (C) 1999-2004 Free Software Foundation, Inc.
Written by: Manuel Guesdon <mguesdon@orange-concept.com>
Date: Jan 1999
$Revision$
$Date$
$Id$
This file is part of the GNUstep Web Library.
<license>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free
Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
</license>
**/
#include "config.h"
RCS_ID("$Id$")
#include "GSWeb.h"
#include "NSData+Compress.h"
static NSStringEncoding globalDefaultEncoding=NSISOLatin1StringEncoding;
static NSString* globalDefaultURLEncoding=nil;
//====================================================================
#ifndef NO_GNUSTEP
@interface GSWMessage (GSWMessageCachePrivate)
-(void)_cacheAppendString:(NSString*)string;
-(void)_cacheAppendData:(NSData*)data;
-(void)_cacheAppendBytes:(const void*)aBuffer
length:(unsigned int)bufferSize;
@end
#endif
//====================================================================
@implementation GSWMessage
//--------------------------------------------------------------------
// init
-(id)init
{
LOGObjectFnStart();
if ((self=[super init]))
{
ASSIGN(_httpVersion,@"HTTP/1.0");
_headers=[NSMutableDictionary new];
_contentEncoding=[[self class] defaultEncoding];
[self _initContentData];
};
LOGObjectFnStop();
return self;
};
//--------------------------------------------------------------------
-(void)dealloc
{
// GSWLogAssertGood(self);
// NSDebugFLog(@"dealloc Message %p",self);
// NSDebugFLog0(@"Release Message httpVersion");
DESTROY(_httpVersion);
// NSDebugFLog0(@"Release Message headers");
DESTROY(_headers);
// NSDebugFLog0(@"Release Message contentString");
DESTROY(_contentString);
// NSDebugFLog0(@"Release Message contentData");
DESTROY(_contentData);
// NSDebugFLog0(@"Release Message userInfo");
DESTROY(_userInfo);
//NSDebugFLog0(@"Release Message cookies");
DESTROY(_cookies);
// NSDebugFLog0(@"Release Message");
#ifndef NO_GNUSTEP
DESTROY(_cachesStack);
#endif
[super dealloc];
};
//--------------------------------------------------------------------
-(id)copyWithZone:(NSZone*)zone
{
GSWMessage* clone = [[isa allocWithZone:zone] init];
if (clone)
{
ASSIGNCOPY(clone->_httpVersion,_httpVersion);
DESTROY(clone->_headers);
clone->_headers=[_headers mutableCopyWithZone:zone];
clone->_contentEncoding=_contentEncoding;
ASSIGNCOPY(clone->_userInfo,_userInfo);
ASSIGNCOPY(clone->_cookies,_cookies);
DESTROY(clone->_contentString);
clone->_contentString=[_contentString mutableCopyWithZone:zone];
DESTROY(clone->_contentData);
clone->_contentData=[_contentData mutableCopyWithZone:zone];
#ifndef NO_GNUSTEP
DESTROY(clone->_cachesStack);
clone->_cachesStack=[_cachesStack mutableCopyWithZone:zone];
#endif
};
return clone;
};
//--------------------------------------------------------------------
// Used in transactions
-(BOOL)isEqual:(id)anObject
{
BOOL isEqual=NO;
if (anObject==self)
isEqual=YES;
else if ([anObject isKindOfClass:[GSWMessage class]])
{
GSWMessage* aMessage=(GSWMessage*)anObject;
if ((_headers == aMessage->_headers
|| [_headers isEqual:aMessage->_headers])
&& [_contentData isEqual:aMessage->_contentData]
&& [_contentString isEqual:aMessage->_contentString])
isEqual=YES;
};
return isEqual;
}
//--------------------------------------------------------------------
// setHTTPVersion:
//sets the http version (like @"HTTP/1.0").
-(void)setHTTPVersion:(NSString*)version
{
ASSIGN(_httpVersion,version);
};
//--------------------------------------------------------------------
// httpVersion
//return http version like @"HTTP/1.0"
-(NSString*)httpVersion
{
return _httpVersion;
};
//--------------------------------------------------------------------
// setUserInfo:
-(void)setUserInfo:(NSDictionary*)userInfo
{
ASSIGN(_userInfo,userInfo);
};
//--------------------------------------------------------------------
// userInfo
-(NSDictionary*)userInfo
{
return _userInfo;
};
//--------------------------------------------------------------------
// setHeader:forKey:
// Should replace, not append. FIXME later
-(void)setHeader:(NSString*)header
forKey:(NSString*)key
{
//OK
id object=nil;
NSAssert(header,@"No header");
NSAssert(key,@"No header key");
object=[_headers objectForKey:key];
if (object)
[self setHeaders:[object arrayByAddingObject:header]
forKey:key];
else
[self setHeaders:[NSArray arrayWithObject:header]
forKey:key];
};
//--------------------------------------------------------------------
-(void)appendHeader:(NSString*)header
forKey:(NSString*)key
{
[self appendHeaders:[NSArray arrayWithObject:header]
forKey:key];
}
//--------------------------------------------------------------------
// setHeaders:forKey:
-(void)setHeaders:(NSArray*)headers
forKey:(NSString*)key
{
NSAssert(headers,@"No headers");
NSAssert(key,@"No header key");
NSDebugMLLog(@"GSWMessage",@"_headers=%@",_headers);
if (!_headers)
_headers=[NSMutableDictionary new];
NSDebugMLLog(@"GSWMessage",@"key=%@ headers=%@",key,headers);
[_headers setObject:headers
forKey:key];
};
//--------------------------------------------------------------------
-(void)appendHeaders:(NSArray*)headers
forKey:(NSString*)key
{
id object=nil;
NSAssert(headers,@"No headers");
NSAssert(key,@"No header key");
object=[_headers objectForKey:key];
if (object)
[self setHeaders:[object arrayByAddingObjectsFromArray:headers]
forKey:key];
else
[self setHeaders:headers
forKey:key];
};
//--------------------------------------------------------------------
// setHeaders:
-(void)setHeaders:(NSDictionary*)headerDictionary
{
NSDebugMLLog(@"GSWMessage",@"headerDictionary=%@",headerDictionary);
NSDebugMLLog(@"GSWMessage",@"_headers=%@",_headers);
if (!_headers && [headerDictionary count]>0)
_headers=[NSMutableDictionary new];
if (headerDictionary)
{
NSEnumerator* keyEnum=nil;
id headerName=nil;
keyEnum = [headerDictionary keyEnumerator];
while ((headerName = [keyEnum nextObject]))
{
id value=[headerDictionary objectForKey:headerName];
if (![value isKindOfClass:[NSArray class]])
value=[NSArray arrayWithObject:value];
[self setHeaders:value
forKey:headerName];
};
};
NSDebugMLLog(@"GSWMessage",@"_headers=%@",_headers);
};
//--------------------------------------------------------------------
// headers
-(NSMutableDictionary*)headers
{
return _headers;
};
//--------------------------------------------------------------------
// headerForKey:
// return:
// nil: if no header for key_
// 1st header: if multiple headers for key_
// header: otherwise
-(NSString*)headerForKey:(NSString*)key
{
id object=[_headers objectForKey:key];
if (object && [object isKindOfClass:[NSArray class]])
return [object objectAtIndex:0];
else
return (NSString*)object;
};
//--------------------------------------------------------------------
// headerKeys
// return array of header keys or nil if no header
-(NSArray*)headerKeys
{
return [_headers allKeys];
};
//--------------------------------------------------------------------
// headersForKey:
//return array of headers of key_
-(NSArray*)headersForKey:(NSString*)key
{
id object=[_headers objectForKey:key];
if (!object || [object isKindOfClass:[NSArray class]])
return (NSArray*)object;
else
return [NSArray arrayWithObject:object];
};
//--------------------------------------------------------------------
-(void)removeHeadersForKey:(NSString*)key
{
[_headers removeObjectForKey:key];
}
//--------------------------------------------------------------------
-(void)_initContentData
{
LOGObjectFnStart();
DESTROY(_contentString);
DESTROY(_contentData);
_contentString=[NSMutableString new];
_contentData=[NSMutableData new];
LOGObjectFnStop();
};
//--------------------------------------------------------------------
/** Set content with contentData
**/
-(void)setContent:(NSData*)contentData
{
LOGObjectFnStart();
[self _initContentData];
[self appendContentData:contentData];
LOGObjectFnStop();
};
//--------------------------------------------------------------------
/** Set content with contentString
**/
-(void)setContentString:(NSString*)contentString
{
LOGObjectFnStart();
[self _initContentData];
[self appendContentString:contentString];
LOGObjectFnStop();
};
//--------------------------------------------------------------------
// content
-(NSData*)content
{
NSData* content=nil;
LOGObjectFnStart();
if ([_contentString length]>0)
{
NS_DURING
{
content=[_contentString dataUsingEncoding:[self contentEncoding]];
}
NS_HANDLER
{
//TODO
[localException raise];
}
NS_ENDHANDLER;
}
else
content=_contentData;
LOGObjectFnStop();
return content;
};
//--------------------------------------------------------------------
// contentString
-(NSString*)contentString
{
NSString* contentString=nil;
LOGObjectFnStart();
if ([_contentString length]>0)
contentString=[NSString stringWithString:_contentString];
else
contentString=[[[NSString alloc]initWithData:_contentData
encoding:[self contentEncoding]]
autorelease];
LOGObjectFnStop();
return contentString;
}
//--------------------------------------------------------------------
-(void)appendContentData:(NSData*)contentData
{
LOGObjectFnStart();
NSDebugMLLog(@"low",@"contentData:%@",contentData);
if ([contentData length]>0) // is there something to append ?
{
if ([_contentString length]>0) // is actual content is string ?
{
// Convert contentData to append into string and append it to _contentString
NSString* tmpString=nil;
NSDebugMLog(@"Converting appending Data To String");
tmpString=[[[NSString alloc]initWithData:contentData
encoding:[self contentEncoding]]
autorelease];
[_contentString appendString:tmpString];
#ifndef NO_GNUSTEP
if (_cachesStack)
[self _cacheAppendString:tmpString];
#endif
}
else // No actual content or data one
{
if ([_contentData length]>0)
{
[_contentData appendData:contentData];
}
else
{
_contentData = (NSMutableData*)[contentData mutableCopy];
};
#ifndef NO_GNUSTEP
if (_cachesStack)
[self _cacheAppendData:contentData];
#endif
};
};
LOGObjectFnStop();
}
//--------------------------------------------------------------------
-(void)_appendContentAsciiString:(NSString*)aString
{
NSString* string=nil;
LOGObjectFnStart();
NSAssert2([_contentData length]==0,
@"Try to append string but content is data. \nString: '%@'\nData: '%@'",
string,
[[[NSString alloc]initWithData:_contentData
encoding:[self contentEncoding]]
autorelease]);
NSDebugMLLog(@"low",@"aString:%@",aString);
string=[NSString stringWithObject:aString];
NSDebugMLLog(@"low",@"string:%@",string);
[_contentString appendString:string];
#ifndef NO_GNUSTEP
if (_cachesStack)
[self _cacheAppendString:string];
#endif
LOGObjectFnStop();
};
//--------------------------------------------------------------------
// _appendContentCharacter:
-(void)_appendContentCharacter:(char)aChar
{
NSString* string=nil;
LOGObjectFnStart();
NSDebugMLLog(@"low",@"aChar:%c",aChar);
NSAssert2([_contentData length]==0,
@"Try to append string but content is data. \naChar: '%c'\nData: '%@'",
aChar,
[[[NSString alloc]initWithData:_contentData
encoding:[self contentEncoding]]
autorelease]);
string=[NSString stringWithFormat:@"%c",aChar];
[_contentString appendString:string];
#ifndef NO_GNUSTEP
if (_cachesStack)
[self _cacheAppendString:string];
#endif
LOGObjectFnStop();
};
//--------------------------------------------------------------------
-(void)appendContentString:(NSString*)string
{
LOGObjectFnStart();
NSDebugMLLog(@"low",@"string:%@",string);
NSAssert2([_contentData length]==0,
@"Try to append string but content is data. \nString: '%@'\nData: '%@'",
string,
[[[NSString alloc]initWithData:_contentData
encoding:[self contentEncoding]]
autorelease]);
[_contentString appendString:string];
#ifndef NO_GNUSTEP
if (_cachesStack)
[self _cacheAppendString:string];
#endif
LOGObjectFnStop();
}
//--------------------------------------------------------------------
-(int)_contentLength
{
int contentLength=[_contentString length];
if (contentLength==0)
contentLength=[_contentData length];
return contentLength;
}
//--------------------------------------------------------------------
// contentEncoding
-(NSStringEncoding)contentEncoding
{
return _contentEncoding;
};
//--------------------------------------------------------------------
// setContentEncoding:
-(void)setContentEncoding:(NSStringEncoding)encoding
{
NSDebugMLLog(@"low",@"setContentEncoding:%d",(int)encoding);
_contentEncoding=encoding;
};
@end
//====================================================================
@implementation GSWMessage (GSWContentConveniences)
//--------------------------------------------------------------------
// appendContentBytes:length:
-(void)appendContentBytes:(const void*)bytes
length:(unsigned)length
{
LOGObjectFnStart();
if (length>0)
{
[_contentData appendBytes:bytes
length:length];
#ifndef NO_GNUSTEP
if (_cachesStack)
[self _cacheAppendBytes:bytes
length:length];
#endif
};
LOGObjectFnStop();
};
//--------------------------------------------------------------------
// appendContentCharacter:
-(void)appendContentCharacter:(char)aChar
{
LOGObjectFnStart();
/* [self appendContentBytes:&aChar
length:1];
*/
[self _appendContentCharacter:aChar];
LOGObjectFnStop();
};
/*
//--------------------------------------------------------------------
// appendContentData:
-(void)appendContentData:(NSData*)dataObject
{
const void* bytes=NULL;
unsigned int length=0;
LOGObjectFnStart();
NSDebugMLLog(@"low",@"response=%p dataObject:%@",self,dataObject);
bytes=[dataObject bytes];
length=[dataObject length];
[self appendContentBytes:bytes
length:length];
LOGObjectFnStop();
};
*/
//--------------------------------------------------------------------
// appendContentString:
/*
-(void)appendContentString:(NSString*)aString
{
LOGObjectFnStart();
NSDebugMLLog(@"low",@"response=%p contentEncoding=%d",self,(int)_contentEncoding);
[self _appendContentString:aString];
if (aString)
{
NSData* newData=nil;
NSString* string=nil;
string=[NSString stringWithObject:aString];
NSAssert(string,@"Can't get string from object");
#ifndef NDEBUG
NSAssert3(![string isKindOfClass:[NSString class]] || [string canBeConvertedToEncoding:_contentEncoding],
@"string %s (of class %@) can't be converted to encoding %d",
[string lossyCString],
[string class],
_contentEncoding);
#endif
newData=[string dataUsingEncoding:_contentEncoding];
NSAssert3(newData,@"Can't create data from %@ \"%s\" using encoding %d",
[string class],
([string isKindOfClass:[NSString class]] ? [string lossyCString] : "**Not a string**"),
(int)_contentEncoding);
NSDebugMLLog(@"low",@"newData=%@",newData);
[_contentData appendData:newData];
};
LOGObjectFnStop();
};
*/
//--------------------------------------------------------------------
// appendDebugCommentContentString:
-(void)appendDebugCommentContentString:(NSString*)aString
{
#ifndef NDEBUG
if (GSDebugSet(@"debugComments") == YES)
[self appendContentString:[NSString stringWithFormat:@"\n<!-- %@ -->\n",aString]];
#endif
};
//--------------------------------------------------------------------
-(void)replaceContentString:(NSString*)replaceString
byString:(NSString*)byString
{
LOGObjectFnStart();
NSDebugMLog(@"replaceString=%@",replaceString);
NSDebugMLog(@"byString=%@",byString);
if ([replaceString length]>0) // is there something to replace ?
{
NSDebugMLog(@"[_contentString length]=%d",[_contentString length]);
NSDebugMLog(@"[_contentData length]=%d",[_contentData length]);
if ([_contentString length]>0) // is actual content is string ?
{
[_contentString replaceOccurrencesOfString:replaceString
withString:byString
options:0
range:NSMakeRange(0,[_contentString length])];
}
else // No actual content or data one
{
if ([_contentData length]>0)
{
// Convert to data
NSData* tmpReplaceData=nil;
NSData* tmpByData=nil;
NSDebugMLog(@"Converting String To Data");
tmpReplaceData=[replaceString dataUsingEncoding:[self contentEncoding]];
tmpByData=[byString dataUsingEncoding:[self contentEncoding]];
[_contentData replaceOccurrencesOfData:tmpReplaceData
withData:tmpByData
range:NSMakeRange(0,[_contentData length])];
};
};
};
LOGObjectFnStop();
};
//--------------------------------------------------------------------
-(void)replaceContentData:(NSData*)replaceData
byData:(NSData*)byData
{
LOGObjectFnStart();
if ([replaceData length]>0) // is there something to replace ?
{
NSDebugMLog(@"[_contentString length]=%d",[_contentString length]);
NSDebugMLog(@"[_contentData length]=%d",[_contentData length]);
if ([_contentString length]>0) // is actual content is string ?
{
// Convert to string
NSString* tmpReplaceString=nil;
NSString* tmpByString=nil;
NSDebugMLog(@"Converting Data To String");
tmpReplaceString=[[[NSString alloc]initWithData:replaceData
encoding:[self contentEncoding]]
autorelease];
tmpByString=[[[NSString alloc]initWithData:byData
encoding:[self contentEncoding]]
autorelease];
[_contentString replaceOccurrencesOfString:tmpReplaceString
withString:tmpByString
options:0
range:NSMakeRange(0,[_contentString length])];
}
else // No actual content or data one
{
if ([_contentData length]>0)
{
[_contentData replaceOccurrencesOfData:replaceData
withData:byData
range:NSMakeRange(0,[_contentData length])];
};
};
};
LOGObjectFnStop();
};
@end
//====================================================================
@implementation GSWMessage (GSWHTMLConveniences)
//--------------------------------------------------------------------
// appendContentHTMLAttributeValue:
-(void)appendContentHTMLAttributeValue:(NSString*)value
{
NSString* string=nil;
LOGObjectFnStart();
NSDebugMLLog(@"low",@"response=%p value=%@",self,value);
string=[NSString stringWithObject:value];
[self appendContentString:[[self class]stringByEscapingHTMLAttributeValue:string]];
LOGObjectFnStop();
};
//--------------------------------------------------------------------
// appendContentHTMLString:
-(void)appendContentHTMLString:(NSString*)aString
{
NSString* string=nil;
LOGObjectFnStart();
NSDebugMLLog(@"low",@"aString=%@",aString);
string=[NSString stringWithObject:aString];
NSDebugMLLog(@"low",@"string=%@",string);
[self appendContentString:[[self class]stringByEscapingHTMLString:string]];
LOGObjectFnStop();
};
//--------------------------------------------------------------------
-(void)appendContentHTMLConvertString:(NSString*)aString
{
NSString* string=nil;
LOGObjectFnStart();
NSDebugMLLog(@"low",@"aString=%@",aString);
string=[NSString stringWithObject:aString];
NSDebugMLLog(@"low",@"string=%@",string);
[self appendContentString:[[self class]stringByConvertingToHTML:string]];
LOGObjectFnStop();
};
//--------------------------------------------------------------------
-(void)appendContentHTMLEntitiesConvertString:(NSString*)aString
{
NSString* string=nil;
LOGObjectFnStart();
NSDebugMLLog(@"low",@"aString=%@",aString);
string=[NSString stringWithObject:aString];
NSDebugMLLog(@"low",@"string=%@",string);
[self appendContentString:[[self class]stringByConvertingToHTMLEntities:string]];
LOGObjectFnStop();
};
//--------------------------------------------------------------------
+(NSString*)stringByEscapingHTMLString:(NSString*)aString
{
NSString* string=[NSString stringWithObject:aString];
NSDebugMLLog(@"low",@"aString=%@",aString);
NSDebugMLLog(@"low",@"string=%@",string);
return [string stringByEscapingHTMLString];
};
//--------------------------------------------------------------------
+(NSString*)stringByEscapingHTMLAttributeValue:(NSString*)aString
{
NSString* string=[NSString stringWithObject:aString];
NSDebugMLLog(@"low",@"aString=%@",aString);
NSDebugMLLog(@"low",@"string=%@",string);
return [string stringByEscapingHTMLAttributeValue];
};
//--------------------------------------------------------------------
+(NSString*)stringByConvertingToHTMLEntities:(NSString*)aString
{
NSString* string=[NSString stringWithObject:aString];
NSDebugMLLog(@"low",@"aString=%@",aString);
NSDebugMLLog(@"low",@"string=%@",string);
return [string stringByConvertingToHTMLEntities];
};
//--------------------------------------------------------------------
+(NSString*)stringByConvertingToHTML:(NSString*)aString
{
NSString* string=[NSString stringWithObject:aString];
NSDebugMLLog(@"low",@"aString=%@",aString);
NSDebugMLLog(@"low",@"string=%@",string);
return [string stringByConvertingToHTML];
};
@end
//====================================================================
@implementation GSWMessage (Cookies)
//--------------------------------------------------------------------
-(NSString*)_formattedCookiesString
{
LOGObjectFnNotImplemented(); //TODOFN
return nil;
};
//--------------------------------------------------------------------
-(NSMutableArray*)_initCookies
{
if (!_cookies)
_cookies=[NSMutableArray new];
return _cookies;
};
//--------------------------------------------------------------------
-(void)addCookie:(GSWCookie*)cookie
{
//OK
NSMutableArray* cookies=nil;
LOGObjectFnStart();
cookies=[self _initCookies];
if (cookie)
[cookies addObject:cookie];
LOGObjectFnStop();
};
//--------------------------------------------------------------------
-(void)removeCookie:(GSWCookie*)cookie
{
NSMutableArray* cookies=nil;
LOGObjectFnStart();
cookies=[self _initCookies];
if (cookie)
[cookies removeObject:cookie];
LOGObjectFnStop();
};
//--------------------------------------------------------------------
-(NSArray*)cookies
{
NSMutableArray* cookies=[self _initCookies];
return cookies;
};
//--------------------------------------------------------------------
//NDFN
-(NSArray*)cookiesHeadersValues
{
NSMutableArray* strings=nil;
NSArray* cookies=[self cookies];
if ([cookies count]>0)
{
int i=0;
int count=[cookies count];
GSWCookie* cookie=nil;
NSString* cookieString=nil;
strings=[NSMutableArray array];
for(i=0;i<count;i++)
{
cookie=[cookies objectAtIndex:i];
cookieString=[cookie headerValue];
NSAssert(cookieString,@"No cookie HeaderValue");
[strings addObject:cookieString];
};
};
return (strings ? [NSArray arrayWithArray:strings] : nil);
};
//--------------------------------------------------------------------
-(void)_finalizeCookiesInContext:(GSWContext*)aContext
{
NSArray* cookieHeader=nil;
NSArray* cookies=nil;
NSString* cookiesKey=nil;
BOOL isRequest=NO;
isRequest=[self isKindOfClass:[GSWRequest class]];
if (isRequest)
cookiesKey=GSWHTTPHeader_Cookie;
else
cookiesKey=GSWHTTPHeader_SetCookie;
cookieHeader=[self headersForKey:cookiesKey];
if (cookieHeader)
{
ExceptionRaise(@"GSWResponse",
@"%@ header already exists",
GSWHTTPHeader_SetCookie);
};
cookies=[self cookies];
if ([cookies count]>0)
{
id cookiesHeadersValues=[self cookiesHeadersValues];
NSDebugMLLog(@"low",@"cookiesHeadersValues=%@",cookiesHeadersValues);
[self setHeaders:cookiesHeadersValues
forKey:cookiesKey];
};
};
@end
//====================================================================
@implementation GSWMessage (KeyValueCoding)
+(BOOL)canAccessFieldsDirectly
{
return YES;
}
@end
//====================================================================
@implementation GSWMessage (GSWMessageDefaultEncoding)
//--------------------------------------------------------------------
+(void)setDefaultEncoding:(NSStringEncoding)encoding
{
globalDefaultEncoding=encoding;
};
//--------------------------------------------------------------------
+(NSStringEncoding)defaultEncoding
{
return globalDefaultEncoding;
};
//--------------------------------------------------------------------
-(void)setDefaultURLEncoding:(NSString*)enc
{
ASSIGN(globalDefaultURLEncoding,enc);
}
//--------------------------------------------------------------------
-(NSString*)defaultURLEncoding
{
return globalDefaultURLEncoding;
}
@end
//====================================================================
#ifndef NO_GNUSTEP
@implementation GSWMessage (GSWMessageCache)
//--------------------------------------------------------------------
-(int)startCache
{
int index=0;
LOGObjectFnStart();
if (!_cachesStack)
{
_cachesStack=[NSMutableArray new];
};
if (_contentData)
[_cachesStack addObject:[NSMutableData data]];
else
[_cachesStack addObject:[NSMutableString string]];
index=[_cachesStack count]-1;
LOGObjectFnStop();
return index;
};
-(id)appendCacheData:(id)fromCacheData
toCacheData:(id)toCacheData
{
LOGObjectFnStart();
if ([fromCacheData length]>0)
{
if ([fromCacheData isKindOfClass:[NSString class]])
{
if ([toCacheData isKindOfClass:[NSString class]]) // String+String
{
[toCacheData appendString:(NSString*)fromCacheData];
}
else if ([toCacheData length]==0)
{ // Empty Data+String
toCacheData=[NSMutableString stringWithString:fromCacheData];
}
else
{
// Empty String
NSAssert(NO,
@"Try to append cache string to cache");
};
}
else // ??+Data
{
if ([toCacheData isKindOfClass:[NSData class]]) // Data+Data
{
[toCacheData appendData:fromCacheData];
}
else // String+Data
{
// Convert fromCacheData data to append into toCacheData string
NSString* fromCacheDataString=nil;
NSDebugMLog(@"Converting appending Data To String");
fromCacheDataString=[[[NSString alloc]initWithData:(NSData*)fromCacheData
encoding:[self contentEncoding]]
autorelease];
[toCacheData appendString:fromCacheDataString];
};
};
};
LOGObjectFnStop();
return toCacheData;
}
//--------------------------------------------------------------------
-(id)stopCacheOfIndex:(int)cacheIndex
{
id cachedData=nil;
int cacheStackCount=0;
LOGObjectFnStart();
NSDebugMLLog(@"GSWCacheElement",@"cacheIndex=%d",cacheIndex);
cacheStackCount=[_cachesStack count];
NSDebugMLLog(@"GSWCacheElement",@"cacheStackCount=%d",cacheStackCount);
if (cacheIndex<cacheStackCount)
{
cachedData=[_cachesStack objectAtIndex:cacheIndex];
AUTORELEASE(RETAIN(cachedData));
NSDebugMLLog(@"GSWCacheElement",@"cachedData=%@",cachedData);
// Last one ? (normal case)
if (cacheIndex==(cacheStackCount-1))
{
[_cachesStack removeObjectAtIndex:cacheIndex];
}
else
{
// Strange case: may be an exception which avoided component to retrieve their cache ?
cacheIndex++;
while(cacheIndex<cacheStackCount)
{
id tmp=[_cachesStack objectAtIndex:cacheIndex];
NSDebugMLLog(@"GSWCacheElement",@"tmp=%@",tmp);
cachedData=[self appendCacheData:tmp
toCacheData:cachedData];
[_cachesStack removeObjectAtIndex:cacheIndex];
};
};
cacheStackCount=[_cachesStack count];
//Add cachedData to previous cache item data
if (cacheStackCount>0 && [cachedData length]>0)
{
id previous=[_cachesStack objectAtIndex:cacheStackCount-1];
id newPrevious=[self appendCacheData:cachedData
toCacheData:previous];
if (newPrevious!=previous)
[_cachesStack replaceObjectAtIndex:cacheStackCount-1
withObject:newPrevious];
};
};
NSDebugMLLog(@"GSWCacheElement",@"cachedData=%@",cachedData);
LOGObjectFnStop();
return cachedData;
}
@end
@implementation GSWMessage (GSWMessageCachePrivate)
//--------------------------------------------------------------------
-(void)_cacheAppendString:(NSString*)string
{
LOGObjectFnStart();
if ([string length]>0)
{
int index=0;
index=[_cachesStack count]-1;
if (index>=0)
{
id cachedData=[_cachesStack objectAtIndex:index];
if ([cachedData isKindOfClass:[NSData class]])
{
if ([cachedData length]>0)
{
NSAssert2(NO,
@"Try to append string to cache but content is data. \nString: '%@'\nData: '%@'",
string,
[[[NSString alloc]initWithData:_contentData
encoding:[self contentEncoding]]
autorelease]);
}
else
[_cachesStack replaceObjectAtIndex:index
withObject:[NSMutableString stringWithString:string]];
}
else
[cachedData appendString:string];
};
};
LOGObjectFnStop();
}
//--------------------------------------------------------------------
-(void)_cacheAppendData:(NSData*)data
{
LOGObjectFnStart();
if ([data length]>0)
{
int index=0;
index=[_cachesStack count]-1;
if (index>=0)
{
id cachedData=[_cachesStack objectAtIndex:index];
if ([cachedData isKindOfClass:[NSString class]])
{
if ([cachedData length]>0)
{
// Convert contentData to append into string and append it to _contentString
NSString* tmpString=nil;
NSDebugMLog(@"Converting appending Data To String");
tmpString=[[[NSString alloc]initWithData:data
encoding:[self contentEncoding]]
autorelease];
[cachedData appendString:tmpString];
}
else
[_cachesStack replaceObjectAtIndex:index
withObject:[NSMutableData dataWithData:data]];
}
else
[cachedData appendData:data];
};
};
LOGObjectFnStop();
}
//--------------------------------------------------------------------
-(void)_cacheAppendBytes:(const void*)aBuffer
length: (unsigned int)bufferSize
{
LOGObjectFnStart();
if (bufferSize>0)
{
int index=0;
index=[_cachesStack count]-1;
if (index>=0)
{
id cachedData=[_cachesStack objectAtIndex:index];
if ([cachedData isKindOfClass:[NSString class]])
{
if ([cachedData length]>0)
{
// Convert contentData to append into string and append it to _contentString
NSString* tmpString=nil;
NSData* tmpData=nil;
NSDebugMLog(@"Converting appending Data To String");
tmpData=[NSData dataWithBytes:aBuffer
length:bufferSize];
tmpString=[[[NSString alloc]initWithData:tmpData
encoding:[self contentEncoding]]
autorelease];
[cachedData appendString:tmpString];
}
else
[_cachesStack replaceObjectAtIndex:index
withObject:[NSMutableData dataWithBytes:aBuffer
length:bufferSize]];
}
else
[cachedData appendBytes:aBuffer
length:bufferSize];
};
};
LOGObjectFnStop();
};
@end
#endif
Reference in a new issue View git blame Copy permalink