/// <summary>
/// Copy the contents of one <see cref="Stream"/> to another.
/// </summary>
/// <param name="source">The stream to source data from.</param>
/// <param name="destination">The stream to write data to.</param>
/// <param name="buffer">The buffer to use during copying.</param>
/// <remarks>This is taken from SharpZipLib.Core.StreamUtils and modified for progress callbacks.</remarks>
protected void Copy(Stream source, Stream destination, byte[] buffer)
{
PscxArgumentException.ThrowIfIsNull(source, "source");
PscxArgumentException.ThrowIfIsNull(destination, "destination");
PscxArgumentException.ThrowIfIsNull(buffer, "buffer");
PscxArgumentException.ThrowIf(buffer.Length < 128, "Buffer is too small");
long sourceLength = source.Length;
long bytesWritten = 0;
bool copying = true;
Debug.WriteLine("StartCopy", "WriterBase.Copy");
while (copying)
{
int bytesRead = source.Read(buffer, 0, buffer.Length);
if (bytesRead > 0)
{
destination.Write(buffer, 0, bytesRead);
bytesWritten += bytesRead;
OnWriteProgress(sourceLength, bytesWritten);
}
else
{
destination.Flush();
copying = false;
}
}
OnWriteComplete();
Debug.WriteLine("EndCopy", "WriterBase.Copy");
}
private Object Read(BinaryParser parser, FieldInfo field, Type type)
{
PscxArgumentException.ThrowIf((type == field.DeclaringType), "Parsing field {0} would loop forever.", field);
if (IsRecord(type))
{
return(new RecordParser(type).Parse(parser));
}
if (type == typeof(String))
{
return(ReadString(parser, field));
}
if (type == typeof(DateTime))
{
return(ReadDateTime(parser, field));
}
if (type == typeof(Version))
{
return(ReadVersion(parser, field));
}
return(ReadIntegral(parser, type));
}
public static NonSIUnit Parse(String str)
{
NonSIUnit result;
Boolean success = TryParse(str, out result);
PscxArgumentException.ThrowIf(!success, Resources.Errors.UnknownNonSIUnit, str);
return(result);
}
/// <summary>
/// Registers a delegate called when specified type of object
/// is read from the pipeline.
/// </summary>
/// <remarks>
/// You may register an interface type too, but they are processed only when
/// there is no handler available for the actual type.
/// </remarks>
/// <example>
/// <para>For example, if you register the following types, the IDisposable handler
/// will be executed only on objects which do not inherit from Stream.</para>
/// <code>
/// RegisterInputType<IDisposable>(/* ... */);
/// RegisterInputType<FileStream>(/* ... */);
/// RegisterInputType<Stream>(/* ... */);
/// </code>
/// </example>
/// <typeparam name="T">The type which should be processed. </typeparam>
/// <param name="action">
/// The delegate that is called when the object is available.
/// </param>
protected void RegisterInputType <T>(Action <T> action)
{
PscxArgumentException.ThrowIfIsNull(action,
"To ignore an input type, use IgnoreInputType<T>().");
PscxArgumentException.ThrowIf(typeof(T) == typeof(Object),
"You cannot register an action for Object. Override the ProcessInputObject method instead.");
PscxArgumentException.ThrowIf(typeof(T) == typeof(PSObject),
"You cannot register an action for PSObject. Override the ProcessInputObject method instead.");
if (_recurseIEnumerable)
{
PscxArgumentException.ThrowIf(typeof(T) == typeof(IEnumerable),
"You cannot register an action for IEnumerable when ProcessIEnumerableRecursively is true.");
}
SetTypeAction(typeof(T), action);
}
private Delegate CreateDelegate(Type type)
{
if (type.IsAbstract)
{
PscxArgumentOutOfRangeException.Throw("Type {0} is abstract.", type.Name);
}
// need a target for delegate
PscxArgumentException.ThrowIf(this._arguments.Length == 0,
"Please supply a ScriptBlock as an argument.");
// must be a scriptblock
ScriptBlock target = this._arguments[0] as ScriptBlock;
PscxArgumentException.ThrowIfIsNull(target, "The only argument in ArgumentList must be a ScriptBlock.");
Delegate invoker = GetScriptBlockDelegate(target, type);
return(invoker);
}
// this took blood, sweat and tears AND my first born.
private static Delegate GetScriptBlockDelegate(ScriptBlock block, Type delegateType)
{
PscxArgumentException.ThrowIfIsNull(block, "block");
PscxArgumentException.ThrowIfIsNull(delegateType, "block");
bool isDelegate = typeof(Delegate).IsAssignableFrom(delegateType);
PscxArgumentException.ThrowIf((!isDelegate) || (delegateType.IsAbstract),
"Invalid delegateType: {0}", delegateType.Name);
MethodInfo invoke = delegateType.GetMethod("Invoke");
Debug.Assert(invoke != null, "delegate invoke != null");
ParameterInfo[] parameters = invoke.GetParameters();
Type returnType = invoke.ReturnParameter.ParameterType;
List <Type> args = new List <Type>();
args.Add(typeof(ScriptBlock)); // first argument is instance
foreach (ParameterInfo parameter in parameters)
{
args.Add(parameter.ParameterType);
}
DynamicMethod method = new DynamicMethod(String.Empty, returnType, args.ToArray(),
typeof(ScriptBlock).Module);
ILGenerator ilgen = method.GetILGenerator();
LocalBuilder[] locals = new LocalBuilder[2]
{
ilgen.DeclareLocal(typeof(object[]), true),
ilgen.DeclareLocal(typeof(object[]), true)
};
ilgen.Emit(OpCodes.Ldc_I4, parameters.Length);
ilgen.Emit(OpCodes.Newarr, typeof(object));
ilgen.Emit(OpCodes.Stloc, 1);
for (int index = 1; index < args.Count; index++)
{
ilgen.Emit(OpCodes.Ldloc, 1);
EmitFastPushInt(ilgen, (index - 1)); // e.g. Ldc_I4_1
ilgen.Emit(OpCodes.Ldarg, index);
if (args[index].IsValueType)
{
ilgen.Emit(OpCodes.Box, args[index]);
}
ilgen.Emit(OpCodes.Stelem_Ref);
}
ilgen.Emit(OpCodes.Ldloc_1);
ilgen.Emit(OpCodes.Stloc_0);
ilgen.Emit(OpCodes.Ldarg_0); // this
ilgen.Emit(OpCodes.Ldloc_0); // object[] args for script block
ilgen.EmitCall(OpCodes.Callvirt, typeof(ScriptBlock).GetMethod("InvokeReturnAsIs"), null);
if (invoke.ReturnType == typeof(void))
{
ilgen.Emit(OpCodes.Pop);
}
else
{
// need to convert return type to the target delegate's return type
// ...
}
ilgen.Emit(OpCodes.Ret);
return(method.CreateDelegate(delegateType, block));
}
