root/trunk/Models/JVChatTranscript.m

#import "JVChatTranscript.h"
#import "JVChatSession.h"
#import "JVChatMessage.h"
#import "JVChatEvent.h"
#import "KAIgnoreRule.h"
#import "NSAttributedStringMoreAdditions.h"

#import <libxml/tree.h>

NSString *JVChatTranscriptUpdatedNotification = @"JVChatTranscriptUpdatedNotification";

#pragma mark -

/* Future method ideas (implement when needed):
- (void) prependMessage:(JVChatMessage *) message;
- (void) prependMessages:(NSArray *) messages;

- (void) prependChatTranscript:(JVChatTranscript *) transcript;

- (void) insertMessage:(JVChatMessage *) message atIndex:(unsigned) index;

- (void) replaceMessageAtIndex:(unsigned) index withMessage:(JVChatMessage *) message;
- (void) replaceMessagesInRange:(NSRange) range withMessages:(NSArray *) messages;

- (void) removeMessage:(JVChatMessage *) message;
- (void) removeMessageAtIndex:(unsigned) index;
- (void) removeMessageAtIndexes:(NSIndexSet *) indexes;
- (void) removeMessagesInRange:(NSRange) range;
- (void) removeMessagesInArray:(NSArray *) messages;
- (void) removeAllMessages;
*/

@interface JVChatSession (JVChatSessionPrivate)
- (id) _initWithNode:(xmlNode *) node andTranscript:(JVChatTranscript *) transcript;
- (void) _setNode:(xmlNode *) node;
@end

#pragma mark -

@interface JVChatMessage (JVChatMessagePrivate)
- (id) _initWithNode:(xmlNode *) node andTranscript:(JVChatTranscript *) transcript;
- (void) _setNode:(xmlNode *) node;
- (void) _loadFromXML;
- (void) _loadSenderFromXML;
- (void) _loadBodyFromXML;
@end

#pragma mark -

@interface JVChatEvent (JVChatEventPrivate)
- (id) _initWithNode:(xmlNode *) node andTranscript:(JVChatTranscript *) transcript;
- (void) _setNode:(xmlNode *) node;
@end

#pragma mark -

@interface JVChatTranscript (JVChatTranscriptPrivate)
- (void) _enforceElementLimit;
- (void) _incrementalWriteToLog:(xmlNodePtr) node continuation:(BOOL) cont;
- (void) _changeFileAttributesAtPath:(NSString *) path;
@end

#pragma mark -

@implementation JVChatTranscript
+ (id) chatTranscript {
        return [[[self alloc] init] autorelease];
}

+ (id) chatTranscriptWithChatTranscript:(JVChatTranscript *) transcript {
        return [[[self alloc] initWithChatTranscript:transcript] autorelease];
}

+ (id) chatTranscriptWithElements:(NSArray *) elements {
        return [[[self alloc] initWithElements:elements] autorelease];
}

+ (id) chatTranscriptWithContentsOfFile:(NSString *) path {
        return [[[self alloc] initWithContentsOfFile:path] autorelease];
}

+ (id) chatTranscriptWithContentsOfURL:(NSURL *) url {
        return [[[self alloc] initWithContentsOfURL:url] autorelease];
}

#pragma mark -

- (id) init {
        if( ( self = [super init] ) ) {
                _filePath = nil;
                _logFile = nil;
                _objectSpecifier = nil;
                _autoWriteChanges = NO;
                _requiresNewEnvelope = YES;
                _previousLogOffset = 0;
                _elementLimit = 0;

                @synchronized( self ) {
                        _messages = [[NSMutableArray allocWithZone:[self zone]] initWithCapacity:100];

                        _xmlLog = xmlNewDoc( (xmlChar *) "1.0" );
                        xmlDocSetRootElement( _xmlLog, xmlNewNode( NULL, (xmlChar *) "log" ) );
                        xmlSetProp( xmlDocGetRootElement( _xmlLog ), (xmlChar *) "began", (xmlChar *) [[[NSDate date] description] UTF8String] );
                }
        }

        return self;
}

- (id) initWithChatTranscript:(JVChatTranscript *) transcript {
        if( ( self = [self init] ) )
                [self appendChatTranscript:transcript];

        return self;
}

- (id) initWithElements:(NSArray *) elements {
        if( ( self = [self init] ) )
                [self appendElements:elements];

        return self;
}

- (id) initWithContentsOfFile:(NSString *) path {
        if( ( self = [self init] ) ) {
                path = [path stringByStandardizingPath];

                @synchronized( self ) {
                        xmlFreeDoc( _xmlLog ); // release the empty document we made in [self init]
                        if( ! ( _xmlLog = xmlParseFile( [path fileSystemRepresentation] ) ) ) {
                                [self autorelease]; // file failed to parse, return nil
                                return nil;
                        }
                }

                [self setAutomaticallyWritesChangesToFile:YES];
                [self setFilePath:path];
        }

        return self;
}

- (id) initWithContentsOfURL:(NSURL *) url {
        if( ( self = [self init] ) ) {
                NSData *contents = [NSData dataWithContentsOfURL:url];
                if( ! contents || ! [contents length] ) {
                        [self release]; // URL failed to return content, return nil
                        return nil;
                }

                @synchronized( self ) {
                        xmlFreeDoc( _xmlLog ); // release the empty document we made in [self init]
                        if( ! ( _xmlLog = xmlParseMemory( [contents bytes], [contents length] ) ) ) {
                                [self autorelease]; // data failed to parse, return nil
                                return nil;
                        }
                }
        }

        return self;
}

- (void) dealloc {
        [_filePath release];
        [_logFile release];
        [_messages release];
        [_objectSpecifier release];

        xmlFreeDoc( _xmlLog );

        _objectSpecifier = nil;
        _filePath = nil;
        _logFile = nil;
        _messages = nil;
        _xmlLog = NULL;

        [super dealloc];
}

#pragma mark -

- (void *) document {
        return _xmlLog;
}

#pragma mark -

- (BOOL) isEmpty {
        @synchronized( self ) {
                xmlNode *node = xmlDocGetRootElement( _xmlLog ) -> children;
                do {
                        if( node && node -> type == XML_ELEMENT_NODE )
                                return NO;
                } while( node && ( node = node -> next ) );
        }

        return YES;
}

- (unsigned long) elementCount {
        unsigned long count = 0;

        @synchronized( self ) {
                xmlNode *node = xmlDocGetRootElement( _xmlLog ) -> children;
                do {
                        if( node && node -> type == XML_ELEMENT_NODE && ! strcmp( "envelope", (char *) node -> name ) ) {
                                xmlNode *subNode = node -> children;
                                do {
                                        if( subNode && subNode -> type == XML_ELEMENT_NODE && ! strcmp( "message", (char *) subNode -> name ) )
                                                count++;
                                } while( subNode && ( subNode = subNode -> next ) );
                        } else if( node && node -> type == XML_ELEMENT_NODE ) count++;
                } while( node && ( node = node -> next ) );
        }

        return count;
}

- (unsigned long) sessionCount {
        unsigned long count = 0;

        @synchronized( self ) {
                xmlNode *node = xmlDocGetRootElement( _xmlLog ) -> children;
                do {
                        if( node && node -> type == XML_ELEMENT_NODE && ! strcmp( "session", (char *) node -> name ) )
                                count++;
                } while( node && ( node = node -> next ) );
        }

        return count;
}

- (unsigned long) messageCount {
        unsigned long count = 0;

        @synchronized( self ) {
                xmlNode *node = xmlDocGetRootElement( _xmlLog ) -> children;
                do {
                        if( node && node -> type == XML_ELEMENT_NODE && ! strcmp( "envelope", (char *) node -> name ) ) {
                                xmlNode *subNode = node -> children;
                                do {
                                        if( subNode && subNode -> type == XML_ELEMENT_NODE && ! strcmp( "message", (char *) subNode -> name ) )
                                                count++;
                                } while( subNode && ( subNode = subNode -> next ) );
                        }
                } while( node && ( node = node -> next ) );
        }

        return count;
}

- (unsigned long) eventCount {
        unsigned long count = 0;

        @synchronized( self ) {
                xmlNode *node = xmlDocGetRootElement( _xmlLog ) -> children;
                do {
                        if( node && node -> type == XML_ELEMENT_NODE && ! strcmp( "event", (char *) node -> name ) )
                                count++;
                } while( node && ( node = node -> next ) );
        }

        return count;
}

#pragma mark -

- (void) setElementLimit:(unsigned int) limit {
        _elementLimit = limit;
        [self _enforceElementLimit];
}

- (unsigned int) elementLimit {
        return _elementLimit;
}

#pragma mark -

- (NSArray *) elements {
        return [self elementsInRange:NSMakeRange( 0, -1 )]; // will stop at the total number of elements.
}

- (NSArray *) elementsInRange:(NSRange) range {
        if( ! range.length ) return [NSArray array];

        @synchronized( self ) {
                unsigned long i = 0;
                NSMutableArray *ret = [[NSMutableArray allocWithZone:nil] initWithCapacity:range.length];

                xmlNode *node = xmlDocGetRootElement( _xmlLog ) -> children;
                do {
                        if( node && node -> type == XML_ELEMENT_NODE && ! strcmp( "envelope", (char *) node -> name ) ) {
                                xmlNode *subNode = node -> children;
                                do {
                                        if( subNode && subNode -> type == XML_ELEMENT_NODE && ! strcmp( "message", (char *) subNode -> name ) ) {
                                                if( NSLocationInRange( i, range ) ) {
                                                        JVChatMessage *msg = [[JVChatMessage allocWithZone:nil] _initWithNode:subNode andTranscript:self];
                                                        if( msg ) [ret addObject:msg];
                                                        [msg release];
                                                }

                                                if( ++i > ( range.location + range.length ) ) goto done;
                                        }
                                } while( subNode && ( subNode = subNode -> next ) );
                        } else if( node && node -> type == XML_ELEMENT_NODE && ! strcmp( "session", (char *) node -> name ) ) {
                                if( NSLocationInRange( i, range ) ) {
                                        JVChatSession *session = [[JVChatSession allocWithZone:nil] _initWithNode:node andTranscript:self];
                                        if( session ) [ret addObject:session];
                                        [session release];
                                }

                                if( ++i > ( range.location + range.length ) ) goto done;
                        } else if( node && node -> type == XML_ELEMENT_NODE && ! strcmp( "event", (char *) node -> name ) ) {
                                if( NSLocationInRange( i, range ) ) {
                                        JVChatEvent *event = [[JVChatEvent allocWithZone:nil] _initWithNode:node andTranscript:self];
                                        if( event ) [ret addObject:event];
                                        [event release];
                                }

                                if( ++i > ( range.location + range.length ) ) goto done;
                        }
                } while( node && ( node = node -> next ) );

        done:
                return [ret autorelease];
        } return nil;
}

- (id) elementAtIndex:(unsigned long) index {
        return [[self elementsInRange:NSMakeRange( index, 1 )] lastObject];
}

- (id) lastElement {
        @synchronized( self ) {
                xmlNode *node = xmlGetLastChild( xmlDocGetRootElement( _xmlLog ) );
                do {
                        if( node && node -> type == XML_ELEMENT_NODE && ! strcmp( "envelope", (char *) node -> name ) ) {
                                xmlNode *subNode = xmlGetLastChild( node );
                                do {
                                        if( subNode && subNode -> type == XML_ELEMENT_NODE && ! strcmp( "message", (char *) subNode -> name ) )
                                                return [[[JVChatMessage allocWithZone:nil] _initWithNode:subNode andTranscript:self] autorelease];
                                } while( subNode && ( subNode = subNode -> prev ) );
                        } else if( node && node -> type == XML_ELEMENT_NODE && ! strcmp( "session", (char *) node -> name ) ) {
                                return [[[JVChatSession allocWithZone:nil] _initWithNode:node andTranscript:self] autorelease];
                        } else if( node && node -> type == XML_ELEMENT_NODE && ! strcmp( "event", (char *) node -> name ) ) {
                                return [[[JVChatEvent allocWithZone:nil] _initWithNode:node andTranscript:self] autorelease];
                        }
                } while( node && ( node = node -> prev ) );
        }

        return nil;
}

#pragma mark -

- (NSArray *) appendElements:(NSArray *) elements {
        NSMutableArray *ret = [[NSMutableArray allocWithZone:nil] initWithCapacity:[elements count]];
        NSEnumerator *enumerator = [elements objectEnumerator];
        id element = nil;

        while( ( element = [enumerator nextObject] ) ) {
                if( ! [element conformsToProtocol:@protocol( JVChatTranscriptElement )] ) continue;
                @synchronized( ( [element transcript] ? (id) [element transcript] : (id) element ) ) {
                        id newElement = nil;
                        if( [element isKindOfClass:[JVChatMessage class]] ) newElement = [self appendMessage:element];
                        else if( [element isKindOfClass:[JVChatEvent class]] ) newElement = [self appendEvent:element];
                        else if( [element isKindOfClass:[JVChatSession class]] ) newElement = [self appendSession:element];
                        if( newElement ) [ret addObject:newElement];
                }
        }

        return [ret autorelease];
}

- (void) appendChatTranscript:(JVChatTranscript *) transcript {
        [self appendElements:[transcript elements]];
}

#pragma mark -

- (NSArray *) messages {
        return [self messagesInRange:NSMakeRange( 0, -1 )]; // will stop at the total number of messages.
}

- (NSArray *) messagesInRange:(NSRange) range {
        if( ! range.length ) return [NSArray array];

        @synchronized( self ) {
                if( [_messages count] >= ( range.location + range.length ) ) {
                        NSArray *sub = [_messages subarrayWithRange:range];
                        if( ! [sub containsObject:[NSNull null]] ) {
                                return sub;
                        }
                }

                if( [_messages count] < range.location )
                        for( unsigned long i = [_messages count]; i < range.location; i++ )
                                [_messages insertObject:[NSNull null] atIndex:i];

                NSMutableArray *ret = [[NSMutableArray allocWithZone:nil] initWithCapacity:range.length];
                JVChatMessage *msg = nil;

                unsigned long i = 0;

                xmlNode *node = xmlDocGetRootElement( _xmlLog ) -> children;
                do {
                        if( node && node -> type == XML_ELEMENT_NODE && ! strcmp( "envelope", (char *) node -> name ) ) {
                                xmlNode *subNode = node -> children;
                                do {
                                        if( subNode && subNode -> type == XML_ELEMENT_NODE && ! strcmp( "message", (char *) subNode -> name ) ) {
                                                if( NSLocationInRange( i, range ) ) {
                                                        if( [_messages count] > i && [[_messages objectAtIndex:i] isKindOfClass:[JVChatMessage class]] ) {
                                                                msg = [[_messages objectAtIndex:i] retain];
                                                        } else if( [_messages count] > i && [[_messages objectAtIndex:i] isKindOfClass:[NSNull class]] ) {
                                                                msg = [[JVChatMessage allocWithZone:nil] _initWithNode:subNode andTranscript:self];
                                                                id classDesc = [NSClassDescription classDescriptionForClass:[self class]];
                                                                [msg setObjectSpecifier:[[[NSUniqueIDSpecifier alloc] initWithContainerClassDescription:classDesc containerSpecifier:[self objectSpecifier] key:@"messages" uniqueID:[msg messageIdentifier]] autorelease]];
                                                                [_messages replaceObjectAtIndex:i withObject:msg];
                                                        } else if( [_messages count] == i ) {
                                                                msg = [[JVChatMessage allocWithZone:nil] _initWithNode:subNode andTranscript:self];
                                                                id classDesc = [NSClassDescription classDescriptionForClass:[self class]];
                                                                [msg setObjectSpecifier:[[[NSUniqueIDSpecifier alloc] initWithContainerClassDescription:classDesc containerSpecifier:[self objectSpecifier] key:@"messages" uniqueID:[msg messageIdentifier]] autorelease]];
                                                                [_messages insertObject:msg atIndex:i];
                                                        } else continue;
                                                        if( msg ) [ret addObject:msg];
                                                        [msg release];
                                                }

                                                if( ++i > ( range.location + range.length ) ) goto done;
                                        }
                                } while( subNode && ( subNode = subNode -> next ) );
                        }
                } while( node && ( node = node -> next ) );

        done:
                return [ret autorelease];
        } return nil;
}

- (JVChatMessage *) messageAtIndex:(unsigned long) index {
        NSRange range = NSMakeRange( index, 1 );

        @synchronized( self ) {
                if( [_messages count] > index ) {
                        id obj = [_messages objectAtIndex:index];
                        if( ! [obj isKindOfClass:[NSNull class]] ) {
                                return obj;
                        }
                }
        }

        return [[self messagesInRange:range] lastObject];
}

- (JVChatMessage *) messageWithIdentifier:(NSString *) identifier {
        NSParameterAssert( identifier != nil );
        NSParameterAssert( [identifier length] > 0 );

        @synchronized( self ) {
                const char *ident = [identifier UTF8String];
                xmlNode *foundNode = NULL;

                xmlNode *node = xmlDocGetRootElement( _xmlLog ) -> children;
                do {
                        if( node && node -> type == XML_ELEMENT_NODE && ! strcmp( "envelope", (char *) node -> name ) ) {
                                xmlNode *subNode = node -> children;
                                do {
                                        if( subNode && subNode -> type == XML_ELEMENT_NODE && ! strcmp( "message", (char *) subNode -> name ) ) {
                                                xmlChar *prop = xmlGetProp( subNode, (xmlChar *) "id" );
                                                if( prop && ! strcmp( (char *) prop, ident ) ) foundNode = subNode;
                                                if( prop ) xmlFree( prop );
                                                if( foundNode ) break;
                                        }
                                } while( subNode && ( subNode = subNode -> next ) );
                        }
                } while( node && ( node = node -> next ) );

                return ( foundNode ? [[[JVChatMessage allocWithZone:nil] _initWithNode:foundNode andTranscript:self] autorelease] : nil );
        } return nil;
}

- (JVChatMessage *) lastMessage {
        @synchronized( self ) {
                xmlNode *foundNode = NULL;
                xmlNode *node = xmlGetLastChild( xmlDocGetRootElement( _xmlLog ) );

                do {
                        if( node && node -> type == XML_ELEMENT_NODE && ! strcmp( "envelope", (char *) node -> name ) ) {
                                xmlNode *subNode = xmlGetLastChild( node );
                                do {
                                        if( subNode && subNode -> type == XML_ELEMENT_NODE && ! strcmp( "message", (char *) subNode -> name ) ) {
                                                foundNode = subNode;
                                                break;
                                        }
                                } while( subNode && ( subNode = subNode -> prev ) );
                        }
                } while( node && ( node = node -> prev ) );

                return ( foundNode ? [[[JVChatMessage allocWithZone:nil] _initWithNode:foundNode andTranscript:self] autorelease] : nil );
        } return nil;
}

#pragma mark -

- (BOOL) containsMessageWithIdentifier:(NSString *) identifier {
        NSParameterAssert( identifier != nil );
        NSParameterAssert( [identifier length] > 0 );

        @synchronized( self ) {
                xmlNode *node = xmlDocGetRootElement( _xmlLog ) -> children;
                const char *ident = [identifier UTF8String];
                BOOL found = NO;

                do {
                        if( node && node -> type == XML_ELEMENT_NODE && ! strcmp( "envelope", (char *) node -> name ) ) {
                                xmlNode *subNode = node -> children;
                                do {
                                        if( subNode && subNode -> type == XML_ELEMENT_NODE && ! strcmp( "message", (char *) subNode -> name ) ) {
                                                xmlChar *prop = xmlGetProp( subNode, (xmlChar *) "id" );
                                                if( prop && ! strcmp( (char *) prop, ident ) ) found = YES;
                                                if( prop ) xmlFree( prop );
                                                if( found ) return YES;
                                        }
                                } while( subNode && ( subNode = subNode -> next ) );
                        }
                } while( node && ( node = node -> next ) );
        }

        return NO;
}

#pragma mark -

- (JVChatMessage *) appendMessage:(JVChatMessage *) message {
        return [self appendMessage:message forceNewEnvelope:NO];
}

- (JVChatMessage *) appendMessage:(JVChatMessage *) message forceNewEnvelope:(BOOL) forceEnvelope {
        NSParameterAssert( message != nil );
        NSParameterAssert( [message node] != NULL );
        NSParameterAssert( [message transcript] != self );

        xmlNode *root = NULL, *child = NULL, *parent = NULL;

        @synchronized( self ) {
                if( ! _requiresNewEnvelope && ! forceEnvelope ) {
                        // check if the last node is an envelope by the same sender (and maybe source), if so append this message to that envelope
                        xmlNode *lastChild = xmlGetLastChild( xmlDocGetRootElement( _xmlLog ) );
                        if( lastChild && lastChild -> type == XML_ELEMENT_NODE && ! strcmp( "envelope", (char *) lastChild -> name ) ) {
                                NSString *msgSource = [[message source] absoluteString];

                                xmlChar *sourceStr = xmlGetProp( lastChild, (xmlChar *) "source" );
                                NSString *source = ( sourceStr ? [NSString stringWithUTF8String:(char *) sourceStr] : nil );
                                xmlFree( sourceStr );

                                if( ( ! msgSource && ! source ) || [msgSource isEqualToString:source] ) { // same chat source, proceed to sender check
                                        xmlNode *subNode = lastChild -> children;
                                        do {
                                                if( subNode && subNode -> type == XML_ELEMENT_NODE && ! strcmp( "sender", (char *) subNode -> name ) ) {
                                                        NSString *identifier = [message senderIdentifier];
                                                        NSString *nickname = [message senderNickname];
                                                        NSString *name = [message senderName];

                                                        xmlChar *senderNameStr = xmlNodeGetContent( subNode );
                                                        NSString *senderName = [NSString stringWithUTF8String:(char *) senderNameStr];
                                                        xmlFree( senderNameStr );

                                                        NSString *senderNickname = nil;
                                                        NSString *senderIdentifier = nil;

                                                        xmlChar *prop = xmlGetProp( subNode, (xmlChar *) "nickname" );
                                                        if( prop ) senderNickname = [NSString stringWithUTF8String:(char *) prop];
                                                        xmlFree( prop );

                                                        prop = xmlGetProp( subNode, (xmlChar *) "identifier" );
                                                        if( prop ) senderIdentifier = [NSString stringWithUTF8String:(char *) prop];
                                                        xmlFree( prop );

                                                        if( [senderIdentifier isEqualToString:identifier] || [senderNickname isEqualToString:nickname] || [senderName isEqualToString:name] )
                                                                parent = lastChild;

                                                        break;
                                                }
                                        } while( subNode && ( subNode = subNode -> next ) );
                                }
                        }
                }

                if( ! parent ) { // make a new envelope to append
                        root = xmlNewNode( NULL, (xmlChar *) "envelope" );
                        root = xmlAddChild( xmlDocGetRootElement( _xmlLog ), root );

                        if( [message source] ) xmlSetProp( root, (xmlChar *) "source", (xmlChar *) [[[message source] absoluteString] UTF8String] );

                        if( [message ignoreStatus] == JVUserIgnored )
                                xmlSetProp( root, (xmlChar *) "ignored", (xmlChar *) "yes" );

                        xmlNode *subNode = ((xmlNode *) [message node]) -> parent -> children;

                        do {
                                if( ! strcmp( "sender", (char *) subNode -> name ) ) break;
                        } while( subNode && ( subNode = subNode -> next ) );

                        child = xmlDocCopyNode( subNode, _xmlLog, 1 );
                        xmlAddChild( root, child );

                        child = xmlDocCopyNode( (xmlNode *) [message node], _xmlLog, 1 );
                        xmlAddChild( root, child );
                } else { // append message to an existing envelope
                        root = parent;
                        child = (xmlNode *) [message node];
                        child = xmlAddChild( parent, xmlDocCopyNode( child, _xmlLog, 1 ) );
                }

                [self _enforceElementLimit];
                [self _incrementalWriteToLog:root continuation:( parent ? YES : NO )];

                if( _logFile ) {
                        NSString *lastDateString = [[message date] description];
                        fsetxattr( [_logFile fileDescriptor], "lastMessageDate", [lastDateString UTF8String], [lastDateString length], 0, 0 );
                }

                _requiresNewEnvelope = NO;

                return [[[JVChatMessage allocWithZone:nil] _initWithNode:child andTranscript:self] autorelease];
        } return nil;
}

- (NSArray *) appendMessages:(NSArray *) messages {
        return [self appendMessages:messages forceNewEnvelope:NO];
}

- (NSArray *) appendMessages:(NSArray *) messages forceNewEnvelope:(BOOL) forceEnvelope {
        NSEnumerator *enumerator = [messages objectEnumerator];
        JVChatMessage *message = nil;
        NSMutableArray *ret = [[NSMutableArray allocWithZone:nil] initWithCapacity:[messages count]];

        if( forceEnvelope ) _requiresNewEnvelope = YES;

        while( ( message = [enumerator nextObject] ) ) {
                if( ! [message isKindOfClass:[JVChatMessage class]] ) continue;
                @synchronized( ( [message transcript] ? (id) [message transcript] : (id) message ) ) {
                        message = [self appendMessage:message];
                        if( message ) [ret addObject:message];
                }
        }

        return [ret autorelease];
}

#pragma mark -

- (NSArray *) sessions {
        return [self sessionsInRange:NSMakeRange( 0, -1 )]; // will stop at the total number of sessions.
}

- (NSArray *) sessionsInRange:(NSRange) range {
        if( ! range.length ) return [NSArray array];

        @synchronized( self ) {
                unsigned long i = 0;
                NSMutableArray *ret = [[NSMutableArray allocWithZone:nil] initWithCapacity:range.length];

                xmlNode *node = xmlDocGetRootElement( _xmlLog ) -> children;
                do {
                        if( node && node -> type == XML_ELEMENT_NODE && ! strcmp( "session", (char *) node -> name ) ) {
                                if( NSLocationInRange( i, range ) ) {
                                        JVChatSession *session = [[JVChatSession allocWithZone:nil] _initWithNode:node andTranscript:self];
                                        if( session ) [ret addObject:session];
                                        [session release];
                                }

                                if( ++i > ( range.location + range.length ) ) goto done