File GedcomxFile/Manifest.php | gedcomx-php-client

  1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17  18  19  20  21  22  23  24  25  26  27  28  29  30  31  32  33  34  35  36  37  38  39  40  41  42  43  44  45  46  47  48  49  50  51  52  53  54  55  56  57  58  59  60  61  62  63  64  65  66  67  68  69  70  71  72  73  74  75  76  77  78  79  80  81  82  83  84  85  86  87  88  89  90  91  92  93  94  95  96  97  98  99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226

<?php

namespace Gedcomx\GedcomxFile;

/**
 * Class Manifest
 *
 * @package Gedcomx\GedcomxFile
 *
 *          An object representing the MANIFEST.MF file of a .gedx archive
 */
class Manifest
{
    /**
     * The folder (within a JAR file) under which the manifest meta file resides.
     */
    const MANIFEST_FOLDER = 'META-INF';
    /**
     * The name of the manifest meta file.
     */
    const MANIFEST_FILE = 'MANIFEST.MF';

    /**
     * Associative array containing ManifestAttribute[], keyed by file name
     *
     * @var array
     */
    private $entries;
    /**
     * Attributes of the mainifest file
     *
     * @var ManifestAttribute[]
     */
    private $attributes;

    /**
     * Create an instance of Gedcomx\GedcomxFile\Manifest
     */
    public function __construct()
    {
        $this->entries = array();
    }

    /**
     * Return the value of a given attribute
     *
     * @param string $key
     *
     * @return null|string
     */
    public function getAttribute($key)
    {
        foreach ($this->attributes as $attr) {
            if ($attr->getKey() == $key) {
                return $attr->getValue();
            }
        }

        return null;
    }

    /**
     * Return the attributes of a given file entry
     *
     * @param string $name
     *
     * @return MainfestAttribute[]|null
     */
    public function getEntryAttributes($name)
    {
        return isset($this->entries[$name]) ? $this->entries[$name] : null;
    }

    /**
     * Add an attribute to the manifest file
     *
     * @param string $key
     * @param string $value
     */
    public function addAttribute($key, $value)
    {
        $this->attributes[] = new ManifestAttribute($key, $value);
    }

    /**
     * Add an attribute to a given file entry.
     *
     * @param string $name
     * @param string $key
     * @param string $value
     */
    public function addAttributeToEntry($name, $key, $value)
    {
        $this->entries[$name][] = new ManifestAttribute($key, $value);
    }

    /**
     * Update a given attribute of a given file entry
     *
     * @param string $name
     * @param string $key
     * @param string $value
     */
    public function updateEntryAttribute($name, $key, $value)
    {
        foreach ($this->entries[$name] as $attr) {
            if($attr->getKey() == $key){
                $attr->setValue($value);
            }
        }
    }

    /**
     * Create a new entry record
     *
     * @param string $name
     */
    public function addEntry($name)
    {
        $this->entries[$name] = array();
        $this->entries[$name][] = new ManifestAttribute("Name", $name);
    }

    /**
     * Parse an existing manifest file into its component objects
     *
     * @param string $incoming
     */
    public function parse($incoming){
        $incoming = $this->normalizeLineEndings($incoming);
        $blocks = explode("\n\n", $incoming);
        /*
         *  The first block should be the attributes of the gedx file itself.
         *  Parse and remove those before parsing attributes of the archive entries.
         */
        $lines = explode("\n",$blocks[0]);
        foreach ($lines as $line) {
            list($key, $value) = explode(": ", $line);
            $this->addAttribute($key, $value);
        }
        array_shift($blocks);
        /*
         *  Parse the entry attributes
         */
        $this->entries = $this->createEntries($blocks);
    }

    /**
     * Convert the Manifest object to a string
     *
     * @return string
     */
    public function toString(){
        return $this->__toString();
    }

    /**
     * Define the string output
     *
     * @return string
     */
    public function __toString()
    {
        $output = '';
        foreach ($this->attributes as $attr) {
            $output .= $attr->toString() . "\n";
        }
        $output .= "\n";
        foreach ($this->entries as $entry) {
            foreach ($entry as $attr) {
                $output .= $attr->toString() . "\n";
            }
            $output .= "\n";
        }

        return $output;
    }

    /**
     * Create the a file entry
     *
     * @param string[] $blocks
     *
     * @return ManifestAttribute[]
     */
    private function createEntries($blocks)
    {
        $entries = array();

        foreach ($blocks as $block) {
            if (strlen($block) == 0) {
                continue;
            }

            $lines = explode("\n", $block);
            $name = null;
            $entry = array();

            foreach ($lines as $line) {
                list($key, $value) = explode(": ", $line);
                $entry[] = new ManifestAttribute($key, $value);
                if ($key == "Name") {
                    $name = $value;
                }
            }
            $entries[$name] = $entry;
        }

        return $entries;
    }

    /**
     * Normalize line endings to LF
     *
     * @param $stringData
     *
     * @return string
     */
    private function normalizeLineEndings($stringData)
    {
        $stringData = str_replace("\r\n", "\n", $stringData);
        $stringData = str_replace("\r", "\n", $stringData);

        return $stringData;
    }
}

Namespaces

Classes

Interfaces

Exceptions