Overloaded to display the correctly formatted value for this data type

@param array $properties
@return string
729
public function Field($properties = array())
    {
        if ($this->value) {
            $val = Convert::raw2xml($this->value);
            $val = DBCurrency::config()->get('currency_symbol')
                . number_format(preg_replace('/[^0-9.-]/', '', $val), 2);
            $valforInput = Convert::raw2att($val);
        } else {
            $valforInput = '';
        }
        return "<input class=\"text\" type=\"text\" disabled=\"disabled\""
        . " name=\"" . $this->name . "\" value=\"" . $valforInput . "\" />";
    }
282638
public function FieldHolder($properties = array())
    {
        $context = $this;

        if (count($properties)) {
            $context = $this->customise($properties);
        }

        return $context->renderWith($this->getFieldHolderTemplates());
    }
839380
private function renderValue($printFormat, array $variables)
    {
        return str_replace(
            array_map(
                function($variable) {
                    return '{{' . $variable . '}}';
                },
                array_keys($variables)
            ),
            array_values($variables),
            $printFormat
        );
    }
197632
public function FieldHolder($properties = array())
    {
        $obj = $properties ? $this->customise($properties) : $this;

        return $obj->renderWith($this->getTemplates());
    }
263841
public function field_format_value($fields, $data) 
    {
        if (!$fields || !$data || !is_array($data)) {
            return $data;
        }
        foreach ($fields as $field) {
            $obj = $this->get($field['fieldtype']);
            if (!$obj) {
                continue;
            }
            if ($field['fieldtype'] === 'Group') {
                continue;
            }
            $data = $obj->output_data($data, $field);
        }
        return $data;
    }
333314
private function setType(array &$properties)
    {
        $type = array_pull($properties, 'type', null);

        $this->type = is_null($type)
            ? $this->guessType($properties)
            : $type;

        return $this;
    }
240392
public function format($value, $property = null)
    {
        switch ($property) {
            case 'http_access':
                return $this->formatHttpAccess($value);

            case 'token':
                return '******';

            case 'addon_credentials':
                if (is_array($value) && isset($value['shared_secret'])) {
                    $value['shared_secret'] = '******';
                }
                break;

            case 'app_credentials':
                if (is_array($value) && isset($value['secret'])) {
                    $value['secret'] = '******';
                }
                break;

            case 'author.date':
            case 'committer.date':
            case 'created_at':
            case 'updated_at':
            case 'expires_at':
            case 'started_at':
            case 'completed_at':
            case 'ssl.expires_on':
                $value = $this->formatDate($value);
                break;

            case 'ssl':
                if ($property === 'ssl' && is_array($value) && isset($value['expires_on'])) {
                    $value['expires_on'] = $this->formatDate($value['expires_on']);
                }
        }

        if (!is_string($value)) {
            $value = rtrim(Yaml::dump($value, 2));
        }

        return $value;
    }
1173805
protected function filterProperties(array $properties) {
        $tags = array_fill_keys($this->allowedTags, 1);

        if (empty($tags) || isset($tags['*'])) {
            return $properties;
        }

        $filtered = [];

        foreach ($properties as $key => $value) {
            if (isset($tags[$key])) {
                $filtered[$key] = $value;
                continue;
            }

            if (($pos = strpos($key, ':')) !== false) {
                $namespace = substr($key, 0, $pos);

                if (isset($tags[$namespace . ':*'])) {
                    $filtered[$key] = $value;
                    continue;
                }
            }
        }

        return $filtered;
    }
389213
public function buildPropertiesString(array $properties)
    {
        $chunks = array();

        foreach ($properties as $property) {
            $chunks[] = $property->toString();
        }

        return implode(' ', $chunks);
    }
345506
public function encodeProperties($properties)
	{
		// Replace empty values with null, if value is not required
		foreach ($properties as $k => & $v) {
			if (isset($this->properties[$k])) {
				$prop = $this->properties[$k];
				if (empty($prop['required']) && ($v === array() || (is_string($v) && ctype_space($v)))) {
					$v = null;
				}
			} else {
				// Value is not valid property, throw it away
				unset($properties[$k]);
			}
		}

		// Split composed properties to individual columns
		foreach ($this->composed_properties as $property => $components) {
			foreach ($components as $component => $column) {
				if (isset($properties[$property][$component])) {
					$properties[$column] = $properties[$property][$component];
				} else {
					$properties[$column] = null;
				}
			}
			unset($properties[$property]);
		}

		// Encode JSON columns
		foreach ($this->json_columns as $column_name) {
			if (isset($properties[$column_name])) {
				$json_data = json_encode($properties[$column_name], JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE | JSON_NUMERIC_CHECK);
				if ($json_data === FALSE) {
					switch (json_last_error()) {
						case JSON_ERROR_NONE: $json_error = 'No error has occurred'; break;
						case JSON_ERROR_DEPTH: $json_error = 'The maximum stack depth has been exceeded'; break;
						case JSON_ERROR_STATE_MISMATCH: $json_error = 'Invalid or malformed JSON'; break;
						case JSON_ERROR_CTRL_CHAR: $json_error = 'Control character error, possibly incorrectly encoded'; break;
						case JSON_ERROR_SYNTAX: $json_error = 'Syntax error'; break;
						case JSON_ERROR_UTF8: $json_error = 'Malformed UTF-8 characters, possibly incorrectly encoded'; break;
						case JSON_ERROR_RECURSION: $json_error = 'One or more recursive references in the value to be encoded'; break;
						case JSON_ERROR_INF_OR_NAN: $json_error = 'One or more NAN or INF values in the value to be encoded'; break;
						case JSON_ERROR_UNSUPPORTED_TYPE: $json_error = 'A value of a type that cannot be encoded was given'; break;
						default: $json_error = 'Error '.json_last_error(); break;
					}
					throw new \InvalidArgumentException('Failed to serialize invoice data to JSON: '.$json_error);
				}
				$properties[$column_name] = $json_data;
			}
		}

		return $properties;
	}
675161
public function Field($properties = array())
    {
        $source = ArrayLib::flatten($this->getSource());
        $values = $this->getValueArray();

        // Get selected values
        $mapped = [];
        foreach ($values as $value) {
            if (isset($source[$value])) {
                $mapped[] = Convert::raw2xml($source[$value]);
            }
        }

        // Don't check if string arguments are matching against the source,
        // as they might be generated HTML diff views instead of the actual values
        if ($this->value && is_string($this->value) && empty($mapped)) {
            $mapped[] = Convert::raw2xml(trim($this->value));
            $values = [];
        }

        if ($mapped) {
            $attrValue = implode(', ', array_values($mapped));
            $inputValue = implode(', ', array_values($values));
        } else {
            $attrValue = '<i>(' . _t('SilverStripe\\Forms\\FormField.NONE', 'none') . ')</i>';
            $inputValue = '';
        }

        $properties = array_merge($properties, array(
            'AttrValue' => DBField::create_field('HTMLFragment', $attrValue),
            'InputValue' => $inputValue
        ));

        return parent::Field($properties);
    }
392458
public function Field($properties = array())
    {
        // Build inner content
        $fieldContent = '';
        foreach ($this->getChildren() as $field) {
            /** @var FormField $field */
            $field->setDisabled($this->isDisabled());
            $field->setReadonly($this->isReadonly());

            if (count($this->attributes)) {
                foreach ($this->attributes as $name => $value) {
                    $field->setAttribute($name, $value);
                }
            }

            $fieldContent .= $field->FieldHolder();
        }

        if (!$this->showOnClick) {
            return $fieldContent;
        }

        if ($this->getShowOnClickTitle()) {
            $title = $this->getShowOnClickTitle();
        } else {
            $title = _t(
                __CLASS__ . '.SHOWONCLICKTITLE',
                'Change Password',
                'Label of the link which triggers display of the "change password" formfields'
            );
        }

        // Check if the field should be visible up front
        $visible = $this->hiddenField->Value();
        $classes = $visible
            ? 'showOnClickContainer'
            : 'showOnClickContainer d-none';

        // Build display holder
        $container = HTML::createTag('div', ['class' => $classes], $fieldContent);
        $actionLink = HTML::createTag('a', ['href' => '#'], $title);
        return HTML::createTag(
            'div',
            ['class' => 'showOnClick'],
            $actionLink . "\n" . $container
        );
    }
543684
protected function renderProperties( array $values  = array(),
                                         array $addAttr = array() )
    {
        $markup = '';

        foreach ( $values as $key => $data )
        {
            if ( is_string( $key ) && isset( $data['value'] ) )
            {
                $markup .= $this->renderProperty(
                    $key,
                    $data['value'],
                    ! empty( $data['priority'] ),
                    $addAttr
                );
            }
        }

        return $markup;
    }
1360273
private function formatEntities(array $entities) : string
    {
        $formattedEntities = array_map(function (DistanceMatrixLocation $entry) {
            return $entry->getFormattedLocation();
        }, $entities);
        $formattedEntities = implode('|', $formattedEntities);

        return $formattedEntities;
    }
717311
public function formatAttribute($attributes = [])
    {
        $attributes = $attributes ?: $this->attributes;

        if ($this->hasFile()) {
            $attributes['enctype'] = 'multipart/form-data';
        }

        $html = [];
        foreach ($attributes as $key => $val) {
            $html[] = "$key=\"$val\"";
        }

        return implode(' ', $html) ?: '';
    }
608423
public function sort($properties) {
		if (is_string($properties)) {
			if (strpos($properties, ',') === false) {
				$properties = [$properties];
			} else {
				$properties = explode(',', $properties);
			}
		}
		
		if (is_array($properties)) {
			$properties = array_map('trim', $properties);
		} else {
			throw new Exception('Uncnown property type "' . gettype($properties) . '"');
		}
		
		foreach ($properties as $property) {
			if (strpos($property, ' ') === false) {
				$this->_sort[$property] = self::MONGO_SORT_ASC;
			} else {
				list ($property, $sort) = explode(' ', $property);
				
				$sort = strtolower($sort);
				
				if ($sort === self::SORT_ASC) {
					$this->_sort[$property] = self::MONGO_SORT_ASC;
				} else if ($sort === self::SORT_DESC) {
					$this->_sort[$property] = self::MONGO_SORT_DESC;
				} else {
					throw new Exception('Uncnown sort condition "' . $sort . '"');
				}
			}
		}
		
		return $this;
	}
1174527
function addFormat($properties = array())
    {
        $format = new Spreadsheet_Excel_Writer_Format($this->_BIFF_version, $this->_xf_index, $properties);
        $this->_xf_index += 1;
        $this->_formats[] = $format;
        return $format;
    }