Call the include function thats equal to the name

@return Array
485644
protected function includeByName( $name, $model )
    {

        $functionName = sprintf( 'include%s', ucfirst( $name ) );

        if ( ! method_exists( static::class, $functionName ) ) {
            throw new \Exception(sprintf( 'The function name "%s" does not exists on %s', $functionName, static::class ));
        }

        return $this->{$functionName}( $model );

    }
385597
static function includeFile($paths, $file_name) {
        $path_arr = explode(';', $paths);
        foreach ($path_arr as $p) {
            $file = $p . '/' . $file_name;
            if (file_exists($file)){
                return include $file;
            }
        }
        throw new FileNotExistException("unable to include the file $file_name");
    }
1275303
private function includeAll()
    {
        $config = $this->readConfig();
        $files = array_merge(
            (array) $this->goals['include'],
            (array) $config['components']['include']
        );
        $this->includeGoals($files);
    }
947433
public static function load()
    {
        if (!extension_loaded('opencensus')) {
            trigger_error('opencensus extension required to load Wordpress integrations.', E_USER_WARNING);
            return;
        }

        Mysql::load();

        $nameClosure = function () {
            if (func_num_args() > 0) {
                return [
                    'attributes' => ['name' => func_get_arg(0)]
                ];
            }
            return [];
        };

        // void function get_sidebar( $name = null )
        opencensus_trace_function('get_sidebar', $nameClosure);

        // void function get_header( $name = null )
        opencensus_trace_function('get_header', $nameClosure);

        // function get_footer( $name = null )
        opencensus_trace_function('get_footer', $nameClosure);

        // bool function load_textdomain( $domain, $mofile )
        opencensus_trace_function('load_textdomain', function ($name, $mofile) {
            return [
                'attributes' => ['name' => $name]
            ];
        });

        // void load_template(string $template, bool $require_once = true)
        opencensus_trace_function('load_template', function ($template) {
            return [
                'attributes' => ['template' => $template]
            ];
        });
    }
188836
function include(val) {
  var i, inc;
  // disallow the empty string
  if(Array.isArray(val)) {
    for(i = 0;i < val.length;i++) {
      inc = val[i];
      if(!inc) throw new Error('Invalid include value');
    }
  }
}
133498
function include(filename, absolute) {
            filename = absolute
                ? filename
                : __dirname + '/' + filename;
            var _program  = __program,  // Previous meta program
                _source   = __source,   // Previous source
                _filename = __filename, // Previous source file
                _dirname  = __dirname,  // Previous source directory
                _indent   = __;         // Previous indentation level
            var files;
            if (/(?:^|[^\\])\*/.test(filename)) {
                files = require("glob").sync(filename, { cwd : __dirname, nosort: true });
                files.sort(naturalCompare); // Sort these naturally (e.g. int8 < int16)
            } else {
                files = [filename];
            }
            files.forEach(function(file) {
                var source = require("fs").readFileSync(file)+"";
                __program = MetaScript.compile(indent(source, __));
                __source = source;
                __filename = file;
                __dirname = dirname(__filename);
                __runProgram();
                __program = _program;
                __source = _source;
                __filename = _filename;
                __dirname = _dirname;
                __ = _indent;
            });
        }
595241
protected function getRawIncludeMap(): array
    {
        $map = [];

        foreach ($this->includes as $includeKey => $definition) {
            if (\is_int($includeKey)) {
                $includeKey = $definition;
                $definition = null;
            }

            $settings = [];
            if (!empty($definition)) {
                $parts = preg_split('/\s*\|\s*/', $definition);
                foreach ($parts as $part) {
                    if (!preg_match('/^([^:]+)(:(.+))?$/', $part, $match)) {
                        throw new ParseDefinitionException("Unable to parse field definition for '{$includeKey}''");
                    }
                    // If only list() was viable ...
                    $directive = $match[1];
                    $val = $match[3] ?? null;
                    switch ($directive) {
                        case 'default':
                            $settings['default'] = true;
                            break;
                        case 'relation':
                            $settings['relation'] = !empty($val) ?
                                preg_split('/s*,\s*/', $val) : [$includeKey];
                            break;
                        case 'method':
                            if (!empty($val)) {
                                $settings['method'] = $val;
                            }
                            break;
                        case 'item':
                            $settings['resource_type'] = 'item';
                            break;
                        case 'collection':
                            $settings['resource_type'] = 'collection';
                            break;
                        default:
                            throw new ParseDefinitionException("Invalid key '{$directive}' for {$includeKey}");
                    }
                }
            }

            if (!isset($settings['relation'])) {
                $settings['relation'] = [];
            }
            if (!isset($settings['method'])) {
                $settings['method'] = 'include'.StrHelper::studlyCase($includeKey);
            }
            if (!isset($settings['default'])) {
                $settings['default'] = false;
            }
            if (!isset($settings['resource_type'])) {
                $settings['resource_type'] = null;
            }

            $map[$includeKey] = $settings;
        }

        return $map;
    }
964369
def p_include(self, p):
        ''''''
        if len(p) == 4:
            p[0] = ast.Include(name=p[2], path=p[3], lineno=p.lineno(1))
        else:
            p[0] = ast.Include(name=None, path=p[2], lineno=p.lineno(1))
735222
public function getExcluded(): array
    {
        $arr = [];
        foreach ($this->columns as $name => $column) {
            if ($column->isExcluded()) {
                $arr[] = $name;
            }
        }

        return $arr;
    }
448205
public function head($include = null)
    {
        if (null === $include) {
            $include = $this->defaults;
        }

        $include = (array) $include;

        $this->process($include);

        return "\n"
            . ( in_array(self::METAS, $include)   ? $this->metas() : '')
            . ( in_array(self::TITLE, $include)   ? $this->title() : '')
            . ( in_array(self::LINKS, $include)   ? $this->links() : '')
            . ( in_array(self::STYLES, $include)  ? $this->styles() : '')
            . ( in_array(self::SCRIPTS, $include) ? $this->scripts() : '')
            ;
    }
1209558
function values($name)
    {
        $normalizer = new HeaderCaseNormalizer();
        $name = $normalizer->normalize($name);
        $values = array();

        foreach ($this->_headers as $header) {
            if ($header->getName() == $name) {
                $values[] = $header->getValue();
            }
        }

        return $values;
    }
54343
public function parseIncludes($includes)
    {
        $includes = $this->normalizeIncludesOrExcludes($includes);

        $this->includes = array_merge($this->includes, (array) $includes);

        return $this;
    }
444552
def include_file(name, indent)
      if (full_name = find_include_file(name))
        content = File.open(full_name) {|f| f.read}
        # strip leading '#'s, but only if all lines start with them
        if content =~ /^[^#]/
          content.gsub(/^/, indent)
        else
          content.gsub(/^#?/, indent)
        end
      else
        $stderr.puts "Couldn't find file to include: '#{name}'"
        ''
      end
    end
432187
function initializeIncludes()
    {
        // If we have this global variable we shouldn't do any processing
        if ( !empty( $GLOBALS['eZSimpleTagsInit'] ) )
            return;

        $GLOBALS['eZSimpleTagsInit'] = true;
        $ini = eZINI::instance( 'template.ini' );
        $extensions = $ini->variable( 'SimpleTagsOperator', 'Extensions' );
        $pathList = eZExtension::expandedPathList( $extensions, 'simpletags' );
        $includeList = $ini->variable( 'SimpleTagsOperator', 'IncludeList' );

        foreach ( $includeList as $includeFile )
        {
            foreach ( $pathList as $path )
            {
                $file = $path . '/' . $includeFile;
                if ( file_exists( $file ) )
                {
                    include_once( $file );
                }
            }
        }
    }
604101
public function getDefaultIncludes(): array
    {
        return array_values(array_filter(array_keys($this->getIncludeMap()), function ($includeKey) {
            return $this->getIncludeMap()[$includeKey]['default'];
        }));
    }
553173
private function checkInclude($include,$deep = false){
		if (is_string($include)){
			$include = array($include);
		}
		$include = Hash::normalize($include);

		foreach($include as $key => $val){
			$val = Hash::merge($this->includeDef,$val);
			// if Embed in config is true all include array set true
			if($this->config['embed']){
				$val['embed'] = true;
			}
			if ($val['include']){
				$val['include'] = $this->checkInclude($val['include'],true);
			}
			$include[$key] = $val;

		}
		
		
		if (!$deep){
			$this->include = $include;
		}
    	return $include;
	}
865160
protected function _compile(){
		if(!$this->regex){
			// Compile the chain
			$tokens=preg_split('#
					(?<!\\\)(
						\{[a-zA-Z_]\w+\}|
						\*|
						\+
					)
				#Ssx',
				$this->chain,
				null,
				PREG_SPLIT_DELIM_CAPTURE
			);
			$regex='';
			foreach($tokens as $token){
				$name=substr($token,1,strlen($token)-2);
				// Named slug
				if($token && $token{0}=='{'){
					$regex.='(?<'.$name.'>.*?)';
				}
				// Joker slug
				elseif($token=='*'){
					$regex.='.+?';
				}
				// Word slug
				elseif($token=='+'){
					$regex.='\w+?';
				}
				// Text
				else{
					$regex.=preg_quote(
						str_replace(
							array('\{','\*','\+'),
							array('{','*','+'),
							$token
						),
						'/'
					);
				}
				// Default value
				if(isset($this->default_values[$name])){
					$regex.='?';
				}
			}
			$this->regex="/^$regex$/Ss";
		}
		return $this->regex;
	}