parse classes properties into struct

@var    string
@access private
@return null
192183
protected function classPropertiesIntoStruct($className)
    {
        if (!isset($this->wsdlStruct[$className])) {
            $class = new ReflectionClass($className);
            $properties = $class->getProperties();
            $this->wsdlStruct['class'][$className]['property'] = array();
            for ($i = 0; $i < count($properties); ++$i) {
                if ($properties[$i]->isPublic()) {
                    preg_match_all(
                        '~@var\s(\S+)~',
                        $properties[$i]->getDocComment(),
                        $var
                    );

                    $_cleanType = str_replace('[]', '', $var[1][0], $_length);
                    $_typens    = str_repeat('ArrayOf', $_length);

                    $this->wsdlStruct['class'][$className]['property'][$properties[$i]->getName()]['type']
                        = $_cleanType;
                    $this->wsdlStruct['class'][$className]['property'][$properties[$i]->getName()]['wsdltype']
                        = $_typens.$_cleanType;
                    $this->wsdlStruct['class'][$className]['property'][$properties[$i]->getName()]['length']
                        = $_length;
                    $this->wsdlStruct['class'][$className]['property'][$properties[$i]->getName()]['array']
                        = ($_length > 0 && in_array($_cleanType, $this->simpleTypes)) ? true : false;
                    $isObject = (!in_array($_cleanType, $this->simpleTypes) && new ReflectionClass($_cleanType)) ? true : false;
                    $this->wsdlStruct['class'][$className]['property'][$properties[$i]->getName()]['class']
                        = $isObject;
                    if ($isObject == true) {
                        $this->classPropertiesIntoStruct($_cleanType);
                    }
                    if ($_length > 0) {
                        $_typensSource = '';
                        for ($j = $_length; $j > 0;  --$j) {
                            $_typensSource .= 'ArrayOf';
                            $this->wsdlStruct['array'][$_typensSource.$_cleanType]
                                = substr(
                                    $_typensSource,
                                    0,
                                    strlen($_typensSource) - 7
                                )
                                . $_cleanType;
                        }
                    }
                }
            }
        }
    }
527770
public function decodeProperties($properties)
	{
		// Compose components to objects
		foreach ($this->composed_properties as $property => $components) {
			$value = array();
			foreach ($components as $component => $column) {
				$value[$component] = isset($properties[$column]) ? $properties[$column] : null;
			}
			$properties[$property] = $value;
		}

		// Decode JSON columns
		foreach ($this->json_columns as $column_name) {
			if (isset($properties[$column_name])) {
				$properties[$column_name] = json_decode($properties[$column_name], TRUE, 512, JSON_BIGINT_AS_STRING);
			}
		}
		return $properties;
	}
791775
protected function classMethodsIntoStruct()
    {
        $class = new ReflectionClass($this->classname);
        $methods = $class->getMethods();
        // params
        foreach ($methods as $method) {
            if ($method->isPublic()
                && !in_array($method->getName(), $this->preventMethods)
            ) {
                $docComments = $method->getDocComment();
                $_docComments_Description = trim(
                    str_replace(
                        '/**',
                        '',
                        substr($docComments, 0, strpos($docComments, '@'))
                    )
                );
                $docComments_Description = trim(
                    substr(
                        $_docComments_Description,
                        strpos(
                            $_docComments_Description,
                            '*'
                        ) + 1,
                        strpos($_docComments_Description, '*', 1) - 1
                    )
                );
                $this->wsdlStruct[$this->wsdlclassname]['method'][$method->getName()]['description'] = $docComments_Description;
                preg_match_all('~@param\s(\S+)~', $docComments, $param);
                preg_match_all(
                    '~@return\s(\S+)~',
                    $method->getDocComment(),
                    $return
                );
                $params = $method->getParameters();
                for ($i = 0; $i < count($params); ++$i) {
                    $_class = $params[$i]->getClass();
                    $_type  = ($_class) ? $_class->getName() : $param[1][$i];

                    $_cleanType = str_replace('[]', '', $_type, $_length);
                    $_typens    = str_repeat('ArrayOf', $_length);

                    $this->wsdlStruct[$this->wsdlclassname]['method'][$method->getName()]['var'][$i]['name']
                        = $params[$i]->getName();
                    $this->wsdlStruct[$this->wsdlclassname]['method'][$method->getName()]['var'][$i]['wsdltype']
                        = $_typens . $_cleanType;
                    $this->wsdlStruct[$this->wsdlclassname]['method'][$method->getName()]['var'][$i]['type']
                        = $_cleanType;
                    $this->wsdlStruct[$this->wsdlclassname]['method'][$method->getName()]['var'][$i]['length']
                        = $_length;
                    $this->wsdlStruct[$this->wsdlclassname]['method'][$method->getName()]['var'][$i]['array']
                        = ($_length > 0 && in_array($_cleanType, $this->simpleTypes)) ? true : false;
                    $this->wsdlStruct[$this->wsdlclassname]['method'][$method->getName()]['var'][$i]['class']
                        = (!in_array($_cleanType, $this->simpleTypes) && new ReflectionClass($_cleanType)) ? true : false;
                    $this->wsdlStruct[$this->wsdlclassname]['method'][$method->getName()]['var'][$i]['param']
                        = true;
                }
                // return
                if (isset($return[1][0])) {
                    $_cleanType = str_replace('[]', '', $return[1][0], $_length);
                } else {
                    $_cleanType = 'void';
                    $_length = 0;
                }
                $_typens = str_repeat('ArrayOf', $_length);

                $this->wsdlStruct[$this->wsdlclassname]['method'][$method->getName()]['var'][$i]['wsdltype']
                    = $_typens.$_cleanType;
                $this->wsdlStruct[$this->wsdlclassname]['method'][$method->getName()]['var'][$i]['type']
                    = $_cleanType;
                $this->wsdlStruct[$this->wsdlclassname]['method'][$method->getName()]['var'][$i]['length']
                    = $_length;
                $this->wsdlStruct[$this->wsdlclassname]['method'][$method->getName()]['var'][$i]['array']
                    = ($_length > 0 && $_cleanType != 'void' && in_array($_cleanType, $this->simpleTypes)) ? true : false;
                $this->wsdlStruct[$this->wsdlclassname]['method'][$method->getName()]['var'][$i]['class']
                    = ($_cleanType != 'void' && !in_array($_cleanType, $this->simpleTypes) && new ReflectionClass($_cleanType)) ? true : false;
                $this->wsdlStruct[$this->wsdlclassname]['method'][$method->getName()]['var'][$i]['return']
                    = true;
            }
        }
    }
1189764
protected function parse()
	{
		$inside = false;
		$doc_open	= false;
		$func_data	= array();

		$f = new FS_File_Reader( $this->fileName );
		$lines = $f->readArray();
		array_pop( $lines );
		array_shift( $lines ); 
		foreach( $lines as $line )
		{
			$line = trim( $line );
			$line = str_replace( array( "*", "\t\t", "\t\t" ), array( "#", "\t", "\t" ), $line );
			if( $inside )
			{
				if( !$doc_open )
				{
					if( ereg( $this->patterns['doc_start'], $line ) )
						$doc_open = true;
					else if( ereg( $this->patterns["method"], $line ) )
					{
						$parts = explode( "function", $line );
						$method = substr( $parts[1], 0, strpos($parts[1], "(" ) );
						$method = str_replace( "&", "", $method );
						$method = trim( $method );
						$this->methods[$method] = $func_data;
						$func_data = array();
					}
				}
				if( $doc_open )
				{
					$found_pattern = false;
					if( ereg( $this->patterns["doc_data"], $line ) )
					{
						foreach( $this->methodProperties as $prop => $pattern )
						{
							if( ereg( $this->patterns[$pattern], $line ) )
							{
								$found_pattern = true;
								$func_data[$prop] = $this->getValueOfDocLine( $line, $pattern );
							}
						}
						if( ereg( $this->patterns["d_param"], $line ) )
						{
							$parts = explode( $this->patterns["d_param"], $line );
							$parts = explode( "\t", trim($parts[1] ) );
							$func_data["param"][$parts[1]]['type'] = $parts[0];
							if( isset( $parts[2] ) )
								$func_data["param"][$parts[1]]['desc'] = $parts[2];
						}
						else if( !$found_pattern && !ereg( $this->patterns['doc_end'], $line ) )
						{
							$desc = ereg_replace( $this->patterns["doc_data"], "", $line );
							$desc = trim( $desc );
							if( $desc )
								$func_data["desc"][] = $desc;
						}
					}
					else	if( ereg( $this->patterns["d_var"], $line ) )
					{
						$parts = explode( $this->patterns["d_var"], $line );
						$parts = preg_split( "@\t+@", trim($parts[1] ) );
						$this->vars[$parts[1]]['type'] = $parts[0];
						$access = ( substr($parts[1], 0, 1) == "_" ) ? "private" : "public";
							$this->vars[$parts[1]]['access'] = $access;
						$this->vars[$parts[1]]['desc'][] = str_replace( array( "#", "/" ), "", $parts[2] );
					}
					if( ereg( $this->patterns['doc_end'], $line ) )
						$doc_open = false;
				}
			}
			else
			{
				if( eregi( $this->patterns["import"], $line ) )
				{
					$import = str_replace( array( "import", " ", "(", ")", ";", "'", '"' ), "", $line );
					$parts = explode( ".", $import );
					$this->imports[$parts[count( $parts )-1]] = implode( "/", $parts );
				}
				else if( eregi( $this->patterns["class"], $line ) )
				{
					$line	= preg_replace( "@".$this->patterns["class"]."@i", "", $line );
					$parts = explode( " extends ", $line );
					$class = explode( " implements ", $parts[0] );
					$class = $class[0];
					
//					$class = str_replace( array( "class", " " ), "", $class );
					$this->classData["class"] = $class;
					if( isset( $parts[1] ) )
						$this->classData["extends"] = $parts[1];
					$inside = true;
				}
				else if( !$doc_open )
				{
					if( ereg( $this->patterns['doc_start'], $line ) )
						$doc_open = true;
				}
				else if( $doc_open )
				{
					if( ereg( $this->patterns['doc_end'], $line ) )
						$doc_open = false;
					else
					{
						if( ereg( $this->patterns["doc_data"], $line ) )
						{
							$found_pattern = false;
							foreach( $this->classProperties as $prop => $pattern )
							{
								if( ereg( $this->patterns[$pattern], $line ) )
								{
									$found_pattern = true;
									$this->classData[$prop][] = $this->getValueOfDocLine( $line, $pattern );
								}
							}
							if( !$found_pattern && !ereg( $this->patterns['doc_end'], $line ) )
							{
								if( ereg( $this->patterns['d_uses'], $line ) )
								{
									$parts = explode( $this->patterns["d_uses"], $line );
									$uses = trim( $parts[1] );
									if( !in_array ( $uses, $this->classData["uses"] ) )
										$this->classData["uses"][] = $uses; 
								}
								else if( ereg( $this->patterns['d_todo'], $line ) )
								{
									$parts = explode( $this->patterns["d_todo"], $line );
									$todo = trim( $parts[1] );
									if( !in_array( $todo, $this->classData["todo"] ) )
										$this->classData["todo"][] = $todo; 
								}
								else
								{
									$desc = ereg_replace( $this->patterns["doc_data"], "", $line );
									$desc = trim( $desc );
									if( $desc && !in_array( $desc, $this->classData["desc"] ) )
										$this->classData["desc"][] = $desc;
								}
							}
						}
					}	
				}
			}
		}
		foreach( $this->classProperties as $prop => $pattern )
			if( isset( $this->classData[$prop] ) && is_array( $this->classData[$prop] ) )
				$this->classData[$prop]	= array_unique( $this->classData[$prop] );
	}
1146501
function parseClass(params, constructor) {
        var opts = {},
            key,
            value,
            saved = {},
            unallowed,
            ambiguous;

        // Check and save constants to parse later
        if (hasOwn(params, '$constants')) {
            // Check argument
            if (!isObject(params.$constants)) {
                throw new Error('$constants of class "' + constructor.prototype.$name + '" must be an object.');
            }

            // Check reserved keywords
            checkKeywords(params.$constants, 'statics');

            // Check unallowed keywords
            unallowed = testKeywords(params.$constants);
            if (unallowed) {
                throw new Error('$constants of class "' + constructor.prototype.$name + '" contains an unallowed keyword: "' + unallowed + '".');
            }

            // Check ambiguity
            if (isObject(params.$statics)) {
                ambiguous = intersection(keys(params.$constants), keys(params.$statics));
                if (ambiguous.length) {
                    throw new Error('There are members defined in class "' + constructor.prototype.$name + '" with the same name but with different modifiers: "' + ambiguous.join('", ') + '".');
                }
            }

            saved.$constants = params.$constants;
            delete params.$constants;
        }

        // Check and save finals to parse later
        if (hasOwn(params, '$finals')) {
            // Check argument
            if (!isObject(params.$finals)) {
                throw new Error('$finals of class "' + constructor.prototype.$name + '" must be an object.');
            }

            // Check reserved keywords
            checkKeywords(params.$finals);

            // Check unallowed keywords
            unallowed = testKeywords(params.$finals, ['$statics']);
            if (unallowed) {
                throw new Error('$finals of class "' + constructor.prototype.$name + '" contains an unallowed keyword: "' + unallowed + '".');
            }

            // Check ambiguity
            if (isObject(params.$finals.$statics)) {
                if (isObject(params.$statics)) {
                    ambiguous = intersection(keys(params.$finals.$statics), keys(params.$statics));
                    if (ambiguous.length) {
                        throw new Error('There are members defined in class "' + constructor.prototype.$name + '" with the same name but with different modifiers: "' + ambiguous.join('", ') + '".');
                    }
                }
                if (saved.$constants) {
                    ambiguous = intersection(keys(params.$finals.$statics), keys(saved.$constants));
                    if (ambiguous.length) {
                        throw new Error('There are members defined in class "' + constructor.prototype.$name + '" with the same name but with different modifiers: "' + ambiguous.join('", ') + '".');
                    }
                }
            }
            ambiguous = intersection(keys(params), keys(params.$finals));
            if (ambiguous.length) {
                remove(ambiguous, '$statics');
                if (ambiguous.length) {
                    throw new Error('There are members defined in class "' + constructor.prototype.$name + '" with the same name but with different modifiers: "' + ambiguous.join('", ') + '".');
                }
            }

            saved.$finals = params.$finals;
            delete params.$finals;
        }

        // Check and save locked to parse later
        if (hasOwn(params, '$locked')) {
            if (!isBoolean(params.$locked)) {
                throw new Error('$locked of class "' + constructor.prototype.name + '" must be a boolean.');
            }

            saved.$locked = params.$locked;
            delete params.$locked;
        }

        // Parse members
        parseMembers(params, constructor);

        // Parse constants
        if (saved.$constants) {
            opts.isConst = true;

            for (key in saved.$constants) {
                value = saved.$constants[key];

                addProperty(key, value, constructor, opts);
            }

            delete opts.isConst;
        }

        // Parse finals
        if (saved.$finals) {
            parseMembers(saved.$finals, constructor, true);
        }

        // Parse locked
        if (hasOwn(saved, '$locked')) {
            if (constructor[$class].forceUnlocked && saved.$locked) {
                throw new Error('Class "' + constructor.prototype.$name + '" cannot be locked because it borrows or extends from a vanilla class.');
            }
            if (constructor[$class].locked === false && saved.$locked) {
                throw new Error('Class "' + constructor.prototype.$name + '" inherits from an unlocked class, therefore its subclasses cannot be locked.');
            }
            constructor[$class].locked = !!saved.$locked;
            delete constructor.prototype.$locked;
        } else if (!hasOwn(constructor[$class], 'locked')) {
            constructor[$class].locked = !!options.locked;
        }
    }
1169898
private function _renderproperties() {
        $out = '';

        $out   .= '<divisions>'.$this->divisions.'</divisions>';
        $staves = 1;

        if (isset($this->key)) {
            $out .= $this->key->toMusicXML();
        }

        if (isset($this->time)) {
            $time = $this->time;
            if (!$time instanceof Time) {
                $time = new Time($time);
            }

            $out .= $this->time->toMusicXML();
        }

        // we count the number of clefs, and that is our number of staves
        $clefs = '';
        if (isset($this->clef)) {
            if (!is_array($this->clef)) {
                $this->clef = array($this->clef);
            }

            $num = 0;
            foreach ($this->clef as $clef) {
                $num++;
                $clefs .= $clef->toMusicXML($num);
            }

            $staves = $num;
        }

        if (isset($this->staves)) {
            $staves = $this->staves;
        }

        // output staves first, and then clefs.
        $out .= '<staves>'.$staves.'</staves>';
        $out .= $clefs;

        return $out;

    }
691671
private function parse(){
        if(self::$parser === null){
            self::$parser   = (new ParserFactory())
                ->create(\PhpParser\ParserFactory::ONLY_PHP7);
        }

        $stmt   = self::$parser->parse(file_get_contents($this->path));

        if(!is_array($stmt)){
            throw new \LogicException;
        }

        $stmt   = array_filter($stmt, function($v){
            return $v instanceof \PhpParser\Node\Stmt\Namespace_;
        });

        if(empty($stmt)){
            throw new \LogicException;
        }

        $this->namespace    = implode("\\", $stmt[0]->name->parts);

        foreach($stmt[0]->stmts as $sub_stmt){
            if($sub_stmt instanceof \PhpParser\Node\Stmt\Use_
                || $sub_stmt instanceof \PhpParser\Node\Stmt\GroupUse
            ){
                $prefix = "";

                if($sub_stmt instanceof \PhpParser\Node\Stmt\GroupUse){
                    $prefix = $sub_stmt->prefix;
                }

                foreach($sub_stmt->uses as $use){
                    $name   = implode("\\", $use->name->parts);
                    $alias  = $use->alias;

                    if($prefix !== ""){
                        $name   = "{$prefix}\\{$name}";
                    }

                    $this->uses[$name]  = $alias;
                }
            }else if($sub_stmt instanceof \PhpParser\Node\Stmt\Class_){
                $this->class    = $sub_stmt->name;
            }
        }
    }
301900
public function collectionProperties()
    {
        $props = $this->properties();

        foreach ($props as $propertyIdent => $property) {
            $propertyMetadata = $props[$propertyIdent];

            $p = $this->propertyFactory()->create($propertyMetadata['type']);
            $p->setIdent($propertyIdent);
            $p->setData($propertyMetadata);

            $options = $this->viewOptions($propertyIdent);
            $classes = $this->parsePropertyCellClasses($p);

            if (isset($options['label'])) {
                $label = $this->translator()->translate($options['label']);
            } else {
                $label = strval($p->label());
            }

            $column = [
                'label' => trim($label)
            ];

            if (!isset($column['attr'])) {
                $column['attr'] = [];
            }

            if (isset($options['attr'])) {
                $column['attr'] = array_merge($column['attr'], $options['attr']);
            }

            if (isset($classes)) {
                if (isset($column['attr']['class'])) {
                    if (is_string($classes)) {
                        $classes = explode(' ', $column['attr']['class']);
                    }

                    if (is_string($column['attr']['class'])) {
                        $column['attr']['class'] = explode(' ', $column['attr']['class']);
                    }

                    $column['attr']['class'] = array_unique(array_merge($column['attr']['class'], $classes));
                } else {
                    $column['attr']['class'] = $classes;
                }

                unset($classes);
            }

            $column['attr'] = html_build_attributes($column['attr']);

            yield $column;
        }
    }
153303
protected function loadProperties()
    {
        $methods = get_class_methods($this);

        foreach ($methods as $method) {
            preg_match("/load[a-zA-Z]+Property/", $method, $matches);

            if (count($matches)) {
                $this->$method();
            }
        }
    }
1176474
public function __findSerialisablePropertyAccessors() {

        // Grab the class name first.
        $className = get_class($this);

        // If no accessor map has been previously cached for this class type, cache it now.
        if (!isset (self::$__accessorMaps [$className])) {


            $reflectionClass = new \ReflectionClass ($className);

            // Create the accessors array for storing all possible accessors.
            $accessors = array();

            // Loop through all methods, checking for public get and set accessors first.
            $methods = $reflectionClass->getMethods();
            foreach ($methods as $method) {

                if ($method->isStatic())
                    continue;

                if ((substr($method->getName(), 0, 3) == "get") && ($method->getNumberOfRequiredParameters() == 0)) {
                    $propertyName = strtolower(substr($method->getName(), 3));
                    if (!isset ($accessors [$propertyName])) {
                        $accessors [$propertyName] = array();
                    }
                    $accessors [$propertyName] ["get"] = $method;
                } else if (substr($method->getName(), 0, 3) == "set") {
                    $propertyName = strtolower(substr($method->getName(), 3));
                    if (!isset ($accessors [$propertyName])) {
                        $accessors [$propertyName] = array();
                    }
                    $accessors [$propertyName] ["set"] = $method;
                }
            }

            // Now loop through all properties, checking for any public / protected ones
            $properties = $reflectionClass->getProperties();
            foreach ($properties as $property) {

                if ($property->isStatic())
                    continue;

                $propertyName = strtolower($property->getName());

                if (!isset ($accessors [$propertyName])) {
                    $accessors [$propertyName] = array();
                }
                if (!isset ($accessors [$propertyName] ["get"]))
                    $accessors [$propertyName] ["get"] = $property;
                if (!isset ($accessors [$propertyName] ["set"]))
                    $accessors [$propertyName] ["set"] = $property;

            }

            self::$__accessorMaps [$className] = $accessors;

        }

        return self::$__accessorMaps [$className];
    }
985432
protected function processProperties() {

		$ret = '';

		if ($this->required and (!isset($this->type) or (isset($this->type) and 'bool' != $this->type))) {
			$ret .= ' required';
		}

		if ($this->disabled) {
			$ret .= ' disabled';
		}

		if ($this->readonly) {
			$ret .= ' readonly';
		}

		if ($this->placeholder) {
			$ret .= ' placeholder="' . $this->placeholder . '"';
		}
		
		// CSS classes
		if (count($this->class)) {
			$ret .= ' class="' . implode(' ', $this->class) . '"';
		}
		
		// misc tag attributes
		foreach ($this->attributes as $attr=>$val) {
			$ret .= ' ' . $attr . '="' . addslashes($val) . '"';
		}
		
		return $ret;

	}
879774
private function parseInput()
    {
        $result = null;
        try {
            $rawBody = file_get_contents('php://input');
            if (strpos($rawBody, '&form_key=')) {
                $parts = explode('&form_key=', $rawBody);
                $rawBody = reset($parts);
            }
            $obj = json_decode($rawBody, true);
            if ($obj) {
                $type = $this->getInDataType();
                $asArray = (array)$obj;
                $result = $this->inputProcessor->convertValue($asArray, $type);
            }
        } catch (\Throwable $t) {
            $this->logger->error("Cannot parse input data: " . $t->getMessage());
        }
        return $result;
    }
726959
public function parse()
    {
        $count = (int) $this->data;
        if ($count < 0) {
            return null;
        }

        $elements = [];
        for ($i=0; $i < $count; $i++) {
            $elements[$i] = call_user_func($this->receiver);
        }
        return $elements;
    }
794887
function parseStruct (struct) {
  var s = struct.substring(1, struct.length-1)
    , equalIndex = s.indexOf('=')
    , rtn = {
        name: s.substring(0, equalIndex)
      , props: []
    }
  s = s.substring(equalIndex+1);

  var curProp = [], numBrackets = 0, entries = [];

  for (var i=0; i < s.length; i++) {
    var cur = s[i];
    switch (cur) {
      case '"':
        if (numBrackets > 0)
          curProp.push(cur);
        else {
          entries.push(curProp.join(''));
          curProp = [];
          numBrackets = 0;
        }
        break;
      case '{':
      case '[':
      case '(':
        numBrackets++;
        curProp.push(cur);
        break;
      case '}':
      case ']':
      case ')':
        numBrackets--;
        curProp.push(cur);
        break;
      default:
        curProp.push(cur);
        break;
    }
  }
  entries.push(curProp.join(''));
  curProp = [];
  numBrackets = 0;

  for (var i=1; i < entries.length; i+=2) {
    rtn.props.push([entries[i], entries[i+1]]);
  }
  return rtn
}
223152
function parseBorrows(params, constructor) {
        if (hasOwn(params, '$borrows')) {
            var current,
                k,
                key,
                value,
                mixins = toArray(params.$borrows),
                i = mixins.length;

            for (i -= 1; i >= 0; i -= 1) {
                current = mixins[i];
                // If it's a vanilla object
                if (isObject(current)) {
                    borrowFromVanilla(current, constructor);
                    continue;
                }
                // If it's a vanilla class
                if (isFunction(current) && !current[$class]) {
                    borrowFromVanilla(current.prototype, constructor);
                    continue;
                }

                current = current.prototype;

                // Grab mixin members
                borrowFromVanilla(current, constructor);

                // Grab mixin static methods
                for (k = current.$static[$class].staticMethods.length - 1; k >= 0; k -= 1) {
                    key = current.$static[$class].staticMethods[k];

                    insert(constructor[$class].staticMethods, key);
                    constructor[key] = current.$static[key];
                }

                // Grab mixin static properties
                for (key in current.$static[$class].staticProperties) {
                    value = current.$static[$class].staticProperties[key];

                    constructor[$class].staticProperties[key] = value;
                    constructor[key] = value;
                }

                // Merge the binds
                combine(constructor[$class].binds, current.$static[$class].binds);
            }

            delete params.$borrows;
        }
    }
1086922
protected function parsedFormProperties()
    {
        if ($this->parsedFormProperties === null) {
            $groupProperties = $this->groupProperties();
            $formProperties  = $this->form()->formProperties($groupProperties);

            $this->parsedFormProperties = $formProperties;
        }

        return $this->parsedFormProperties;
    }
838110
protected function parseProperties( & $properties )
    {
        if ( empty( $properties ) )
        {
            return array();
        }

        $result = array();
        foreach ( json_decode( $properties, true ) as $property )
        {
            $name = (string) $property['name'];

            $result[$name] = array(
                'name'      => $name,
                'value'     => $property['value'],
                'priority'  => $property['priority'],
            );
        }

        return $result;
    }