/**
* Load all class symbols from classes.json, its enumerations from
* class_enumerations.json and variables from class_variables.json.
*/
private function LoadClassesFromJson()
{
$classes_def = Json::Decode(file_get_contents($this->definitions_path . "classes.json"));
$enumerations_def = array();
if (file_exists($this->definitions_path . "class_enumerations.json")) {
$enumerations_def = Json::Decode(file_get_contents($this->definitions_path . "class_enumerations.json"));
}
$variables_def = array();
if (file_exists($this->definitions_path . "class_variables.json")) {
$variables_def = Json::Decode(file_get_contents($this->definitions_path . "class_variables.json"));
}
foreach ($classes_def as $header => $namespaces) {
$this->symbols->AddHeader($header);
foreach ($namespaces as $namespace => $classes) {
foreach ($classes as $class_name => $methods) {
$class = new Element\ClassElement($class_name);
// Set class details
if (isset($methods["_description"])) {
$class->description = $methods["_description"];
unset($methods["_description"]);
}
if (isset($methods["_parents"])) {
$class->AddParents($methods["_parents"]);
unset($methods["_parents"]);
}
if (isset($methods["_struct"])) {
$class->struct = true;
unset($methods["_struct"]);
}
if (isset($methods["_forward_declaration"])) {
$class->forward_declaration = true;
unset($methods["_forward_declaration"]);
}
if (isset($methods["_platforms"])) {
$class->platforms = $methods["_platforms"];
unset($methods["_platforms"]);
}
// Add methods
foreach ($methods as $method_name => $method_overloads) {
$method = new Element\FunctionElement($method_name);
foreach ($method_overloads as $method_overload) {
$overload = new Element\Overload($method_overload["description"]);
$overload->SetReturnType(new Element\ReturnType($method_overload["return_type"]));
if (isset($method_overload["constant"])) {
$overload->constant = $method_overload["constant"];
}
if (isset($method_overload["static"])) {
$overload->static = $method_overload["static"];
}
if (isset($method_overload["virtual"])) {
$overload->virtual = $method_overload["virtual"];
}
if (isset($method_overload["pure_virtual"])) {
$overload->pure_virtual = $method_overload["pure_virtual"];
}
if (isset($method_overload["protected"])) {
$overload->protected = $method_overload["protected"];
}
if (isset($method_overload["parameters"])) {
foreach ($method_overload["parameters"] as $parameter) {
if (!isset($parameter["value"])) {
$parameter["value"] = "";
}
if (!isset($parameter["description"])) {
$parameter["description"] = "";
}
$param = new Element\Parameter($parameter["name"], $parameter["type"], $parameter["value"], $parameter["description"]);
if (isset($parameter["is_array"])) {
$param->is_array = true;
}
$overload->AddParameter($param);
}
}
$method->AddOverload($overload);
}
$class->AddMethod($method);
}
// Add enumerations
if (isset($enumerations_def[$header][$namespace][$class_name])) {
foreach ($enumerations_def[$header][$namespace][$class_name] as $enumeration_name => $enumeration_data) {
if (!isset($enumeration_data["description"])) {
$enumeration_data["description"] = "";
}
$class->AddEnumeration(new Element\Enumeration($enumeration_name, $enumeration_data["options"], $enumeration_data["description"]));
}
}
// Add variables
if (isset($variables_def[$header][$namespace][$class_name])) {
foreach ($variables_def[$header][$namespace][$class_name] as $variable_name => $variable_options) {
$variable = new Element\ClassVariable($variable_name, $variable_options["type"]);
if (isset($variable_options["static"])) {
$variable->static = $variable_options["static"];
}
if (isset($variable_options["mutable"])) {
$variable->mutable = $variable_options["mutable"];
}
if (isset($variable_options["protected"])) {
$variable->protected = $variable_options["protected"];
}
if (isset($variable_options["public"])) {
$variable->public = $variable_options["public"];
}
if (isset($variable_options["description"])) {
$variable->description = $variable_options["description"];
}
$class->AddVariable($variable);
}
}
$this->symbols->headers[$header]->AddClass($class, $namespace);
}
}
}
unset($classes_def);
unset($enumerations_def);
unset($variables_def);
}
/**
* Save class symbols into classes.json, the class
* enumerations into class_enumerations.json and its variables into
* class_variables.json.
*/
private function SaveClassesToJson()
{
$classes = array();
$enumerations = array();
$variables = array();
foreach ($this->symbols->headers as $header) {
if (!$header->HasClasses()) {
continue;
}
foreach ($header->namespaces as $namespace) {
if (!$namespace->HasClasses()) {
continue;
}
foreach ($namespace->classes as $class) {
// Set class details
if ($class->description) {
$classes[$header->name][$namespace->name][$class->name]["_description"] = $class->description;
}
if ($class->parents) {
foreach ($class->parents as $parent) {
$classes[$header->name][$namespace->name][$class->name]["_parents"][] = $parent;
}
}
if ($class->struct) {
$classes[$header->name][$namespace->name][$class->name]["_struct"] = $class->struct;
}
if ($class->forward_declaration) {
$classes[$header->name][$namespace->name][$class->name]["_forward_declaration"] = $class->forward_declaration;
}
if ($class->platforms) {
$classes[$header->name][$namespace->name][$class->name]["_platforms"] = $class->platforms;
}
// Get methods
foreach ($class->methods as $function) {
foreach ($function->overloads as $overload) {
$parameters = array();
if ($overload->HasParameters()) {
foreach ($overload->parameters as $parameter) {
$parameter_array = array();
$parameter_array["name"] = $parameter->name;
$parameter_array["type"] = $parameter->original_type;
if ($parameter->is_array) {
$parameter_array["is_array"] = $parameter->is_array;
}
if ($parameter->default_value) {
$parameter_array["value"] = $parameter->default_value;
}
if (trim($parameter->description)) {
$parameter_array["description"] = $parameter->description;
}
$parameters[] = $parameter_array;
}
$classes[$header->name][$namespace->name][$class->name][$function->name][] = ["description" => $overload->description, "return_type" => $overload->return_type->original_type, "parameters" => $parameters];
} else {
$classes[$header->name][$namespace->name][$class->name][$function->name][] = ["description" => $overload->description, "return_type" => $overload->return_type->original_type];
}
}
}
// Get enumerations
foreach ($class->enumerations as $enumeration) {
if (trim($enumeration->description)) {
$enumerations[$header->name][$namespace->name][$class->name][$enumeration->name] = ["options" => $enumeration->options, "description" => $enumeration->description];
} else {
$enumerations[$header->name][$namespace->name][$class->name][$enumeration->name] = ["options" => $enumeration->options];
}
}
// Get variables
foreach ($class->variables as $variable) {
$variable_array = array();
if (trim($variable->type)) {
$variable_array["type"] = $variable->type;
}
if (trim($variable->static)) {
$variable_array["static"] = $variable->static;
}
if (trim($variable->protected)) {
$variable_array["protected"] = $variable->protected;
}
if (trim($variable->mutable)) {
$variable_array["mutable"] = $variable->mutable;
}
if (trim($variable->description)) {
$variable_array["description"] = $variable->description;
}
$variables[$header->name][$namespace->name][$class->name][$variable->name] = $variable_array;
}
}
}
}
if (count($classes) > 0) {
file_put_contents($this->definitions_path . "classes.json", Json::Encode($classes));
unset($classes);
}
if (count($enumerations) > 0) {
file_put_contents($this->definitions_path . "class_enumerations.json", Json::Encode($enumerations));
unset($enumerations);
}
if (count($variables) > 0) {
file_put_contents($this->definitions_path . "class_variables.json", Json::Encode($variables));
unset($variables);
}
}
