/* MAPIStoreTable.m - this file is part of SOGo
 *
 * Copyright (C) 2010-2012 Inverse inc
 *
 * Author: Wolfgang Sourdeau <wsourdeau@inverse.ca>
 *
 * This file is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3, or (at your option)
 * any later version.
 *
 * This file 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; see the file COPYING.  If not, write to
 * the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */

#import <Foundation/NSException.h>

#import <NGExtensions/NSObject+Logs.h>
#import <EOControl/EOQualifier.h>

#import <SOGo/EOBitmaskQualifier.h>
#import "MAPIStoreActiveTables.h"
#import "MAPIStoreObject.h"
#import "MAPIStoreTypes.h"
#import "NSData+MAPIStore.h"
#import "NSString+MAPIStore.h"

#import "MAPIStoreContext.h"
#import "MAPIStoreObject.h"

#import "MAPIStoreTable.h"

#undef DEBUG
#include <mapistore/mapistore.h>
#include <mapistore/mapistore_errors.h>
#include <libmapiproxy.h>

@interface MAPIStoreTable (Private)

- (MAPIRestrictionState) evaluateRestriction: (const struct mapi_SRestriction *) res
			       intoQualifier: (EOQualifier **) qualifier;
@end

static Class NSDataK, NSStringK;

// static NSString *
// MAPIStringForRestrictionState (MAPIRestrictionState state)
// {
//   NSString *stateStr;

//   if (state == MAPIRestrictionStateAlwaysTrue)
//     stateStr = @"always true";
//   else if (state == MAPIRestrictionStateAlwaysFalse)
//     stateStr = @"always false";
//   else
//     stateStr = @"needs eval";

//   return stateStr;
// }

// static NSString *
// MAPIStringForRestriction (const struct mapi_SRestriction *resPtr);

// static NSString *
// _MAPIIndentString(int indent)
// {
//   NSString *spaces;
//   char *buffer;

//   if (indent > 0)
//     {
//       buffer = malloc (indent + 1);
//       memset (buffer, 32, indent);
//       *(buffer+indent) = 0;
//       spaces = [NSString stringWithFormat: @"%s", buffer];
//       free (buffer);
//     }
//   else
//     spaces = @"";

//   return spaces;
// }

// static NSString *
// MAPIStringForAndRestriction (const struct mapi_SAndRestriction *resAnd)
// {
//   NSMutableArray *restrictions;
//   uint16_t count;

//   restrictions = [NSMutableArray arrayWithCapacity: 8];
//   for (count = 0; count < resAnd->cRes; count++)
//     [restrictions addObject: MAPIStringForRestriction ((struct mapi_SRestriction *) resAnd->res + count)];

//   return [NSString stringWithFormat: @"(%@)", [restrictions componentsJoinedByString: @" && "]];
// }

// static NSString *
// MAPIStringForOrRestriction (const struct mapi_SOrRestriction *resOr)
// {
//   NSMutableArray *restrictions;
//   uint16_t count;

//   restrictions = [NSMutableArray arrayWithCapacity: 8];
//   for (count = 0; count < resOr->cRes; count++)
//     [restrictions addObject: MAPIStringForRestriction ((struct mapi_SRestriction *) resOr->res + count)];

//   return [NSString stringWithFormat: @"(%@)", [restrictions componentsJoinedByString: @" || "]];
// }

// static NSString *
// MAPIStringForNotRestriction (const struct mapi_SNotRestriction *resNot)
// {
//   return [NSString stringWithFormat: @"!(%@)",
// 		   MAPIStringForRestriction ((struct mapi_SRestriction *) &resNot->res)];
// }

// static NSString *
// MAPIStringForContentRestriction (const struct mapi_SContentRestriction *resContent)
// {
//   NSString *eqMatch, *caseMatch;
//   id value;
//   const char *propName;

//   switch (resContent->fuzzy & 0xf)
//     {
//     case 0: eqMatch = @"eq"; break;
//     case 1: eqMatch = @"substring"; break;
//     case 2: eqMatch = @"prefix"; break;
//     default: eqMatch = @"[unknown]";
//     }

//   switch (((resContent->fuzzy) >> 16) & 0xf)
//     {
//     case 0: caseMatch = @"fl"; break;
//     case 1: caseMatch = @"nc"; break;
//     case 2: caseMatch = @"ns"; break;
//     case 4: caseMatch = @"lo"; break;
//     default: caseMatch = @"[unknown]";
//     }

//   propName = get_proptag_name (resContent->ulPropTag);
//   if (!propName)
//     propName = "<unknown>";

//   value = NSObjectFromMAPISPropValue (&resContent->lpProp);

//   return [NSString stringWithFormat: @"%s(0x%.8x) %@,%@ %@",
// 		   propName, resContent->ulPropTag, eqMatch, caseMatch, value];
// }

// static NSString *
// MAPIStringForExistRestriction (const struct mapi_SExistRestriction *resExist)
// {
//   const char *propName;

//   propName = get_proptag_name (resExist->ulPropTag);
//   if (!propName)
//     propName = "<unknown>";

//   return [NSString stringWithFormat: @"%s(0x%.8x) IS NOT NULL", propName, resExist->ulPropTag];
// }

// static NSString *
// MAPIStringForPropertyRestriction (const struct mapi_SPropertyRestriction *resProperty)
// {
//   static NSString *operators[] = { @"<", @"<=", @">", @">=", @"==", @"!=",
// 				   @"=~" };
//   NSString *operator;
//   id value;
//   const char *propName;

//   propName = get_proptag_name (resProperty->ulPropTag);
//   if (!propName)
//     propName = "<unknown>";

//   if (resProperty->relop >= 0 && resProperty->relop < 7)
//     operator = operators[resProperty->relop];
//   else
//     operator = [NSString stringWithFormat: @"<invalid op %d>", resProperty->relop];
//   value = NSObjectFromMAPISPropValue (&resProperty->lpProp);

//   return [NSString stringWithFormat: @"%s(0x%.8x) %@ %@",
// 		   propName, resProperty->ulPropTag, operator, value];
// }

// static NSString *
// MAPIStringForBitmaskRestriction (const struct mapi_SBitmaskRestriction *resBitmask)
// {
//   NSString *format;
//   const char *propName;

//   propName = get_proptag_name (resBitmask->ulPropTag);
//   if (!propName)
//     propName = "<unknown>";

//   if (resBitmask->relMBR == 0)
//     format = @"((%s(0x%.8x) & 0x%.8x) == 0)";
//   else
//     format = @"((%s(0x%.8x) & 0x%.8x) != 0)";

//   return [NSString stringWithFormat: format,
// 		   propName, resBitmask->ulPropTag, resBitmask->ulMask];
// }

// static NSString *
// MAPIStringForRestriction (const struct mapi_SRestriction *resPtr)
// {
//   NSString *restrictionStr;

//   if (resPtr)
//     {
//       switch (resPtr->rt)
// 	{
// 	  // RES_CONTENT=(int)(0x3),
// 	  // RES_BITMASK=(int)(0x6),
// 	  // RES_EXIST=(int)(0x8),

// 	case 0: restrictionStr = MAPIStringForAndRestriction(&resPtr->res.resAnd); break;
// 	case 1: restrictionStr = MAPIStringForOrRestriction(&resPtr->res.resOr); break;
// 	case 2: restrictionStr = MAPIStringForNotRestriction(&resPtr->res.resNot); break;
// 	case 3: restrictionStr = MAPIStringForContentRestriction(&resPtr->res.resContent); break;
// 	case 4: restrictionStr = MAPIStringForPropertyRestriction(&resPtr->res.resProperty); break;
// 	case 6: restrictionStr = MAPIStringForBitmaskRestriction(&resPtr->res.resBitmask); break;
// 	case 8: restrictionStr = MAPIStringForExistRestriction(&resPtr->res.resExist); break;
// 	  // case 5: MAPIStringForComparePropsRestriction(&resPtr->res.resCompareProps); break;
// 	  // case 7: MAPIStringForPropertyRestriction(&resPtr->res.resProperty); break;
// 	  // case 9: MAPIStringForPropertyRestriction(&resPtr->res.resProperty); break;
// 	  // case 10: MAPIStringForPropertyRestriction(&resPtr->res.resProperty); break;
// 	default:
// 	  restrictionStr
// 	    = [NSString stringWithFormat: @"[unhandled restriction type: %d]",
// 			resPtr->rt];
// 	}
//     }
//   else
//     restrictionStr = @"[unrestricted]";

//   return restrictionStr;
// }

@implementation MAPIStoreTable

+ (void) initialize
{
  NSDataK = [NSData class];
  NSStringK = [NSString class];
}

+ (id) tableForContainer: (MAPIStoreObject *) newContainer
{
  MAPIStoreTable *newTable;

  newTable = [[self alloc] initForContainer: newContainer];
  [newTable autorelease];

  return newTable;
}

+ (Class) childObjectClass
{
  [self subclassResponsibility: _cmd];

  return Nil;
}

- (id) init
{
  if ((self = [super init]))
    {
      // [self logWithFormat: @"-init"];
      tableType = MAPISTORE_MESSAGE_TABLE;
      handleId = -1;

      container = nil;

      childKeys = nil;
      restrictedChildKeys = nil;

      currentRow = (uint32_t) -1;
      currentChild = nil;

      restriction = nil;
      restrictionState = MAPIRestrictionStateAlwaysTrue;
      sortOrderings = nil;

      columns = NULL;
      columnsCount = 0;
    }

  return self;
}

- (id) initForContainer: (MAPIStoreObject *) newContainer
{
  if ((self = [self init]))
    {
      container = newContainer;
    }

  return self;
}

// - (id) retain
// {
//   [self logWithFormat: @"-retain"];
//   return [super retain];
// }

// - (void) release
// {
//   [self logWithFormat: @"-release"];
//   [super release];
// }

- (void) dealloc
{
  // [self logWithFormat: @"-dealloc"];
  if (columns)
    NSZoneFree (NULL, columns);
  [currentChild release];
  [childKeys release];
  [restrictedChildKeys release];
  [sortOrderings release];
  [restriction release];
  [super dealloc];
}

- (id) container
{
  return container;
}

- (enum mapistore_table_type) tableType
{
  return tableType;
}

- (void) setHandleId: (uint32_t) newHandleId
{
  handleId = newHandleId;
  if (newHandleId)
    [[MAPIStoreActiveTables activeTables] registerTable: self];
}

- (void) destroyHandle: (uint32_t) tableHandleId
{
  if (tableHandleId && (handleId == tableHandleId))
    [[MAPIStoreActiveTables activeTables] unregisterTable: self];
}

- (void) cleanupCaches
{
  [restrictedChildKeys release];
  restrictedChildKeys = nil;
  [childKeys release];
  childKeys = nil;
  [currentChild release];
  currentChild = nil;
  currentRow = (uint32_t) -1;
}

- (enum mapistore_error) getAvailableProperties: (struct SPropTagArray **) propertiesP
                                       inMemCtx: (TALLOC_CTX *) memCtx
{
  return [[isa childObjectClass] getAvailableProperties: propertiesP
                                               inMemCtx: memCtx];
}

- (void) setRestrictions: (const struct mapi_SRestriction *) res
{
  //EOQualifier *oldRestriction;

  // [self logWithFormat: @"set restriction to (table type: %d): %@",
  // 	type, MAPIStringForRestriction (res)];

  //oldRestriction = restriction;
  [restriction autorelease];
  if (res)
    restrictionState = [self evaluateRestriction: res
				   intoQualifier: &restriction];
  else
    restrictionState = MAPIRestrictionStateAlwaysTrue;
  
  if (restrictionState == MAPIRestrictionStateNeedsEval)
    [restriction retain];
  else
    restriction = nil;
  
  // FIXME: we should not flush the caches if the restrictions matches
  [self cleanupCaches];
  
  //if (restriction)
  //  [self logWithFormat: @"restriction set to EOQualifier: %@",
//	  restriction];
 // else if (oldRestriction)
   // [self logWithFormat: @"restriction unset (was %@)", oldRestriction];
}

- (MAPIRestrictionState) evaluateNotRestriction: (struct mapi_SNotRestriction *) res
				  intoQualifier: (EOQualifier **) qualifierPtr
{
  MAPIRestrictionState state, subState;
  EONotQualifier *qualifier;
  EOQualifier *subQualifier;

  subState = [self evaluateRestriction: (struct mapi_SRestriction *)&res->res
			 intoQualifier: &subQualifier];
  if (subState == MAPIRestrictionStateAlwaysTrue)
    state = MAPIRestrictionStateAlwaysFalse;
  else if (subState == MAPIRestrictionStateAlwaysFalse)
    state = MAPIRestrictionStateAlwaysTrue;
  else
    {
      state = MAPIRestrictionStateNeedsEval;
      qualifier = [[EONotQualifier alloc] initWithQualifier: subQualifier];
      [qualifier autorelease];
      *qualifierPtr = qualifier;
    }

  return state;
}

- (MAPIRestrictionState) evaluateAndRestriction: (struct mapi_SAndRestriction *) res
				  intoQualifier: (EOQualifier **) qualifierPtr
{
  MAPIRestrictionState state, subState;
  EOAndQualifier *qualifier;
  EOQualifier *subQualifier;
  NSMutableArray *subQualifiers;
  uint16_t count;

  state = MAPIRestrictionStateNeedsEval;

  subQualifiers = [NSMutableArray arrayWithCapacity: 8];
  for (count = 0;
       state == MAPIRestrictionStateNeedsEval && count < res->cRes;
       count++)
    {
      subState = [self evaluateRestriction: (struct mapi_SRestriction *) res->res + count
			     intoQualifier: &subQualifier];
      if (subState == MAPIRestrictionStateNeedsEval)
	[subQualifiers addObject: subQualifier];
      else if (subState == MAPIRestrictionStateAlwaysFalse)
	state = MAPIRestrictionStateAlwaysFalse;
    }

  if (state == MAPIRestrictionStateNeedsEval)
    {
      if ([subQualifiers count] == 0)
	state = MAPIRestrictionStateAlwaysTrue;
      else
	{
	  qualifier = [[EOAndQualifier alloc]
			initWithQualifierArray: subQualifiers];
	  [qualifier autorelease];
	  *qualifierPtr = qualifier;
	}
    }

  return state;
}

- (MAPIRestrictionState) evaluateOrRestriction: (struct mapi_SOrRestriction *) res
				 intoQualifier: (EOQualifier **) qualifierPtr
{
  MAPIRestrictionState state, subState;
  EOOrQualifier *qualifier;
  EOQualifier *subQualifier;
  NSMutableArray *subQualifiers;
  uint16_t count, falseCount;

  state = MAPIRestrictionStateNeedsEval;

  falseCount = 0;
  subQualifiers = [NSMutableArray arrayWithCapacity: 8];
  for (count = 0;
       state == MAPIRestrictionStateNeedsEval && count < res->cRes;
       count++)
    {
      subState = [self evaluateRestriction: (struct mapi_SRestriction *) res->res + count
			     intoQualifier: &subQualifier];
      if (subState == MAPIRestrictionStateNeedsEval)
	[subQualifiers addObject: subQualifier];
      else if (subState == MAPIRestrictionStateAlwaysTrue)
	state = MAPIRestrictionStateAlwaysTrue;
      else
	falseCount++;
    }

  if (falseCount == res->cRes)
    state = MAPIRestrictionStateAlwaysFalse;
  else if ([subQualifiers count] == 0)
    state = MAPIRestrictionStateAlwaysTrue;

  if (state == MAPIRestrictionStateNeedsEval)
    {
      qualifier = [[EOOrQualifier alloc]
		    initWithQualifierArray: subQualifiers];
      [qualifier autorelease];
      *qualifierPtr = qualifier;
    }

  return state;
}

- (void) warnUnhandledProperty: (enum MAPITAGS) property
                    inFunction: (const char *) function
{
  const char *propName;

  propName = get_proptag_name (property);
  if (!propName)
    propName = "<unknown>";
  [self warnWithFormat:
	  @"property %s (%.8x) has no matching field name (%@) in '%s'",
	propName, property, self, function];
}

- (MAPIRestrictionState) evaluateContentRestriction: (struct mapi_SContentRestriction *) res
				      intoQualifier: (EOQualifier **) qualifier
{
  NSString *property;
  // SEL operator;
  id value;
  MAPIRestrictionState rc;

  property = [self backendIdentifierForProperty: res->ulPropTag];
  if (property)
    {  
      value = NSObjectFromMAPISPropValue (&res->lpProp);
      if ([value isKindOfClass: NSDataK])
	{
	  value = [[NSString alloc] initWithData: value
					encoding: NSUTF8StringEncoding];
	  [value autorelease];
	}
      else if (![value isKindOfClass: NSStringK])
	[NSException raise: @"MAPIStoreTypeConversionException"
		    format: @"unhandled content restriction for class '%@'",
		     NSStringFromClass ([value class])];

      // switch (res->fuzzy & 0xf)
      //   {
      //   case 0:
      //     operator = EOQualifierOperatorEqual;
      //     break;
      //   case 1:
      //     operator = EOQualifierOperatorLike;
      //     value = [NSString stringWithFormat: @"%%%@%%", value];
      //     break;
      //   case 2:
      //     operator = EOQualifierOperatorEqual;
      //     value = [NSString stringWithFormat: @"%@%%", value];
      //     break;
      //   default: [NSException raise: @"MAPIStoreInvalidOperatorException"
      //   		     format: @"fuzzy operator value '%.4x' is invalid",
      //   		      res->fuzzy];
      //   }
      
      *qualifier = [[EOKeyValueQualifier alloc] initWithKey: property
					   operatorSelector: EOQualifierOperatorCaseInsensitiveLike
						      value: value];
      [*qualifier autorelease];

      [self logWithFormat: @"%s: resulting qualifier: %@",
	    __PRETTY_FUNCTION__, *qualifier];
      
      rc =  MAPIRestrictionStateNeedsEval;
    }
  else
    {
      [self warnUnhandledProperty: res->ulPropTag
                       inFunction: __FUNCTION__];
      
      rc = MAPIRestrictionStateAlwaysFalse;
    }

  return rc;
}

- (SEL) operatorFromRestrictionOperator: (uint32_t) resOp
{
  static SEL operators[] = { EOQualifierOperatorLessThan,
			     EOQualifierOperatorLessThanOrEqualTo,
			     EOQualifierOperatorGreaterThan,
			     EOQualifierOperatorGreaterThanOrEqualTo,
			     EOQualifierOperatorEqual,
			     EOQualifierOperatorNotEqual,
			     EOQualifierOperatorContains };
  SEL operator;

  if (resOp < 7)
    operator = operators[resOp];
  else
    {
      operator = NULL;
      [NSException raise: @"MAPIStoreRestrictionException"
                  format: @"unhandled operator type number %d", resOp];
    }

  return operator;
}

- (MAPIRestrictionState) evaluatePropertyRestriction: (struct mapi_SPropertyRestriction *) res
				       intoQualifier: (EOQualifier **) qualifier
{
  SEL operator;
  id value;
  NSString *property;
  MAPIRestrictionState rc;

  property = [self backendIdentifierForProperty: res->ulPropTag];
  if (property)
    {
      operator = [self operatorFromRestrictionOperator: res->relop];
      value = NSObjectFromMAPISPropValue (&res->lpProp);
      *qualifier = [[EOKeyValueQualifier alloc] initWithKey: property
					   operatorSelector: operator
						      value: value];
      [*qualifier autorelease];
      
      rc = MAPIRestrictionStateNeedsEval;
    }
  else
    {
      [self warnUnhandledProperty: res->ulPropTag
                       inFunction: __FUNCTION__];
      rc = MAPIRestrictionStateAlwaysFalse;
    }

  return rc;
}

- (MAPIRestrictionState) evaluateBitmaskRestriction: (struct mapi_SBitmaskRestriction *) res
				      intoQualifier: (EOQualifier **) qualifier
{
  NSString *property;
  MAPIRestrictionState rc;

  property = [self backendIdentifierForProperty: res->ulPropTag];
  if (property)
    {
      *qualifier = [[EOBitmaskQualifier alloc] initWithKey: property
						      mask: res->ulMask
						    isZero: (res->relMBR == BMR_EQZ)];
      [*qualifier autorelease];

      rc = MAPIRestrictionStateNeedsEval;
    }
  else
    {
      [self warnUnhandledProperty: res->ulPropTag
                       inFunction: __FUNCTION__];
      rc = MAPIRestrictionStateAlwaysFalse;
    }

  return rc;
}

- (MAPIRestrictionState) evaluateExistRestriction: (struct mapi_SExistRestriction *) res
				    intoQualifier: (EOQualifier **) qualifier
{
  NSString *property;
  MAPIRestrictionState rc;

  property = [self backendIdentifierForProperty: res->ulPropTag];
  if (property)
    {
      *qualifier = [[EOKeyValueQualifier alloc] initWithKey: property
					   operatorSelector: EOQualifierOperatorNotEqual
						      value: nil];
      [*qualifier autorelease];
      
      rc = MAPIRestrictionStateNeedsEval;
    }
  else
    {
      [self warnUnhandledProperty: res->ulPropTag
                       inFunction: __FUNCTION__];
      rc = MAPIRestrictionStateAlwaysFalse;
    }

  return rc;
}

- (MAPIRestrictionState) evaluateRestriction: (struct mapi_SRestriction *) res
			       intoQualifier: (EOQualifier **) qualifier
{
  MAPIRestrictionState state;

  switch (res->rt)
    {
      /* basic operators */
    case RES_AND: state = [self evaluateAndRestriction: &res->res.resAnd
                                         intoQualifier: qualifier];
      break;
    case RES_OR: state = [self evaluateOrRestriction: &res->res.resOr
                                       intoQualifier: qualifier];
      break;
    case RES_NOT: state = [self evaluateNotRestriction: &res->res.resNot
                                         intoQualifier: qualifier];
      break;

      /* content restrictions */
    case RES_CONTENT: state = [self evaluateContentRestriction: &res->res.resContent
                                                 intoQualifier: qualifier];
      break;
    case RES_PROPERTY: state = [self evaluatePropertyRestriction: &res->res.resProperty
                                                   intoQualifier: qualifier];
      break;
    case RES_BITMASK: state = [self evaluateBitmaskRestriction: &res->res.resBitmask
                                                 intoQualifier: qualifier];
      break;

    case RES_SIZE: state = MAPIRestrictionStateAlwaysTrue; /* let's cheat a little */
      break;
    case RES_EXIST: state = [self evaluateExistRestriction: &res->res.resExist
                                             intoQualifier: qualifier];
      break;

    case RES_COMMENT:
      if (res->res.resComment.RestrictionPresent)
        state = [self evaluateRestriction: (struct mapi_SRestriction *) res->res.resComment.Restriction.res
                            intoQualifier: qualifier];
      else
        state = MAPIRestrictionStateAlwaysTrue;
      break;

    // case 5: MAPIStringForComparePropsRestriction(&resPtr->res.resCompareProps); break;
    // case 7: MAPIStringForPropertyRestriction(&resPtr->res.resProperty); break;
    // case 9: MAPIStringForPropertyRestriction(&resPtr->res.resProperty); break;
    // case 10: MAPIStringForPropertyRestriction(&resPtr->res.resProperty); break;
    default:
      [NSException raise: @"MAPIStoreRestrictionException"
                   format: @"unhandled restriction type: %.2x", res->rt];
      state = MAPIRestrictionStateAlwaysTrue;
    }

  // [self logRestriction: res withState: state];

  return state;
}

/* proof of concept */
- (enum mapistore_error) setColumns: (enum MAPITAGS *) newColumns
                          withCount: (uint16_t) newColumnsCount
{
  NSUInteger count;

  if (columns)
    NSZoneFree (NULL, columns);
  columns = NSZoneMalloc (NULL, newColumnsCount * sizeof (enum MAPITAGS));
  for (count = 0; count < newColumnsCount; count++)
    columns[count] = newColumns[count];
  columnsCount = newColumnsCount;

  return MAPISTORE_SUCCESS;
}

- (id) childAtRowID: (uint32_t) rowId
       forQueryType: (enum mapistore_query_type) queryType
{
  id child;
  NSArray *children, *restrictedChildren;
  NSString *childKey;

  if (rowId == currentRow)
    child = currentChild;
  else
    {
      [currentChild release];
      child = nil;

      if (queryType == MAPISTORE_PREFILTERED_QUERY)
        {
          children = [self restrictedChildKeys];
          restrictedChildren = nil;
        }
      else
        {
          children = [self childKeys];
          restrictedChildren = [self restrictedChildKeys];
        }

      if ([children count] > rowId)
        {
          childKey = [children objectAtIndex: rowId];
          
          if (queryType == MAPISTORE_PREFILTERED_QUERY
              || [restrictedChildren containsObject: childKey])
            child = [self lookupChild: childKey];
        }

      currentChild = child;
      [currentChild retain];

      if (child)
        currentRow = rowId;
      else
        currentRow = (uint32_t) -1;
    }

  return child;
}

- (NSArray *) childKeys
{
  [self subclassResponsibility: _cmd];

  return nil;
}

- (NSArray *) restrictedChildKeys
{
  [self subclassResponsibility: _cmd];

  return nil;
}

- (id) lookupChild: (NSString *) childKey
{
  [self subclassResponsibility: _cmd];

  return nil;
}

- (enum mapistore_error) getRow: (struct mapistore_property_data **) dataP
                      withRowID: (uint32_t) rowId
                   andQueryType: (enum mapistore_query_type) queryType
                       inMemCtx: (TALLOC_CTX *) memCtx
{
  NSUInteger count;
  MAPIStoreObject *child;
  struct mapistore_property_data *rowData;
  enum mapistore_error rc;

  child = [self childAtRowID: rowId forQueryType: queryType];
  if (child)
    {
      rowData = talloc_array(memCtx, struct mapistore_property_data, columnsCount);
      for (count = 0; count < columnsCount; count++)
        rowData[count].error = [child getProperty: &rowData[count].data
                                          withTag: columns[count]
                                         inMemCtx: memCtx];
      *dataP = rowData;
      rc = MAPISTORE_SUCCESS;
    }
  else
    rc = MAPISTORE_ERR_NOT_FOUND;

  return rc;
}

- (enum mapistore_error) getRowCount: (uint32_t *) countP
                       withQueryType: (enum mapistore_query_type) queryType
{
  NSArray *children;

  if (queryType == MAPISTORE_PREFILTERED_QUERY)
    children = [self restrictedChildKeys];
  else
    children = [self childKeys];

  *countP = [children count];

  return MAPISTORE_SUCCESS;
}

/* subclasses */
- (NSString *) backendIdentifierForProperty: (enum MAPITAGS) property
{
  [self subclassResponsibility: _cmd];

  return nil;
}

- (void) setSortOrder: (const struct SSortOrderSet *) set
{
  [self subclassResponsibility: _cmd];
}

@end
