public static Clang.Ast.Type CleanType(QualType qt)
{
var et = qt.Type as ElaboratedType;
if (et == null)
return qt.Type;
return et.UnqualifiedDesugaredType;
}
public static bool TryParse(string text, out QualType result)
{
if (text.Match(Keywords.w_NONE))
{
result = QualType.NONE;
}
else if (text.Match(Keywords.w_CHEM))
{
result = QualType.CHEM;
}
else if (text.Match(Keywords.w_AGE))
{
result = QualType.AGE;
}
else if (text.Match(Keywords.w_TRACE))
{
result = QualType.TRACE;
}
else
{
result = (QualType)(-1);
return(false);
}
return(true);
}
bool IsExtVector(Decl decl, QualType type, ref string simd_type)
{
var rv = false;
var t = type.CanonicalQualType.Type;
// Unpoint the type
var pointerType = t as Clang.Ast.PointerType;
if (pointerType != null)
{
t = pointerType.PointeeQualType.Type;
}
if (t.Kind == TypeKind.ExtVector)
{
rv = true;
}
else
{
var r = (t as RecordType)?.Decl;
if (r != null)
{
foreach (var f in r.Fields)
{
var qt = f.QualType.CanonicalQualType.Type;
if (qt.Kind == TypeKind.ExtVector)
{
rv = true;
break;
}
var at = qt as ConstantArrayType;
if (at != null)
{
if (at.ElementType.Type.Kind == TypeKind.ExtVector)
{
rv = true;
break;
}
}
}
}
}
var typeName = type.ToString();
if (!rv && typeName.Contains("simd"))
{
var framework = Helpers.GetFramework(decl);
Log.On(framework).Add($"!unknown-simd-type! Could not detect that {typeName} is a Simd type, but its name contains 'simd'. Something needs fixing in SimdCheck.cs");
}
if (rv)
{
simd_type = typeName;
}
return(rv);
}
public static string CleanTypeCplusplus(QualType qt)
{
var s = CleanType(qt).ToString();
if (s == "_Bool")
return "bool";
// Ok, I want to click on that blue thing and use the action, the "1"//
if (s.IndexOf("_Bool") != -1)
Console.WriteLine("f");
if (s.StartsWith("class ")) {
s = s.Substring(6);
return s;
}
if (s.StartsWith("struct "))
return s.Substring(7);
return s;
}
bool IsSimdType(QualType type, ref string simd_type, ref bool requires_marshal_directive)
{
var str = Undecorate(type.ToString());
if (type_mapping.TryGetValue(str, out var info))
{
requires_marshal_directive = true;
simd_type = str;
return(true);
}
if (IsExtVector(type, ref simd_type))
{
Console.WriteLine($"!unknown-simd-type-mapping! The Simd type {simd_type} does not have a mapping to a managed type. Please add one in SimdCheck.cs");
}
return(false);
}
bool IsSimdType(Decl decl, QualType type, ref string simd_type, ref bool requires_marshal_directive)
{
var str = Undecorate(type.ToString());
if (type_mapping.TryGetValue(str, out var info))
{
requires_marshal_directive = true;
simd_type = str;
return(true);
}
if (IsExtVector(decl, type, ref simd_type))
{
var framework = Helpers.GetFramework(decl);
Log.On(framework).Add($"!unknown-simd-type-mapping! The Simd type {simd_type} does not have a mapping to a managed type. Please add one in SimdCheck.cs");
}
return(false);
}
//
// Given a Clang QualType, returns the AstType to use to marshal, both for the
// P/Invoke signature and for the high level binding
//
// Handles RefCounted objects that we wrap
//
void LookupMarshalTypes(QualType qt,
out AstType lowLevel, out ICSharpCode.NRefactory.CSharp.ParameterModifier lowLevelParameterMod,
out AstType highLevel, out ICSharpCode.NRefactory.CSharp.ParameterModifier highLevelParameterMod,
out WrapKind wrapKind, bool isReturn = false)
{
wrapKind = WrapKind.None;
lowLevelParameterMod = ICSharpCode.NRefactory.CSharp.ParameterModifier.None;
highLevelParameterMod = ICSharpCode.NRefactory.CSharp.ParameterModifier.None;
var cleanType = CleanType(qt);
var cleanTypeStr = cleanType.ToString();
switch (cleanTypeStr) {
case "const char *":
lowLevel = new PrimitiveType("string");
highLevel = new PrimitiveType("string");
return;
case "ThreadID":
// Troublesome because on windows it is a sizeof(unsigned), on unix sizeof(pthread_t), which is
// 32 or 64 bits.
case "void *":
lowLevel = new PrimitiveType("IntPtr");
highLevel = new PrimitiveType("IntPtr");
return;
case "const Urho3D::String &":
case "class Urho3D::String":
case ConstStringReference:
if (isReturn) {
lowLevel = new PrimitiveType("IntPtr");
highLevel = new PrimitiveType("string");
wrapKind = WrapKind.MarshalPtrToString;
return;
} else {
lowLevel = new PrimitiveType("string");
highLevel = new PrimitiveType("string");
return;
}
case "const class Urho3D::Vector2 &":
case "const class Urho3D::Vector3 &":
case "const class Urho3D::Vector4 &":
case "const class Urho3D::Quaternion &":
case "const class Urho3D::Plane &":
case "const class Urho3D::BoundingBox &":
case "const class Urho3D::Color &":
case "const class Urho3D::IntVector2 &":
case "const class Urho3D::IntRect &":
case "const struct Urho3D::TileMapInfo2D &":
case "const class Urho3D::XMLElement &":
case "class Urho3D::XMLElement &":
case "const class Urho3D::Ray &":
var simpleType = RemapTypeToNamespace (cleanTypeStr.DropConstAndReference().DropClassOrStructPrefix().DropUrhoNamespace().RemapAcronyms());
highLevel = new SimpleType (simpleType);
lowLevel = new SimpleType (simpleType);
lowLevelParameterMod = ICSharpCode.NRefactory.CSharp.ParameterModifier.Ref;
wrapKind = WrapKind.RefBlittable;
return;
case "struct Urho3D::PhysicsRaycastResult &":
lowLevelParameterMod = ICSharpCode.NRefactory.CSharp.ParameterModifier.Ref;
highLevelParameterMod = ICSharpCode.NRefactory.CSharp.ParameterModifier.Ref;
highLevel = new SimpleType ("PhysicsRaycastResult");
lowLevel = new SimpleType ("PhysicsRaycastResult");
wrapKind = WrapKind.RefBlittable;
return;
case "const struct Urho3D::CrowdObstacleAvoidanceParams &":
lowLevelParameterMod = ICSharpCode.NRefactory.CSharp.ParameterModifier.Ref;
highLevel = new SimpleType ("CrowdObstacleAvoidanceParams");
lowLevel = new SimpleType ("CrowdObstacleAvoidanceParams");
wrapKind = WrapKind.RefBlittable;
return;
case "const struct Urho3D::BiasParameters &":
lowLevelParameterMod = ICSharpCode.NRefactory.CSharp.ParameterModifier.Ref;
highLevel = new SimpleType ("BiasParameters");
lowLevel = new SimpleType ("BiasParameters");
wrapKind = WrapKind.RefBlittable;
return;
case "const struct Urho3D::CascadeParameters &":
lowLevelParameterMod = ICSharpCode.NRefactory.CSharp.ParameterModifier.Ref;
highLevel = new SimpleType ("CascadeParameters");
lowLevel = new SimpleType ("CascadeParameters");
wrapKind = WrapKind.RefBlittable;
return;
case "class Urho3D::Serializer &":
case "class Urho3D::Deserializer &":
highLevel = new SimpleType ("File");
lowLevel = new SimpleType ("IntPtr");
wrapKind = WrapKind.HandleMember;
return;
case "struct Urho3D::TouchState *":
if (isReturn)
{
lowLevel = new PrimitiveType("IntPtr");
highLevel = new SimpleType("TouchState");
wrapKind = WrapKind.MarshalPtrToStruct;
return;
}
break;
// currently "Vector<X> &" are only supported for return values
case "const Vector<SharedPtr<class Urho3D::AnimationState> > &":
case "const Vector<SharedPtr<class Urho3D::Node> > &":
case "const Vector<SharedPtr<class Urho3D::Component> > &":
case "const Vector<SharedPtr<class Urho3D::VertexBuffer> > &":
case "const Vector<SharedPtr<class Urho3D::IndexBuffer> > &":
case "const Vector<SharedPtr<class Urho3D::UIElement> > &":
case "const Vector<SharedPtr<class Urho3D::PackageFile> > &":
case "const Vector<SharedPtr<class Urho3D::Texture2D> > &":
var sp = cleanTypeStr.IndexOf ("::");
var ep = cleanTypeStr.IndexOf ("> >");
string tn = cleanTypeStr.Substring (sp + 2, ep - sp - 2);
highLevel = csParser.ParseTypeReference ("IReadOnlyList<" + tn + ">");
lowLevel = new SimpleType ("IntPtr");
wrapKind = WrapKind.VectorSharedPtr;
return;
case "class Urho3D::StringHash":
highLevel = new SimpleType ("StringHash");
lowLevel = new PrimitiveType ("int");
wrapKind = WrapKind.StringHash;
return;
default:
//Console.WriteLine (cleanTypeStr);
break;
}
if (isReturn && cleanTypeStr.Contains("SharedPtr<"))
{
string type = cleanTypeStr.ExtractGenericParameter().DropClassOrStructPrefix().DropUrhoNamespace();
highLevel = new SimpleType(RemapTypeName(type));
if (cleanTypeStr.Contains("class")) //TODO: inspect underlying type instead
{
wrapKind = WrapKind.HandleMember;
lowLevel = new SimpleType("IntPtr");
}
else
{
lowLevel = new SimpleType(RemapTypeName(type));
}
return;
}
if (cleanType.Kind == TypeKind.Pointer) {
var ptrType = cleanType as PointerType;
var underlying = GetPointersUnderlyingType(ptrType);
CXXRecordDecl decl;
if (underlying != null && ScanBaseTypes.nameToDecl.TryGetValue(underlying.Decl.QualifiedName, out decl)) {
if (decl.IsDerivedFrom(ScanBaseTypes.UrhoObjectType)) {
lowLevel = new SimpleType("IntPtr");
var remapped = RemapTypeName(decl.Name);
if (remapped != decl.Name)
highLevel = csParser.ParseTypeReference(RemapTypeToNamespace (remapped));
else
highLevel = underlying.Bind();
wrapKind = WrapKind.UrhoObject;
return;
}
if (decl.IsDerivedFrom(ScanBaseTypes.UrhoRefCounted)) {
lowLevel = new SimpleType("IntPtr");
var remapped = RemapTypeName(decl.Name);
if (remapped != decl.Name)
highLevel = csParser.ParseTypeReference(RemapTypeToNamespace (remapped));
else
highLevel = underlying.Bind();
wrapKind = WrapKind.HandleMember;
return;
}
if (decl == ScanBaseTypes.EventHandlerType) {
wrapKind = WrapKind.EventHandler;
lowLevel = new SimpleType("IntPtr");
highLevel = new SimpleType("IntPtr");
return;
}
if (decl.Name == "ProfilerBlock") {
lowLevel = new SimpleType("ProfilerBlock");
highLevel = new SimpleType("ProfilerBlock");
}
if (decl.Name == "Deserializer") {
lowLevel = new SimpleType("IntPtr");
highLevel = new SimpleType("IDeserializer");
wrapKind = WrapKind.HandleMember;
return;
}
if (decl.Name == "Serializer") {
lowLevel = new SimpleType("IntPtr");
highLevel = new SimpleType("ISerializer");
wrapKind = WrapKind.HandleMember;
return;
}
}
}
lowLevel = cleanType.Bind();
highLevel = cleanType.Bind();
}
// Temporary, just to help us get the bindings bootstrapped
//
// This limits which C++ types we can bind, and lets us progressively add more
static bool IsUnsupportedType(QualType qt, bool returnType = false)
{
var ct = CleanType(qt);
var ctstring = ct.ToString ();
// String references are hand-bound, so we are going to let those though
if (ctstring == ConstStringReference || ctstring == "const Urho3D::String &")
return false;
switch (ctstring) {
case "const class Urho3D::Vector3 &":
case "const class Urho3D::IntRect &":
case "const class Urho3D::Color &":
case "const class Urho3D::Vector2 &":
case "const class Urho3D::Vector4 &":
case "const class Urho3D::IntVector2 &":
case "const class Urho3D::Quaternion &":
case "const class Urho3D::Plane &":
case "const class Urho3D::BoundingBox &":
case "const struct Urho3D::BiasParameters &":
case "const struct Urho3D::CascadeParameters &":
case "const struct Urho3D::TileMapInfo2D &":
case "const class Urho3D::XMLElement &":
case "class Urho3D::XMLElement &":
case "struct Urho3D::PhysicsRaycastResult &":
case "const class Urho3D::Ray &":
case "const struct Urho3D::CrowdObstacleAvoidanceParams &":
case "class Urho3D::Serializer &":
case "class Urho3D::Deserializer &":
return false;
}
if (returnType) {
switch (ctstring) {
case "const Vector<SharedPtr<class Urho3D::Node> > &":
case "const Vector<SharedPtr<class Urho3D::Component> > &":
case "const Vector<SharedPtr<class Urho3D::VertexBuffer> > &":
case "const Vector<SharedPtr<class Urho3D::IndexBuffer> > &":
case "const Vector<SharedPtr<class Urho3D::UIElement> > &":
case "const Vector<SharedPtr<class Urho3D::PackageFile> > &":
case "const Vector<SharedPtr<class Urho3D::Texture2D> > &":
case "const Vector<SharedPtr<class Urho3D::AnimationState> > &":
return false;
}
#if false
if (ctstring.Contains ("Vector")) {
if (!displayed.Contains (ctstring)) {
Console.WriteLine (ctstring);
displayed.Add (ctstring);
}
}
#endif
} else {
// The & at the end is redundant, Urho always uses PODVector & on parameters
// but there for future proofing.
if (ctstring.Contains ("PODVector<") && ctstring.EndsWith ("&")) {
string plainPodClass = StringUtil.DropConstAndReference (ctstring);
// Now, white list the classes we know about, for now
// we are going to bind the ones that are UrhoObjects
switch (plainPodClass) {
case "PODVector<class Urho3D::Node *>":
case "PODVector<class Urho3D::Component *>":
case "PODVector<class Urho3D::VertexBuffer *>":
case "PODVector<class Urho3D::RigidBody *>":
case "PODVector<class Urho3D::RigidBody2d *>":
case "PODVector<class Urho3D::Resource *>":
podClasses.Add (plainPodClass);
break;
default:
missingPodClasses.Add (plainPodClass);
break;
}
}
}
if (ctstring.StartsWith("SharedPtr<") && returnType)
return false;
var s = ct.Bind().ToString();
if (s.Contains ("unsupported")) {
return true;
}
// Quick hack, just while we get thigns going
if (s.Contains("EventHandler**")) {
return true;
}
if (s.Contains("b2") || s.Contains ("bt"))
return true;
// Candidate for a hand binding (Connection.h)
if (qt.ToString().Contains("kNet::SharedPtr"))
return true;
if (s.Contains("XMLElement"))
return true;
if (s.Contains ("CollisionGeometryData"))
return true;
if (s.Contains ("SDL"))
return true;
return false;
}
static bool IsVariantType(QualType qt)
{
var ct = CleanType(qt);
var ctstring = ct.ToString();
return ctstring == "const class Urho3D::Variant &";
}
///<summary>Initializes WQ solver system</summary>
public QualitySim(EpanetNetwork net, TraceSource ignored)
{
// this.log = log;
_net = net;
_nodes = net.Nodes.Select(QualityNode.Create).ToArray();
_tanks = _nodes.OfType <QualityTank>().ToArray();
_juncs = _nodes.Where(x => !(x is QualityTank)).ToArray();
_links = net.Links.Select(n => new QualityLink(net.Nodes, _nodes, n)).ToArray();
/*
* this.nodes = new List<QualityNode>(net.Nodes.Count);
* this.links = new List<QualityLink>(net.Links.Count);
* this.tanks = new List<QualityTank>(net.Tanks.Count());
* this.juncs = new List<QualityNode>(net.Junctions.Count());
*
* foreach (Node n in net.Nodes) {
* QualityNode qN = QualityNode.Create(n);
*
* this.nodes.Add(qN);
*
* var tank = qN as QualityTank;
*
* if (tank != null)
* this.tanks.Add(tank);
* else
* this.juncs.Add(qN);
* }
*
* foreach (Link n in net.Links)
* this.links.Add(new QualityLink(net.Nodes, this.nodes, n));
*
*/
_bucf = 1.0;
_tucf = 1.0;
_reactflag = false;
_qualflag = _net.QualFlag;
if (_qualflag != QualType.NONE)
{
if (_qualflag == QualType.TRACE)
{
foreach (QualityNode qN in _nodes)
{
if (qN.Node.Name.Equals(_net.TraceNode, StringComparison.OrdinalIgnoreCase))
{
_traceNode = qN;
_traceNode.Quality = 100.0;
break;
}
}
}
if (_net.Diffus > 0.0)
{
_sc = _net.Viscos / _net.Diffus;
}
else
{
_sc = 0.0;
}
_bucf = GetUcf(_net.BulkOrder);
_tucf = GetUcf(_net.TankOrder);
_reactflag = GetReactflag();
}
_wbulk = 0.0;
_wwall = 0.0;
_wtank = 0.0;
_wsource = 0.0;
_htime = 0;
_rtime = _net.RStart;
_qtime = 0;
_nperiods = 0;
_elevUnits = _net.FieldsMap.GetUnits(FieldType.ELEV);
}
///<summary>Update fields and units, after loading the INP.</summary>
public void Prepare(
UnitsType targetUnits,
FlowUnitsType flowFlag,
PressUnitsType pressFlag,
QualType qualFlag,
string chemUnits,
double spGrav,
long hstep)
{
double dcf,
ccf,
qcf,
hcf,
pcf,
wcf;
if (targetUnits == UnitsType.SI)
{
GetField(FieldType.DEMAND).Units = flowFlag.ToString();
GetField(FieldType.ELEV).Units = Keywords.u_METERS;
GetField(FieldType.HEAD).Units = Keywords.u_METERS;
GetField(FieldType.PRESSURE).Units = pressFlag == PressUnitsType.METERS
? Keywords.u_METERS
: Keywords.u_KPA;
GetField(FieldType.LENGTH).Units = Keywords.u_METERS;
GetField(FieldType.DIAM).Units = Keywords.u_MMETERS;
GetField(FieldType.FLOW).Units = flowFlag.ToString();
GetField(FieldType.VELOCITY).Units = Keywords.u_MperSEC;
GetField(FieldType.HEADLOSS).Units = "m" + Keywords.u_per1000M;
GetField(FieldType.FRICTION).Units = "";
GetField(FieldType.POWER).Units = Keywords.u_KW;
dcf = 1000.0 * Constants.MperFT;
qcf = Constants.LPSperCFS;
if (flowFlag == FlowUnitsType.LPM)
{
qcf = Constants.LPMperCFS;
}
if (flowFlag == FlowUnitsType.MLD)
{
qcf = Constants.MLDperCFS;
}
if (flowFlag == FlowUnitsType.CMH)
{
qcf = Constants.CMHperCFS;
}
if (flowFlag == FlowUnitsType.CMD)
{
qcf = Constants.CMDperCFS;
}
hcf = Constants.MperFT;
if (pressFlag == PressUnitsType.METERS)
{
pcf = Constants.MperFT * spGrav;
}
else
{
pcf = Constants.KPAperPSI * Constants.PSIperFT * spGrav;
}
wcf = Constants.KWperHP;
}
else
{
GetField(FieldType.DEMAND).Units = flowFlag.ToString();
GetField(FieldType.ELEV).Units = Keywords.u_FEET;
GetField(FieldType.HEAD).Units = Keywords.u_FEET;
GetField(FieldType.PRESSURE).Units = Keywords.u_PSI;
GetField(FieldType.LENGTH).Units = Keywords.u_FEET;
GetField(FieldType.DIAM).Units = Keywords.u_INCHES;
GetField(FieldType.FLOW).Units = flowFlag.ToString();
GetField(FieldType.VELOCITY).Units = Keywords.u_FTperSEC;
GetField(FieldType.HEADLOSS).Units = "ft" + Keywords.u_per1000FT;
GetField(FieldType.FRICTION).Units = "";
GetField(FieldType.POWER).Units = Keywords.u_HP;
dcf = 12.0;
qcf = 1.0;
if (flowFlag == FlowUnitsType.GPM)
{
qcf = Constants.GPMperCFS;
}
if (flowFlag == FlowUnitsType.MGD)
{
qcf = Constants.MGDperCFS;
}
if (flowFlag == FlowUnitsType.IMGD)
{
qcf = Constants.IMGDperCFS;
}
if (flowFlag == FlowUnitsType.AFD)
{
qcf = Constants.AFDperCFS;
}
hcf = 1.0;
pcf = Constants.PSIperFT * spGrav;
wcf = 1.0;
}
GetField(FieldType.QUALITY).Units = "";
ccf = 1.0;
switch (qualFlag)
{
case QualType.CHEM:
ccf = 1.0 / Constants.LperFT3;
GetField(FieldType.QUALITY).Units = chemUnits;
GetField(FieldType.REACTRATE).Units = chemUnits + Keywords.t_PERDAY;
break;
case QualType.AGE:
GetField(FieldType.QUALITY).Units = Keywords.u_HOURS;
break;
case QualType.TRACE:
GetField(FieldType.QUALITY).Units = Keywords.u_PERCENT;
break;
}
SetUnits(FieldType.DEMAND, qcf);
SetUnits(FieldType.ELEV, hcf);
SetUnits(FieldType.HEAD, hcf);
SetUnits(FieldType.PRESSURE, pcf);
SetUnits(FieldType.QUALITY, ccf);
SetUnits(FieldType.LENGTH, hcf);
SetUnits(FieldType.DIAM, dcf);
SetUnits(FieldType.FLOW, qcf);
SetUnits(FieldType.VELOCITY, hcf);
SetUnits(FieldType.HEADLOSS, hcf);
SetUnits(FieldType.LINKQUAL, ccf);
SetUnits(FieldType.REACTRATE, ccf);
SetUnits(FieldType.FRICTION, 1.0);
SetUnits(FieldType.POWER, wcf);
SetUnits(FieldType.VOLUME, hcf * hcf * hcf);
if (hstep < 1800)
{
SetUnits(FieldType.TIME, 1.0 / 60.0);
GetField(FieldType.TIME).Units = Keywords.u_MINUTES;
}
else
{
SetUnits(FieldType.TIME, 1.0 / 3600.0);
GetField(FieldType.TIME).Units = Keywords.u_HOURS;
}
}
