private static string GetTypeCheckerAndConverterLambdas(Type type)
{
string rtType = TX.ToWinRT(type);
string[] jsToElementType = ToWinRT(type, TX.MainModel.Types.ContainsKey(type));
string checkType;
if (type == typeof(String))
{
// if the expected winRT type is String, allow non winrtWrapped object to be passed in and converted to Platform::String^
checkType = "(!NodeRT::Utils::IsWinRtWrapper({0}))";
}
else
{
checkType = TypeCheck(type, TX.MainModel.Types.ContainsKey(type));
}
return
(" [](Local<Value> value) -> bool {{\r\n" +
" return " + ReplaceBracketsWithDoubleBrackets(String.Format(checkType, "value")) + ";\r\n" +
" }},\r\n" +
" [](Local<Value> value) -> " + rtType + " {{\r\n" +
" return " + ReplaceBracketsWithDoubleBrackets(String.Format(jsToElementType[1], "value")) + ";\r\n" +
" }}");
}
public static string[] ToReadOnlyKeyValueCollection(string collectionName, Type keyType, Type valueType)
{
string keyRtType = TX.ToWinRT(keyType);
string[] keyTypeToJs = ToJS(keyType, TX.MainModel.Types.ContainsKey(keyType));
string keyCheckType = TypeCheck(keyType, TX.MainModel.Types.ContainsKey(keyType));
string[] jsToKeyElementType = ToWinRT(keyType, TX.MainModel.Types.ContainsKey(keyType));
string valueRtType = TX.ToWinRT(valueType);
string[] valueTypeToJs = ToJS(valueType, TX.MainModel.Types.ContainsKey(valueType));
// note that double curl braces here are used because String.Format will
string creatorFunction = "NodeRT::Collections::" + collectionName + "Wrapper<" + keyRtType + "," + valueRtType + ">::Create" + collectionName + "Wrapper({0}, \r\n" +
" [](" + keyRtType + " val) -> Local<Value> {{\r\n" +
" return " + ReplaceBracketsWithDoubleBrackets(String.Format(keyTypeToJs[1], "val")) + ";\r\n" +
" }},\r\n" +
" [](Local<Value> value) -> bool {{\r\n" +
" return " + ReplaceBracketsWithDoubleBrackets(String.Format(keyCheckType, "value")) + ";\r\n" +
" }},\r\n" +
" [](Local<Value> value) -> " + keyRtType + " {{\r\n" +
" return " + ReplaceBracketsWithDoubleBrackets(String.Format(jsToKeyElementType[1], "value")) + ";\r\n" +
" }},\r\n" +
" [](" + valueRtType + " val) -> Local<Value> {{\r\n" +
" return " + ReplaceBracketsWithDoubleBrackets(String.Format(valueTypeToJs[1], "val")) + ";\r\n" +
" }}\r\n" +
" )";
return(new[] { "NodeRT::Collections::Create" + collectionName + "<" + keyRtType + "," + valueRtType + ">", creatorFunction });
}
private static string[] GetKeyValueTypeAndLambdas(Type keyType, Type valueType)
{
string keyRtType = TX.ToWinRT(keyType);
string valueRtType = TX.ToWinRT(valueType);
string templateVals = (keyType == typeof(String)) ? "<" + valueRtType + ">" : "<" + keyRtType + ", " + valueRtType + ">";
return(new[] { templateVals,
GetTypeCheckerAndConverterLambdas(keyType) + ",\r\n" + GetTypeCheckerAndConverterLambdas(valueType) + "\r\n" });
}
public static string ForEachParameter(IEnumerable <ParameterInfo> parameters, string format, int lenToRemove)
{
var sb = new System.Text.StringBuilder();
foreach (var param in parameters)
{
sb.AppendFormat(format, param.Name, TX.ToWinRT(param.ParameterType));
}
if (sb.Length > 0)
{
sb.Remove(sb.Length - lenToRemove, lenToRemove);
}
return(sb.ToString());
}
public static string ForEachEvent(IEnumerable <dynamic> events, string format, int lenToRemove)
{
var sb = new System.Text.StringBuilder();
foreach (var e in events)
{
sb.AppendFormat(format, e.EventInfo.Name, Uncap(e.EventInfo.Name), TX.ToWinRT(e.EventInfo.EventHandlerType));
}
if (sb.Length > 0)
{
sb.Remove(sb.Length - lenToRemove, lenToRemove);
}
return(sb.ToString());
}
public static string[] ToReadOnlyCollection(string collectionName, Type elementType)
{
string elementRtType = TX.ToWinRT(elementType);
string[] elementTypeToJs = ToJS(elementType, TX.MainModel.Types.ContainsKey(elementType));
// note that double curl braces here are used because String.Format will
string creatorFunction = "NodeRT::Collections::" + collectionName + "Wrapper<" + elementRtType + ">::Create" + collectionName + "Wrapper({0}, \r\n" +
" [](" + elementRtType + " val) -> Local<Value> {{\r\n" +
" return " + ReplaceBracketsWithDoubleBrackets(String.Format(elementTypeToJs[1], "val")) + ";\r\n" +
" }}\r\n" +
" )";
return(new[] { "NodeRT::Collections::Create" + collectionName + "<" + elementRtType + ">", creatorFunction });
}
public static string ForEachType(IEnumerable <Type> types, string format, int lenToRemove)
{
var sb = new System.Text.StringBuilder();
var counter = 0;
foreach (var type in types)
{
sb.AppendFormat(format, type.Name, TX.ToWinRT(type), counter);
counter++;
}
if (sb.Length > 0)
{
sb.Remove(sb.Length - lenToRemove, lenToRemove);
}
return(sb.ToString());
}
public static string TypeCheck(Type type, bool typeIsInNameSpace = false)
{
// The primitive types are Boolean, Byte, SByte, Int16, UInt16, Int32, UInt32, Int64, UInt64, IntPtr, UIntPtr, Char, Double, and Single.
if (type.IsPrimitive)
{
if (type == typeof(Byte) ||
type == typeof(SByte) ||
type == typeof(Int16) ||
type == typeof(UInt16) ||
type == typeof(Int32)
)
{
return("{0}->IsInt32()");
}
else if (type == typeof(UInt32))
{
return("{0}->IsUint32()");
}
else if (type == typeof(Int64) ||
type == typeof(UInt64))
{
return("{0}->IsNumber()");
}
else if (type == typeof(Double) ||
type == typeof(Single) ||
type == typeof(IntPtr) ||
type == typeof(UIntPtr))
{
return("{0}->IsNumber()");
}
else if (type == typeof(Boolean))
{
return("{0}->IsBoolean()");
}
else if (type == typeof(Char))
{
return("{0}->IsString()");
}
}
if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable <>))
{
return(TypeCheck(type.GetGenericArguments()[0], TX.MainModel.Types.ContainsKey(type.GetGenericArguments()[0])));
}
if (type == typeof(Guid))
{
return("NodeRT::Utils::IsGuid({0})");
}
if (type.FullName == "Windows.UI.Color")
{
return("NodeRT::Utils::IsColor({0})");
}
if (type.FullName == "Windows.Foundation.Point")
{
return("NodeRT::Utils::IsPoint({0})");
}
if (type.FullName == "Windows.Foundation.Size")
{
return("NodeRT::Utils::IsSize({0})");
}
if (type.FullName == "Windows.Foundation.Rect")
{
return("NodeRT::Utils::IsRect({0})");
}
if (type.IsEnum)
{
return("{0}->IsInt32()");
}
if (type == typeof(String))
{
return("{0}->IsString()");
}
if (type == typeof(DateTimeOffset) || type == typeof(DateTime))
{
return("{0}->IsDate()");
}
if (type == typeof(TimeSpan))
{
return("{0}->IsNumber()");
}
// this if clause should come after IsEnum, since an enum will also return true for IsValueType
if (type.IsValueType && !(type.IsGenericType && type.FullName.StartsWith("System.Collections.Generic.KeyValuePair`2")))
{
return("Is" + type.Name + "JsObject({0})");
}
string wrapperTest = "NodeRT::Utils::IsWinRtWrapperOf<" + TX.ToWinRT(type, true) + ">({0})";
string jsType;
if (IsWinrtCollection(type, out jsType))
{
// in case the type is a winrt collection, we allow to pass a JS Object/Array instead of a wrapped collection
return("(" + wrapperTest + " || " + "{0}->Is" + jsType + "())");
}
return(wrapperTest);
}
public static string[] ToWinRT(Type type, bool typeIsInNameSpace = false)
{
// The primitive types are Boolean, Byte, SByte, Int16, UInt16, Int32, UInt32, Int64, UInt64, IntPtr, UIntPtr, Char, Double, and Single.
if (type.IsPrimitive)
{
if (type == typeof(Byte))
{
return(new[] { "unsigned char", "static_cast<unsigned char>(Nan::To<int32_t>({0}).FromMaybe(0))" });
}
else if (type == typeof(SByte))
{
return(new[] { "char", "static_cast<char>(Nan::To<int32_t>({0}).FromMaybe(0))" });
}
else if (type == typeof(Int16))
{
return(new[] { "short", "static_cast<short>(Nan::To<int32_t>({0}).FromMaybe(0))" });
}
else if (type == typeof(UInt16))
{
return(new[] { "unsigned short", "static_cast<unsigned short>(Nan::To<int32_t>({0}).FromMaybe(0))" });
}
else if (type == typeof(Int32))
{
return(new[] { "int", "static_cast<int>(Nan::To<int32_t>({0}).FromMaybe(0))" });
}
else if (type == typeof(UInt32))
{
return(new[] { "unsigned int", "static_cast<unsigned int>(Nan::To<uint32_t>({0}).FromMaybe(0))" });
}
else if (type == typeof(Int64))
{
return(new[] { "__int64", "Nan::To<int64_t>({0}).FromMaybe(0)" });
}
else if (type == typeof(UInt64))
{
return(new[] { "unsigned __int64", "static_cast<unsigned __int64>(Nan::To<int64_t>({0}).FromMaybe(0))" });
}
else if (type == typeof(IntPtr))
{
return(new[] { "__int64", "Nan::To<int64_t>({0}).FromMaybe(0)" });
}
else if (type == typeof(UIntPtr))
{
return(new[] { "unsigned __int64", "static_cast<unsigned __int64>(Nan::To<int64_t>({0}).FromMaybe(0))" });
}
else if (type == typeof(Single))
{
return(new[] { "float", "static_cast<float>(Nan::To<double>({0}).FromMaybe(0.0))" });
}
else if (type == typeof(Double))
{
return(new[] { "double", "Nan::To<double>({0}).FromMaybe(0.0)" });
}
else if (type == typeof(Boolean))
{
return(new[] { "bool", "Nan::To<bool>({0}).FromMaybe(false)" });
}
else if (type == typeof(Char))
{
return(new[] { "wchar_t", "NodeRT::Utils::GetFirstChar({0})" });
}
}
if (type == typeof(String))
{
return(new[] { "Platform::String^", "ref new Platform::String(NodeRT::Utils::StringToWchar(v8::String::Value({0})))" });
}
if (type == typeof(DateTime) || type == typeof(DateTimeOffset))
{
return(new[] { "::Windows::Foundation::DateTime", "NodeRT::Utils::DateTimeFromJSDate({0})" });
}
if (type == typeof(Guid))
{
return(new[] { "::Platform::Guid", "NodeRT::Utils::GuidFromJs({0})" });
}
if (type == typeof(Exception))
{
return(new[] { "::Windows::Foundation::HResult", "NodeRT::Utils::HResultFromJsInt32(Nan::To<int32_t>({0}).FromMaybe(0))" });
}
if (type == typeof(TimeSpan))
{
return(new[] { "::Windows::Foundation::TimeSpan", "NodeRT::Utils::TimeSpanFromMilli(Nan::To<int64_t>({0}).FromMaybe(0))" });
}
if (type.FullName == "Windows.UI.Color")
{
return(new[] { "::Windows::UI::Color", "NodeRT::Utils::ColorFromJs({0})" });
}
if (type.FullName == "Windows.Foundation.Point")
{
return(new[] { "::Windows::Foundation::Point", "NodeRT::Utils::PointFromJs({0})" });
}
if (type.FullName == "Windows.Foundation.Rect")
{
return(new[] { "::Windows::Foundation::Rect", "NodeRT::Utils::RectFromJs({0})" });
}
if (type.FullName == "Windows.Foundation.Size")
{
return(new[] { "::Windows::Foundation::Size", "NodeRT::Utils::SizeFromJs({0})" });
}
if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable <>))
{
var genericArgConversionInfo = ToWinRT(type.GetGenericArguments()[0]);
return(new[] { "::Platform::IBox<" + genericArgConversionInfo[0] + ">^", "ref new ::Platform::Box<" + genericArgConversionInfo[0] + ">(" + genericArgConversionInfo[1] + ")" });
}
var winrtFullType = TX.ToWinRT(type);
if (type.IsEnum)
{
return(new[] { winrtFullType, "static_cast<" + winrtFullType + ">(Nan::To<int32_t>({0}).FromMaybe(0))" });
}
// this if clause should come after IsEnum, since an enum will also return true for IsValueType
if (type.IsValueType && !(type.IsGenericType && type.FullName.StartsWith("System.Collections.Generic.KeyValuePair`2")))
{
return(new[] { winrtFullType, type.Name + "FromJsObject({0})" });
}
string jsType;
if (IsWinrtCollection(type, out jsType))
{
return(new[] { winrtFullType, JsToWinrtCollection(type, jsType, winrtFullType, typeIsInNameSpace) });
}
if (typeIsInNameSpace)
{
return(new[] { winrtFullType, "Unwrap" + type.Name + "({0})" });
}
return(new[] { winrtFullType, "dynamic_cast<" + winrtFullType + ">(NodeRT::Utils::GetObjectInstance({0}))" });
}
public static string[] GetValueTypeAndLambdas(Type valueType)
{
return(new[] { "<" + TX.ToWinRT(valueType) + ">", GetTypeCheckerAndConverterLambdas(valueType) + "\r\n" });
}
