nur-sery/src/schema/Schema.php

<?php
namespace nur\sery\schema;

use nulib\cl;
use nur\sery\schema\values\IValue;

abstract class Schema {
  /**
   * créer si besoin une nouvelle instance à partir d'une définition de schéma
   */
  static function new(&$md, $definition): self {
    if ($md === null) {
      if (AssocSchema::isa_definition($definition)) {
        $md = new AssocSchema($definition);
      } elseif (ListSchema::isa_definition($definition)) {
        $md = new ListSchema($definition);
      } elseif (ScalarSchema::isa_definition($definition)) {
        $md = new ScalarSchema($definition);
      } else {
        throw SchemaException::invalid_schema();
      }
    }
    return $md;
  }

  protected static function ensure_string(&$string): void {
    if (!is_string($string)) $string = strval($string);
  }
  protected static function ensure_nstring(&$string): void {
    if ($string !== null) self::ensure_string($string);
  }
  protected static function ensure_bool(&$bool): void {
    if (!is_bool($bool)) $bool = boolval($bool);
  }
  protected static function ensure_nbool(&$bool): void {
    if ($bool !== null) self::ensure_bool($bool);
  }
  protected static function ensure_callable(&$callable): void {
    if (!is_callable($callable)) throw SchemaException::invalid_callable($callable);
  }
  protected static function ensure_ncallable(&$callable): void {
    if ($callable !== null) self::ensure_callable($callable);
  }
  protected static function ensure_array(&$array): void {
    if (!is_array($array)) $array = cl::with($array);
  }
  protected static function ensure_narray(&$array): void {
    if ($array !== null) self::ensure_array($array);
  }
  protected static function ensure_key(&$key): void {
    if (!is_string($key) && !is_int($key)) $key = strval($key);
  }
  protected static function ensure_nkey(&$key): void {
    if ($key !== null) self::ensure_key($key);
  }
  protected static function ensure_pkey(&$pkey): void {
    if (!is_string($pkey) && !is_int($pkey) && !is_array($pkey)) $pkey = strval($pkey);
    if (is_array($pkey)) {
      foreach ($pkey as &$key) {
        self::ensure_key($key);
      }; unset($key);
    }
  }
  protected static function ensure_npkey(&$pkey): void {
    if ($pkey !== null) self::ensure_pkey($pkey);
  }
  protected static function ensure_content(&$content): void {
    if (!is_string($content) && !is_array($content)) $content = strval($content);
  }
  protected static function ensure_ncontent(&$content): void {
    if ($content !== null) self::ensure_content($content);
  }

  /**
   * @var array définition du schéma, à redéfinir le cas échéant dans une classe
   * dérivée
   */
  const SCHEMA = null;

  /** @var array */
  protected $definition;

  /** retourner true si le schéma est de nature tableau associatif */
  function isAssoc(?AssocSchema &$assoc=null): bool { return false; }
  /** retourner true si le schéma est de nature liste */
  function isList(?ListSchema &$list=null): bool { return false; }
  /** retourner true si le schéma est de nature scalaire */
  function isScalar(?ScalarSchema &$scalar=null): bool { return false; }

  abstract function getValue(&$value, $key=null): IValue;
}