/**
* Retrieve the template path for return, also checks
* if a valid override exists and returns that instead.
* @param \Peg\Lib\Definitions\Element\ReturnType $return
* @param string $namespace
* @param string $type Can be function, method or static_method.
* @return string Path to template file.
*/
public function GetReturnTemplate(\Peg\Lib\Definitions\Element\ReturnType $return, $namespace = "", $type = "function")
{
if (!$this->generator_name) {
throw new \Exception(t("The generator name wasn't set."));
}
if ($namespace) {
$namespace = str_replace(array("\\", "::"), "_", $namespace) . "_";
}
$function_name = strtolower($return->overload->function->name);
$return_type = strtolower($return->type);
$const = "";
if ($return->is_const) {
$const .= "_const";
}
$ptr = "";
if ($return->is_pointer) {
for ($i = 0; $i < $return->indirection_level; $i++) {
$ptr .= "_ptr";
}
}
$ref = "";
if ($return->is_reference) {
$ref .= "_ref";
}
$array = "";
if ($return->is_array) {
$array .= "_arr";
}
$override_function = $this->templates_path . "return/{$type}/overrides/" . $function_name . "_" . $return_type . $const . $ptr . $ref . $array . ".php";
if (file_exists($override_function)) {
return $override_function;
}
$override = $this->templates_path . "return/{$type}/overrides/" . $return_type . $const . $ptr . $ref . $array . ".php";
if (file_exists($override)) {
return $override;
}
$standard_type = $this->symbols->GetStandardType($return);
$template = $this->templates_path . "return/{$type}/" . $standard_type . $const . $ptr . $ref . $array . ".php";
if (!file_exists($template)) {
return $this->templates_path . "return/{$type}/" . "default.php";
}
return $template;
}
/**
* 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);
}
