Back to index

awl  0.53
Public Member Functions | Protected Attributes
vComponent Class Reference
Inheritance diagram for vComponent:
Inheritance graph
[legend]

List of all members.

Public Member Functions

 __construct ($content=null)
 

@-


 CollectParameterValues ($parameter_name)
 Collect an array of all parameters of our properties which are the specified type Mainly used for collecting the full variety of references TZIDs.
 ParseFrom ($content)
 Parse the text $content into sets of vProperty & vComponent within this vComponent.
 UnwrapComponent ($content)
 This unescapes the (CRLF + linear space) wrapping specified in RFC2445.
 WrapComponent ($content)
 This imposes the (CRLF + linear space) wrapping specified in RFC2445.
 GetType ()
 Return the type of component which this is.
 SetType ($type)
 Set the type of component which this is.
 GetProperty ($type)
 Return the first instance of a property of this name.
 GetPValue ($type)
 Return the value of the first instance of a property of this name, or null.
 GetProperties ($type=null)
 Get all properties, or the properties matching a particular type, or matching an array associating property names with true values: array( 'PROPERTY' => true, 'PROPERTY2' => true )
 ClearProperties ($type=null)
 Clear all properties, or the properties matching a particular type.
 SetProperties ($new_properties, $type=null)
 Set all properties, or the ones matching a particular type.
 AddProperty ($new_property, $value=null, $parameters=null)
 Adds a new property.
 ComponentCount ()
 Return number of components.
 GetComponents ($type=null, $normal_match=true)
 Get all sub-components, or at least get those matching a type, or failling to match, should the second parameter be set to false.
 ClearComponents ($type=null)
 Clear all components, or the components matching a particular type.
 SetComponents ($new_component, $type=null)
 Sets some or all sub-components of the component to the supplied new components.
 AddComponent ($new_component)
 Adds a new subcomponent.
 MaskComponents ($keep, $recursive=true)
 Mask components, removing any that are not of the types in the list.
 MaskProperties ($keep, $component_list=null)
 Mask properties, removing any that are not in the list.
 Render ($restricted_properties=null, $force_rendering=false)
 Renders the component, possibly restricted to only the listed properties.
 __toString ()
 GetPropertiesByPath ($path)
 Return an array of properties matching the specified path.
 TestFilter ($filters)
 Test a PROP-FILTER or COMP-FILTER and return a true/false COMP-FILTER (is-defined | is-not-defined | (time-range?, prop-filter*, comp-filter*)) PROP-FILTER (is-defined | is-not-defined | ((time-range | text-match)?, param-filter*))

Protected Attributes

 $type
 $properties
 $components
 $rendered

Detailed Description

Definition at line 409 of file vComponent.php.


Constructor & Destructor Documentation

vComponent::__construct ( content = null)

@-

A basic constructor

Reimplemented in vCalendar.

Definition at line 447 of file vComponent.php.

                                          {
    $this->type = "";
    $this->properties = array();
    $this->components = array();
    $this->rendered = "";
    if ( $content != null && (gettype($content) == 'string' || gettype($content) == 'array') ) {
      $this->ParseFrom($content);
    }
  }

Here is the call graph for this function:


Member Function Documentation

Definition at line 875 of file vComponent.php.

                               {
    return $this->Render();
  }

Here is the call graph for this function:

vComponent::AddComponent ( new_component)

Adds a new subcomponent.

Parameters:
vComponent$new_componentThe new component to append to the set

Definition at line 796 of file vComponent.php.

                                          {
    if ( is_array($new_component) && count($new_component) == 0 ) return;
    if ( isset($this->rendered) ) unset($this->rendered);
    if ( is_array($new_component) ) {
      foreach( $new_component AS $k => $v ) {
        $this->components[] = $v;
      }
    }
    else {
      $this->components[] = $new_component;
    }
  }

Here is the caller graph for this function:

vComponent::AddProperty ( new_property,
value = null,
parameters = null 
)

Adds a new property.

Parameters:
vProperty$new_propertyThe new property to append to the set, or a string with the name
string$valueThe value of the new property (default: param 1 is an vProperty with everything
array$parametersThe key/value parameter pairs (default: none, or param 1 is an vProperty with everything)

Definition at line 693 of file vComponent.php.

                                                                           {
    if ( isset($this->rendered) ) unset($this->rendered);
    if ( isset($value) && gettype($new_property) == 'string' ) {
      $new_prop = new vProperty();
      $new_prop->Name($new_property);
      $new_prop->Value($value);
      if ( $parameters != null ) $new_prop->Parameters($parameters);
//      dbg_error_log('vComponent'," Adding new property '%s'", $new_prop->Render() );
      $this->properties[] = $new_prop;
    }
    else if ( $new_property instanceof vProperty ) {
      $this->properties[] = $new_property;
    }
  }

Here is the caller graph for this function:

vComponent::ClearComponents ( type = null)

Clear all components, or the components matching a particular type.

Parameters:
string$typeThe type of component - omit for all components

Definition at line 751 of file vComponent.php.

                                           {
    if ( $type != null ) {
      $testtypes = (gettype($type) == 'string' ? array( $type => true ) : $type );
      // First remove all the existing ones of that type
      foreach( $this->components AS $k => $v ) {
        if ( isset($testtypes[$v->GetType()]) && $testtypes[$v->GetType()] ) {
          unset($this->components[$k]);
          if ( isset($this->rendered) ) unset($this->rendered);
        }
        else {
          if ( ! $this->components[$k]->ClearComponents($testtypes) ) {
            if ( isset($this->rendered) ) unset($this->rendered);
          }
        }
      }
      return isset($this->rendered);
    }
    else {
      if ( isset($this->rendered) ) unset($this->rendered);
      $this->components = array();
      return false;
    }
  }

Here is the caller graph for this function:

vComponent::ClearProperties ( type = null)

Clear all properties, or the properties matching a particular type.

Parameters:
string | array$typeThe type of property - omit for all properties - or an array associating property names with true values: array( 'PROPERTY' => true, 'PROPERTY2' => true )

Definition at line 655 of file vComponent.php.

                                           {
    if ( $type != null ) {
      $testtypes = (gettype($type) == 'string' ? array( $type => true ) : $type );
      // First remove all the existing ones of that type
      foreach( $this->properties AS $k => $v ) {
        if ( isset($testtypes[$v->Name()]) && $testtypes[$v->Name()] ) {
          unset($this->properties[$k]);
          if ( isset($this->rendered) ) unset($this->rendered);
        }
      }
      $this->properties = array_values($this->properties);
    }
    else {
      if ( isset($this->rendered) ) unset($this->rendered);
      $this->properties = array();
    }
  }

Here is the caller graph for this function:

vComponent::CollectParameterValues ( parameter_name)

Collect an array of all parameters of our properties which are the specified type Mainly used for collecting the full variety of references TZIDs.

Definition at line 462 of file vComponent.php.

                                                     {
    $values = array();
    foreach( $this->components AS $k => $v ) {
      $also = $v->CollectParameterValues($parameter_name);
      $values = array_merge( $values, $also );
    }
    foreach( $this->properties AS $k => $v ) {
      $also = $v->GetParameterValue($parameter_name);
      if ( isset($also) && $also != "" ) {
//        dbg_error_log( 'vComponent', "::CollectParameterValues(%s) : Found '%s'", $parameter_name, $also);
        $values[$also] = 1;
      }
    }
    return $values;
  }

Return number of components.

Definition at line 712 of file vComponent.php.

                            {
    return count($this->components);
  }
vComponent::GetComponents ( type = null,
normal_match = true 
)

Get all sub-components, or at least get those matching a type, or failling to match, should the second parameter be set to false.

Component types may be a string or an array associating property names with true values: array( 'TYPE' => true, 'TYPE2' => true )

Parameters:
mixed$typeThe type(s) to match (default: All)
boolean$normal_matchSet to false to invert the match (default: true)
Returns:
array an array of the sub-components

Definition at line 726 of file vComponent.php.

                                                               {
    $components = $this->components;
    if ( $type != null ) {
      $testtypes = (gettype($type) == 'string' ? array( $type => true ) : $type );
      foreach( $components AS $k => $v ) {
//        printf( "Type: %s, %s, %s\n", $v->GetType(),
//                 ($normal_match && isset($testtypes[$v->GetType()]) && $testtypes[$v->GetType()] ? 'true':'false'),
//                 ( !$normal_match && (!isset($testtypes[$v->GetType()]) || !$testtypes[$v->GetType()]) ? 'true':'false')
//               );
        if ( !($normal_match && isset($testtypes[$v->GetType()]) && $testtypes[$v->GetType()] )
            && !( !$normal_match && (!isset($testtypes[$v->GetType()]) || !$testtypes[$v->GetType()])) ) {
          unset($components[$k]);
        }
      }
      $components = array_values($components);
    }
//    print_r($components);
    return $components;
  }

Here is the caller graph for this function:

vComponent::GetProperties ( type = null)

Get all properties, or the properties matching a particular type, or matching an array associating property names with true values: array( 'PROPERTY' => true, 'PROPERTY2' => true )

Definition at line 638 of file vComponent.php.

                                         {
    $properties = array();
    $testtypes = (gettype($type) == 'string' ? array( $type => true ) : $type );
    foreach( $this->properties AS $k => $v ) {
      if ( $type == null || (isset($testtypes[$v->Name()]) && $testtypes[$v->Name()]) ) {
        $properties[] = $v;
      }
    }
    return $properties;
  }

Here is the caller graph for this function:

Return an array of properties matching the specified path.

Returns:
array An array of vProperty within the tree which match the path given, in the form [/]COMPONENT[/...]/PROPERTY in a syntax kind of similar to our poor man's XML queries. We also allow COMPONENT and PROPERTY to be !COMPONENT and !PROPERTY for ++fun.
Note:
At some point post PHP4 this could be re-done with an iterator, which should be more efficient for common use cases.

There is more to the path, so we recurse into that sub-part

Our input $path was not rooted, so we recurse further

Definition at line 889 of file vComponent.php.

                                        {
    $properties = array();
    dbg_error_log( 'vComponent', "GetPropertiesByPath: Querying within '%s' for path '%s'", $this->type, $path );
    if ( !preg_match( '#(/?)(!?)([^/]+)(/?.*)$#', $path, $matches ) ) return $properties;

    $anchored = ($matches[1] == '/');
    $inverted = ($matches[2] == '!');
    $ourtest = $matches[3];
    $therest = $matches[4];
    dbg_error_log( 'vComponent', "GetPropertiesByPath: Matches: %s -- %s -- %s -- %s\n", $matches[1], $matches[2], $matches[3], $matches[4] );
    if ( $ourtest == '*' || (($ourtest == $this->type) !== $inverted) && $therest != '' ) {
      if ( preg_match( '#^/(!?)([^/]+)$#', $therest, $matches ) ) {
        $normmatch = ($matches[1] =='');
        $proptest  = $matches[2];
        foreach( $this->properties AS $k => $v ) {
          if ( $proptest == '*' || (($v->Name() == $proptest) === $normmatch ) ) {
            $properties[] = $v;
          }
        }
      }
      else {
        foreach( $this->components AS $k => $v ) {
          $properties = array_merge( $properties, $v->GetPropertiesByPath($therest) );
        }
      }
    }

    if ( ! $anchored ) {
      foreach( $this->components AS $k => $v ) {
        $properties = array_merge( $properties, $v->GetPropertiesByPath($path) );
      }
    }
    dbg_error_log('vComponent', "GetPropertiesByPath: Found %d within '%s' for path '%s'\n", count($properties), $this->type, $path );
    return $properties;
  }

Here is the caller graph for this function:

Return the first instance of a property of this name.

So we can call methods on the result of this, make sure we always return a vProperty of some kind

Definition at line 610 of file vComponent.php.

                                {
    foreach( $this->properties AS $k => $v ) {
      if ( is_object($v) && $v->Name() == $type ) {
        return $v;
      }
      else if ( !is_object($v) ) {
        debug_error_log("ERROR", 'vComponent::GetProperty(): Trying to get %s on %s which is not an object!', $type, $v );
      }
    }
    return null;
  }

Here is the caller graph for this function:

vComponent::GetPValue ( type)

Return the value of the first instance of a property of this name, or null.

Definition at line 627 of file vComponent.php.

                              {
    $p = $this->GetProperty($type);
    if ( isset($p) ) return $p->Value();
    return null;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

Return the type of component which this is.

Definition at line 592 of file vComponent.php.

                     {
    return $this->type;
  }
vComponent::MaskComponents ( keep,
recursive = true 
)

Mask components, removing any that are not of the types in the list.

Parameters:
array$keepAn array of component types to be kept
boolean$recursive(default true) Whether to recursively MaskComponents on the ones we find

Definition at line 815 of file vComponent.php.

                                                      {
    foreach( $this->components AS $k => $v ) {
      if ( !isset($keep[$v->GetType()]) ) {
        unset($this->components[$k]);
        if ( isset($this->rendered) ) unset($this->rendered);
      }
      else if ( $recursive ) {
        $v->MaskComponents($keep);
      }
    }
  }

Here is the caller graph for this function:

vComponent::MaskProperties ( keep,
component_list = null 
)

Mask properties, removing any that are not in the list.

Parameters:
array$keepAn array of property names to be kept
array$component_listAn array of component types to check within

Definition at line 833 of file vComponent.php.

                                                         {
    if ( !isset($component_list) || isset($component_list[$this->type]) ) {
      foreach( $this->properties AS $k => $v ) {
        if ( !isset($keep[$v->Name()]) || !$keep[$v->Name()] ) {
          unset($this->properties[$k]);
          if ( isset($this->rendered) ) unset($this->rendered);
        }
      }
    }
    foreach( $this->components AS $k => $v ) {
      $v->MaskProperties($keep, $component_list);
    }
  }

Here is the caller graph for this function:

vComponent::ParseFrom ( content)

Parse the text $content into sets of vProperty & vComponent within this vComponent.

Parameters:
string$contentThe raw RFC2445-compliant vComponent component, including BEGIN:TYPE & END:TYPE

Definition at line 483 of file vComponent.php.

                                 {
    $this->rendered = $content;
    $content = $this->UnwrapComponent($content);

    $type = false;
    $subtype = false;
    $finish = null;
    $subfinish = null;

    $length = strlen($content);
    $linefrom = 0;
    while( $linefrom < $length ) {
      $lineto = strpos( $content, "\n", $linefrom );
      if ( $lineto === false ) {
        $lineto = strpos( $content, "\r", $linefrom );
      }
      if ( $lineto > 0 ) {
        $line = substr( $content, $linefrom, $lineto - $linefrom);
        $linefrom = $lineto + 1;
      }
      else {
        $line = substr( $content, $linefrom );
        $linefrom = $length;
      }
      if ( preg_match('/^\s*$/', $line ) ) continue;
      $line = rtrim( $line, "\r\n" );
//      dbg_error_log( 'vComponent',  "::ParseFrom: Parsing line: $line");

      if ( $type === false ) {
        if ( preg_match( '/^BEGIN:(.+)$/i', $line, $matches ) ) {
          // We have found the start of the main component
          $type = strtoupper($matches[1]);
          $finish = 'END:'.$type;
          $this->type = $type;
//          dbg_error_log( 'vComponent', "::ParseFrom: Start component of type '%s'", $type);
        }
        else {
          dbg_error_log( 'vComponent', "::ParseFrom: Ignoring crap before start of component: $line");
          // unset($lines[$k]);  // The content has crap before the start
          if ( $line != "" ) $this->rendered = null;
        }
      }
      else if ( $type == null ) {
        dbg_error_log( 'vComponent', "::ParseFrom: Ignoring crap after end of component");
        if ( $line != "" ) $this->rendered = null;
      }
      else if ( strtoupper($line) == $finish ) {
//        dbg_error_log( 'vComponent', "::ParseFrom: End of component");
        $type = null;  // We have reached the end of our component
      }
      else {
        if ( $subtype === false && preg_match( '/^BEGIN:(.+)$/i', $line, $matches ) ) {
          // We have found the start of a sub-component
          $subtype = strtoupper($matches[1]);
          $subfinish = "END:$subtype";
          $subcomponent = $line . "\r\n";
//          dbg_error_log( 'vComponent', "::ParseFrom: Found a subcomponent '%s'", $subtype);
        }
        else if ( $subtype ) {
          // We are inside a sub-component
          $subcomponent .= $this->WrapComponent($line);
          if ( strtoupper($line) == $subfinish ) {
//            dbg_error_log( 'vComponent', "::ParseFrom: End of subcomponent '%s'", $subtype);
            // We have found the end of a sub-component
            $this->components[] = new vComponent($subcomponent);
            $subtype = false;
          }
//          else
//            dbg_error_log( 'vComponent', "::ParseFrom: Inside a subcomponent '%s'", $subtype );
        }
        else {
//          dbg_error_log( 'vComponent', "::ParseFrom: Parse property of component");
          // It must be a normal property line within a component.
          $this->properties[] = new vProperty($line);
        }
      }
    }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

vComponent::Render ( restricted_properties = null,
force_rendering = false 
)

Renders the component, possibly restricted to only the listed properties.

Definition at line 851 of file vComponent.php.

                                                                             {

    $unrestricted = (!isset($restricted_properties) || count($restricted_properties) == 0);

    if ( !$force_rendering && isset($this->rendered) && $unrestricted )
      return $this->rendered;

    $rendered = "BEGIN:$this->type\r\n";
    foreach( $this->properties AS $k => $v ) {
      if ( method_exists($v, 'Render') ) {
        if ( $unrestricted || isset($restricted_properties[$v]) ) $rendered .= $v->Render() . "\r\n";
      }
    }
    foreach( $this->components AS $v ) {   $rendered .= $v->Render( $restricted_properties, $force_rendering );  }
    $rendered .= "END:$this->type\r\n";

    $rendered = preg_replace('{(?<!\r)\n}', "\r\n", $rendered);
    if ( $unrestricted ) $this->rendered = $rendered;

    return $rendered;
  }

Here is the caller graph for this function:

vComponent::SetComponents ( new_component,
type = null 
)

Sets some or all sub-components of the component to the supplied new components.

Parameters:
arrayof vComponent $new_components The new components to replace the existing ones
string$typeThe type of components to be replaced. Defaults to null, which means all components will be replaced.

Definition at line 782 of file vComponent.php.

                                                         {
    if ( isset($this->rendered) ) unset($this->rendered);
    $this->ClearComponents($type);
    foreach( $new_component AS $k => $v ) {
      $this->components[] = $v;
    }
  }

Here is the call graph for this function:

vComponent::SetProperties ( new_properties,
type = null 
)

Set all properties, or the ones matching a particular type.

Definition at line 677 of file vComponent.php.

                                                          {
    if ( isset($this->rendered) && count($new_properties) > 0 ) unset($this->rendered);
    $this->ClearProperties($type);
    foreach( $new_properties AS $k => $v ) {
      $this->properties[] = $v;
    }
  }

Here is the call graph for this function:

vComponent::SetType ( type)

Set the type of component which this is.

Definition at line 600 of file vComponent.php.

                            {
    if ( isset($this->rendered) ) unset($this->rendered);
    $this->type = strtoupper($type);
    return $this->type;
  }

Here is the caller graph for this function:

vComponent::TestFilter ( filters)

Test a PROP-FILTER or COMP-FILTER and return a true/false COMP-FILTER (is-defined | is-not-defined | (time-range?, prop-filter*, comp-filter*)) PROP-FILTER (is-defined | is-not-defined | ((time-range | text-match)?, param-filter*))

Parameters:
array$filterAn array of XMLElement defining the filter
Returns:
boolean Whether or not this vComponent passes the test

Definition at line 942 of file vComponent.php.

                                  {
    foreach( $filters AS $k => $v ) {
      $tag = $v->GetNSTag();
//      dbg_error_log( 'vCalendar', ":TestFilter: '%s' ", $tag );
      switch( $tag ) {
        case 'urn:ietf:params:xml:ns:caldav:is-defined':
        case 'urn:ietf:params:xml:ns:carddav:is-defined':
          if ( count($this->properties) == 0 && count($this->components) == 0 ) return false;
          break;
        
        case 'urn:ietf:params:xml:ns:caldav:is-not-defined':
        case 'urn:ietf:params:xml:ns:carddav:is-not-defined':
          if ( count($this->properties) > 0 || count($this->components) > 0 ) return false;
          break;

        case 'urn:ietf:params:xml:ns:caldav:comp-filter':
        case 'urn:ietf:params:xml:ns:carddav:comp-filter':
          $subcomponents = $this->GetComponents($v->GetAttribute('name'));
          $subfilter = $v->GetContent();
//          dbg_error_log( 'vCalendar', ":TestFilter: Found '%d' (of %d) subs of type '%s'",
//                       count($subcomponents), count($this->components), $v->GetAttribute('name') );
          $subtag = $subfilter[0]->GetNSTag(); 
          if ( $subtag == 'urn:ietf:params:xml:ns:caldav:is-not-defined'
                             || $subtag == 'urn:ietf:params:xml:ns:carddav:is-not-defined' ) {
            if ( count($properties) > 0 ) {
//              dbg_error_log( 'vComponent', ":TestFilter: Wanted none => false" );
              return false;
            }
          }
          else if ( count($subcomponents) == 0 ) {
            if ( $subtag == 'urn:ietf:params:xml:ns:caldav:is-defined'
                             || $subtag == 'urn:ietf:params:xml:ns:carddav:is-defined' ) {
//              dbg_error_log( 'vComponent', ":TestFilter: Wanted some => false" );
              return false;
            }
            else {
//              dbg_error_log( 'vCalendar', ":TestFilter: Wanted something from missing sub-components => false" );
              $negate = $subfilter[0]->GetAttribute("negate-condition");
              if ( empty($negate) || strtolower($negate) != 'yes' ) return false;
            }
          }
          else {
            foreach( $subcomponents AS $kk => $subcomponent ) {
              if ( ! $subcomponent->TestFilter($subfilter) ) return false;
            }
          }
          break;

        case 'urn:ietf:params:xml:ns:carddav:prop-filter':
        case 'urn:ietf:params:xml:ns:caldav:prop-filter':
          $subfilter = $v->GetContent();
          $properties = $this->GetProperties($v->GetAttribute("name"));
          dbg_error_log( 'vCalendar', ":TestFilter: Found '%d' props of type '%s'", count($properties), $v->GetAttribute('name') );
          $subtag = $subfilter[0]->GetNSTag();
          if ( $subtag == 'urn:ietf:params:xml:ns:caldav:is-not-defined'
                             || $subtag == 'urn:ietf:params:xml:ns:carddav:is-not-defined' ) {
            if ( count($properties) > 0 ) {
//              dbg_error_log( 'vCalendar', ":TestFilter: Wanted none => false" );
              return false;
            }
          }
          else if ( count($properties) == 0 ) {
            if ( $subtag == 'urn:ietf:params:xml:ns:caldav:is-defined'
                             || $subtag == 'urn:ietf:params:xml:ns:carddav:is-defined' ) {
//              dbg_error_log( 'vCalendar', ":TestFilter: Wanted some => false" );
              return false;
            }
            else {
//              dbg_error_log( 'vCalendar', ":TestFilter: Wanted '%s' from missing sub-properties => false", $subtag );
              $negate = $subfilter[0]->GetAttribute("negate-condition");
              if ( empty($negate) || strtolower($negate) != 'yes' ) return false;
            }
          }
          else {
            foreach( $properties AS $kk => $property ) {
              if ( !$property->TestFilter($subfilter) ) return false;
            }
          }
          break;
      }
    }
    return true;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

This unescapes the (CRLF + linear space) wrapping specified in RFC2445.

According to RFC2445 we should always end with CRLF but the CalDAV spec says that normalising XML parsers often muck with it and may remove the CR. We accept either case.

Definition at line 568 of file vComponent.php.

                                       {
    return preg_replace('/\r?\n[ \t]/', '', $content );
  }

Here is the caller graph for this function:

vComponent::WrapComponent ( content)

This imposes the (CRLF + linear space) wrapping specified in RFC2445.

According to RFC2445 we should always end with CRLF but the CalDAV spec says that normalising XML parsers often muck with it and may remove the CR. We output RFC2445 compliance.

In order to preserve pre-existing wrapping in the component, we split the incoming string on line breaks before running wordwrap over each component of that.

Definition at line 580 of file vComponent.php.

                                     {
    $strs = preg_split( "/\r?\n/", $content );
    $wrapped = "";
    foreach ($strs as $str) {
      $wrapped .= preg_replace( '/(.{72})/u', '$1'."\r\n ", $str ) ."\r\n";
    }
    return $wrapped;
  }

Here is the caller graph for this function:


Member Data Documentation

Definition at line 433 of file vComponent.php.

Definition at line 426 of file vComponent.php.

vComponent::$rendered [protected]

Definition at line 440 of file vComponent.php.

vComponent::$type [protected]

Definition at line 419 of file vComponent.php.


The documentation for this class was generated from the following file: