private string CSharpName(MetaNullableType mtype, MetaModel mmodel, ClassKind kind = ClassKind.None, bool fullName = false)
        {
            string result = this.CSharpName(mtype.InnerType, mmodel, kind, fullName);

            if (mtype.InnerType is MetaPrimitiveType)
            {
                MetaPrimitiveType mpt = (MetaPrimitiveType)mtype.InnerType;
                if (mpt.Name != "object" || mpt.Name != "string" || mpt.Name != "ModelObject")
                {
                    result = result + "?";
                }
            }
            return(result);
        }
示例#2
0
     /// <summary>
 	/// Implements the constructor: MetaPrimitiveType()
 	/// Direct superclasses: global::MetaDslx.Core.MetaType, global::MetaDslx.Core.MetaNamedElement
 	/// All superclasses: global::MetaDslx.Core.MetaType, global::MetaDslx.Core.MetaNamedElement, global::MetaDslx.Core.MetaDocumentedElement
     /// </summary>
     public virtual void MetaPrimitiveType(MetaPrimitiveType @this)
     {
         this.MetaType(@this);
         this.MetaNamedElement(@this);
     }
        private string CSharpName(MetaPrimitiveType mtype, MetaModel mmodel, ClassKind kind = ClassKind.None, bool fullName = false)
        {
            string result;

            if (mtype is MetaExternalType)
            {
                switch (kind)
                {
                case ClassKind.ImmutableInstance:
                case ClassKind.BuilderInstance:
                case ClassKind.FactoryMethod:
                    result = mtype.Name;
                    break;

                default:
                    return(((MetaExternalType)mtype).ExternalName);
                }
                if (fullName)
                {
                    bool modelContainsType = this.ContainsType(mmodel, mtype);
                    if (kind == ClassKind.Descriptor || kind == ClassKind.ImmutableInstance || kind == ClassKind.BuilderInstance || kind == ClassKind.FactoryMethod)
                    {
                        string fullNamePrefix = this.CSharpName(mtype.MetaModel, this.ToModelKind(kind), !modelContainsType);
                        result = fullNamePrefix + "." + result;
                    }
                    else if (!modelContainsType)
                    {
                        string fullNamePrefix = this.CSharpName(mtype.Namespace, this.ToNamespaceKind(kind), true);
                        result = "global::" + fullNamePrefix + "." + result;
                    }
                }
                return(result);
            }
            if (mtype.Name == "ModelObject")
            {
                switch (kind)
                {
                case ClassKind.Immutable:
                    return(_generator.Properties.CoreNs + ".ImmutableObject");

                case ClassKind.Builder:
                    return(_generator.Properties.CoreNs + ".MutableObject");

                case ClassKind.ImmutableInstance:
                    return("ModelObject");

                case ClassKind.BuilderInstance:
                    return("ModelObject");

                default:
                    return("ModelObject");
                }
            }
            else
            {
                switch (kind)
                {
                case ClassKind.ImmutableInstance:
                    result = this.ToPascalCase(mtype.Name);
                    break;

                case ClassKind.BuilderInstance:
                    result = this.ToPascalCase(mtype.Name);
                    break;

                case ClassKind.FactoryMethod:
                    result = this.ToPascalCase(mtype.Name);
                    break;

                default:
                    result = mtype.Name;
                    break;
                }
            }
            if (fullName)
            {
                if (kind == ClassKind.ImmutableInstance || kind == ClassKind.BuilderInstance || kind == ClassKind.FactoryMethod)
                {
                    //string fullNamePrefix = this.CSharpName(mmodel, this.ToModelKind(kind), !this.ContainsType(mmodel, mtype));
                    result = _generator.Properties.MetaNs + ".MetaInstance." + result;
                }
            }
            return(result);
        }