gnustep/libs-gsweb
0
0
Fork 0
mirror of https://github.com/gnustep/libs-gsweb.git synced 2025-02-22 03:01:27 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
libs-gsweb/GSWeb/GSWComponentDefinition.m
Sebastian Reitenbach ec3794334c * GSWeb/GSWComponentDefinition.m 
* GSWeb/GSWComponentReference.m
        * GSWeb/GSWContext.m
        * GSWeb/GSWHTMLDynamicElement.m
        * GSWeb/GSWHyperlink.m
        * GSWeb/GSWResourceManager.m
        * GSWeb/GSWResourceRequestHandler.m
          get rid of extaneous parentheses on equality tests


git-svn-id: svn+ssh://svn.gna.org/svn/gnustep/libs/gsweb/trunk@36245 72102866-910b-0410-8b05-ffd578937521
2013-03-03 02:02:36 +00:00

694 lines
19 KiB
Objective-C
Raw Blame History

/** GSWComponentDefinition.m - <title>GSWeb: Class GSWComponentDefinition</title>
Copyright (C) 1999-2002 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 "GSWeb.h"
#include <GNUstepBase/NSObject+GNUstepBase.h>
#include <GNUstepBase/GSMime.h>
//====================================================================
/* Static variables */
static NSLock * ComponentConstructorLock;
static NSLock * TemplateLock;
static GSWContext * TheTemporaryContext;
@implementation GSWComponentDefinition
+ (void) initialize
{
if (self == [GSWComponentDefinition class]) {
ComponentConstructorLock = [[NSLock alloc] init];
TemplateLock = [[NSLock alloc] init];
TheTemporaryContext = nil;
}
}
// that Method is used INTERNAL.
+ (GSWContext *) TheTemporaryContext
{
return TheTemporaryContext;
}
//--------------------------------------------------------------------
// CHECKME: missing Languages?
// we my have a different name and class?
// aName StartPage
// aPath /Users/dave/projects/new/PBXBilling/trunk/PBX.gswa/Resources/StartPage.wo
// baseURL /WebObjects/PBX.gswa/Resources/StartPage.wo
-(id)initWithName:(NSString*)aName
path:(NSString*)aPath
baseURL:(NSString*)baseURL
frameworkName:(NSString*)aFrameworkName
{
NSString * myBasePath = nil;
NSFileManager * defaultFileManager = nil;
[super init];
ASSIGN(_name, [aName stringByDeletingPathExtension]); // does it ever happen that
ASSIGN(_className, aName); // those are different? dw.
_componentClass = NSClassFromString(_className);
ASSIGN(_path, aPath);
ASSIGN(_url, baseURL);
ASSIGN(_frameworkName, aFrameworkName);
DESTROY(_language);
DESTROY(_wooReadDate);
DESTROY(_htmlReadDate);
_hasBeenAccessed = NO;
_hasContextConstructor = NO;
_isStateless = NO;
DESTROY(_instancePool);
_instancePool = [NSMutableArray new];
_lockInstancePool = [GSWApp isConcurrentRequestHandlingEnabled];
if ((_name != nil) && (_frameworkName != nil)) {
_componentClass = NSClassFromString(_className);
}
myBasePath = [aPath stringByAppendingPathComponent: aName];
ASSIGN(_htmlPath,[myBasePath stringByAppendingPathExtension:@"html"]);
ASSIGN(_wodPath,[myBasePath stringByAppendingPathExtension:GSWComponentDeclarationsSuffix[GSWebNamingConv]]);
ASSIGN(_wooPath,[myBasePath stringByAppendingPathExtension:GSWArchiveSuffix[GSWebNamingConv]]);
defaultFileManager = [NSFileManager defaultManager];
if (_componentClass == Nil) {
[self autorelease];
NSLog(@"%s: No component class for component named '%@' found", __PRETTY_FUNCTION__, _name);
return nil;
}
// if (([defaultFileManager fileExistsAtPath: _htmlPath] == NO) ||
// ([defaultFileManager fileExistsAtPath: _wodPath] == NO) ||
// ([defaultFileManager fileExistsAtPath: _wooPath] == NO) ||
// (_componentClass == Nil)) {
//
// [NSException raise:NSInvalidArgumentException
// format:@"%s: No template found for component named '%@'",
// __PRETTY_FUNCTION__, _name];
// }
_archive = nil;
_encoding = 0; // to test for real value later
_template = nil;
[self setCachingEnabled:[[GSWApp class] isCachingEnabled]];
_isAwake = NO;
_instancePoolLock = [[NSLock alloc] init];
return self;
}
//--------------------------------------------------------------------
-(void)dealloc
{
DESTROY(_name);
DESTROY(_path);
DESTROY(_url);
DESTROY(_frameworkName);
DESTROY(_language);
DESTROY(_className);
_componentClass = Nil;
DESTROY(_template);
DESTROY(_htmlPath);
DESTROY(_wodPath);
DESTROY(_wooPath);
DESTROY(_archive);
DESTROY(_sharedInstance);
DESTROY(_instancePool);
DESTROY(_wooReadDate);
DESTROY(_htmlReadDate);
[super dealloc];
};
//--------------------------------------------------------------------
- (void) checkInComponentInstance:(GSWComponent*) component
{
if (_sharedInstance == nil)
{
_sharedInstance = component;
} else
{
[_instancePool addObject:component];
}
}
- (void) _checkInComponentInstance:(GSWComponent*) component
{
BOOL locked = NO;
if (_lockInstancePool) {
NS_DURING
[_instancePoolLock lock];
locked = YES;
[self checkInComponentInstance: component];
locked = NO;
[_instancePoolLock unlock];
NS_HANDLER
if (locked) {
[_instancePoolLock unlock];
}
localException=[localException exceptionByAddingUserInfoFrameInfoFormat:@"In %s",
__PRETTY_FUNCTION__];
[localException raise];
NS_ENDHANDLER;
} else {
[self checkInComponentInstance: component];
}
}
//--------------------------------------------------------------------
-(NSString*)frameworkName
{
return _frameworkName;
};
//--------------------------------------------------------------------
-(NSString*)baseURL
{
return _url;
}
//--------------------------------------------------------------------
-(NSString*)path
{
return _path;
};
//--------------------------------------------------------------------
-(NSString*)name
{
return _name;
};
//--------------------------------------------------------------------
-(NSString*)description
{
//TODO
return [NSString stringWithFormat:@"<%s %p - name:[%@] frameworkName=[%@] componentClass=[%@] isCachingEnabled=[%s] isAwake=[%s]>",
object_getClassName(self),
(void*)self,
_name,
_frameworkName,
_componentClass,
_caching ? "YES" : "NO",
_isAwake ? "YES" : "NO"];
};
//--------------------------------------------------------------------
-(void)sleep
{
//OK
_isAwake=NO;
};
//--------------------------------------------------------------------
// dw
-(void)awake
{
if (!_isAwake) {
_isAwake = YES;
if (! _caching) {
[self componentClass];
}
}
};
//--------------------------------------------------------------------
-(BOOL)isCachingEnabled
{
return _caching;
};
//--------------------------------------------------------------------
-(void)setCachingEnabled:(BOOL)flag
{
_caching = flag;
};
//--------------------------------------------------------------------
-(void)_clearCache
{
}
// CHECKME
-(GSWComponent*) _componentInstanceInContext:(GSWContext*) aContext
{
Class myClass = [self componentClass];
GSWComponent * component = nil;
IMP instanceInitIMP = NULL;
IMP componentInitIMP = NULL;
GSWComponent * myInstance = nil;
BOOL locked = NO;
if ([myClass isSubclassOfClass: [GSWComponent class]]) {
[aContext _setComponentName:_className];
}
[aContext _setTempComponentDefinition:self];
NS_DURING
if (!_hasBeenAccessed) {
myInstance = [myClass alloc];
instanceInitIMP = [myInstance methodForSelector:@selector(init)];
componentInitIMP = [GSWComponent instanceMethodForSelector:@selector(init)];
if (instanceInitIMP != componentInitIMP) {
// NSLog(@"Class %s should implement initWithContext: and not init", object_getClassName(myClass));
[ComponentConstructorLock lock];
locked = YES;
TheTemporaryContext = aContext;
component = AUTORELEASE([myInstance init]);
TheTemporaryContext = nil;
locked = NO;
_hasContextConstructor = NO;
[ComponentConstructorLock unlock];
} else {
component = AUTORELEASE([myInstance initWithContext: aContext]);
_hasContextConstructor = YES;
}
} else {
// check if we can use some intelligent caching here.
myInstance = [myClass alloc];
if (_hasContextConstructor == NO) {
[ComponentConstructorLock lock];
locked = YES;
TheTemporaryContext = aContext;
component = AUTORELEASE([myInstance init]);
TheTemporaryContext = nil;
locked = NO;
[ComponentConstructorLock unlock];
} else {
component = AUTORELEASE([myInstance initWithContext: aContext]);
}
}
NS_HANDLER
if (locked) {
[ComponentConstructorLock unlock];
}
localException=[localException exceptionByAddingUserInfoFrameInfoFormat:@"In %s",
__PRETTY_FUNCTION__];
[localException raise];
NS_ENDHANDLER;
if ([component context] == nil) {
[NSException raise:NSInvalidArgumentException
format:@"Component '%@' was not properly initialized. Make sure [super initWithContext:] is called. In %s",
_className,
__PRETTY_FUNCTION__];
}
return component;
}
- (BOOL) isStateless
{
return _isStateless;
}
// this is called when we are already holding a lock.
-(GSWComponent*) _sharedInstanceInContext:(GSWContext*)aContext
{
GSWComponent * component = nil;
if (_sharedInstance != nil) {
component = _sharedInstance;
_sharedInstance = nil;
} else {
if ([_instancePool count] > 0) {
component = AUTORELEASE(RETAIN([_instancePool lastObject]));
[_instancePool removeLastObject];
} else {
component = [self _componentInstanceInContext:aContext];
}
}
return component;
}
//--------------------------------------------------------------------
-(GSWComponent*)componentInstanceInContext:(GSWContext*)aContext
{
GSWComponent* component=nil;
BOOL locked = NO;
if (aContext == nil) {
[NSException raise:NSInvalidArgumentException
format:@"Attempt to create component instance without a context. In %s",
__PRETTY_FUNCTION__];
}
NS_DURING
if (!_hasBeenAccessed) {
component = [self _componentInstanceInContext: aContext];
_isStateless = [component isStateless];
_hasBeenAccessed = YES;
} else {
if (_isStateless) {
if (_lockInstancePool) {
[_instancePoolLock lock];
locked = YES;
component = [self _sharedInstanceInContext:aContext];
locked = NO;
[_instancePoolLock unlock];
} else {
component = [self _sharedInstanceInContext:aContext];
}
} else {
component = [self _componentInstanceInContext:aContext];
}
}
NS_HANDLER
localException=[localException exceptionByAddingUserInfoFrameInfoFormat:@"In %s",
__PRETTY_FUNCTION__];
if (_lockInstancePool && locked) {
[_instancePoolLock unlock];
}
[localException raise];
NS_ENDHANDLER;
return component;
}
//--------------------------------------------------------------------
/** Find the class of the component **/
-(Class) componentClass
{
Class componentClass = Nil;
if (_componentClass) {
return _componentClass;
}
componentClass = _componentClass;
if (!componentClass) {
componentClass=NSClassFromString(_name);//???
}
if (!componentClass) // There's no class with that name
{
BOOL createClassesOk=NO;
NSString* superClassName=nil;
// If we haven't found a superclass, use GSWComponent as the superclass
if (!superClassName)
superClassName=@"WOComponent";
// Create class
createClassesOk=[GSWApplication createUnknownComponentClasses:[NSArray arrayWithObject:_name]
superClassName:superClassName];
// Use it
componentClass=NSClassFromString(_name);
};
//call GSWApp isCaching
_componentClass=componentClass;
return componentClass;
};
//--------------------------------------------------------------------
-(GSWComponentReference*)componentReferenceWithAssociations:(NSDictionary*)associations
template:(GSWElement*)template
{
//OK
GSWComponentReference* componentReference=nil;
componentReference=[[[GSWComponentReference alloc]initWithName:_name
associations:associations
template:template] autorelease];
return componentReference;
};
//--------------------------------------------------------------------
-(void) finishInitializingComponent:(GSWComponent*)component
{
NSDictionary * archive=nil;
NSBundle * bundle = [NSBundle bundleForClass:NSClassFromString(_className)];
archive = [self archive];
if (archive) {
[bundle initializeObject:component
fromArchive:archive];
}
}
//--------------------------------------------------------------------
-(void)_notifyObserversForDyingComponent:(GSWComponent*)aComponent
{
[self notImplemented: _cmd]; //TODOFN
};
//--------------------------------------------------------------------
-(void)_awakeObserversForComponent:(GSWComponent*)aComponent
{
[self notImplemented: _cmd]; //TODOFN
};
//--------------------------------------------------------------------
-(void)_deallocForComponent:(GSWComponent*)aComponent
{
[self notImplemented: _cmd]; //TODOFN
};
//--------------------------------------------------------------------
-(void)_awakeForComponent:(GSWComponent*)aComponent
{
[self notImplemented: _cmd]; //TODOFN
};
//--------------------------------------------------------------------
-(void)_registerObserver:(id)observer
{
[self notImplemented: _cmd]; //TODOFN
};
//--------------------------------------------------------------------
+(void)_registerObserver:(id)observer
{
[self notImplemented: _cmd]; //TODOFN
};
/*
* returns the contents of the .woo
*/
- (NSDictionary *) archive
{
if ((_caching) && (_archive)) {
// nothing to waste time with.
return _archive;
} else {
NSFileManager * defaultManager = [NSFileManager defaultManager];
NSDictionary * attributes;
NSDate * modDate;
attributes = [defaultManager attributesOfItemAtPath:_wooPath error:NULL];
modDate = [attributes fileModificationDate];
// file not found.
if (!modDate) {
modDate = [NSDate date];
ASSIGN(_wooReadDate, modDate);
ASSIGN(_archive, [NSDictionary dictionary]);
return _archive;
}
if ((!_wooReadDate) || (([modDate compare:_wooReadDate] == NSOrderedDescending))) {
ASSIGN(_wooReadDate, [NSDate date]);
ASSIGN(_archive, [NSDictionary dictionaryWithContentsOfFile:_wooPath]);
}
}
return _archive;
}
-(NSStringEncoding) encoding
{
NSDictionary * archive = nil;
NSString * encodingName = nil;
if (_encoding == 0) {
_encoding = [GSWMessage defaultEncoding]; // safer, because we may not have a .woo file
archive = [self archive];
if (archive)
{
encodingName = [archive objectForKey:@"encoding"];
if (encodingName)
{
_encoding = [GSMimeDocument encodingFromCharset:encodingName];
if (_encoding == 0) {
[NSException raise: NSInvalidArgumentException
format: @"%s %@ -- unknown encoding '%@'",__PRETTY_FUNCTION__, _wooPath, encodingName];
}
}
}
}
return _encoding;
}
- (GSWElement *) _lockedTemplate
{
//OK
GSWElement* template=nil;
NSStringEncoding encoding = [self encoding];
NSString* pageDefString=nil;
NSString* htmlString = [NSString stringWithContentsOfFile:_htmlPath
encoding:encoding];
if (!htmlString)
{
[NSException raise:NSInvalidArgumentException
format:@"%s: No HTML file found at '%@'",
__PRETTY_FUNCTION__, _htmlPath];
}
pageDefString = [NSString stringWithContentsOfFile:_wodPath
encoding:encoding];
if (!pageDefString) {
[NSException raise:NSInvalidArgumentException
format:@"%s: No WOD file found at '%@'",
__PRETTY_FUNCTION__, _wodPath];
}
NS_DURING
{
template=[GSWTemplateParser templateNamed:_name
inFrameworkNamed:nil
withParserType:GSWTemplateParserType_Default
parserClassName:nil
withString:htmlString
encoding:encoding
fromPath:nil
declarationsString:pageDefString
languages:nil
declarationsPath:nil];
}
NS_HANDLER
{
localException=ExceptionByAddingUserInfoObjectFrameInfo0(localException,
@"In template Parsing");
[localException raise];
}
NS_ENDHANDLER;
return template;
}
- (GSWElement *) template
{
BOOL htmlChangedOnDisk = NO;
// _htmlReadDate
if (_caching == NO) {
htmlChangedOnDisk = YES;
} else {
NSFileManager * defaultManager = [NSFileManager defaultManager];
NSDictionary * attributes;
NSDate * modDate;
attributes = [defaultManager attributesOfItemAtPath:_wooPath error:NULL];
modDate = [attributes fileModificationDate];
if ((!_htmlReadDate) || (([modDate compare:_htmlReadDate] == NSOrderedDescending))) {
htmlChangedOnDisk = YES;
} else {
attributes = [defaultManager attributesOfItemAtPath:_wodPath error:NULL];
modDate = [attributes fileModificationDate];
if (([modDate compare:_htmlReadDate] == NSOrderedDescending)) {
htmlChangedOnDisk = YES;
}
}
}
if (_htmlPath != nil && (_template == nil || htmlChangedOnDisk)) {
ASSIGN(_htmlReadDate, [NSDate date]);
NS_DURING
[TemplateLock lock];
DESTROY(_template);
_template = RETAIN([self _lockedTemplate]);
[TemplateLock unlock];
NS_HANDLER
DESTROY(_template);
[TemplateLock unlock];
[localException raise];
NS_ENDHANDLER
}
return _template;
}
- (void) encodeWithCoder: (NSCoder*)aCoder
{
[self notImplemented: _cmd];
return;
}
- (id) initWithCoder: (NSCoder*)aDecoder
{
[self notImplemented: _cmd];
return self;
}
- (id) copyWithZone: (NSZone*)z
{
[self notImplemented: _cmd];
return self;
}
@end
Reference in a new issue View git blame Copy permalink