public static void AddMethodHandlersClass(DefClass type, IndentStringBuilder sb)
{
if (!type.HasWrapType(WrapTypes.NativeDirector))
throw new Exception("Unexpected");
if (type.IsNested)
sb.AppendIndent("public: ");
else
sb.AppendIndent("public ");
sb.Append("ref class " + type.Name + " abstract sealed\n");
sb.AppendLine("{");
sb.AppendLine("public:");
sb.IncreaseIndent();
foreach (DefFunction f in type.PublicMethods)
{
if (f.IsDeclarableFunction && f.IsVirtual)
{
sb.AppendIndent("delegate static " + f.CLRTypeName + " " + f.CLRName + "Handler(");
for (int i = 0; i < f.Parameters.Count; i++)
{
DefParam param = f.Parameters[i];
sb.Append(" " + param.Type.GetCLRParamTypeName(param) + " " + param.Name);
if (i < f.Parameters.Count - 1) sb.Append(",");
}
sb.Append(" );\n");
}
}
sb.DecreaseIndent();
sb.AppendLine("};");
sb.AppendLine();
}
public CppClassProducer(Wrapper wrapper, DefClass t, IndentStringBuilder sb)
: base(wrapper, t, sb)
{
//if (AllowSubclassing)
//{
// _wrapper.PreClassProducers.Add(new CppNativeProtectedTypesProxy(_wrapper, _t, _sb));
//}
}
public IncClassProducer(Wrapper wrapper, DefClass t, IndentStringBuilder sb)
: base(wrapper, t, sb)
{
AddPreDeclarations();
if (_t.BaseClass != null)
AddTypeDependancy(_t.BaseClass);
if (AllowSubclassing)
{
_wrapper.PreClassProducers.Add(new NativeProtectedTypesProxy(_wrapper, _t, _sb));
_wrapper.PostClassProducers.Add(new NativeProtectedStaticsProxy(_wrapper, _t, _sb));
//_wrapper.PreClassProducers.Add(new IncNativeProtectedTypesProxy(_wrapper, _t, _sb));
}
}
public ClassProducer(Wrapper wrapper, DefClass t, IndentStringBuilder sb)
{
this._wrapper = wrapper;
this._t = t;
this._sb = sb;
foreach (DefClass iface in _t.GetInterfaces())
{
AddTypeDependancy(iface);
_interfaces.Add(iface);
}
if (_t.IsInterface)
{
// Declaring an overridable class for interface
_interfaces.Add(_t);
}
}
public IncInterfaceClassProducer(Wrapper wrapper, DefClass t, IndentStringBuilder sb)
: base(wrapper, t, sb)
{
}
public IncNativePtrValueClassProducer(Wrapper wrapper, DefClass t, IndentStringBuilder sb)
: base(wrapper, t, sb)
{
}
public IncCLRHandleClassProducer(Wrapper wrapper, DefClass t, IndentStringBuilder sb)
: base(wrapper, t, sb)
{
}
public void IncAddValueTypeTypeDef(DefTypeDef t, IndentStringBuilder sb)
{
sb.AppendIndent("");
if (t.IsNested)
sb.Append(Producer.GetProtectionString(t.ProtectionType) + ": ");
sb.Append("typedef " + t.BaseType.FullCLRName + " " + t.CLRName + ";\n\n");
}
public void IncAddSTLContainer(DefTypeDef t, IndentStringBuilder sb)
{
if (t is DefStdPair)
{
//sb.AppendIndent("");
//if (t.IsNested)
// sb.Append(Producer.GetProtectionString(t.ProtectionType) + ": ");
//sb.Append("typedef " + t.FullSTLContainerTypeName + " " + t.CLRName + ";\n\n");
return;
}
if (!t.IsNested)
{
this.AddPreDeclaration("ref class " + t.CLRName + ";");
this.AddPreDeclaration("ref class Const_" + t.CLRName + ";");
}
if (t is DefTemplateOneType)
{
if (t.HasAttribute<STLListNoRemoveAndUniqueAttribute>())
{
sb.AppendLine("#undef INC_STLLIST_DEFINE_REMOVE_AND_UNIQUE");
sb.AppendLine("#define INC_STLLIST_DEFINE_REMOVE_AND_UNIQUE(M)");
sb.AppendLine();
}
sb.AppendLine("#define STLDECL_MANAGEDTYPE " + t.TypeMembers[0].CLRTypeName);
sb.AppendLine("#define STLDECL_NATIVETYPE " + t.TypeMembers[0].NativeTypeName);
CheckTypeForDependancy(t.TypeMembers[0].Type);
}
else if (t is DefTemplateTwoTypes)
{
sb.AppendLine("#define STLDECL_MANAGEDKEY " + t.TypeMembers[0].CLRTypeName);
sb.AppendLine("#define STLDECL_MANAGEDVALUE " + t.TypeMembers[1].CLRTypeName);
sb.AppendLine("#define STLDECL_NATIVEKEY " + t.TypeMembers[0].NativeTypeName);
sb.AppendLine("#define STLDECL_NATIVEVALUE " + t.TypeMembers[1].NativeTypeName);
CheckTypeForDependancy(t.TypeMembers[0].Type);
CheckTypeForDependancy(t.TypeMembers[1].Type);
}
sb.AppendIndent("");
string publicprot, privateprot;
if (!t.IsNested)
{
publicprot = "public";
privateprot = "private";
}
else
{
publicprot = Producer.GetProtectionString(t.ProtectionType) + ": ";
privateprot = "private:";
sb.Append(publicprot);
}
sb.Append("INC_DECLARE_STL" + t.STLContainer.ToUpper());
if (t.IsReadOnly)
sb.Append("_READONLY");
sb.Append("( " + t.CLRName);
if (t is DefTemplateOneType)
sb.Append(", STLDECL_MANAGEDTYPE, STLDECL_NATIVETYPE, " + publicprot + ", " + privateprot + " )\n");
else if (t is DefTemplateTwoTypes)
sb.Append(", STLDECL_MANAGEDKEY, STLDECL_MANAGEDVALUE, STLDECL_NATIVEKEY, STLDECL_NATIVEVALUE, " + publicprot + ", " + privateprot + " )\n");
else
throw new Exception("Unexpected");
if (t is DefTemplateOneType)
{
sb.AppendLine("#undef STLDECL_MANAGEDTYPE");
sb.AppendLine("#undef STLDECL_NATIVETYPE");
if (t.HasAttribute<STLListNoRemoveAndUniqueAttribute>())
{
sb.AppendLine();
sb.AppendLine("#undef INC_STLLIST_DEFINE_REMOVE_AND_UNIQUE");
sb.AppendLine("#define INC_STLLIST_DEFINE_REMOVE_AND_UNIQUE(M) INC_STLLIST_REMOVE_AND_UNIQUE_DEFINITIONS(M)");
}
}
else if (t is DefTemplateTwoTypes)
{
sb.AppendLine("#undef STLDECL_MANAGEDKEY");
sb.AppendLine("#undef STLDECL_MANAGEDVALUE");
sb.AppendLine("#undef STLDECL_NATIVEKEY");
sb.AppendLine("#undef STLDECL_NATIVEVALUE");
}
sb.AppendLine();
}
//, bool inProtectedTypesProxy)
//public void IncAddEnum(DefEnum enm, IndentStringBuilder sb)
//{
// IncAddEnum(enm, sb, false);
//}
public void IncAddEnum(DefEnum enm, IndentStringBuilder sb)
{
if (enm.Name[0] == '@')
return;
if (enm.HasAttribute<FlagsEnumAttribute>())
{
sb.AppendLine("[Flags]");
}
sb.AppendIndent("");
if (!enm.IsNested)
sb.Append("public ");
else
sb.Append(Producer.GetProtectionString(enm.ProtectionType) + ": ");
//if (inProtectedTypesProxy)
//sb.Append("enum " + enm.Name + "\n");
//else
sb.Append("enum class " + enm.CLRName + "\n");
sb.AppendLine("{");
sb.IncreaseIndent();
for (int i=0; i < enm.CLREnumValues.Length; i++)
{
string value = enm.NativeEnumValues[i];
sb.AppendIndent("");
//if (inProtectedTypesProxy)
//{
// value = enm.ParentFullNativeName + "::" + enm.CLREnumValues[i];
// sb.Append("PUBLIC_");
//}
sb.Append(enm.CLREnumValues[i] + " = " + value);
if (i < enm.CLREnumValues.Length - 1)
sb.Append(",");
sb.Append("\n");
}
sb.DecreaseIndent();
sb.AppendLine("};\n");
}
public static void AddNativeProxyMethodBody(DefFunction f, string managedTarget, IndentStringBuilder sb)
{
string managedCall;
string fullPostConv = null;
if (f.IsGetProperty)
{
sb.AppendLine(f.CLRTypeName + " mp_return = " + managedTarget + "->" + f.CLRName + ";");
managedCall = "mp_return";
}
else if (f.IsSetProperty)
{
DefParam param = f.Parameters[0];
managedCall = managedTarget + "->" + f.CLRName + " = " + param.Type.GetNativeCallConversion(param.Name, param);
}
else
{
string pre, post, conv;
foreach (DefParam param in f.Parameters)
{
param.Type.GetNativeParamConversion(param, out pre, out conv, out post);
if (!String.IsNullOrEmpty(pre))
sb.AppendLine(pre);
if (!String.IsNullOrEmpty(post))
fullPostConv += post + "\n";
}
bool explicitCast = f.HasAttribute<ExplicitCastingForParamsAttribute>();
if (!f.IsVoid)
{
sb.AppendIndent(f.CLRTypeName + " mp_return = " + managedTarget + "->" + f.CLRName + "(");
for (int i = 0; i < f.Parameters.Count; i++)
{
DefParam param = f.Parameters[i];
param.Type.GetNativeParamConversion(param, out pre, out conv, out post);
sb.Append(" ");
if (explicitCast) sb.Append("(" + param.CLRTypeName + ")");
sb.Append(conv);
if (i < f.Parameters.Count - 1) sb.Append(",");
}
sb.Append(" );\n");
managedCall = "mp_return";
if (!String.IsNullOrEmpty(fullPostConv))
sb.AppendLine(fullPostConv);
}
else
{
managedCall = managedTarget + "->" + f.CLRName + "(";
for (int i = 0; i < f.Parameters.Count; i++)
{
DefParam param = f.Parameters[i];
param.Type.GetNativeParamConversion(param, out pre, out conv, out post);
managedCall += " ";
if (explicitCast) managedCall += "(" + param.CLRTypeName + ")";
managedCall += conv;
if (i < f.Parameters.Count - 1) managedCall += ",";
}
managedCall += " )";
}
}
if (!f.IsVoid)
{
if (f.Type is IDefString)
{
sb.AppendLine("SET_NATIVE_STRING( Mogre::Implementation::cachedReturnString, " + managedCall + " )");
sb.AppendLine("return Mogre::Implementation::cachedReturnString;");
}
else
{
string returnExpr;
string newname, expr, postcall;
DefParam param = new DefParam(f, managedCall);
expr = f.Type.GetPreCallParamConversion(param, out newname);
postcall = f.Type.GetPostCallParamConversionCleanup(param);
if (!String.IsNullOrEmpty(expr))
{
sb.AppendLine(expr);
if (String.IsNullOrEmpty(postcall))
returnExpr = newname;
else
{
throw new Exception("Unexpected");
}
}
else
{
returnExpr = newname;
}
if (IsCachedFunction(f))
{
sb.AppendLine("STATIC_ASSERT( sizeof(" + f.Type.FullNativeName + ") <= CACHED_RETURN_SIZE )");
sb.AppendLine("memcpy( Mogre::Implementation::cachedReturn, &" + returnExpr + ", sizeof(" + f.Type.FullNativeName + ") );");
sb.AppendLine("return *reinterpret_cast<" + f.Type.FullNativeName + "*>(Mogre::Implementation::cachedReturn);");
}
else
{
sb.AppendLine("return " + returnExpr + ";");
}
}
}
else
{
sb.AppendLine(managedCall + ";");
if (!String.IsNullOrEmpty(fullPostConv))
sb.AppendLine(fullPostConv);
}
}
public override void Add()
{
if (_t.IsInterface)
{
IndentStringBuilder tempsb = _sb;
_sb = new IndentStringBuilder();
base.Add();
string fname = _t.FullCLRName.Replace(_t.CLRName, _t.Name);
string res = _sb.ToString().Replace(_t.FullCLRName + "::", fname + "::");
fname = GetClassName().Replace(_t.CLRName, _t.Name);
res = res.Replace(GetClassName() + "::", fname + "::");
_sb = tempsb;
_sb.AppendLine(res);
}
else
base.Add();
}
public CppOverridableClassProducer(Wrapper wrapper, DefClass t, IndentStringBuilder sb)
: base(wrapper, t, sb)
{
_wrapper.PostClassProducers.Add(new CppNativeProxyClassProducer(_wrapper, _t, _sb));
}
public NativeProtectedTypesProxy(Wrapper wrapper, DefClass t, IndentStringBuilder sb)
: base(wrapper, t, sb)
{
}
public virtual void AddFirst()
{
IndentStringBuilder orig = _sb;
_sb = new IndentStringBuilder();
Add();
orig.sb.Insert(0, _sb.ToString());
_sb = orig;
}
public string CreateIncludeCodeForIncludeFile(string include)
{
UsedTypes.Clear();
PreClassProducers.Clear();
PostClassProducers.Clear();
IndentStringBuilder sbTypes = new IndentStringBuilder();
foreach (DefType t in IncludeFiles[include])
{
IncAddType(t, sbTypes);
}
foreach (ClassProducer producer in PostClassProducers)
{
producer.Add();
}
foreach (ClassProducer producer in PreClassProducers)
{
producer.AddFirst();
}
IndentStringBuilder sb = new IndentStringBuilder();
sb.AppendLine("#pragma once\n");
IncAddIncludeFiles(include, UsedTypes, sb);
sb.AppendFormat("namespace {0}\n{{\n", ManagedNamespace);
sb.IncreaseIndent();
sb.AppendLine(sbTypes.ToString());
sb.DecreaseIndent();
sb.AppendLine("}");
return sb.ToString().Replace("\r","");
}
public string CreateIncludeCodeForOverridable(DefClass type)
{
UsedTypes.Clear();
PreClassProducers.Clear();
PostClassProducers.Clear();
IndentStringBuilder sbTypes = new IndentStringBuilder();
new IncSubclassingClassProducer(this, type, sbTypes, null).Add();
if (type.HasAttribute<InterfacesForOverridableAttribute>())
{
List<DefClass[]> interfaces = type.GetAttribute<InterfacesForOverridableAttribute>().Interfaces;
foreach (DefClass[] ifaces in interfaces)
{
new IncSubclassingClassProducer(this, type, sbTypes, ifaces).Add();
}
}
foreach (ClassProducer producer in PostClassProducers)
{
if (!(producer is NativeProtectedTypesProxy)
&& !(producer is NativeProtectedStaticsProxy))
producer.Add();
}
foreach (ClassProducer producer in PreClassProducers)
{
if (!(producer is NativeProtectedTypesProxy)
&& !(producer is NativeProtectedStaticsProxy))
producer.AddFirst();
}
IndentStringBuilder sb = new IndentStringBuilder();
sb.AppendLine("#pragma once\n");
sb.AppendFormat("namespace {0}\n{{\n", ManagedNamespace);
sb.IncreaseIndent();
sb.AppendLine(sbTypes.ToString());
sb.DecreaseIndent();
sb.AppendLine("}");
return sb.ToString().Replace("\r", "");
}
public CppSubclassingClassProducer(Wrapper wrapper, DefClass t, IndentStringBuilder sb, DefClass[] additionalInterfaces)
: base(wrapper, t, sb)
{
this._additionalInterfaces = additionalInterfaces;
}
public void IncAddIterator(DefIterator t, IndentStringBuilder sb)
{
if (!t.IsNested)
{
this.AddPreDeclaration("ref class " + t.CLRName + ";");
}
CheckTypeForDependancy(t.IterationElementTypeMember.Type);
if (t.IsMapIterator)
CheckTypeForDependancy(t.IterationKeyTypeMember.Type);
sb.AppendIndent(Producer.GetProtectionString(t.ProtectionType));
if (t.IsNested) sb.Append(":");
if (t.IsMapIterator)
sb.Append(" INC_DECLARE_MAP_ITERATOR");
else
sb.Append(" INC_DECLARE_ITERATOR");
if (t.TypeMembers[0].Type.ProtectionType == ProtectionType.Protected
&& !t.TypeMembers[0].Type.ParentClass.AllowVirtuals)
{
// the container type will not be declared,
// declare an iterator without a constructor that takes a container class
sb.Append("_NOCONSTRUCTOR");
}
if (t.IsMapIterator)
sb.Append("( " + t.CLRName + ", " + t.FullNativeName + ", " + t.TypeMembers[0].Type.FullCLRName + ", " + t.IterationElementTypeMember.CLRTypeName + ", " + t.IterationElementTypeMember.NativeTypeName + ", " + t.IterationKeyTypeMember.CLRTypeName + ", " + t.IterationKeyTypeMember.NativeTypeName + " )\n");
else
sb.Append("( " + t.CLRName + ", " + t.FullNativeName + ", " + t.TypeMembers[0].Type.FullCLRName + ", " + t.IterationElementTypeMember.CLRTypeName + ", " + t.IterationElementTypeMember.NativeTypeName + " )\n");
sb.AppendLine();
}
private void IncAddIncludeFiles(string include, List<DefType> usedTypes, IndentStringBuilder sb)
{
sb.AppendFormat("#include \"{0}\"\n", include);
List<string> added = new List<string>();
foreach (DefType type in usedTypes)
{
if (String.IsNullOrEmpty(type.IncludeFile) || type.IncludeFile == include)
continue;
if (added.Contains(type.IncludeFile))
continue;
sb.AppendLine("#include \"" + GetManagedIncludeFileName(type.IncludeFile) + "\"");
added.Add(type.IncludeFile);
}
sb.AppendLine();
}
public void IncAddType(DefType t, IndentStringBuilder sb)
{
if (t.HasAttribute<CustomIncClassDefinitionAttribute>())
{
string txt = t.GetAttribute<CustomIncClassDefinitionAttribute>().Text;
sb.AppendLine(txt);
return;
}
if (t is DefClass)
{
if (!t.HasAttribute<WrapTypeAttribute>())
{
//Ignore
}
else
{
switch (t.GetAttribute<WrapTypeAttribute>().WrapType)
{
case WrapTypes.NonOverridable:
new IncNonOverridableClassProducer(this, t as DefClass, sb).Add();
break;
case WrapTypes.Overridable:
new IncOverridableClassProducer(this, t as DefClass, sb).Add();
break;
case WrapTypes.NativeDirector:
new IncNativeDirectorClassProducer(this, t as DefClass, sb).Add();
break;
case WrapTypes.Interface:
new IncInterfaceClassProducer(this, t as DefClass, sb).Add();
new IncOverridableClassProducer(this, t as DefClass, sb).Add();
break;
case WrapTypes.Singleton:
new IncSingletonClassProducer(this, t as DefClass, sb).Add();
break;
case WrapTypes.ReadOnlyStruct:
new IncReadOnlyStructClassProducer(this, t as DefClass, sb).Add();
break;
case WrapTypes.ValueType:
new IncValueClassProducer(this, t as DefClass, sb).Add();
break;
case WrapTypes.NativePtrValueType:
new IncNativePtrValueClassProducer(this, t as DefClass, sb).Add();
break;
case WrapTypes.CLRHandle:
new IncCLRHandleClassProducer(this, t as DefClass, sb).Add();
break;
case WrapTypes.PlainWrapper:
new IncPlainWrapperClassProducer(this, t as DefClass, sb).Add();
break;
case WrapTypes.SharedPtr:
IncAddSharedPtrType(t, sb);
break;
}
}
}
else if (t is DefEnum)
{
IncAddEnum(t as DefEnum, sb);
}
else if (t is DefTypeDef)
{
DefTypeDef explicitType;
if (t.IsUnnamedSTLContainer)
explicitType = t as DefTypeDef;
else
explicitType = (t.IsNested) ? t.ParentClass.FindType<DefTypeDef>(t.Name) : t.NameSpace.FindType<DefTypeDef>(t.Name);
if (t.HasWrapType(WrapTypes.SharedPtr))
{
IncAddSharedPtrType(t, sb);
}
else if (explicitType.IsSTLContainer)
{
IncAddSTLContainer(explicitType, sb);
}
else if (explicitType is DefIterator)
{
IncAddIterator(explicitType as DefIterator, sb);
}
else if (explicitType.BaseType is DefInternal)
{
IncAddInternalTypeDef(explicitType, sb);
}
else if (explicitType.BaseType.HasAttribute<ValueTypeAttribute>())
{
IncAddValueTypeTypeDef(explicitType, sb);
}
}
}
private void IncAddSharedPtrType(DefType type, IndentStringBuilder sb)
{
if (!type.Name.EndsWith("Ptr"))
throw new Exception("SharedPtr class that doesn't have a name ending to 'Ptr'");
string basename = null;
if (type is DefClass)
basename = (type as DefClass).Inherits[0];
else
basename = (type as DefTypeDef).BaseTypeName;
int s = basename.IndexOf("<");
int e = basename.LastIndexOf(">");
string baseClass = basename.Substring(s + 1, e - s - 1).Trim();
//string nativeClass = _nativePrefix + "::" + baseClass;
string nativeClass = type.FindType<DefType>(baseClass).FullNativeName;
string className = type.FullCLRName;
if (className.Contains("::"))
className = className.Substring(className.IndexOf("::") + 2);
if (!type.IsNested)
{
PreDeclarations.Add("ref class " + type.Name + ";");
sb.AppendIndent("public ");
}
else
{
sb.AppendIndent(Producer.GetProtectionString(type.ProtectionType) + ": ");
}
sb.Append("ref class " + type.Name + " : public " + baseClass + "\n");
sb.AppendLine("{");
sb.AppendLine("internal:");
sb.IncreaseIndent();
sb.AppendLine("\t" + type.FullNativeName + "* _sharedPtr;");
sb.AppendLine();
sb.AppendLine(type.Name + "(" + type.FullNativeName + "& sharedPtr) : " + baseClass + "( sharedPtr.getPointer() )");
sb.AppendLine("{");
sb.AppendLine("\t_sharedPtr = new " + type.FullNativeName + "(sharedPtr);");
sb.AppendLine("}");
sb.AppendLine();
sb.AppendLine("!" + type.Name + "()");
sb.AppendLine("{");
sb.IncreaseIndent();
sb.AppendLine("if (_sharedPtr != 0)");
sb.AppendLine("{");
sb.AppendLine("\tdelete _sharedPtr;");
sb.AppendLine("\t_sharedPtr = 0;");
sb.AppendLine("}");
sb.DecreaseIndent();
sb.AppendLine("}");
sb.AppendLine();
sb.AppendLine("~" + type.Name + "()");
sb.AppendLine("{");
sb.AppendLine("\tthis->!" + type.Name + "();");
sb.AppendLine("}");
sb.AppendLine();
sb.DecreaseIndent();
sb.AppendLine("public:");
sb.IncreaseIndent();
sb.AppendLine("DEFINE_MANAGED_NATIVE_CONVERSIONS_FOR_SHAREDPTR( " + className + " )");
sb.AppendLine();
if (type is DefClass)
{
DefClass realType = type.FindType<DefClass>(baseClass, false);
if (realType != null && realType.BaseClass != null && realType.BaseClass.Name == "Resource")
{
// For Resource subclasses (Material etc.) allow implicit conversion of ResourcePtr (i.e ResourcePtr -> MaterialPtr)
AddTypeDependancy(realType.BaseClass);
sb.AppendLine("static " + type.Name + "^ FromResourcePtr( ResourcePtr^ ptr )");
sb.AppendLine("{");
sb.AppendLine("\treturn (" + type.Name + "^) ptr;");
sb.AppendLine("}");
sb.AppendLine();
sb.AppendLine("static operator " + type.Name + "^ ( ResourcePtr^ ptr )");
sb.AppendLine("{");
sb.IncreaseIndent();
sb.AppendLine("void* castptr = dynamic_cast<" + nativeClass + "*>(ptr->_native);");
sb.AppendLine("if (castptr == 0) throw gcnew InvalidCastException(\"The underlying type of the ResourcePtr object is not of type " + baseClass + ".\");");
sb.AppendLine("return gcnew " + type.Name + "( (" + type.FullNativeName + ") *(ptr->_sharedPtr) );");
sb.DecreaseIndent();
sb.AppendLine("}");
sb.AppendLine();
}
}
//sb.AppendLine(type.Name + "() : " + baseClass + "( (" + nativeClass + "*) 0 )");
//sb.AppendLine("{");
//sb.AppendLine("\t_sharedPtr = new " + type.FullNativeName + "();");
//sb.AppendLine("}");
//sb.AppendLine();
sb.AppendLine(type.Name + "(" + baseClass + "^ obj) : " + baseClass + "( obj->_native )");
sb.AppendLine("{");
sb.AppendLine("\t_sharedPtr = new " + type.FullNativeName + "( static_cast<" + nativeClass + "*>(obj->_native) );");
sb.AppendLine("}");
sb.AppendLine();
//sb.AppendLine("void Bind(" + baseClass + "^ obj)");
//sb.AppendLine("{");
//sb.AppendLine("\t(*_sharedPtr).bind( static_cast<" + nativeClass + "*>(obj->_native) );");
//sb.AppendLine("}");
//sb.AppendLine();
sb.AppendLine("virtual bool Equals(Object^ obj) override");
sb.AppendLine("{");
sb.IncreaseIndent();
sb.AppendLine(type.Name + "^ clr = dynamic_cast<" + type.Name + "^>(obj);");
sb.AppendLine("if (clr == CLR_NULL)");
sb.AppendLine("{");
sb.AppendLine("\treturn false;");
sb.AppendLine("}");
sb.AppendLine();
sb.AppendLine("return (_native == clr->_native);");
sb.DecreaseIndent();
sb.AppendLine("}");
sb.AppendLine("bool Equals(" + type.Name + "^ obj)");
sb.AppendLine("{");
sb.IncreaseIndent();
sb.AppendLine("if (obj == CLR_NULL)");
sb.AppendLine("{");
sb.AppendLine("\treturn false;");
sb.AppendLine("}");
sb.AppendLine();
sb.AppendLine("return (_native == obj->_native);");
sb.DecreaseIndent();
sb.AppendLine("}");
sb.AppendLine();
sb.AppendLine("static bool operator == (" + type.Name + "^ val1, " + type.Name + "^ val2)");
sb.AppendLine("{");
sb.IncreaseIndent();
sb.AppendLine("if ((Object^)val1 == (Object^)val2) return true;");
sb.AppendLine("if ((Object^)val1 == nullptr || (Object^)val2 == nullptr) return false;");
sb.AppendLine("return (val1->_native == val2->_native);");
sb.DecreaseIndent();
sb.AppendLine("}");
sb.AppendLine();
sb.AppendLine("static bool operator != (" + type.Name + "^ val1, " + type.Name + "^ val2)");
sb.AppendLine("{");
sb.AppendLine("\treturn !(val1 == val2);");
sb.AppendLine("}");
sb.AppendLine();
sb.AppendLine("virtual int GetHashCode() override");
sb.AppendLine("{");
sb.AppendLine("\treturn reinterpret_cast<int>( _native );");
sb.AppendLine("}");
sb.AppendLine();
sb.AppendLine("property IntPtr NativePtr");
sb.AppendLine("{");
sb.AppendLine("\tIntPtr get() { return (IntPtr)_sharedPtr; }");
sb.AppendLine("}");
sb.AppendLine();
sb.AppendLine("property bool Unique");
sb.AppendLine("{");
sb.IncreaseIndent();
sb.AppendLine("bool get()");
sb.AppendLine("{");
sb.AppendLine("\treturn (*_sharedPtr).unique();");
sb.AppendLine("}");
sb.DecreaseIndent();
sb.AppendLine("}");
sb.AppendLine();
sb.AppendLine("property int UseCount");
sb.AppendLine("{");
sb.IncreaseIndent();
sb.AppendLine("int get()");
sb.AppendLine("{");
sb.AppendLine("\treturn (*_sharedPtr).useCount();");
sb.AppendLine("}");
sb.DecreaseIndent();
sb.AppendLine("}");
sb.AppendLine();
//sb.AppendLine("void SetNull()");
//sb.AppendLine("{");
//sb.AppendLine("\t(*_sharedPtr).setNull();");
//sb.AppendLine("\t_native = 0;");
//sb.AppendLine("}");
//sb.AppendLine();
sb.AppendLine("property bool IsNull");
sb.AppendLine("{");
sb.IncreaseIndent();
sb.AppendLine("bool get()");
sb.AppendLine("{");
sb.AppendLine("\treturn (*_sharedPtr).isNull();");
sb.AppendLine("}");
sb.DecreaseIndent();
sb.AppendLine("}");
sb.AppendLine();
sb.AppendLine("property " + baseClass + "^ Target");
sb.AppendLine("{");
sb.IncreaseIndent();
sb.AppendLine(baseClass + "^ get()");
sb.AppendLine("{");
sb.AppendLine("\treturn static_cast<" + nativeClass + "*>(_native);");
sb.AppendLine("}");
sb.DecreaseIndent();
sb.AppendLine("}");
sb.DecreaseIndent();
sb.AppendLine("};\n\n");
}
//protected List<DefFunction> _protectedFunctions = new List<DefFunction>();
public NativeProxyClassProducer(Wrapper wrapper, DefClass t, IndentStringBuilder sb)
: base(wrapper, t, sb)
{
//SearchProtectedFunctions(_t);
}
public void CppAddIterator(DefIterator t, IndentStringBuilder sb)
{
string prefix;
if (!t.IsNested)
{
prefix = t.FullNativeName;
prefix = prefix.Substring(0, prefix.LastIndexOf("::"));
}
else
{
prefix = t.ParentClass.FullNativeName;
}
if (prefix.Contains("::"))
prefix = prefix.Substring(prefix.IndexOf("::") + 2) + "::";
else
prefix = "";
if (t.IsMapIterator)
sb.Append("CPP_DECLARE_MAP_ITERATOR");
else
sb.Append("CPP_DECLARE_ITERATOR");
bool noConstructor = t.TypeMembers[0].Type.ProtectionType == ProtectionType.Protected
&& !t.TypeMembers[0].Type.ParentClass.AllowVirtuals;
if (noConstructor)
{
// the container type will not be declared,
// declare an iterator without a constructor that takes a container class
sb.Append("_NOCONSTRUCTOR");
}
if (t.IsMapIterator)
sb.Append("( " + prefix + ", " + t.CLRName + ", " + t.FullNativeName + ", " + t.TypeMembers[0].Type.FullCLRName + ", " + t.IterationElementTypeMember.CLRTypeName + ", " + t.IterationElementTypeMember.NativeTypeName + ", " + t.IterationKeyTypeMember.CLRTypeName + ", " + t.IterationKeyTypeMember.NativeTypeName);
else
sb.Append("( " + prefix + ", " + t.CLRName + ", " + t.FullNativeName + ", " + t.TypeMembers[0].Type.FullCLRName + ", " + t.IterationElementTypeMember.CLRTypeName + ", " + t.IterationElementTypeMember.NativeTypeName);
if (!noConstructor)
{
if (t.IsConstIterator)
sb.Append(", const");
else
sb.Append(", ");
}
sb.Append(" )\n");
AddTypeDependancy(t.TypeMembers[0].Type);
sb.AppendLine();
}
public IncSingletonClassProducer(Wrapper wrapper, DefClass t, IndentStringBuilder sb)
: base(wrapper, t, sb)
{
}
public void CppAddSTLContainer(DefTypeDef t, IndentStringBuilder sb)
{
if (t is DefStdPair)
{
return;
}
if (t is DefTemplateOneType)
{
if (t.HasAttribute<STLListNoRemoveAndUniqueAttribute>())
{
sb.AppendLine("#undef CPP_STLLIST_DEFINE_REMOVE_AND_UNIQUE");
sb.AppendLine("#define CPP_STLLIST_DEFINE_REMOVE_AND_UNIQUE(PREFIX,CLASS_NAME,M,N)");
sb.AppendLine();
}
sb.AppendLine("#define STLDECL_MANAGEDTYPE " + t.TypeMembers[0].CLRTypeName);
sb.AppendLine("#define STLDECL_NATIVETYPE " + t.TypeMembers[0].NativeTypeName);
CppCheckTypeForDependancy(t.TypeMembers[0].Type);
}
else if (t is DefTemplateTwoTypes)
{
sb.AppendLine("#define STLDECL_MANAGEDKEY " + t.TypeMembers[0].CLRTypeName);
sb.AppendLine("#define STLDECL_MANAGEDVALUE " + t.TypeMembers[1].CLRTypeName);
sb.AppendLine("#define STLDECL_NATIVEKEY " + t.TypeMembers[0].NativeTypeName);
sb.AppendLine("#define STLDECL_NATIVEVALUE " + t.TypeMembers[1].NativeTypeName);
CppCheckTypeForDependancy(t.TypeMembers[0].Type);
CppCheckTypeForDependancy(t.TypeMembers[1].Type);
}
sb.AppendIndent("CPP_DECLARE_STL" + t.STLContainer.ToUpper());
if (t.IsReadOnly)
sb.Append("_READONLY");
string prefix;
if (!t.IsNested)
{
prefix = t.FullNativeName;
prefix = prefix.Substring(0, prefix.LastIndexOf("::"));
}
else
{
prefix = t.ParentClass.FullNativeName;
}
if (prefix.Contains("::"))
prefix = prefix.Substring(prefix.IndexOf("::") + 2) + "::";
else
prefix = "";
sb.Append("( " + prefix + ", " + t.CLRName);
if (t is DefTemplateOneType)
sb.Append(", STLDECL_MANAGEDTYPE, STLDECL_NATIVETYPE )\n");
else if (t is DefTemplateTwoTypes)
sb.Append(", STLDECL_MANAGEDKEY, STLDECL_MANAGEDVALUE, STLDECL_NATIVEKEY, STLDECL_NATIVEVALUE )\n");
else
throw new Exception("Unexpected");
if (t is DefTemplateOneType)
{
sb.AppendLine("#undef STLDECL_MANAGEDTYPE");
sb.AppendLine("#undef STLDECL_NATIVETYPE");
if (t.HasAttribute<STLListNoRemoveAndUniqueAttribute>())
{
sb.AppendLine();
sb.AppendLine("#undef CPP_STLLIST_DEFINE_REMOVE_AND_UNIQUE");
sb.AppendLine("#define CPP_STLLIST_DEFINE_REMOVE_AND_UNIQUE(PREFIX,CLASS_NAME,M,N) CPP_STLLIST_REMOVE_AND_UNIQUE_DEFINITIONS(PREFIX,CLASS_NAME,M,N)");
}
}
else if (t is DefTemplateTwoTypes)
{
sb.AppendLine("#undef STLDECL_MANAGEDKEY");
sb.AppendLine("#undef STLDECL_MANAGEDVALUE");
sb.AppendLine("#undef STLDECL_NATIVEKEY");
sb.AppendLine("#undef STLDECL_NATIVEVALUE");
}
sb.AppendLine();
}
public IncNonOverridableClassProducer(Wrapper wrapper, DefClass t, IndentStringBuilder sb)
: base(wrapper, t, sb)
{
}
public void CppAddType(DefType t, IndentStringBuilder sb)
{
if (t.HasAttribute<CustomCppClassDefinitionAttribute>())
{
string txt = t.GetAttribute<CustomCppClassDefinitionAttribute>().Text;
sb.AppendLine(txt);
return;
}
if (t is DefClass)
{
if (!t.HasAttribute<WrapTypeAttribute>())
{
//Ignore
}
else
{
switch (t.GetAttribute<WrapTypeAttribute>().WrapType)
{
case WrapTypes.NonOverridable:
new CppNonOverridableClassProducer(this, t as DefClass, sb).Add();
break;
case WrapTypes.Overridable:
new CppOverridableClassProducer(this, t as DefClass, sb).Add();
break;
case WrapTypes.Interface:
new CppOverridableClassProducer(this, t as DefClass, sb).Add();
break;
case WrapTypes.NativeDirector:
new CppNativeDirectorClassProducer(this, t as DefClass, sb).Add();
break;
case WrapTypes.NativePtrValueType:
new CppNativePtrValueClassProducer(this, t as DefClass, sb).Add();
break;
case WrapTypes.Singleton:
new CppSingletonClassProducer(this, t as DefClass, sb).Add();
break;
case WrapTypes.CLRHandle:
new CppCLRHandleClassProducer(this, t as DefClass, sb).Add();
break;
case WrapTypes.PlainWrapper:
new CppPlainWrapperClassProducer(this, t as DefClass, sb).Add();
break;
}
}
}
else if (t is DefTypeDef)
{
DefTypeDef explicitType;
if (t.IsUnnamedSTLContainer)
explicitType = t as DefTypeDef;
else
explicitType = (t.IsNested) ? t.ParentClass.FindType<DefTypeDef>(t.Name) : t.NameSpace.FindType<DefTypeDef>(t.Name);
if (explicitType.IsSTLContainer)
{
CppAddSTLContainer(explicitType, sb);
}
else if (explicitType is DefIterator)
{
CppAddIterator(explicitType as DefIterator, sb);
}
}
}
public CppNativeDirectorClassProducer(Wrapper wrapper, DefClass t, IndentStringBuilder sb)
: base(wrapper, t, sb)
{
}
public string CreateCppCodeForIncludeFile(string include, out bool hasContent)
{
UsedTypes.Clear();
PreClassProducers.Clear();
PostClassProducers.Clear();
IndentStringBuilder contentsb = new IndentStringBuilder();
foreach (DefType t in IncludeFiles[include])
{
CppAddType(t, contentsb);
}
foreach (ClassProducer producer in PostClassProducers)
{
producer.Add();
}
foreach (ClassProducer producer in PreClassProducers)
{
producer.AddFirst();
}
IndentStringBuilder sb = new IndentStringBuilder();
hasContent = false;
CppAddIncludeFiles(include, UsedTypes, sb);
sb.AppendFormat("namespace {0}\n{{\n", ManagedNamespace);
sb.IncreaseIndent();
string txt = contentsb.ToString();
if (txt != "")
{
hasContent = true;
sb.AppendLine(txt);
}
sb.DecreaseIndent();
sb.AppendLine("}");
return sb.ToString().Replace("\r", "");
}
