/// <summary> /// Generate fast transfer stream data. /// </summary> /// <param name="serverId">server id.</param> /// <param name="buffer">Input buffer data.</param> /// <returns>AbstractFastTransferStream object.</returns> private AbstractFastTransferStream GenerateAbstractFastTransferStream( int serverId, byte[] buffer) { using (FastTransferStream fs = new FastTransferStream(buffer, false)) { AbstractFastTransferStream afts; // Record all property list generated while deserializing. SyntacticalBase.AllPropList = new List<PropList>(); int icsStateIndex = -1; switch (this.streamType) { case FastTransferStreamType.state: State s = new State(fs); this.VerifyMarkers(s); // Insert state to the ICSStateContainer icsStateIndex = this.InsertStateDict(s); afts = new AbstractFastTransferStream(); // Get the AbstractState corresponding to the state from the fast transfer stream. AbstractState astate = this.GetAbstractState(serverId, icsStateIndex, s); // Set the AbstractState of the AbstractFastTransferStream. afts.AbstractState = new AbstractState { AbstractICSStateIndex = icsStateIndex, IdSetGiven = astate.IdSetGiven }; //// Other fields of the AbstractState of the AbstractFastTransferStream do not need. afts.StreamType = FastTransferStreamType.state; return afts; case FastTransferStreamType.attachmentContent: AttachmentContent att = new AttachmentContent(fs); this.VerifyMarkers(att); return att.GetAbstractFastTransferStream(); case FastTransferStreamType.contentsSync: ContentsSync cs = new ContentsSync(fs); this.VerifyMarkers(cs); // Insert the state of the contentsSync to the ICSStateContainer icsStateIndex = this.InsertStateDict(cs.State); afts = this.GetAbstractContentSync( serverId, icsStateIndex, cs); return afts; case FastTransferStreamType.folderContent: FolderContent fc = new FolderContent(fs); this.VerifyMarkers(fc); this.VerifyFolderReplicaInfoStructure(fc); afts = fc.GetAbstractFastTransferStream(); if (!this.existNoPermissionFolder) { afts.AbstractFolderContent.IsNoPermissionObjNotOut = false; } this.VerifyMetaProperty(afts); return afts; case FastTransferStreamType.hierarchySync: HierarchySync hs = new HierarchySync(fs); this.VerifyMarkers(hs); if (hs.FolderChangeList.Count > 0) { PropValue property = hs.FolderChangeList[hs.FolderChangeList.Count - 1].PropList.PropValues.Find(p => p.PropInfo.PropID == 0x65e3); if (property != null) { this.lastConflictInfo.PCLXFromServer = ((VarPropTypePropValue)property).ValueArray; this.VerifyPidTagPredecessorChangeList(); } } // Insert state to the ICSStateContainer icsStateIndex = this.InsertStateDict(hs.State); afts = this.GetAbstractHierachySync(serverId, hs, icsStateIndex); return afts; case FastTransferStreamType.MessageContent: MessageContent mc = new MessageContent(fs); for (int i = 0; i < mc.PropList.PropValues.Count; i++) { PropValue propValue = mc.PropList.PropValues[i]; if (propValue.PropType == 0x84b0) { CodePage codePage = new CodePage(); codePage.Deserialize(propValue.PropType); this.VerifyCodePageProperty(codePage); } } this.VerifyMarkers(mc); afts = mc.GetAbstractFastTransferStream(); this.VerifyMetaProperty(afts); return afts; case FastTransferStreamType.MessageList: MessageList ml = new MessageList(fs); afts = ml.GetAbstractFastTransferStream(); this.VerifyMetaProperty(afts); this.VerifyMarkers(ml); return afts; case FastTransferStreamType.TopFolder: TopFolder tf = new TopFolder(fs); this.VerifyMarkers(tf); afts = tf.GetAbstractFastTransferStream(); this.VerifyMetaProperty(afts); return afts; default: AdapterHelper.Site.Assert.Fail("The stream type is invalid, its value is:{0}.", this.streamType); return new AbstractFastTransferStream(); } } }
/// <summary> /// Get HierachySync data. /// </summary> /// <param name="serverId">server id.</param> /// <param name="hsync">Content sync object</param> /// <param name="stateIndex">Start index.</param> /// <returns>The AbstractFastTransferStream</returns> private AbstractFastTransferStream GetAbstractHierachySync( int serverId, HierarchySync hsync, int stateIndex) { AbstractFastTransferStream afts = new AbstractFastTransferStream(); AbstractHierarchySync ahsync = new AbstractHierarchySync(); afts.StreamType = FastTransferStreamType.hierarchySync; ahsync.FinalICSState = this.GetAbstractState(serverId, stateIndex, hsync.State); ahsync.AbstractDeletion = this.GetAbstractDeletion(hsync.Deletions); AbstractFolderChange fc = new AbstractFolderChange(); // Get the FolderchangeInfo, FolderCount and IsParentFolderBeforeChild // of the AbstractHierarchySync. if (hsync.FolderChangeList != null && hsync.FolderChangeList.Count > 0) { AbstractFolderChange tmp = new AbstractFolderChange(); // fields:IsPidTagFolderIdExist,IsPidTagParentFolderIdExist // IsPidTagParentSourceKeyValueZero,IsPidTagSourceKeyValueZero // need all folderChange's corresponding flag is true. fc = hsync.FolderChangeList[0].GetAbstractFolderChange(); for (int i = 1; i < hsync.FolderChangeList.Count; i++) { tmp = hsync.FolderChangeList[i].GetAbstractFolderChange(); fc.IsPidTagFolderIdExist = fc.IsPidTagFolderIdExist && tmp.IsPidTagFolderIdExist; fc.IsPidTagParentFolderIdExist = fc.IsPidTagParentFolderIdExist && tmp.IsPidTagParentFolderIdExist; fc.IsPidTagParentSourceKeyValueZero = fc.IsPidTagParentSourceKeyValueZero && tmp.IsPidTagParentSourceKeyValueZero; fc.IsPidTagSourceKeyValueZero = fc.IsPidTagSourceKeyValueZero && tmp.IsPidTagSourceKeyValueZero; } ahsync.FolderchangeInfo = fc; // The count of folderChange. ahsync.FolderCount = hsync.FolderChangeList.Count; // If parents are before their children, // for a specific folder change, its ParentSourceKey // must be zero if its parent is the sync folder // or can be found before the position of the folder change. ahsync.IsParentFolderBeforeChild = hsync.IsParentBeforeChildren; } afts.AbstractHierarchySync = ahsync; return afts; }