Delegate A/S

Serialization

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
11: 
12: 
13: 
14: 
15: 
16: 
17: 
18: 
19: 
20: 
21: 
22: 
23: 
24: 
25: 
26: 
27: 
28: 
val public map2Dictionary :
    Map<'a,'b> -> 
    IDictionary<'a,'b> when 'a : comparison

val public dictionary2Map :
    seq<KeyValuePair<'a,'b>> ->
    Map<'a,'b> when 'a : comparison

val public serialize<'a> :
    Serialize ->
    'a ->
    byte array

val public deserialize<'a> :
    SerializeType ->
    'a

val public deserializeBinary<'a> : 
    byte [] ->
    'a

val public serializeBinary: 
    'a -> 
    byte []

val public xmlPrettyPrinterHelper: 
    byte [] ->
    byte []
val map2Dictionary : Map<'a,'b> -> IDictionary<'a,'b> (requires comparison)

Full name: DG.Daxif.Modules.Serialization.map2Dictionary


 TODO:
Multiple items
module Map

from Microsoft.FSharp.Collections

--------------------
type Map<'Key,'Value (requires comparison)> =
  interface IEnumerable
  interface IComparable
  interface IEnumerable<KeyValuePair<'Key,'Value>>
  interface ICollection<KeyValuePair<'Key,'Value>>
  interface IDictionary<'Key,'Value>
  new : elements:seq<'Key * 'Value> -> Map<'Key,'Value>
  member Add : key:'Key * value:'Value -> Map<'Key,'Value>
  member ContainsKey : key:'Key -> bool
  override Equals : obj -> bool
  member Remove : key:'Key -> Map<'Key,'Value>
  ...

Full name: Microsoft.FSharp.Collections.Map<_,_>

--------------------
new : elements:seq<'Key * 'Value> -> Map<'Key,'Value>
type IDictionary<'TKey,'TValue> =
  member Add : key:'TKey * value:'TValue -> unit
  member ContainsKey : key:'TKey -> bool
  member Item : 'TKey -> 'TValue with get, set
  member Keys : ICollection<'TKey>
  member Remove : key:'TKey -> bool
  member TryGetValue : key:'TKey * value:'TValue -> bool
  member Values : ICollection<'TValue>

Full name: System.Collections.Generic.IDictionary<_,_>
val dictionary2Map : seq<KeyValuePair<'a,'b>> -> Map<'a,'b> (requires comparison)

Full name: DG.Daxif.Modules.Serialization.dictionary2Map


 TODO:
Multiple items
val seq : sequence:seq<'T> -> seq<'T>

Full name: Microsoft.FSharp.Core.Operators.seq

--------------------
type seq<'T> = IEnumerable<'T>

Full name: Microsoft.FSharp.Collections.seq<_>
Multiple items
type KeyValuePair<'TKey,'TValue> =
  struct
    new : key:'TKey * value:'TValue -> KeyValuePair<'TKey, 'TValue>
    member Key : 'TKey
    member ToString : unit -> string
    member Value : 'TValue
  end

Full name: System.Collections.Generic.KeyValuePair<_,_>

--------------------
KeyValuePair()
KeyValuePair(key: 'TKey, value: 'TValue) : unit
val serialize : Serialize -> 'a -> byte array

Full name: DG.Daxif.Modules.Serialization.serialize


 TODO:
type Serialize =
  | BIN
  | XML
  | JSON

Full name: DG.Daxif.Serialize
Multiple items
val byte : value:'T -> byte (requires member op_Explicit)

Full name: Microsoft.FSharp.Core.Operators.byte

--------------------
type byte = Byte

Full name: Microsoft.FSharp.Core.byte
type 'T array = 'T []

Full name: Microsoft.FSharp.Core.array<_>
val deserialize : SerializeType -> 'a

Full name: DG.Daxif.Modules.Serialization.deserialize


 TODO:
type SerializeType =
  | BIN of byte array
  | XML of string
  | JSON of string

Full name: DG.Daxif.SerializeType
val deserializeBinary : byte [] -> 'a

Full name: DG.Daxif.Modules.Serialization.deserializeBinary


 TODO:
val serializeBinary : 'a -> byte []

Full name: DG.Daxif.Modules.Serialization.serializeBinary


 TODO:
val xmlPrettyPrinterHelper : byte [] -> byte []

Full name: DG.Daxif.Modules.Serialization.xmlPrettyPrinterHelper


 TODO: