public ProtectedPointer(SymbolicExpression sexp)
{
this.sexp = sexp.DangerousGetHandle();
this.engine = sexp.Engine;
this.GetFunction <Rf_protect>()(this.sexp);
}
/// <summary>
/// Gets the expression as a symbol.
/// </summary>
/// <param name="expression">The expression.</param>
/// <returns>The symbol.</returns>
public static Symbol AsSymbol(this SymbolicExpression expression)
{
if (!expression.IsSymbol())
{
return(null);
}
return(new Symbol(expression.Engine, expression.DangerousGetHandle()));
}
/// <summary>
/// Gets the expression as an <see cref="REnvironment"/>.
/// </summary>
/// <param name="expression">The environment.</param>
/// <returns>The environment.</returns>
public static REnvironment AsEnvironment(this SymbolicExpression expression)
{
if (!expression.IsEnvironment())
{
return(null);
}
return(new REnvironment(expression.Engine, expression.DangerousGetHandle()));
}
/// <summary>
/// Gets the expression as a function.
/// </summary>
/// <param name="expression">The expression.</param>
/// <returns>The function.</returns>
public static Function AsFunction(this SymbolicExpression expression)
{
switch (expression.Type)
{
case SymbolicExpressionType.Closure:
return(new Closure(expression.Engine, expression.DangerousGetHandle()));
case SymbolicExpressionType.BuiltinFunction:
return(new BuiltinFunction(expression.Engine, expression.DangerousGetHandle()));
case SymbolicExpressionType.SpecialFunction:
return(new SpecialFunction(expression.Engine, expression.DangerousGetHandle()));
default:
throw new ArgumentException();
}
}
/// <summary>
/// Gets the expression as a factor.
/// </summary>
/// <param name="expression">The expression.</param>
/// <returns>The factor.</returns>
public static Factor AsFactor(this SymbolicExpression expression)
{
if (!IsFactor(expression))
{
throw new ArgumentException("Not a factor.", "expression");
}
return(new Factor(expression.Engine, expression.DangerousGetHandle()));
}
/// <summary>
/// Converts the specified expression to a DataFrame.
/// </summary>
/// <param name="expression">The expression.</param>
/// <returns>The DataFrame. Returns <c>null</c> if the specified expression is not vector.</returns>
public static DataFrame AsDataFrame(this SymbolicExpression expression)
{
if (!expression.IsDataFrame())
{
return(null);
}
return(new DataFrame(expression.Engine, expression.DangerousGetHandle()));
}
/// <summary>
/// Gets the expression as a language.
/// </summary>
/// <param name="expression">The expression.</param>
/// <returns>The language.</returns>
public static Language AsLanguage(this SymbolicExpression expression)
{
if (!expression.IsLanguage())
{
return(null);
}
return(new Language(expression.Engine, expression.DangerousGetHandle()));
}
/// <summary>
/// Gets whether the specified expression is an S4 object.
/// </summary>
/// <param name="expression">The expression.</param>
/// <returns><c>True</c> if the specified expression is an S4 object.</returns>
public static bool IsS4(this SymbolicExpression expression)
{
if (expression == null)
{
throw new ArgumentNullException();
}
return(expression.GetFunction <Rf_isS4>()(expression.DangerousGetHandle()));
}
/// <summary>
/// Converts the specified expression to a CharacterVector.
/// </summary>
/// <param name="expression">The expression.</param>
/// <returns>The LogicalVector. Returns <c>null</c> if the specified expression is not vector.</returns>
public static CharacterVector AsCharacter(this SymbolicExpression expression)
{
if (!expression.IsVector())
{
return(null);
}
IntPtr coerced = IntPtr.Zero;
if (expression.IsFactor())
{
coerced = expression.GetFunction <Rf_asCharacterFactor>()(expression.DangerousGetHandle());
}
else
{
coerced = expression.GetFunction <Rf_coerceVector>()(expression.DangerousGetHandle(), SymbolicExpressionType.CharacterVector);
}
return(new CharacterVector(expression.Engine, coerced));
}
/// <summary>
/// Converts the specified expression to a RawVector.
/// </summary>
/// <param name="expression">The expression.</param>
/// <returns>The LogicalVector. Returns <c>null</c> if the specified expression is not vector.</returns>
public static RawVector AsRaw(this SymbolicExpression expression)
{
if (!expression.IsVector())
{
return(null);
}
IntPtr coerced = expression.GetFunction <Rf_coerceVector>()(expression.DangerousGetHandle(), SymbolicExpressionType.RawVector);
return(new RawVector(expression.Engine, coerced));
}
/// <summary>
/// Converts the specified expression to a DynamicVector.
/// </summary>
/// <param name="expression">The expression.</param>
/// <returns>The DynamicVector. Returns <c>null</c> if the specified expression is not vector.</returns>
public static DynamicVector AsVector(this SymbolicExpression expression)
{
if (expression == null)
{
throw new ArgumentNullException();
}
IntPtr coerced = expression.GetFunction <Rf_coerceVector>()(expression.DangerousGetHandle(), expression.Type);
return(new DynamicVector(expression.Engine, coerced));
}
private void SetValue(int rowIndex, int columnIndex, string value)
{
int offset = GetOffset(rowIndex, columnIndex);
SymbolicExpression s = value == null ? Engine.NilValue : new InternalString(Engine, value);
using (new ProtectedPointer(s))
{
Marshal.WriteIntPtr(DataPointer, offset, s.DangerousGetHandle());
}
}
/// <summary>
/// Gets whether the specified expression is factor.
/// </summary>
/// <param name="expression">The expression.</param>
/// <returns><c>True</c> if the specified expression is factor.</returns>
public static bool IsFactor(this SymbolicExpression expression)
{
if (expression == null)
{
throw new ArgumentNullException();
}
var handle = expression.DangerousGetHandle();
return(expression.GetFunction <Rf_isFactor>()(handle));
}
/// <summary>
/// Converts the specified expression to a RawMatrix.
/// </summary>
/// <param name="expression">The expression.</param>
/// <returns>The RawMatrix. Returns <c>null</c> if the specified expression is not vector.</returns>
public static RawMatrix AsRawMatrix(this SymbolicExpression expression)
{
if (!expression.IsVector())
{
return(null);
}
int rowCount = 0;
int columnCount = 0;
if (expression.IsMatrix())
{
if (expression.Type == SymbolicExpressionType.RawVector)
{
return(new RawMatrix(expression.Engine, expression.DangerousGetHandle()));
}
else
{
rowCount = expression.GetFunction <Rf_nrows>()(expression.DangerousGetHandle());
columnCount = expression.GetFunction <Rf_ncols>()(expression.DangerousGetHandle());
}
}
if (columnCount == 0)
{
rowCount = expression.GetFunction <Rf_length>()(expression.DangerousGetHandle());
columnCount = 1;
}
IntPtr coerced = expression.GetFunction <Rf_coerceVector>()(expression.DangerousGetHandle(), SymbolicExpressionType.RawVector);
var dim = new IntegerVector(expression.Engine, new[] { rowCount, columnCount });
SymbolicExpression dimSymbol = expression.Engine.GetPredefinedSymbol("R_DimSymbol");
var matrix = new RawMatrix(expression.Engine, coerced);
matrix.SetAttribute(dimSymbol, dim);
return(matrix);
}
/// <summary>
/// Defines a symbol in this environment.
/// </summary>
/// <param name="name">The name.</param>
/// <param name="expression">The symbol.</param>
public void SetSymbol(string name, SymbolicExpression expression)
{
if (name == null)
{
throw new ArgumentNullException("name", "'name' cannot be null");
}
if (name == string.Empty)
{
throw new ArgumentException("'name' cannot be an empty string");
}
if (expression == null)
{
expression = Engine.NilValue;
}
if (expression.Engine != this.Engine)
{
throw new ArgumentException();
}
IntPtr installedName = this.GetFunction <Rf_install>()(name);
this.GetFunction <Rf_defineVar>()(installedName, expression.DangerousGetHandle(), handle);
}
/// <summary>
/// Gets whether the specified expression is list.
/// </summary>
/// <param name="expression">The expression.</param>
/// <returns><c>True</c> if the specified expression is list.</returns>
public static bool IsList(this SymbolicExpression expression)
{
if (expression == null)
{
throw new ArgumentNullException();
}
// See issue 81. Rf_isList in the R API is NOT the correct thing to use (yes, hard to be more conter-intuitive)
return(expression.Type == SymbolicExpressionType.List ||
// ?is.list ==> "is.list returns TRUE if and only if its argument is a list or a pairlist of length > 0"
(expression.Type == SymbolicExpressionType.Pairlist && expression.GetFunction <Rf_length>()(expression.DangerousGetHandle()) > 0));
}
private void WriteSymbolicExpression(SymbolicExpression sexp, IntPtr pointer, int offset)
{
Marshal.WriteIntPtr(pointer, offset, sexp.DangerousGetHandle());
}
