mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-16 17:10:20 -10:00
335 lines
8.3 KiB
C#
335 lines
8.3 KiB
C#
//
|
|
// (C) 2005 Mainsoft Corporation (http://www.mainsoft.com)
|
|
//
|
|
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining
|
|
// a copy of this software and associated documentation files (the
|
|
// "Software"), to deal in the Software without restriction, including
|
|
// without limitation the rights to use, copy, modify, merge, publish,
|
|
// distribute, sublicense, and/or sell copies of the Software, and to
|
|
// permit persons to whom the Software is furnished to do so, subject to
|
|
// the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be
|
|
// included in all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
|
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
|
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
|
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
//
|
|
|
|
using System;
|
|
using System.Web.Util;
|
|
using System.IO;
|
|
using [email protected];
|
|
using vmw.common;
|
|
using System.ComponentModel;
|
|
using System.Threading;
|
|
using javax.servlet;
|
|
using System.Diagnostics;
|
|
|
|
namespace System.Web.J2EE
|
|
{
|
|
internal static class J2EEUtils
|
|
{
|
|
#region InputStreamWrapper
|
|
|
|
public sealed class InputStreamWrapper : Stream
|
|
{
|
|
readonly java.io.InputStream _ins;
|
|
|
|
public InputStreamWrapper (java.io.InputStream ins) {
|
|
_ins = ins;
|
|
}
|
|
|
|
public override bool CanRead {
|
|
get { return true; }
|
|
}
|
|
|
|
public override bool CanSeek {
|
|
get { return _ins.markSupported (); }
|
|
}
|
|
|
|
public override bool CanWrite {
|
|
get { return false; }
|
|
}
|
|
|
|
public override void Flush () {
|
|
}
|
|
|
|
public override long Length {
|
|
get { return _ins.available (); }
|
|
}
|
|
|
|
public override long Position {
|
|
get {
|
|
throw new NotSupportedException ();
|
|
}
|
|
set {
|
|
throw new NotSupportedException ();
|
|
}
|
|
}
|
|
|
|
public override int Read (byte [] buffer, int offset, int count) {
|
|
int r = _ins.read (TypeUtils.ToSByteArray (buffer), offset, count);
|
|
return r < 0 ? 0 : r;
|
|
}
|
|
|
|
public override long Seek (long offset, SeekOrigin origin) {
|
|
throw new NotImplementedException ();
|
|
}
|
|
|
|
public override void SetLength (long value) {
|
|
throw new NotSupportedException ();
|
|
}
|
|
|
|
public override void Write (byte [] buffer, int offset, int count) {
|
|
throw new NotSupportedException ();
|
|
}
|
|
|
|
public override void Close () {
|
|
_ins.close ();
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
public static int RunProc(string[] cmd)
|
|
{
|
|
java.lang.Runtime rt = java.lang.Runtime.getRuntime();
|
|
java.lang.Process proc = rt.exec(cmd);
|
|
|
|
StreamGobbler errorGobbler = new
|
|
StreamGobbler(proc.getErrorStream(), "ERROR");
|
|
|
|
StreamGobbler outputGobbler = new
|
|
StreamGobbler(proc.getInputStream(), "OUTPUT");
|
|
|
|
errorGobbler.start();
|
|
outputGobbler.start();
|
|
|
|
int exitVal = proc.waitFor();
|
|
return exitVal;
|
|
}
|
|
}
|
|
|
|
public class StreamGobbler : java.lang.Thread
|
|
{
|
|
java.io.InputStream _is;
|
|
String _type;
|
|
|
|
public StreamGobbler(java.io.InputStream ins, String type)
|
|
{
|
|
this._is = ins;
|
|
this._type = type;
|
|
}
|
|
|
|
public override void run()
|
|
{
|
|
try
|
|
{
|
|
java.io.InputStreamReader isr = new java.io.InputStreamReader(_is);
|
|
java.io.BufferedReader br = new java.io.BufferedReader(isr);
|
|
String line=null;
|
|
while ( (line = br.readLine()) != null)
|
|
{
|
|
Debug.WriteLine(_type + ">" + line);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Debug.WriteLine (ex);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#region FileSystemWatcher Stub
|
|
|
|
namespace System.IO
|
|
{
|
|
[DefaultEvent ("Changed")]
|
|
#if NET_2_0
|
|
[IODescription ("")]
|
|
#endif
|
|
public class FileSystemWatcher : Component, ISupportInitialize
|
|
{
|
|
public FileSystemWatcher ()
|
|
: this (String.Empty) {
|
|
}
|
|
|
|
public FileSystemWatcher (string path)
|
|
: this (path, "*.*") {
|
|
}
|
|
|
|
public FileSystemWatcher (string path, string filter) {
|
|
}
|
|
|
|
#region Properties
|
|
|
|
[DefaultValue (false)]
|
|
[IODescription ("Flag to indicate if this instance is active")]
|
|
public bool EnableRaisingEvents {
|
|
get { return false; }
|
|
set { }
|
|
}
|
|
|
|
[DefaultValue ("*.*")]
|
|
[IODescription ("File name filter pattern")]
|
|
[RecommendedAsConfigurable (true)]
|
|
[TypeConverter ("System.Diagnostics.Design.StringValueConverter, " + Consts.AssemblySystem_Design)]
|
|
public string Filter {
|
|
get { return "*.*"; }
|
|
set { }
|
|
}
|
|
|
|
[DefaultValue (false)]
|
|
[IODescription ("Flag to indicate we want to watch subdirectories")]
|
|
public bool IncludeSubdirectories {
|
|
get { return false; }
|
|
set { }
|
|
}
|
|
|
|
[Browsable (false)]
|
|
[DefaultValue (8192)]
|
|
public int InternalBufferSize {
|
|
get { return 8192; }
|
|
set { }
|
|
}
|
|
|
|
[DefaultValue (NotifyFilters.FileName | NotifyFilters.DirectoryName | NotifyFilters.LastWrite)]
|
|
[IODescription ("Flag to indicate which change event we want to monitor")]
|
|
public NotifyFilters NotifyFilter {
|
|
get { return NotifyFilters.FileName | NotifyFilters.DirectoryName | NotifyFilters.LastWrite; }
|
|
set { }
|
|
}
|
|
|
|
[DefaultValue ("")]
|
|
[IODescription ("The directory to monitor")]
|
|
[RecommendedAsConfigurable (true)]
|
|
[TypeConverter ("System.Diagnostics.Design.StringValueConverter, " + Consts.AssemblySystem_Design)]
|
|
[Editor ("System.Diagnostics.Design.FSWPathEditor, " + Consts.AssemblySystem_Design, "System.Drawing.Design.UITypeEditor, " + Consts.AssemblySystem_Drawing)]
|
|
public string Path {
|
|
get { return String.Empty; }
|
|
set { }
|
|
}
|
|
|
|
[DefaultValue (null)]
|
|
[IODescription ("The object used to marshal the event handler calls resulting from a directory change")]
|
|
#if NET_2_0
|
|
[Browsable (false)]
|
|
#endif
|
|
public ISynchronizeInvoke SynchronizingObject {
|
|
get { return null; }
|
|
set { }
|
|
}
|
|
|
|
#endregion // Properties
|
|
|
|
#region Methods
|
|
|
|
protected override void Dispose (bool disposing) {
|
|
base.Dispose (disposing);
|
|
}
|
|
|
|
enum EventType
|
|
{
|
|
FileSystemEvent,
|
|
ErrorEvent,
|
|
RenameEvent
|
|
}
|
|
|
|
void RaiseEvent (Delegate ev, EventArgs arg, EventType evtype) {
|
|
if (ev == null)
|
|
return;
|
|
|
|
if (SynchronizingObject == null) {
|
|
Delegate [] delegates = ev.GetInvocationList ();
|
|
if (evtype == EventType.RenameEvent) {
|
|
foreach (RenamedEventHandler d in delegates) {
|
|
d.BeginInvoke (this, (RenamedEventArgs) arg, null, null);
|
|
}
|
|
}
|
|
else if (evtype == EventType.ErrorEvent) {
|
|
foreach (ErrorEventHandler d in delegates) {
|
|
d.BeginInvoke (this, (ErrorEventArgs) arg, null, null);
|
|
}
|
|
}
|
|
else {
|
|
foreach (FileSystemEventHandler d in delegates) {
|
|
d.BeginInvoke (this, (FileSystemEventArgs) arg, null, null);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
SynchronizingObject.BeginInvoke (ev, new object [] { this, arg });
|
|
}
|
|
|
|
protected void OnChanged (FileSystemEventArgs e) {
|
|
RaiseEvent (Changed, e, EventType.FileSystemEvent);
|
|
}
|
|
|
|
protected void OnCreated (FileSystemEventArgs e) {
|
|
RaiseEvent (Created, e, EventType.FileSystemEvent);
|
|
}
|
|
|
|
protected void OnDeleted (FileSystemEventArgs e) {
|
|
RaiseEvent (Deleted, e, EventType.FileSystemEvent);
|
|
}
|
|
|
|
protected void OnError (ErrorEventArgs e) {
|
|
RaiseEvent (Error, e, EventType.ErrorEvent);
|
|
}
|
|
|
|
protected void OnRenamed (RenamedEventArgs e) {
|
|
RaiseEvent (Renamed, e, EventType.RenameEvent);
|
|
}
|
|
|
|
public WaitForChangedResult WaitForChanged (WatcherChangeTypes changeType) {
|
|
return WaitForChanged (changeType, Timeout.Infinite);
|
|
}
|
|
|
|
public WaitForChangedResult WaitForChanged (WatcherChangeTypes changeType, int timeout) {
|
|
return new WaitForChangedResult ();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Events and Delegates
|
|
|
|
[IODescription ("Occurs when a file/directory change matches the filter")]
|
|
public event FileSystemEventHandler Changed;
|
|
|
|
[IODescription ("Occurs when a file/directory creation matches the filter")]
|
|
public event FileSystemEventHandler Created;
|
|
|
|
[IODescription ("Occurs when a file/directory deletion matches the filter")]
|
|
public event FileSystemEventHandler Deleted;
|
|
|
|
[Browsable (false)]
|
|
public event ErrorEventHandler Error;
|
|
|
|
[IODescription ("Occurs when a file/directory rename matches the filter")]
|
|
public event RenamedEventHandler Renamed;
|
|
|
|
#endregion // Events and Delegates
|
|
|
|
#region ISupportInitialize Members
|
|
|
|
public void BeginInit () {
|
|
}
|
|
|
|
public void EndInit () {
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
}
|
|
#endregion
|