Prints out a Object.
@access		public
@param		mixed		$object		Object variable to print out
@param		int			$offset		Intent Offset Level
@param		string		$key		Element Key Name
@param		string		$sign		Space Sign
@param		int			$factor		Space Factor
@return		void
353693
public function printObject( $object, $offset = 0, $key = NULL, $sign = NULL, $factor = NULL )
	{
		if( is_object( $object ) || gettype( $object ) == "object" )
		{
			extract( self::$channels[$this->channel] );
			$ins_key	= ( $key !== NULL ) ? $key." -> " : "";
			$space		= $this->indentSign( $offset, $sign, $factor );
			echo $space."[O] ".$ins_key."".$highlightOpen.get_class( $object ).$highlightClose.$lineBreak;
			$vars		= get_object_vars( $object );
			foreach( $vars as $key => $value )
			{
				if( is_object( $value ) )
					$this->printObject( $value, $offset + 1, $key, $sign, $factor );
				else if( is_array( $value ) )
					$this->printArray( $value, $offset + 1, $key, $sign, $factor );
				else
					$this->printMixed( $value, $offset + 1, $key, $sign, $factor );
			}
		}
		else
			$this->printMixed( $object, $offset, $key, $sign, $factor );
	}
548947
public function drawSpring(Image $Object, array $Settings = [])
    {
        $this->pChartObject = $Object;

        $Pass = isset($Settings["Pass"]) ? $Settings["Pass"] : 50;
        $Retries = isset($Settings["Retry"]) ? $Settings["Retry"] : 10;
        $this->MagneticForceA = isset($Settings["MagneticForceA"]) ? $Settings["MagneticForceA"] : 1.5;
        $this->MagneticForceR = isset($Settings["MagneticForceR"]) ? $Settings["MagneticForceR"] : 2;
        $this->RingSize = isset($Settings["RingSize"]) ? $Settings["RingSize"] : 40;
        $DrawVectors = isset($Settings["DrawVectors"]) ? $Settings["DrawVectors"] : false;
        $DrawQuietZone = isset($Settings["DrawQuietZone"]) ? $Settings["DrawQuietZone"] : false;
        $CenterGraph = isset($Settings["CenterGraph"]) ? $Settings["CenterGraph"] : true;
        $TextPadding = isset($Settings["TextPadding"]) ? $Settings["TextPadding"] : 4;
        $Algorithm = isset($Settings["Algorithm"]) ? $Settings["Algorithm"] : ALGORITHM_WEIGHTED;

        $this->X1 = $Object->GraphAreaX1;
        $this->Y1 = $Object->GraphAreaY1;
        $this->X2 = $Object->GraphAreaX2;
        $this->Y2 = $Object->GraphAreaY2;

        $Conflicts = 1;
        $Jobs = 0;
        $this->History["MinimumConflicts"] = -1;
        while ($Conflicts != 0 && $Jobs < $Retries) {
            $Jobs++;

            /* Compute the initial settings */
            $this->firstPass($Algorithm);

            /* Apply the vectors */
            if ($Pass > 0) {
                for ($i = 0; $i <= $Pass; $i++) {
                    $this->doPass();
                }
            }

            $Conflicts = $this->lastPass();
            if ($this->History["MinimumConflicts"] == -1
                || $Conflicts < $this->History["MinimumConflicts"]
            ) {
                $this->History["MinimumConflicts"] = $Conflicts;
                $this->History["Result"] = $this->Data;
            }
        }

        $Conflicts = $this->History["MinimumConflicts"];
        $this->Data = $this->History["Result"];

        if ($CenterGraph) {
            $this->center();
        }

        /* Draw the connections */
        $Drawn = [];
        foreach ($this->Data as $Key => $Settings) {
            $X = $Settings["X"];
            $Y = $Settings["Y"];

            if (isset($Settings["Connections"])) {
                foreach ($Settings["Connections"] as $ID => $NodeID) {
                    if (!isset($Drawn[$Key])) {
                        $Drawn[$Key] = "";
                    }
                    if (!isset($Drawn[$NodeID])) {
                        $Drawn[$NodeID] = "";
                    }

                    if (isset($this->Data[$NodeID])
                        && !isset($Drawn[$Key][$NodeID])
                        && !isset($Drawn[$NodeID][$Key])
                    ) {
                        $Color = [
                            "R" => $this->Default["LinkR"],
                            "G" => $this->Default["LinkG"],
                            "B" => $this->Default["LinkB"],
                            "Alpha" => $this->Default["Alpha"]
                        ];

                        if (count($this->Links)) {
                            if (isset($this->Links[$Key][$NodeID]["R"])) {
                                $Color = [
                                    "R" => $this->Links[$Key][$NodeID]["R"],
                                    "G" => $this->Links[$Key][$NodeID]["G"],
                                    "B" => $this->Links[$Key][$NodeID]["B"],
                                    "Alpha" => $this->Links[$Key][$NodeID]["Alpha"]
                                ];
                            }

                            if (isset($this->Links[$Key][$NodeID]["Ticks"])) {
                                $Color["Ticks"] = $this->Links[$Key][$NodeID]["Ticks"];
                            }
                        }

                        $X2 = $this->Data[$NodeID]["X"];
                        $Y2 = $this->Data[$NodeID]["Y"];
                        $this->pChartObject->drawLine($X, $Y, $X2, $Y2, $Color);
                        $Drawn[$Key][$NodeID] = true;

                        if (isset($this->Links) && count($this->Links)) {
                            if (isset($this->Links[$Key][$NodeID]["Name"])
                                || isset($this->Links[$NodeID][$Key]["Name"])
                            ) {
                                $Name = isset($this->Links[$Key][$NodeID]["Name"])
                                    ? $this->Links[$Key][$NodeID]["Name"]
                                    : $this->Links[$NodeID][$Key]["Name"]
                                ;
                                $TxtX = ($X2 - $X) / 2 + $X;
                                $TxtY = ($Y2 - $Y) / 2 + $Y;

                                if ($X <= $X2) {
                                    $Angle = (360 - $this->getAngle($X, $Y, $X2, $Y2)) % 360;
                                } else {
                                    $Angle = (360 - $this->getAngle($X2, $Y2, $X, $Y)) % 360;
                                }
                                $Settings = $Color;
                                $Settings["Angle"] = $Angle;
                                $Settings["Align"] = TEXT_ALIGN_BOTTOMMIDDLE;
                                $this->pChartObject->drawText($TxtX, $TxtY, $Name, $Settings);
                            }
                        }
                    }
                }
            }
        }

        /* Draw the quiet zones */
        if ($DrawQuietZone) {
            foreach ($this->Data as $Key => $Settings) {
                $X = $Settings["X"];
                $Y = $Settings["Y"];
                $FreeZone = $Settings["FreeZone"];

                $this->pChartObject->drawFilledCircle(
                    $X,
                    $Y,
                    $FreeZone,
                    ["R" => 0, "G" => 0, "B" => 0, "Alpha" => 2]
                );
            }
        }


        /* Draw the nodes */
        foreach ($this->Data as $Key => $Settings) {
            $X = $Settings["X"];
            $Y = $Settings["Y"];
            $Name = $Settings["Name"];
            $FreeZone = $Settings["FreeZone"];
            $Shape = $Settings["Shape"];
            $Size = $Settings["Size"];

            $Color = [
                "R" => $Settings["R"],
                "G" => $Settings["G"],
                "B" => $Settings["B"],
                "Alpha" => $Settings["Alpha"],
                "BorderR" => $Settings["BorderR"],
                "BorderG" => $Settings["BorderG"],
                "BorderB" => $Settings["BorderB"],
                "BorderApha" => $Settings["BorderAlpha"]
            ];

            if ($Shape == NODE_SHAPE_CIRCLE) {
                $this->pChartObject->drawFilledCircle($X, $Y, $Size, $Color);
            } elseif ($Shape == NODE_SHAPE_TRIANGLE) {
                $Points = [];
                $Points[] = cos(deg2rad(270)) * $Size + $X;
                $Points[] = sin(deg2rad(270)) * $Size + $Y;
                $Points[] = cos(deg2rad(45)) * $Size + $X;
                $Points[] = sin(deg2rad(45)) * $Size + $Y;
                $Points[] = cos(deg2rad(135)) * $Size + $X;
                $Points[] = sin(deg2rad(135)) * $Size + $Y;
                $this->pChartObject->drawPolygon($Points, $Color);
            } elseif ($Shape == NODE_SHAPE_SQUARE) {
                $Offset = $Size / 2;
                $Size = $Size / 2;
                $this->pChartObject->drawFilledRectangle(
                    $X - $Offset,
                    $Y - $Offset,
                    $X + $Offset,
                    $Y + $Offset,
                    $Color
                );
            }

            if ($Name != "") {
                $LabelOptions = [
                    "R" => $this->Labels["R"],
                    "G" => $this->Labels["G"],
                    "B" => $this->Labels["B"],
                    "Alpha" => $this->Labels["Alpha"]
                ];

                if ($this->Labels["Type"] == LABEL_LIGHT) {
                    $LabelOptions["Align"] = TEXT_ALIGN_BOTTOMLEFT;
                    $this->pChartObject->drawText($X, $Y, $Name, $LabelOptions);
                } elseif ($this->Labels["Type"] == LABEL_CLASSIC) {
                    $LabelOptions["Align"] = TEXT_ALIGN_TOPMIDDLE;
                    $LabelOptions["DrawBox"] = true;
                    $LabelOptions["BoxAlpha"] = 50;
                    $LabelOptions["BorderOffset"] = 4;
                    $LabelOptions["RoundedRadius"] = 3;
                    $LabelOptions["BoxRounded"] = true;
                    $LabelOptions["NoShadow"] = true;

                    $this->pChartObject->drawText($X, $Y + $Size + $TextPadding, $Name, $LabelOptions);
                }
            }
        }

        /* Draw the vectors */
        if ($DrawVectors) {
            foreach ($this->Data as $Key => $Settings) {
                $X1 = $Settings["X"];
                $Y1 = $Settings["Y"];

                if (isset($Settings["Vectors"]) && $Settings["Type"] != NODE_TYPE_CENTRAL) {
                    foreach ($Settings["Vectors"] as $ID => $Vector) {
                        $Type = $Vector["Type"];
                        $Force = $Vector["Force"];
                        $Angle = $Vector["Angle"];
                        $Factor = $Type == "A" ? $this->MagneticForceA : $this->MagneticForceR;
                        $Color = $Type == "A"
                            ? ["FillR" => 255, "FillG" => 0, "FillB" => 0]
                            : ["FillR" => 0, "FillG" => 255, "FillB" => 0]
                        ;

                        $X2 = cos(deg2rad($Angle)) * $Force * $Factor + $X1;
                        $Y2 = sin(deg2rad($Angle)) * $Force * $Factor + $Y1;

                        $this->pChartObject->drawArrow($X1, $Y1, $X2, $Y2, $Color);
                    }
                }
            }
        }

        return ["Pass" => $Jobs, "Conflicts" => $Conflicts];
    }
1321636
public function readObject($object = null)
    {
        if ($object === null) {
            $object = array();
        }

        while (true) {
            $key        = $this->_stream->readUTF();
            $typeMarker = $this->_stream->readByte();
            if ($typeMarker != Zend_Amf_Constants::AMF0_OBJECTTERM ){
                //Recursivly call readTypeMarker to get the types of properties in the object
                $object[$key] = $this->readTypeMarker($typeMarker);
            } else {
                //encountered AMF object terminator
                break;
            }
        }
        $this->_reference[] = $object;
        return (object) $object;
    }
1116497
protected function write($object, $level)
    {
        if ($this->enabled && $this->writer && $level <= $this->level) {
            return $this->writer->write($object, $level);
        } else {
            return false;
        }
    }
1050165
public static function setValuesToObject($object, $values = null) {
		if (! isset ( $values ))
			$values = $_POST;
		foreach ( $values as $key => $value ) {
			$accessor = "set" . ucfirst ( $key );
			if (method_exists ( $object, $accessor )) {
				$object->$accessor ( $value );
				$object->_rest [$key] = $value;
			}
		}
	}
1265901
private function encodeObject($object, array $options, callable $encode)
    {
        if ($options['object.format'] === 'string') {
            return $encode((string) $object);
        } elseif ($options['object.format'] === 'serialize') {
            return sprintf('unserialize(%s)', $encode(serialize($object)));
        } elseif ($options['object.format'] === 'export') {
            return sprintf('\\%s::__set_state(%s)', \get_class($object), $encode($this->getObjectState($object)));
        }

        return $this->encodeObjectArray($object, $options, $encode);
    }
825865
public function log($Object, $Label = null, $Options = array())
    {
        return $this->fb($Object, $Label, FirePHP::LOG, $Options);
    }
728151
private function array_insert(mixed $object, string $key, int $position) : void
    {
        if (0 == count($this->members)) {
            // The array is empty so just add the item
            $this->members[$key] = $object;
        } elseif ($position == count($this->members)) {
            // The item goes at the end of the array
            $this->members[$key] = $object;
        } else {
            $this->members = array_slice($this->members, 0, $position,
                    true) + array($key => $object) + array_slice($this->members, $position, null, true);
        }
    }
473579
public static function log($Object, $Label=null)
    {
        return self::send($Object, $Label, FirePHP::LOG);
    }
209238
public static function serialize( $object, $encoding = "utf-8" )
	{
		$root	= new XML_DOM_Node( "object" );
		$root->setAttribute( 'class', get_class( $object ) );
		$vars	= get_object_vars( $object );
		self::serializeVarsRec( $vars, $root );
		$builder	= new XML_DOM_Builder();
		$serial		= $builder->build( $root, $encoding );
		return $serial;
	}
166702
public function offsetSet($object, $data = null)
       {
            if (! parent::contains($object)) {
                parent::attach($object, $data);
                $this->map[$this->index++] = spl_object_hash($object);
                while(parent::valid()) {
                    parent::next();
                }
            }
       }
716364
private function object($object, string $label = ''): void
    {
        if ($object instanceof PresentationModel) {
            $this->presentationModel($object, $label);
        } elseif ($object instanceof View) {
            $this->view($object);
        } else {
            $this->iterable(get_object_vars($object), $label);
        }
    }
1188899
protected void writeArbitraryObject(Object object) {
        log.debug("writeObject");
        // If we need to serialize class information...
        Class<?> objectClass = object.getClass();
        if (!objectClass.isAnnotationPresent(Anonymous.class)) {
            // Write out start object marker for class name
            buf.put(AMF.TYPE_CLASS_OBJECT);
            putString(buf, Serializer.getClassName(objectClass));
        } else {
            // Write out start object marker without class name
            buf.put(AMF.TYPE_OBJECT);
        }
        // Iterate thru fields of an object to build "name-value" map from it
        for (Field field : objectClass.getFields()) {
            String fieldName = field.getName();
            log.debug("Field: {} class: {}", field, objectClass);
            // Check if the Field corresponding to the getter/setter pair is transient
            if (!serializeField(objectClass, fieldName, field, null)) {
                continue;
            }
            Object value;
            try {
                // Get field value
                value = field.get(object);
            } catch (IllegalAccessException err) {
                // Swallow on private and protected properties access exception
                continue;
            }
            // Write out prop name
            putString(buf, fieldName);
            // Write out
            Serializer.serialize(this, field, null, object, value);
        }
        // write out end of object marker
        buf.put(AMF.END_OF_OBJECT_SEQUENCE);
    }
474313
public static function printError($title, $objectName, $objectId = null, $request = null, $exception = null, $forceConsole = false)
    {
        $data = null;
        if ($exception instanceof \BlockCypher\Exception\BlockCypherConnectionException) {
            $data = $exception->getData();
        }
        self::printOutput($title, $objectName, $objectId, $request, $data, $exception->getMessage(), $forceConsole);
    }
60987
public static function fd($object, $type = 'log')
    {
        $types = array('log', 'debug', 'info', 'warn', 'error', 'assert');

        if (!\in_array($type, $types, true)) {
            $type = 'log';
        }

        $data = json_encode($object);

        echo '<script type="text/javascript">console.' . $type . '(' . $data . ');</script>';
    }
37394
public function writeObject($object)
    {
        // Loop each element and write the name of the property.
        foreach ($object as $key => &$value) {
            // skip variables starting with an _ private transient
            if( $key[0] == "_") continue;
            $this->_stream->writeUTF($key);
            $this->writeTypeMarker($value);
        }

        // Write the end object flag
        $this->_stream->writeInt(0);
        $this->_stream->writeByte(Zend_Amf_Constants::AMF0_OBJECTTERM);
        return $this;
    }
746879
public static function info($Object, $Label=null)
    {
        return self::send($Object, $Label, FirePHP::INFO);
    }