Optional field information.

Serialised field data type describing how to generate code for the field. Each field has a type, which isn't captured in the type of the data type, but is saved in the Q monad in fieldType.

Let t be a type we want to parametrize the field with. There are the following possible types of fields:

Mandatory with no default.

Then fieldType holds t, fieldDefault = Nothing and fieldIsOptional = NotOptional.

Field with a default value.

Then fieldType holds t and fieldDefault = Just exp where exp is an expression of type t and fieldIsOptional = NotOptional.

Optional, no default value.

Then fieldType holds Maybe t, fieldDefault = Nothing and fieldIsOptional is either OptionalOmitNull or OptionalSerializeNull.

Optional fields with a default value are prohibited, as their main intention is to represent the information that a request didn't contain the field data.

Custom (de)serialization: Field can have custom (de)serialization functions that are stored in fieldRead and fieldShow. If they aren't provided, the default is to use readJSON and showJSON for the field's type t. If they are provided, the type of the contained deserializing expression must be

  [(String, JSON.JSValue)] -> JSON.JSValue -> JSON.Result t

where the first argument carries the whole record in the case the deserializing function needs to process additional information.

The type of the contained serializing experssion must be

  t -> (JSON.JSValue, [(String, JSON.JSValue)])

where the result can provide extra JSON fields to include in the output record (or just return [] if they're not needed).

Note that for optional fields the type appearing in the custom functions is still t. Therefore making a field optional doesn't change the functions.

There is also a special type of optional field AndRestArguments which allows to parse any additional arguments not covered by other fields. There can be at most one such special field and it's type must be Map String JSON.JSValue. See also andRestArguments.

Generates a simple field.

Generate an AndRestArguments catch-all field.

Sets the renamed constructor field.

Sets the default value on a field (makes it optional with a default value).

A defaultField which will be serialized only if it's value differs from a default value.

Mark a field as present in the forthcoming variant.

Marks a field optional (turning its base type into a Maybe).

Marks a field optional (turning its base type into a Maybe), but with Nothing serialised explicitly as null.

Make a field optional, if it isn't already.

Sets custom functions on a field.

Computes the record name for a given field, based on either the string value in the JSON serialisation or the custom named if any exists.

Computes the preferred variable name to use for the value of this field. If the field has a specific constructor name, then we use a first-letter-lowercased version of that; otherwise, we simply use the field name. See also fieldRecordName.

Compute the actual field type (taking into account possible optional status).

Checks that a given field is not optional (for object types or fields which should not allow this case).

Construct a function that parses a field value. If the field has a custom fieldRead, it's applied to o and used. Otherwise JSON.readJSON is used.

Produces the expression that will de-serialise a given field. Since some custom parsing functions might need to use the entire object, we do take and pass the object to any custom read functions.

Just as loadFn, but for optional fields.

A simple field, in constrast to the customisable Field type.

A definition for a single constructor for a simple object.

A definition for ADTs with simple fields.

A type alias for an opcode constructor of a regular object.

A type alias for a Luxi constructor of a regular object.

Ensure first letter is lowercase.

Used to convert type name to function prefix, e.g. in data Aa -> aaToRaw.

Ensure first letter is uppercase.

Used to convert constructor name to component

fromObj (Ganeti specific) as an expression, for reuse.

ToRaw function name.

FromRaw function name.

Converts a name to it's varE/litE representations.

Apply a constructor to a list of expressions

Apply a constructor to a list of applicative expressions

Builds a field for a normal constructor.

Builds a constructor based on a simple definition (not field-based).

Generate the save function for a given type.

Generates a data type declaration.

The type will have a fixed list of instances.

Generates a toRaw function.

This generates a simple function of the form:

nameToRaw :: Name -> traw
nameToRaw Cons1 = var1
nameToRaw Cons2 = "value2"

Generates a fromRaw function.

The function generated is monadic and can fail parsing the raw value. It is of the form:

nameFromRaw :: (Monad m) => traw -> m Name
nameFromRaw s | s == var1       = Cons1
              | s == "value2" = Cons2
              | otherwise = fail ...

Generates a data type from a given raw format.

The format is expected to multiline. The first line contains the type name, and the rest of the lines must contain two words: the constructor name and then the string representation of the respective constructor.

The function will generate the data type declaration, and then two functions:

• nameToRaw, which converts the type to a raw type
• nameFromRaw, which (monadically) converts from a raw type to the type

Note that this is basically just a custom show/read instance, nothing else.

Creates the showJSON member of a JSON instance declaration.

This will create what is the equivalent of:

showJSON = showJSON . nameToRaw

in an instance JSON name declaration

Creates the readJSON member of a JSON instance declaration.

This will create what is the equivalent of:

readJSON s = case readJSON s of
               Ok s' -> nameFromRaw s'
               Error e -> Error description

in an instance JSON name declaration

Generates a JSON instance for a given type.

This assumes that the nameToRaw and nameFromRaw functions have been defined as by the declareSADT function.

Transforms a CamelCase string into an_underscore_based_one.

Transform an underscore_name into a CamelCase one.

Computes the name of a given constructor.

Extract all constructor names from a given type.

Builds the generic constructor-to-string function.

This generates a simple function of the following form:

fname (ConStructorOne {}) = trans_fun(ConStructorOne)
fname (ConStructorTwo {}) = trans_fun(ConStructorTwo)

This builds a custom list of name/string pairs and then uses genToRaw to actually generate the function.

Constructor-to-string for OpCode.

Strips Op from the constructor name, converts to lower-case and adds a given prefix.

Builds a list with all defined constructor names for a type.

vstr :: String
vstr = [...]

Where the actual values of the string are the constructor names mapped via trans_fun.

Generates a list of all defined opcode IDs.

Transfers opcode data between the opcode description (through genOpCode) and the Python code generation functions.

Optionally encapsulates default values in PyValueEx.

maybeApp exp typ returns a quoted expression that encapsulates the default value exp of an opcode parameter cast to typ in a PyValueEx, if exp is Just. Otherwise, it returns a quoted expression with Nothing.

Generates a Python type according to whether the field is optional.

The type of created expression is PyType.

Generates Python types from opcode parameters.

Generates Python default values from opcode parameters.

Generates a Haskell function call to "showPyClass" with the necessary information on how to build the Python class string.

Generates a function called "pyClasses" that holds the list of all the opcode descriptors necessary for generating the Python opcodes.

Converts from an opcode constructor to a Luxi constructor.

Generates DictObject instance for an op-code.

Generates the OpCode data type.

This takes an opcode logical definition, and builds both the datatype and the JSON serialisation out of it. We can't use a generic serialisation since we need to be compatible with Ganeti's own, so we have a few quirks to work around.

Generates the function pattern returning the list of fields for a given constructor.

Generates a list of all fields of an opcode constructor.

Generates the "save" clause for an entire opcode constructor.

This matches the opcode with variables named the same as the constructor fields (just so that the spliced in code looks nicer), and passes those name plus the parameter definition to saveObjectField.

Generates the main save opcode function, serializing as a dictionary.

This builds a per-constructor match clause that contains the respective constructor-serialisation code.

Generates load code for a single constructor of the opcode data type. The type of the resulting expression is WriterT UsedKeys J.Result a.

Generates load code for a single constructor of the opcode data type.

Generates the loadOpCode function.

Constructor-to-string for LuxiOp.

Constructor-to-string for MsgKeys.

Generates the LuxiOp data type.

This takes a Luxi operation definition and builds both the datatype and the function transforming the arguments to JSON. We can't use anything less generic, because the way different operations are serialized differs on both parameter- and top-level.

There are two things to be defined for each parameter:

• name
• type

Generates the "save" clause for entire LuxiOp constructor.

Extract the field's declaration from a Field structure.

Build an object declaration.

Build an accessor function for a field of an object that can have a forthcoming variant.

Build lense declartions for a field.

If the type of the field is the same in the forthcoming and the real variant, the lens will be a simple lens (Lens' s a).

Otherwise, the type will be (Lens s s (Maybe a) a). This is because the field in forthcoming variant has type (Maybe a), but the real variant has type a.

Build an object that can have a forthcoming variant. This will create 3 data types: two objects, prefixed by Real and Forthcoming, respectively, and a sum type of those. The JSON representation of the latter will be a JSON object, dispatching on the "forthcoming" key.

Generates an object definition: data type and its JSON instance.

An internal name used for naming variables that hold the entire object of type [(String,JSValue)].

Provides a default toJSArray for ArrayObject instance using its existing DictObject instance. The keys are serialized in the order they're declared. The list must contain all keys possibly generated by toDict.

Provides a default fromJSArray for ArrayObject instance using its existing DictObject instance. The fields are deserialized in the order they're declared.

Generates an additional ArrayObject instance using its existing DictObject instance.

See defaultToJSArray and defaultFromJSArray.

Generates DictObject instance.

Generates the save object functionality.

Generates the code for saving an object's field, handling the various types of fields that we have.

Generates the showJSON clause for a given object name.

Generates the load object functionality.

Generates code for loading an object's field.

Generates the set of all used JSON dictionary keys for a list of fields The equivalent of S.fromList (map T.pack ["f1", "f2", "f3"] )

Generates the list of all used JSON dictionary keys for a list of fields

Generates the list of all used JSON dictionary keys for a list of fields, depending on if any of them has AndRestArguments flag.

Builds the readJSON instance for a given object name.

Compute parameter type names.

Compute the name of a full and a partial parameter field.

Compute information about the type of a parameter field.

Build a parameter declaration.

This function builds two different data structures: a filled one, in which all fields are required, and a partial one, in which all fields are optional. Due to the current record syntax issues, the fields need to be named differrently for the two structures, so the partial ones get a P suffix. Also generate a default value for the partial parameters.

Builds a list of all fields of a parameter.

Generates the serialisation for a partial parameter.

Generates code to save an optional parameter field.

Generates code to load an optional parameter field.

Builds a function that executes the filling of partial parameter from a full copy (similar to Python's fillDict).

Exception simple error message field.

Builds an exception type definition.

Generates the "save" clause for an entire exception constructor.

This matches the exception with variables named the same as the constructor fields (just so that the spliced in code looks nicer), and calls showJSON on it.

Generates load code for a single constructor of an exception.

Generates the code (if there's only one argument, we will use a list, not a tuple:

do
 (x1, x2, ...) <- readJSON args
 return $ Cons x1 x2 ...

Generates the loadException function.

This generates a quite complicated function, along the lines of:

loadFn (JSArray [JSString name, args]) = case name of
   A1 -> do
     (x1, x2, ...) <- readJSON args
     return $ A1 x1 x2 ...
   "a2" -> ...
   s -> fail $ "Unknown exception" ++ s
loadFn v = fail $ "Expected array but got " ++ show v

Compute the ssconf constructor name from its file name.