03序化枚举和类

绝地灬酷狼 2022-08-28 09:42 16阅读 0赞

[原地址][Link 1]  
`序化枚举`,先要考虑是序化`值/名字`.我们按`名`序化,

enum PersonType
    { 
        Unknown,
        Student,
        Staff
    }
    
    struct Person
    { 
        string name;
        int age;
        PersonType type;
    }

按`值类型`检查,则是

is(PersonType==int)
    //或
    isNumeric!PersonType

按`名`则是,

is(T == enum)

`原始类型`中,我们可忽略`枚举`

enum isPrimitiveType(T) = !is(T == enum) && (isNumeric!T || is(T == bool) || is(T == string));
    //第1个判断式.
    JSONValue serialise(T)(T value)
    {     
        static if(isPrimitiveType!T)
        {  /* ... */ }
        else static if(is(T == enum))
        { 
            return JSONValue(value.to!string());
    // PersonType.Student -> "Student", PersonType.Staff -> "Staff", etc.
        }//值转串.
        ...
    }

反序化:

T deserialise(T)(JSONValue json)
    { 
        static if(is(T == enum))
        { //放第1个
            // "Student"->PersonType.Student,etc.
            return json.str.to!T();
        }
        ...
    }

测试:

void main()
    { 
        import std.stdio : writeln;
    
        auto json = serialise(PersonType.Student);
        writeln(json);
        writeln(json.deserialise!PersonType());
    
        json = serialise(Person("Bradley", 20, PersonType.Student));
        writeln(json);
        writeln(json.deserialise!Person());
    
        /* 输出: "Student" Student {"age":20,"name":"Bradley","type":"Student"} Person("Bradley", 20, Student) */
    }

`类`与`构`不一样:

<table> 
 <thead> 
  <tr> 
   <th align="left"><code>序号</code></th> 
   <th align="left">与<code>构</code>不同的特点</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><code>1</code></td> 
   <td align="left">类可为<code>无效</code>.</td> 
  </tr> 
  <tr> 
   <td align="left"><code>2</code></td> 
   <td align="left">不能可靠构建<code>类</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>3</code></td> 
   <td align="left">不能直接暴露<code>类</code>变量,等等</td> 
  </tr> 
 </tbody> 
</table>

`类/构`一起:

else static if(is(T == struct) || is(T == class)) //记得检查类.
    { 
        JSONValue toReturn;
    
        static if(is(T == class))
        { 
            if(value is null)
            { 
                return JSONValue(null);
            }//处理空类.
        }
        else
        { 
            T toReturn; // 类默认为`无效`,我们不能重用这句
        }
    
        static foreach(member; T.tupleof)
        { { 
            /**/
        }}
    
        return toReturn;
    }

简单测试:

void main()
    { 
        import std.stdio : writeln, writefln;
        auto p = new Person();
        p.name = "Bradley";
        p.age = 20;
        p.type = PersonType.Student;
    
        auto json = p.serialise();
        writeln(json);
    
        // writeln不像构一样自动格式化类
        //或者重载`toString`,或者手写.
        writefln("Person(%s, %s, %s)", p.name, p.age, p.type);
    
        /* 输出: {"age":20,"name":"Bradley","type":"Student"} Person(Bradley, 20, Student) */
    }

然后是,解序化:

T deserialise(T)(JSONValue json)
    { 
        ...
        else static if(is(T == struct) || is(T == class)) //记得检查类
        { 
            static if(is(T == class))
            { 
                if(json.type == JSONType.null_)
                    return null;//无效类型
                T toReturn = new T();
            }
            else
            { 
                T toReturn;
            }
    
            /**/
    
            return toReturn;
        }
        else
        {  /*略*/ }
    }

测试`空类`.

void main()
    { 
        import std.stdio : writeln;
        Person p = null;
        auto json = p.serialise();
        writeln(json);
        writeln(json.deserialise!Person());
        /* 输出: 无效 无效 */
    }

当前用`new T()`构建类,仅在`无构造器/有默认构造器`时管用.而实际中,类可有`参数化构造函数,且不支持默认构造函数`.加上:

enum HasDefaultCtor(T) = __traits(compiles, new T());

判断,是否有`默认构造器`.构造函数问题的`变通`,`事实类`一般`不公开`变量.

enum HasStaticDeserialiseFunc(T) = __traits(compiles, {  T obj = T.deserialise(JSONValue()); });
    //要检查代码在`括号`内.

`T.deserialise`解序化`为`静态函数.返回给`T`,检查是否`兼容T`,以`数格值`为第1参数.  
现在,`解序化`是这样的:

enum HasStaticDeserialiseFunc(T) = __traits(compiles, {  T obj = T.deserialise(JSONValue()); });    
    
    T deserialise(T)(JSONValue json)
    { 
        ...
        /**/
        else static if(is(T == struct) || is(T == class))
        { 
            static if(is(T == class))
            { 
                static assert(HasDefaultCtor!T || HasStaticDeserialiseFunc!T, 
                    "class `" ~ T.stringof ~ "`要求默认构造器或匹配静的" ~ T.stringof ~ " deserialise(JSONValue)`"
                ); //条件.用`静态反序化`反序化
                static if(HasDefaultCtor!T)
                { 
                    T toReturn = new T();
                }//有默认构造
            }
            /**/
    
            return toReturn;
        }
        else
        {  /**/ }
    }

外面:

//解序化/反序化
    else static if(is(T == struct) || is(T == class))
    { 
        static if(is(T == class))
        {  /* 前面,处理无效 */ }
        else
        {  /**/ }//类的无效
    
        static if(HasStaticDeserialiseFunc!T)
        { 
            return T.deserialise(json);
        }//类可`解序化`.
        else //
        { 
            static foreach(/**/)
            { { 
                /**/
            }}
            return toReturn;
        }
    }

测试:

class Person
    { 
        private
        { 
            string name;
            int age;
            PersonType type;
        }
    
        // 无默认构造器
        this(string name, int age, PersonType type)
        { 
            this.name = name;
            this.age = age;
            this.type = type;
        }
    
        static Person deserialise(JSONValue value)
        { 
            // 必须自己实现`解序化`
            return new Person(
                value["name"].deserialise!string(),
                value["age"].deserialise!int(),
                value["type"].deserialise!PersonType()
            );
        }
    
        // 显示信息
        override string toString()
        { 
            import std.format : format;
            return format("Person(%s, %s, %s)", this.name, this.age, this.type);
        }
    }
    
    void main()
    { 
        import std.stdio : writeln;
    
        auto person = new Person("Bradley", 20, PersonType.Student);
        auto json = person.serialise();
        writeln(json);
        person = json.deserialise!Person();
        writeln(person);
    
        /* 输出: {"age":20,"name":"Bradley","type":"Student"} Person(Bradley, 20, Student) */
    }

[Link 1]: https://bradley.chatha.dev/blog/dlang-json-serialiser-3