Type

new Type(parameters)

Description:

• Implements a type on a structured hierarchical value.

  See the introduction for a general presentation.

  Type declaration

  • A typical declaration of a type "SomeType" and of name "mytype" with dedicated parameters is given by one of the following two constructs:
    • Here the myType is a static variable in order to be registered during the whole program execution.

  static symboling::SomeType myType("{name: myType ...}");
  

  • Here myType is allocated and remains allocated during the whole program execution, and deleted at program shutdown.

  Type::addType(new SomeType("{name: myType ...}"));
  

  • Predefined parameterized types built on (String|Numeric|Modal|Enum|List|Set|Record)Type can also be defined as data structure, e.g., for a RecordType:

  Type::addType("{type: record name: myType ...}");
  

  Predefined standard types

  • "value": that matches any predefined value, without any further structure.
  • "modal": that corresponds to the basic implementation of the ModalType.
  • "string": that corresponds to the basic implementation of the StringType.

  Implementation of a derived types

  A type defines

  • getValue(value, false): A syntactic projection from any value to a value that can be manipulated in a neighborhood of this type region.

  • getValue(value, true): A semantic projection from a syntactically correct value onto a semantically correct value within the state space region.

  • getCheckMessage(): A human readable report of what was missing in order the value to be syntactically or semantically correct, during the last getValue() call.

  • getDistance(value_1, value_2): A distance between two semantically correct values.

  • getPath(value_1, value_2): A geodesic, i.e. a path of minimal distance, between two semantically correct values.

  • compare(value_1, value_2): A comparison mechanism between two values of a given type.

  • A typical implementation of a derived type of name "mytype" is given by the following construct.

    • Here the justDone(), setDistance() and getDistance() constructs allow the implementation to always have the distance well defined before calculating the path.
    • Here the clearCheckMessage() and addCheckMessage(value, message_a_la_printf, ...), constructs allow to reset and append a standard error message, optionally with additional parameters using the printf syntax.

  #include "Type.hpp"
  namespace symboling {
    class MyType : public Type {
    public:
      MyType() : Type("{name: "MyType", parameter: value,}") {}
  
      virtual wjson::Value getValue(JSON value, bool semantically_else_syntactically = true) const {
        startCheckMessage(); // Opens the check message mechanism
        wjson::Value result = value;
        ../..
        if(result_to_be_modified) {
          ../.. // Modifies the result accordingly
          addCheckMessage(value, "explanation", ...); // Adds a human readable message about the required modification using a à-la printf format
        }
        stopCheckMessage(); // Closes the check message mechanism
        return result;
      }
  
      virtual double getDistance(JSON lhs, JSON rhs) const {
        // Cache mechanism, returns the distance without recalculating it
        if (Type::justDone(lhs, rhs)) return Type::getDistance(lhs, rhs);
        // Otherwise, calculates the distance
        double distance = NAN;
        ../..
        Type::setDistance(lhs, rhs, distance); // Registers the distance for a next call.
        return distance;
      }
  
      virtual wjson::Value getPath(JSON lhs, JSON rhs) const {
        // Cache mechanism, calculates the distance 1st if not yet done
        if (!Type::justDone(lhs, rhs)) MyType::getDistance(lhs, rhs);
        // Then, calculates the path
        ../..
        return path;
      }
  
      virtual int compare(JSON lhs, JSON rhs) const {
        // Implements the semi-order comparison between two values
      }
  
      virtual JSON getBound(unsigned int index) const {
        // Implements the dynamic calculation of the type bound of a given index
        // By contract, in the constructor:
        //  - The protected variable `bounds_count` must be calculated once, at the object construction.
        //  - The protected variable `bounds` allows to store the list of bound values, if not too many.
        //    - In that case the getBound() does not need to be overwritten.
      }
  
      virtual String asString() {
        static std::string string;
        string = Type::asString();
        // Adds complementary information related to MyType parameters and state
        ../..
        return string;
      }
    } myType;
  }
  

  ValueType specification

  Syntactic projection	- Returns the value itself, no projection at this level of specification.
  Semantic projection	- Returns the value itself, no projection at this level of specification.
  Distance value	- Returns NAN no distance defined at this level of specification.
  Geodesic path	- The geodesic is assumed to be atomic, i.e. of length 1 if value are equal and 2 if different.
  Comparison	- Returns NAN no comparison possible at this level of specification.
  Bounds	- The empty value is the unique bound a this level of specification.

Parameters:

Name	Type	Description
parameters	JSON | String	The type parameters. By contract, the type name is a mandatory parameter, default is "value". Note: Since each name has a different type it used to define hash, less and equal function to index type in containers, it is possible to define std::unordered_map<symboling::Type, T> or std::map<symboling::Type, T>.