private ItemCountAdvisor(Guid mailboxGuid, EventCondition condition, EventWatermark watermark) : base(mailboxGuid, false, condition, watermark)
{
if (condition.ObjectType != EventObjectType.Folder || condition.EventType != EventType.ObjectModified)
{
throw new ArgumentException(ServerStrings.ExInvalidItemCountAdvisorCondition);
}
}
public static ConditionAdvisor Create(StoreSession session, EventCondition condition, EventWatermark watermark)
{
if (watermark == null)
{
throw new ArgumentNullException("watermark");
}
return(EventSink.InternalCreateEventSink <ConditionAdvisor>(session, watermark, () => new ConditionAdvisor(session.MailboxGuid, session is PublicFolderSession, condition, watermark)));
}
public static ItemCountAdvisor Create(MailboxSession session, EventCondition condition, EventWatermark watermark)
{
if (watermark == null)
{
throw new ArgumentNullException("watermark");
}
return(EventSink.InternalCreateEventSink <ItemCountAdvisor>(session, watermark, () => new ItemCountAdvisor(session.MailboxGuid, condition, watermark)));
}
public static EventSubscription Create(StoreSession session, EventCondition condition, IEventHandler eventHandler, EventWatermark watermark)
{
if (watermark == null)
{
throw new ArgumentNullException("watermark");
}
return(EventSubscription.InternalCreate(session, condition, eventHandler, watermark));
}
public static EventQueue Create(StoreSession session, EventCondition condition, int maxQueueSize, EventWatermark watermark)
{
if (watermark == null)
{
throw new ArgumentNullException("watermark");
}
return(EventSink.InternalCreateEventSink <EventQueue>(session, watermark, () => new EventQueue(session.MailboxGuid, session is PublicFolderSession, condition, maxQueueSize, watermark)));
}
protected AdvisorBase(Guid mailboxGuid, bool isPublicFolderDatabase, EventCondition condition, EventWatermark watermark) : base(mailboxGuid, isPublicFolderDatabase, condition)
{
if (watermark != null)
{
this.firstMissedEventWatermark = watermark;
this.needsRecovery = true;
this.useRecoveryValues = true;
}
}
public EventCondition(EventCondition condition)
{
this.classNames = new List <string>(condition.classNames);
this.containerFolderIds = new List <StoreObjectId>(condition.containerFolderIds);
this.objectIds = new List <StoreObjectId>(condition.objectIds);
this.eventType = condition.eventType;
this.objectType = condition.objectType;
this.eventFlags = condition.eventFlags;
this.eventSubtreeFlags = condition.eventSubtreeFlags;
}
private static EventSubscription InternalCreate(StoreSession session, EventCondition condition, IEventHandler eventHandler, EventWatermark watermark)
{
if (session == null)
{
throw new ArgumentNullException("session");
}
if (condition == null)
{
throw new ArgumentNullException("condition");
}
if (eventHandler == null)
{
throw new ArgumentNullException("eventHandler");
}
EventQueue eventQueue = null;
if (watermark != null)
{
eventQueue = EventQueue.Create(session, condition, 10, watermark);
}
else
{
eventQueue = EventQueue.Create(session, condition, 10);
}
bool flag = false;
EventSubscription result;
try
{
EventSubscription eventSubscription = new EventSubscription(eventQueue, eventHandler);
flag = true;
result = eventSubscription;
}
finally
{
if (!flag && eventQueue != null)
{
eventQueue.Dispose();
eventQueue = null;
}
}
return(result);
}
private EventQueue(Guid mailboxGuid, bool isPublicFolderDatabase, EventCondition condition, int maxQueueSize, EventWatermark firstMissedEventWatermark) : base(mailboxGuid, isPublicFolderDatabase, condition)
{
using (DisposeGuard disposeGuard = this.Guard())
{
if (maxQueueSize < 10 || maxQueueSize > 1000)
{
throw new ArgumentOutOfRangeException("maxQueueSize", ServerStrings.ExInvalidMaxQueueSize);
}
this.maxQueueSize = maxQueueSize;
this.mainQueue = new Queue <Event>(10);
this.recoveryQueue = new Queue <Event>(10);
if (firstMissedEventWatermark != null)
{
this.firstMissedEventWatermark = firstMissedEventWatermark;
this.startInRecovery = true;
this.areThereMissedEvents = true;
}
disposeGuard.Success();
}
}
private ConditionAdvisor(Guid mailboxGuid, bool isPublicFolderDatabase, EventCondition condition, EventWatermark watermark) : base(mailboxGuid, isPublicFolderDatabase, condition, watermark)
{
}
public static ConditionAdvisor Create(StoreSession session, EventCondition condition)
{
return(EventSink.InternalCreateEventSink <ConditionAdvisor>(session, null, () => new ConditionAdvisor(session.MailboxGuid, session is PublicFolderSession, condition, null)));
}
internal EventSink(Guid mailboxGuid, bool isPublicFolderDatabase, EventCondition condition)
{
using (DisposeGuard disposeGuard = this.Guard())
{
if (condition == null)
{
throw new ArgumentNullException("condition");
}
this.mailboxGuid = mailboxGuid;
this.isPublicFolderDatabase = isPublicFolderDatabase;
this.condition = new EventCondition(condition);
this.mapiEventTypes = (MapiEventTypeFlags)0;
if ((condition.EventType & EventType.NewMail) == EventType.NewMail)
{
this.mapiEventTypes |= MapiEventTypeFlags.NewMail;
}
if ((condition.EventType & EventType.ObjectCreated) == EventType.ObjectCreated)
{
this.mapiEventTypes |= MapiEventTypeFlags.ObjectCreated;
}
if ((condition.EventType & EventType.ObjectDeleted) == EventType.ObjectDeleted)
{
this.mapiEventTypes |= MapiEventTypeFlags.ObjectDeleted;
}
if ((condition.EventType & EventType.ObjectModified) == EventType.ObjectModified)
{
this.mapiEventTypes |= MapiEventTypeFlags.ObjectModified;
}
if ((condition.EventType & EventType.ObjectMoved) == EventType.ObjectMoved)
{
this.mapiEventTypes |= MapiEventTypeFlags.ObjectMoved;
}
if ((condition.EventType & EventType.ObjectCopied) == EventType.ObjectCopied)
{
this.mapiEventTypes |= MapiEventTypeFlags.ObjectCopied;
}
this.parentEntryIds = new byte[condition.ContainerFolderIds.Count][];
int num = 0;
foreach (StoreObjectId storeObjectId in condition.ContainerFolderIds)
{
if (storeObjectId == null)
{
throw new ArgumentException("condition.ContainerFolderIds contains a Null id.");
}
this.parentEntryIds[num++] = storeObjectId.ProviderLevelItemId;
}
this.objectEntryIds = new byte[condition.ObjectIds.Count][];
num = 0;
foreach (StoreObjectId storeObjectId2 in condition.ObjectIds)
{
this.objectEntryIds[num++] = storeObjectId2.ProviderLevelItemId;
}
if (condition.ClassNames.Count != 0)
{
this.considerClassNames = true;
List <string> list = new List <string>();
List <string> list2 = new List <string>();
foreach (string text in condition.ClassNames)
{
if (text == "*")
{
this.considerClassNames = false;
break;
}
if (text.EndsWith(".*"))
{
list2.Add(text.Remove(text.Length - 1));
}
else
{
list.Add(text);
}
}
if (this.considerClassNames)
{
this.expectedClassNameExactMatches = list.ToArray();
this.expectedClassNamePrefixes = list2.ToArray();
}
}
disposeGuard.Success();
}
}
public static ItemCountAdvisor Create(MailboxSession session, EventCondition condition)
{
return(EventSink.InternalCreateEventSink <ItemCountAdvisor>(session, null, () => new ItemCountAdvisor(session.MailboxGuid, condition, null)));
}
public static EventSubscription Create(StoreSession session, EventCondition condition, IEventHandler eventHandler)
{
return(EventSubscription.InternalCreate(session, condition, eventHandler, null));
}
public static EventQueue Create(StoreSession session, EventCondition condition, int maxQueueSize)
{
return(EventSink.InternalCreateEventSink <EventQueue>(session, null, () => new EventQueue(session.MailboxGuid, session is PublicFolderSession, condition, maxQueueSize, null)));
}
