/// <summary> /// Extract to specific directory, retaining filename /// </summary> public static void WriteEntryToDirectory(this IReader reader, string destinationDirectory, ExtractOptions options = ExtractOptions.Overwrite) { string destinationFileName = string.Empty; string file = Path.GetFileName(reader.Entry.Key); if (FlagUtility.HasFlag(options, ExtractOptions.ExtractFullPath)) { string folder = Path.GetDirectoryName(reader.Entry.Key); string destdir = Path.Combine(destinationDirectory, folder); if (!Directory.Exists(destdir)) { Directory.CreateDirectory(destdir); } destinationFileName = Path.Combine(destdir, file); } else { destinationFileName = Path.Combine(destinationDirectory, file); } if (!reader.Entry.IsDirectory) { reader.WriteEntryToFile(destinationFileName, options); } else if (FlagUtility.HasFlag(options, ExtractOptions.ExtractFullPath) && !Directory.Exists(destinationFileName)) { Directory.CreateDirectory(destinationFileName); } }
#pragma warning restore 0649 #endregion #region Base - Override public override bool PassCondition(EventConditionData hData) { var hPlayer = Global_GameplayManager.playerController; if (hPlayer == null || hPlayer.actorData.m_hRigid == null) { return(false); } var vVel = hPlayer.actorData.m_hRigid.velocity; if (FlagUtility.HasFlagUnsafe(m_eYType, VelocityYType.Zero) && vVel.y == m_fCheckY) { return(true); } if (FlagUtility.HasFlagUnsafe(m_eYType, VelocityYType.Up) && vVel.y > m_fCheckY) { return(true); } if (FlagUtility.HasFlagUnsafe(m_eYType, VelocityYType.Down) && vVel.y < m_fCheckY) { return(true); } return(false); }
public void doUnpack() { bool solid = FlagUtility.HasFlag(fileHeader.FileFlags, FileFlags.SOLID); if (fileHeader.PackingMethod == 0x30) { unstoreFile(); return; } switch (fileHeader.RarVersion) { case 15: // rar 1.5 compression unpack15(solid); break; case 20: // rar 2.x compression case 26: // files larger than 2GB unpack20(solid); break; case 29: // rar 3.x compression case 36: // alternative hash unpack29(solid); break; } }
public override void OnUpdateBehaviour(ActorData hActorData, List <IActorBehaviourData> lstBehaviourData) { base.OnUpdateBehaviour(hActorData, lstBehaviourData); if (hActorData.m_hRigid == null || hActorData.m_hStatus == null) { return; } float fHorizontal = hActorData.m_hInputData.m_fHorizontal; if (fHorizontal == 0) { if (!FlagUtility.HasFlagUnsafe(hActorData.m_eStateFlag, ActorStateFlag.Walking)) { return; } hActorData.m_eStateFlag &= ~ActorStateFlag.Walking; } else if (FlagUtility.HasFlagUnsafe(hActorData.m_eStateFlag, ActorStateFlag.IsWalling)) { return; } else if (!FlagUtility.HasFlagUnsafe(hActorData.m_eStateFlag, ActorStateFlag.Walking)) { hActorData.m_eStateFlag |= ActorStateFlag.Walking; } float fMoveSpeed = hActorData.m_hStatus.status.m_fMoveSpeed; Vector2 vVelocity = hActorData.m_hRigid.velocity; vVelocity.x = hActorData.m_hInputData.m_fHorizontal * fMoveSpeed; hActorData.m_hRigid.velocity = vVelocity; }
protected virtual void OnJump(ActorData hActorData, List <IActorBehaviourData> lstBehaviourData) { if (hActorData.m_hRigid == null || hActorData.m_hStatus == null || !FlagUtility.HasFlagUnsafe(hActorData.m_eStateFlag, ActorStateFlag.CanDoubleJump) || FlagUtility.HasFlagUnsafe(hActorData.m_eStateFlag, ActorStateFlag.WallJumping)) { return; } var vVel = hActorData.m_hRigid.velocity; vVel.y = 0; hActorData.m_hRigid.velocity = vVel; hActorData.m_hRigid.AddForce(new Vector2(0, hActorData.m_hStatus.status.m_fDoubleJumpForce)); hActorData.m_fJumpStartTime = Time.time; hActorData.m_eStateFlag |= ActorStateFlag.Jumping; hActorData.m_eStateFlag |= ActorStateFlag.HoldingJump; hActorData.m_eStateFlag &= ~ActorStateFlag.CanDoubleJump; if (hActorData.m_hAnimation != null) { hActorData.m_hAnimation.m_hSpineAnimationState.SetAnimation(0, hActorData.m_hAnimation.m_sJumpStartAnimation, false); hActorData.m_hAnimation.m_hSpineAnimationState.AddAnimation(0, hActorData.m_hAnimation.m_sJumpingAnimation, true, 0.2f); hActorData.m_eCurrentAnimation = ActorAnimation.Airing; } }
protected Stream GetCryptoStream(Stream plainStream) { if ((Header.CompressedSize == 0) && (Header.PkwareTraditionalEncryptionData != null)) { throw new NotSupportedException("Cannot encrypt file with unknown size at start."); } if ((Header.CompressedSize == 0) && FlagUtility.HasFlag(Header.Flags, HeaderFlags.UsePostDataDescriptor)) { plainStream = new NonDisposingStream(plainStream); //make sure AES doesn't close } else { plainStream = new ReadOnlySubStream(plainStream, Header.CompressedSize); //make sure AES doesn't close } if (Header.PkwareTraditionalEncryptionData != null) { return(new PkwareTraditionalCryptoStream(plainStream, Header.PkwareTraditionalEncryptionData, CryptoMode.Decrypt)); } return(plainStream); }
protected Stream GetCryptoStream(Stream plainStream) { if ((Header.CompressedSize == 0) #if !PORTABLE && !NETFX_CORE && ((Header.PkwareTraditionalEncryptionData != null) || (Header.WinzipAesEncryptionData != null))) #else && (Header.PkwareTraditionalEncryptionData != null)) #endif { throw new NotSupportedException("Cannot encrypt file with unknown size at start."); } if ((Header.CompressedSize == 0) && FlagUtility.HasFlag(Header.Flags, HeaderFlags.UsePostDataDescriptor)) { plainStream = new NonDisposingStream(plainStream); //make sure AES doesn't close } else { plainStream = new ReadOnlySubStream(plainStream, Header.CompressedSize); //make sure AES doesn't close } if (Header.PkwareTraditionalEncryptionData != null) { return(new PkwareTraditionalCryptoStream(plainStream, Header.PkwareTraditionalEncryptionData, CryptoMode.Decrypt)); } #if !PORTABLE && !NETFX_CORE if (Header.WinzipAesEncryptionData != null) { //only read 10 less because the last ten are auth bytes return(new WinzipAesCryptoStream(plainStream, Header.WinzipAesEncryptionData, Header.CompressedSize - 10)); } #endif return(plainStream); }
protected override void SetHoldingInputData(InputEventType eEventType, GetInputType eGetType) { if (actorData == null) { return; } var hInputData = m_hActorData.m_hInputData; InputEventType eHoldingInput = hInputData.m_eHoldingInput; if (eGetType == GetInputType.Down) { if (!FlagUtility.HasFlagUnsafe(eHoldingInput, eEventType)) { eHoldingInput |= eEventType; } } else if (eGetType == GetInputType.HoldEnd || eGetType == GetInputType.Up) { if (FlagUtility.HasFlagUnsafe(eHoldingInput, eEventType)) { eHoldingInput &= ~eEventType; } } hInputData.m_eHoldingInput = eHoldingInput; m_hActorData.m_hInputData = hInputData; }
#pragma warning restore 0649 #endregion #endregion #region Base - Override public override void OnStart(List <IDialogueEventData> lstData) { base.OnStart(lstData); if (!lstData.TryGetData(out DialogueEventData_MonoBehaviour <DSC_Dialogue_TypingController> hOutTyping)) { return; } var hTyping = hOutTyping.m_hMono; if (FlagUtility.HasFlagUnsafe(m_eSetType, TypingSetType.TypingDelayTime)) { hTyping.typingDelayTime = m_fTypingDelayTime; } if (FlagUtility.HasFlagUnsafe(m_eSetType, TypingSetType.TypingSound)) { hTyping.typingSound = m_hTypingSound; } if (FlagUtility.HasFlagUnsafe(m_eSetType, TypingSetType.EndEventDelayTime)) { hTyping.endEventDelayTime = m_fEndEventDelayTime; } }
public override void RunEvent(BaseActorController hBaseController, BaseActorBehaviour hBaseBehaviour) { var hInput = hBaseController.baseActorInput; if (hInput == null || !hBaseController.TryGetActorData(out ActorData hActorData)) { return; } float fHorizontal = hInput.inputData.m_fHorizontal; if (fHorizontal == 0) { if (!FlagUtility.HasFlagUnsafe(hActorData.m_eStateFlag, ActorStateFlag.Walking)) { return; } hActorData.m_eStateFlag &= ~ActorStateFlag.Walking; } else if (!FlagUtility.HasFlagUnsafe(hActorData.m_eStateFlag, ActorStateFlag.Walking)) { hActorData.m_eStateFlag |= ActorStateFlag.Walking; } }
private void Start() { if (FlagUtility.HasFlagUnsafe(Global_GameplayManager.playerSkill, m_eSkill)) { GetSkill(); } }
public void doUnpack() { bool solid = FlagUtility.HasFlag <FileFlags>(this.fileHeader.FileFlags, FileFlags.SOLID); if (this.fileHeader.PackingMethod == 0x30) { this.unstoreFile(); } else { switch (this.fileHeader.RarVersion) { case 0x1a: case 20: base.unpack20(solid); break; case 0x1d: case 0x24: this.unpack29(solid); break; case 15: base.unpack15(solid); break; } } }
protected Stream CreateDecompressionStream(Stream stream) { byte[] buffer; switch (this.Header.CompressionMethod) { case ZipCompressionMethod.None: return(stream); case ZipCompressionMethod.Deflate: return(new DeflateStream(stream, CompressionMode.Decompress, CompressionLevel.Default, false)); case ZipCompressionMethod.BZip2: return(new BZip2Stream(stream, CompressionMode.Decompress, false, false)); case ZipCompressionMethod.LZMA: { if (FlagUtility.HasFlag <HeaderFlags>(this.Header.Flags, HeaderFlags.Encrypted)) { throw new NotSupportedException("LZMA with pkware encryption."); } BinaryReader reader = new BinaryReader(stream); reader.ReadUInt16(); buffer = new byte[reader.ReadUInt16()]; reader.Read(buffer, 0, buffer.Length); return(new LzmaStream(buffer, stream, (this.Header.CompressedSize > 0) ? ((this.Header.CompressedSize - 4) - buffer.Length) : -1L, FlagUtility.HasFlag <HeaderFlags>(this.Header.Flags, HeaderFlags.Bit1) ? -1L : ((long)this.Header.UncompressedSize))); } case ZipCompressionMethod.PPMd: buffer = new byte[2]; stream.Read(buffer, 0, buffer.Length); return(new PpmdStream(new PpmdProperties(buffer), stream, false)); case ZipCompressionMethod.WinzipAes: { ExtraData data = Enumerable.SingleOrDefault <ExtraData>(Enumerable.Where <ExtraData>(this.Header.Extra, delegate(ExtraData x) { return(x.Type == ExtraDataType.WinZipAes); })); if (data == null) { throw new InvalidFormatException("No Winzip AES extra data found."); } if (data.Length != 7) { throw new InvalidFormatException("Winzip data length is not 7."); } ushort num = BitConverter.ToUInt16(data.DataBytes, 0); if ((num != 1) && (num != 2)) { throw new InvalidFormatException("Unexpected vendor version number for WinZip AES metadata"); } if (BitConverter.ToUInt16(data.DataBytes, 2) != 0x4541) { throw new InvalidFormatException("Unexpected vendor ID for WinZip AES metadata"); } this.Header.CompressionMethod = (ZipCompressionMethod)BitConverter.ToUInt16(data.DataBytes, 5); return(this.CreateDecompressionStream(stream)); } } throw new NotSupportedException("CompressionMethod: " + this.Header.CompressionMethod); }
protected virtual void OnWallJump(ActorData hActorData, List <IActorBehaviourData> lstBehaviourData) { if (hActorData.m_hRigid == null || hActorData.m_hStatus == null || hActorData.m_hInputData.m_fHorizontal == 0 || !FlagUtility.HasFlagUnsafe(hActorData.m_eStateFlag, ActorStateFlag.IsWalling) || FlagUtility.HasFlagUnsafe(hActorData.m_eStateFlag, ActorStateFlag.WallJumping) || !lstBehaviourData.TryGetDataRW(out WallJumpCacheData hData)) { return; } Vector2 vForce = m_vJumpForce; if (!FlagUtility.HasFlagUnsafe(hActorData.m_eStateFlag, ActorStateFlag.FacingRight)) { vForce.x = -vForce.x; } hActorData.m_hRigid.velocity = Vector2.zero; hActorData.m_hRigid.AddForce(vForce); hActorData.m_fJumpStartTime = Time.time; hActorData.m_eStateFlag |= ActorStateFlag.Jumping; hActorData.m_eStateFlag |= ActorStateFlag.HoldingJump; hActorData.m_eStateFlag |= ActorStateFlag.WallJumping; hData.m_fWallJumpLastTime = Time.time; if (hActorData.m_hAnimation) { hActorData.m_hAnimation.m_hSpineAnimationState.SetAnimation(0, hActorData.m_hAnimation.m_sClimbAnimation, false); hActorData.m_hAnimation.m_hSpineAnimationState.AddAnimation(0, hActorData.m_hAnimation.m_sJumpingAnimation, true, 0.3f); } }
public bool RemoveFlag <Flag>(FlagType eType, Flag eFlag, Object hObject) where Flag : unmanaged, System.Enum { if (dicCurrentSetFlag == null || !dicCurrentSetFlag.ContainsKey(eType)) { return(false); } if (!FlagUtility.TryParseInt(eFlag, out int nFlag)) { Debug.LogWarning("Can remove flag type int only."); return(false); } if (!dicCurrentSetFlag[eType].ContainsKey(nFlag)) { return(false); } var lstData = dicCurrentSetFlag[eType][nFlag].m_lstSetObject; lstData.Remove(hObject); if (lstData.Count <= 0) { MainRemoveFlag(eType, nFlag, hObject); } return(true); }
#pragma warning restore 0649 #endregion #endregion #region Base - Override public override void OnStart(List <IDialogueEventData> lstData) { base.OnStart(lstData); var hGroupController = GetImageGroupController(lstData); if (hGroupController == null) { return; } if (FlagUtility.HasFlagUnsafe(m_eType, ImageSetType.SetSprite)) { SetSprite(hGroupController); } if (FlagUtility.HasFlagUnsafe(m_eType, ImageSetType.SetPosition)) { SetPosition(hGroupController); } if (FlagUtility.HasFlagUnsafe(m_eType, ImageSetType.SetSize)) { SetSize(hGroupController); } if (FlagUtility.HasFlagUnsafe(m_eType, ImageSetType.SetRotation)) { SetRotation(hGroupController); } }
public virtual void Flip() { Quaternion qRightRot; Quaternion qLeftRot; if (m_bDefaultRightFacing) { qLeftRot = Quaternion.Euler(0, 180, 0); qRightRot = Quaternion.Euler(0, 0, 0); } else { qLeftRot = Quaternion.Euler(0, 0, 0); qRightRot = Quaternion.Euler(0, 180, 0); } if (FlagUtility.HasFlagUnsafe(m_hData.m_eStateFlag, ActorStateFlag.FacingRight)) { transform.localRotation = qLeftRot; m_hData.m_eStateFlag &= ~ActorStateFlag.FacingRight; } else { transform.localRotation = qRightRot; m_hData.m_eStateFlag |= ActorStateFlag.FacingRight; } }
protected override void OnUpdate() { Entities.ForEach((ref DSC_ADD_MoveSpeed3D hSpeed , ref DSC_ADD_Run hRun , in DSC_ADD_Input hInput) => { switch (hRun.m_eInputType) { case GetInputType.Down: if (FlagUtility.HasFlagUnsafe(hInput.m_eButtonDown, hRun.m_eButton)) { hRun.m_bRunning = !hRun.m_bRunning; } break; case GetInputType.Hold: hRun.m_bRunning = FlagUtility.HasFlagUnsafe(hInput.m_eButtonHold, hRun.m_eButton); break; case GetInputType.Up: if (FlagUtility.HasFlagUnsafe(hInput.m_eButtonUp, hRun.m_eButton)) { hRun.m_bRunning = !hRun.m_bRunning; } break; } if (hRun.m_bRunning) { hSpeed.m_fCurrentSpeed *= hRun.m_fSpeedMultiplier; } }).ScheduleParallel(); }
private static Options FixOptions(Options options) { if (options_HasFlag(options, Options.KeepStreamsOpen)) { options = (Options)((int)FlagUtility.SetFlag <Options>(options, Options.KeepStreamsOpen, false)); } return(options); }
protected byte[] EncodeString(string str) { if (FlagUtility.HasFlag(Flags, HeaderFlags.UTF8)) { return(Encoding.UTF8.GetBytes(str)); } return(ArchiveEncoding.Default.GetBytes(str)); }
protected override IEnumerable <ZipVolume> LoadVolumes(FileInfo file, Options options) { if (FlagUtility.HasFlag(options, Options.KeepStreamsOpen)) { options = (Options)FlagUtility.SetFlag(options, Options.KeepStreamsOpen, false); } return(new ZipVolume(file.OpenRead(), options).AsEnumerable()); }
protected string DecodeString(byte[] str) { if (FlagUtility.HasFlag(Flags, HeaderFlags.UTF8)) { return(Encoding.UTF8.GetString(str, 0, str.Length)); } return(ArchiveEncoding.Default.GetString(str, 0, str.Length)); }
protected ZipHeader ReadHeader(uint headerBytes, BinaryReader reader) { switch (headerBytes) { case ENTRY_HEADER_BYTES: { var entryHeader = new LocalEntryHeader(); entryHeader.Read(reader); LoadHeader(entryHeader, reader.BaseStream); lastEntryHeader = entryHeader; return(entryHeader); } case DIRECTORY_START_HEADER_BYTES: { var entry = new DirectoryEntryHeader(); entry.Read(reader); return(entry); } case POST_DATA_DESCRIPTOR: { if (FlagUtility.HasFlag(lastEntryHeader.Flags, HeaderFlags.UsePostDataDescriptor)) { lastEntryHeader.Crc = reader.ReadUInt32(); lastEntryHeader.CompressedSize = reader.ReadUInt32(); lastEntryHeader.UncompressedSize = reader.ReadUInt32(); } else { reader.ReadUInt32(); reader.ReadUInt32(); reader.ReadUInt32(); } return(null); } case DIGITAL_SIGNATURE: return(null); case DIRECTORY_END_HEADER_BYTES: { var entry = new DirectoryEndHeader(); entry.Read(reader); return(entry); } case SPLIT_ARCHIVE_HEADER_BYTES: { return(new SplitHeader()); } case ZIP64_END_OF_CENTRAL_DIRECTORY: default: throw new NotSupportedException("Unknown header: " + headerBytes); } }
private void LoadHeader(ZipFileEntry entryHeader, Stream stream) { if (FlagUtility.HasFlag(entryHeader.Flags, HeaderFlags.Encrypted)) { if (!entryHeader.IsDirectory && entryHeader.CompressedSize == 0 && FlagUtility.HasFlag(entryHeader.Flags, HeaderFlags.UsePostDataDescriptor)) { throw new NotSupportedException("SharpCompress cannot currently read non-seekable Zip Streams with encrypted data that has been written in a non-seekable manner."); } if (password == null) { throw new CryptographicException("No password supplied for encrypted zip."); } if (entryHeader.CompressionMethod != ZipCompressionMethod.WinzipAes) { byte[] buffer = new byte[12]; stream.Read(buffer, 0, 12); entryHeader.PkwareTraditionalEncryptionData = PkwareTraditionalEncryptionData.ForRead(password, entryHeader, buffer); entryHeader.CompressedSize -= 12; } else { throw new NotSupportedException("Cannot decrypt Winzip AES with Silverlight or WP7."); } } if (entryHeader.IsDirectory) { return; } //if (FlagUtility.HasFlag(entryHeader.Flags, HeaderFlags.UsePostDataDescriptor)) //{ // entryHeader.PackedStream = new ReadOnlySubStream(stream); //} //else //{ switch (mode) { case StreamingMode.Seekable: { entryHeader.DataStartPosition = stream.Position; stream.Position += entryHeader.CompressedSize; } break; case StreamingMode.Streaming: { entryHeader.PackedStream = stream; } break; default: { throw new InvalidFormatException("Invalid StreamingMode"); } } //} }
protected ZipHeader ReadHeader(uint headerBytes, BinaryReader reader) { switch (headerBytes) { case 0x5054b50: return(null); case 0x6054b50: { DirectoryEndHeader header3 = new DirectoryEndHeader(); header3.Read(reader); return(header3); } case 0x2014b50: { DirectoryEntryHeader header2 = new DirectoryEntryHeader(); header2.Read(reader); return(header2); } case 0x4034b50: { LocalEntryHeader entryHeader = new LocalEntryHeader(); entryHeader.Read(reader); this.LoadHeader(entryHeader, reader.BaseStream); this.lastEntryHeader = entryHeader; return(entryHeader); } case 0x6064b50: case 0x7064b50: { IgnoreHeader header4 = new IgnoreHeader(ZipHeaderType.Ignore); header4.Read(reader); return(header4); } case 0x8074b50: if (FlagUtility.HasFlag <HeaderFlags>(this.lastEntryHeader.Flags, HeaderFlags.UsePostDataDescriptor)) { this.lastEntryHeader.Crc = reader.ReadUInt32(); this.lastEntryHeader.CompressedSize = reader.ReadUInt32(); this.lastEntryHeader.UncompressedSize = reader.ReadUInt32(); } else { reader.ReadUInt32(); reader.ReadUInt32(); reader.ReadUInt32(); } return(null); case 0x30304b50: return(new SplitHeader()); } throw new NotSupportedException("Unknown header: " + headerBytes); }
public void DoDamage(int nDamage, GameObject hAttacker) { if (FlagUtility.HasFlagUnsafe(m_hActorController.actorData.m_eStateFlag, ActorStateFlag.IsDamage)) { return; } DoDamage(nDamage); }
internal IEnumerable <ZipHeader> ReadStreamHeader(Stream stream) { RewindableStream rewindableStream; if (stream is RewindableStream) { rewindableStream = stream as RewindableStream; } else { rewindableStream = new RewindableStream(stream); } while (true) { ZipHeader header = null; BinaryReader reader = new BinaryReader(rewindableStream); if (_lastEntryHeader != null && (FlagUtility.HasFlag(_lastEntryHeader.Flags, HeaderFlags.UsePostDataDescriptor) || _lastEntryHeader.IsZip64)) { reader = (_lastEntryHeader.Part as StreamingZipFilePart).FixStreamedFileLocation(ref rewindableStream); long?pos = rewindableStream.CanSeek ? (long?)rewindableStream.Position : null; uint crc = reader.ReadUInt32(); if (crc == POST_DATA_DESCRIPTOR) { crc = reader.ReadUInt32(); } _lastEntryHeader.Crc = crc; _lastEntryHeader.CompressedSize = reader.ReadUInt32(); _lastEntryHeader.UncompressedSize = reader.ReadUInt32(); if (pos.HasValue) { _lastEntryHeader.DataStartPosition = pos - _lastEntryHeader.CompressedSize; } } _lastEntryHeader = null; uint headerBytes = reader.ReadUInt32(); header = ReadHeader(headerBytes, reader); if (header == null) { yield break; } //entry could be zero bytes so we need to know that. if (header.ZipHeaderType == ZipHeaderType.LocalEntry) { bool isRecording = rewindableStream.IsRecording; if (!isRecording) { rewindableStream.StartRecording(); } uint nextHeaderBytes = reader.ReadUInt32(); header.HasData = !IsHeader(nextHeaderBytes); rewindableStream.Rewind(!isRecording); } yield return(header); } }
#pragma warning restore 0649 #endregion #region Base - Override public override bool PassCondition(ActorData hActorData, List <IActorBehaviourData> lstBehaviourData) { if (!PassAllCondition(hActorData, lstBehaviourData)) { return(false); } return(m_bIsHolding == FlagUtility.HasFlagUnsafe(hActorData.m_hInputData.m_eHoldingInput, m_eInput)); }
#pragma warning restore 0649 #endregion #region Base - Override public override bool PassCondition(ActorData hActorData, List <IActorBehaviourData> lstBehaviourData) { if (!PassAllCondition(hActorData, lstBehaviourData)) { return(false); } return(m_bIsTrue == FlagUtility.HasFlagUnsafe(hActorData.m_eStateFlag, ActorStateFlag.IsGrounding)); }
private static Options FixOptions(Options options) { //make sure we're closing streams with fileinfo if (options.HasFlag(Options.KeepStreamsOpen)) { options = (Options)FlagUtility.SetFlag(options, Options.KeepStreamsOpen, false); } return(options); }