How to navigate back up in a multidimensional array after finding the appropriate child?

Question

I have an array that looks like this:

RecursiveArrayIterator {#605 ▼
  +"xs:schema": array:2 [▼
    "value" => array:1 [▼
      "xs:element" => array:2 [▼
        "value" => array:1 [▼
          "xs:complexType" => array:2 [▼
            "value" => array:2 [▼
              "xs:sequence" => array:2 [▼
                "value" => array:1 [▼
                  "xs:element" => array:3 [▼
                    0 => array:2 [▼
                      "value" => array:1 [▼
                        "xs:simpleType" => array:2 [▼
                          "value" => array:1 [▼
                            "xs:restriction" => array:2 [▼
                              "value" => array:1 [▼
                                "xs:maxLength" => array:1 [▼
                                  "attributes" => array:1 [▼
                                    "value" => "40"
                                  ]
                                ]
                              ]
                              "attributes" => array:1 [▶]
                            ]
                          ]
                          "attributes" => []
                        ]
                      ]
                      "attributes" => array:1 [▼
                        "name" => "title"
                      ]
                    ]
                    1 => array:2 [▶]
                    2 => array:2 [▶]
                  ]
                ]
                "attributes" => []
              ]
              "xs:attribute" => array:2 [▶]
            ]
            "attributes" => []
          ]
        ]
        "attributes" => array:1 [▼
          "name" => "book"
        ]
      ]
    ]
    "attributes" => []
  ]
}

I need to access the xs:maxLength attribute, so in order to that that, I'm using the following method:

private function findRestrictions(array $haystack, $needle)
{
    $iterator = new \RecursiveArrayIterator($haystack);
    $recursive = new \RecursiveIteratorIterator(
        $iterator,
        \RecursiveIteratorIterator::SELF_FIRST
    );

    foreach ($recursive as $key => $value)
    {
        if ($key === $needle)
        {
            return (int)$value['attributes']['value'];
        }
    }
}

$maxLength = findRestrictions($array, 'xs:maxLength');

So that gives me back 40, just like expected. Anyway, my issue is that I need to know to which element this limit belongs to, which is mentioned in xs:element[0]['attributes']['name'] and I'm uncertain on how to reach there to grab the information I need, based on the match for xs:maxLength.

Answer 1

Well I have programmed a pretty good solution I think, this time it is tested.

My sample array:

$array = [
        "we" => 
            ["are" => [
                "lorem" => [
                    "gone" => "away",
                    "my" => "friend"
                    ],
                "never" => "abcd",
                "any" => [
                        "btc" => "abc",
                        "help" => [
                            "mqf" => "bmx"
                            ]
                    ]
                ]
            ],
         "fancy" => [
                "lorem" => [
                    "gone" => "away",
                    "my" => "friend"
                    ],
                "never" => "abcd",
                "any" => [
                        "btc" => "abc",
                        "help" => [
                            "mqf" => "bmx",
                            "abc" => 13
                            ]
                    ]
                ],
         "beer" => "bar",
         "helpful" => [
                "meta" => "column",
                "gamma" => [
                    "lorem" => [
                        "gone" => "mad",
                        "my" => "drink"
                        ],
                    "never" => "abcd",
                    "any" => [
                            "btc" => "abc",
                            "help" => [
                                "mqf" => "bmx",
                                "abc" => "alot"
                                ]
                        ]
                    ]
             ],
          "elements" => [
                0 => 88,
                1 => 99
              ]
        ];

My solution:

    function array_find_value_return_parent($array,$needle,$parentkey) {
        $iterator = new RecursiveIteratorIterator(
            new RecursiveArrayIterator($array),
            RecursiveIteratorIterator::SELF_FIRST);

        foreach($iterator as $key => $value) {
            if($value === $needle) {
                for ($i = $iterator->getDepth() - 1; $i >= 0; $i--) {
                    if($iterator->getSubIterator($i)->key() === $parentkey) {
                        return $iterator->getSubIterator($i)->current();
                    }
                }
            }
        }
    }

    function array_find_key_return_value($array,$findkey) {
        $iterator = new RecursiveIteratorIterator(
            new RecursiveArrayIterator($array),
            RecursiveIteratorIterator::SELF_FIRST);

        foreach($iterator as $key => $value) {
            if($findkey === $key) {
               return $iterator->current();
            }
        }
    }

My test:

    $findvalue = "alot";
    $findparentkey = "gamma";
    $findreturnkey = "gone";

   echo array_find_key_return_value(array_find_value_return_parent($array,$findvalue,$findparentkey),$findreturnkey);

Output: mad

For your case it means that you might do the following:

    $findvalue = "40";
    $findparentkey = "xs:element";
    $findreturnkey = "name";

   echo array_find_key_return_value(array_find_value_return_parent($array,$findvalue,$findparentkey),$findreturnkey);

Expected output: title

Right?

Answer 2

I do not know your original data structure, so I just converted your data to a PHP array. You can use $aks = new ArrayKeySearcher($data, 'xs:maxLength'); to find the key you want. And you can make the search more complex to satisfy your requirement.

However, if you are using something like XML, it is highly recommended to use XML-based solutions, like XPath query (eg: http://php.net/manual/en/domxpath.query.php, http://php.net/manual/en/simplexmlelement.xpath.php). These methods are easier to use, faster and more accurate.

<?php

$data =  [
"xs:schema"=>  [
    "value" =>  [
      "xs:element" =>  [
        "value" =>  [
          "xs:complexType" =>  [
            "value" =>  [
              "xs:sequence" =>  [
                "value" =>  [
                  "xs:element" =>  [
                    0 =>  [
                      "value" =>  [
                        "xs:simpleType" =>  [
                          "value" =>  [
                            "xs:restriction" =>  [
                              "value" =>  [
                                "xs:maxLength" =>  [
                                  "attributes" =>  [
                                    "value" => "40"
                                  ]
                                ]
                              ],
                              "attributes" =>  []
                            ]
                          ],
                          "attributes" => []
                        ]
                      ],
                      "attributes" =>  [
                        "name" => "title"
                      ]
                    ],
                    1 =>  [],
                    2 =>  [],
                  ]
                ],
                "attributes" => []
              ],
              "xs:attribute" =>  []
            ],
            "attributes" => []
          ]
        ],
        "attributes" =>  [
          "name" => "book"
        ]
      ]
    ],
    "attributes" => []
  ]
];


class ArrayKeySearcher
{
    public $data;
    public $path;
    public $value;

    public function __construct($data, $key)
    {
        $this->data = $data;
        $this->findKeyPath($data, $key);
    }

    private function findKeyPath($data, $key)
    {
        foreach ($data as $k => $v) {
            $this->path[] = $k;
            if ($key === $k) {
                $this->value = $v;
                return;
            }
            $this->findKeyPath($v, $key);
            if (!is_null($this->value))
                return;
            array_pop($this->path);
        }
    }

    public function arrayReverseSearch($a, $k, $pos = null)
    {
        $count = count($a);
        $i = ($pos === null) ? ($count - 1) : $pos;
        for(; $i >= 0; $i--) {
            if($a[$i] === $k)
                return $i;
        }
        return $i;
    }

    public function getValueByPath($path)
    {
        $v = $this->data;
        foreach($path as $k) {
            if(isset($v[$k]))
                $v = $v[$k];
        }
        return $v;
    }
}


$aks = new ArrayKeySearcher($data, 'xs:maxLength');
echo 'path: ' . json_encode($aks->path) . PHP_EOL;
echo 'value: ' . json_encode($aks->value) . PHP_EOL;

$p = $aks->path;
$pos = $aks->arrayReverseSearch($p, 'xs:simpleType');
$pos = $aks->arrayReverseSearch($p, 'value', $pos);
$p = array_slice($p, 0, $pos);
$parent = $aks->getValueByPath($p);
echo 'parent path: ' . json_encode($p) . PHP_EOL;
echo 'parent attributes: ' . json_encode($parent['attributes']) . PHP_EOL;

Output:

path: ["xs:schema","value","xs:element","value","xs:complexType","value","xs:sequence","value","xs:element",0,"value","xs:simpleType","value","xs:restriction","value","xs:maxLength"]
value: {"attributes":{"value":"40"}}
parent path: ["xs:schema","value","xs:element","value","xs:complexType","value","xs:sequence","value","xs:element",0]
parent attributes: {"name":"title"}