← Back to branch summary

~jstys-z/helioviewer.org/client5

« back to all changes in this revision

Viewing changes to src/php/Helper/HelioviewerEvents.php

Preparing to merge in my branch

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/php/Helper/HelioviewerEvents.php
1
 
<?php
2
 
/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
3
 
/**
4
 
 * Helper_HelioviewerEvents Class Definition
5
 
 *
6
 
 * PHP version 5
7
 
 *
8
 
 * @category Helper
9
 
 * @package  Helioviewer
10
 
 * @author   Jeff Stys <jeffrey.stys@nasa.gov>
11
 
 * @license  http://www.mozilla.org/MPL/MPL-1.1.html Mozilla Public License 1.1
12
 
 * @link     http://launchpad.net/helioviewer.org
13
 
 */
14
 
 
15
 
/**
16
 
 * A simple class to represent one or more Helioviewer event FRMs in a request.
17
 
 *
18
 
 * @category Helper
19
 
 * @package  Helioviewer
20
 
 * @author   Jeff Stys <jeffrey.stys@nasa.gov>
21
 
 * @license  http://www.mozilla.org/MPL/MPL-1.1.html Mozilla Public License 1.1
22
 
 * @link     http://launchpad.net/helioviewer.org
23
 
 */
24
 
class Helper_HelioviewerEvents {
25
 
 
26
 
    private $_events = array();
27
 
    private $_eventString;
28
 
    private $_eventTree;
29
 
 
30
 
    /**
31
 
     * Creates a new HelioviewerEvents instance
32
 
     *
33
 
     * @param string $eventString Event string format:
34
 
     *                            [event_type,frm_name,visibility]
35
 
     *
36
 
     * @return void
37
 
     */
38
 
    public function __construct($eventString) {
39
 
        $this->_eventString = $eventString;
40
 
 
41
 
        if ( $this->_eventString == '' ) {
42
 
            return;
43
 
        }
44
 
 
45
 
        $eventStringArray = explode("],[", substr($eventString, 1, -1));
46
 
 
47
 
        // Process individual events in string
48
 
        foreach ($eventStringArray as $singleEventString) {
49
 
            $event = $this->_decodeSingleEventString($singleEventString);
50
 
            array_push($this->_events, $event);
51
 
        }
52
 
 
53
 
        // Store a tree representation of the events for generating
54
 
        // human-readable strings
55
 
        $this->_createEventTree();
56
 
 
57
 
        // Check to make sure at least one valid event was specified
58
 
        if (sizeOf($this->_events) === 0) {
59
 
            throw new Exception(
60
 
                "No valid and visible events specified for request.", 20);
61
 
        }
62
 
    }
63
 
 
64
 
    /**
65
 
     * Returns the number of events in the collection
66
 
     *
67
 
     * @return int Number of events in request
68
 
     */
69
 
    public function length() {
70
 
        return sizeOf($this->_events);
71
 
    }
72
 
 
73
 
    /**
74
 
     * Returns the events as an array of associative arrays
75
 
     *
76
 
     * @return array An array of hashes representing the requested events
77
 
     */
78
 
    public function toArray() {
79
 
        return $this->_events;
80
 
    }
81
 
 
82
 
    /**
83
 
     * Returns a string representation of the request events suitable for use in queries
84
 
     *
85
 
     * @return string String representation of the request events for use API queries
86
 
     */
87
 
    public function serialize() {
88
 
        return $this->_eventString;
89
 
    }
90
 
 
91
 
    /**
92
 
     * Creates a tree representation of the events
93
 
     *
94
 
     * @return void
95
 
     */
96
 
    private function _createEventTree() {
97
 
        $tree = array();
98
 
 
99
 
        foreach ($this->_events as $event) {
100
 
            $event_type = $event['event_type'];
101
 
            $frm_name = $event['frm_name'];
102
 
            if ( !isset($tree[$event_type]) ) {
103
 
                $tree[$event_type] = array();
104
 
            }
105
 
            if ( !isset($tree[$event_type][$frm_name]) ) {
106
 
                $tree[$event_type][] = $frm_name;
107
 
            }
108
 
        }
109
 
 
110
 
        $this->_eventTree = $tree;
111
 
    }
112
 
 
113
 
    /**
114
 
     * Takes a single event string and converts it to a more convenient
115
 
     * associative array. filling in any missing details as neccessary
116
 
     *
117
 
     * @param string $eventString A single event represented as a string in
118
 
     *                            the following format:
119
 
     *                            [event_type, frm_name, visible]
120
 
     *
121
 
     * @return array Associative array representation of the event
122
 
     */
123
 
    private function _decodeSingleEventString ($eventString) {
124
 
 
125
 
        // Break up string into individual components
126
 
        $eventArray = explode(",", $eventString);
127
 
 
128
 
        list($event_type, $frm_name, $visible) = $eventArray;
129
 
 
130
 
        // Associative array form
131
 
        return array (
132
 
            "event_type" => $event_type,
133
 
            "frm_name"   => $frm_name,
134
 
            "visible"    => ( $visible == 1 || strtolower($visible) == 'true' ) ? true : false
135
 
        );
136
 
    }
137
 
 
138
 
}
 
 
b'\\ No newline at end of file'