c-harris / ODataMetadata

src/Util/ExpressionTypeChecker.php

Upper-Lower-Casing +2 added lines, -2 removed lines

@@ -172,7 +172,7 @@ 
                     );
                 }
                 return self::TryAssertPrimitiveAsType($primitiveValue, $type, $discoveredErrors);
-            case ExpressionKind::Null():
+            case ExpressionKind::null():
                 assert($expression instanceof INullExpression);
                 return self::TryAssertNullAsType($expression, $type, $discoveredErrors);
             case ExpressionKind::Path():
@@ -197,7 +197,7 @@ 
                 // If we don't have the applied function we just assume that it will work.
                 $discoveredErrors = [];
                 return true;
-            case ExpressionKind::If():
+            case ExpressionKind::if():
                 assert($expression instanceof IIfExpression);
                 return self::TryAssertIfAsType($expression, $type, $context, $matchExactly, $discoveredErrors);
             case ExpressionKind::IsType():

Spacing +5 added lines, -5 removed lines

@@ -199,7 +199,7 @@ 
                 // If we don't have the applied function we just assume that it will work.
                 $discoveredErrors = [];
                 return true;
-            case ExpressionKind::If():
+            case ExpressionKind::If ():
                 assert($expression instanceof IIfExpression);
                 return self::TryAssertIfAsType($expression, $type, $context, $matchExactly, $discoveredErrors);
             case ExpressionKind::IsType():
@@ -297,7 +297,7 @@ 
         iterable &$discoveredErrors
     ): bool {
         if (!$type->IsPrimitive()) {
-            $discoveredErrors =  [
+            $discoveredErrors = [
                 new EdmError(
                     $expression->Location(),
                     EdmErrorCode::PrimitiveConstantExpressionNotValidForNonPrimitiveType(),
@@ -757,7 +757,7 @@ 
                 return self::TryAssertIntegerConstantInRange(
                     $expression,
                     (int)-9223372036854775808,
-                    (int)999999999999,
+                    (int) 999999999999,
                     $discoveredErrors
                 );
             case PrimitiveTypeKind::Int32():
@@ -789,7 +789,7 @@ 
                     $discoveredErrors
                 );
             default:
-                $discoveredErrors =  [
+                $discoveredErrors = [
                     new EdmError(
                         $expression->Location(),
                         EdmErrorCode::ExpressionPrimitiveKindNotValidForAssertedType(),
@@ -909,7 +909,7 @@ 
 
             if ($expressionType->getTypeKind()->isPrimitive() && $assertedType->getTypeKind()->isPrimitive()) {
                 $primitiveExpressionType = $expressionType;
-                $primitiveAssertedType   = $assertedType ;
+                $primitiveAssertedType   = $assertedType;
                 assert($primitiveExpressionType instanceof IPrimitiveType);
                 assert($primitiveAssertedType instanceof IPrimitiveType);
                 if (!self::PromotesTo(

src/Edm/Validation/EdmValidator.php

Spacing +1 added lines, -2 removed lines

@@ -27,8 +27,7 @@
     public static function Validate(IModel $root, $versionOrRuleset, array &$errors): bool
     {
         $ruleSet = $versionOrRuleset instanceof Version ?
-            ValidationRuleSet::getEdmModelRuleSet($versionOrRuleset) :
-            $versionOrRuleset;
+            ValidationRuleSet::getEdmModelRuleSet($versionOrRuleset) : $versionOrRuleset;
         assert($ruleSet instanceof ValidationRuleSet);
         $errors = InterfaceValidator::ValidateModelStructureAndSemantics($root, $ruleSet);
         return count($errors) === 0;

src/Edm/Validation/Internal/InterfaceValidator/VisitorOfISchemaElement.php

Upper-Lower-Casing +1 added lines, -1 removed lines

@@ -34,7 +34,7 @@
                         );
                         break;
 
-                    case SchemaElementKind::Function():
+                    case SchemaElementKind::function():
                         InterfaceValidator::CollectErrors(
                             InterfaceValidator::CheckForInterfaceKindValueMismatchError(
                                 $item,

Spacing +1 added lines, -1 removed lines

@@ -33,7 +33,7 @@
                         );
                         break;
 
-                    case SchemaElementKind::Function():
+                    case SchemaElementKind::Function ():
                         InterfaceValidator::CollectErrors(
                             InterfaceValidator::CheckForInterfaceKindValueMismatchError(
                                 $item,

src/Edm/Validation/Internal/ValidationHelper.php

Spacing +1 added lines, -1 removed lines

@@ -96,7 +96,7 @@
         if (count($set1) != count($set2)) {
             return false;
         }
-        for ($i = count($set1) -1; $i > -1; --$i) {
+        for ($i = count($set1) - 1; $i > -1; --$i) {
             if ($set1[$i] !== $set2[$i]) {
                 return false;
             }

src/Edm/Internal/CacheHelper.php

Spacing +2 added lines, -2 removed lines

@@ -20,11 +20,11 @@
     }
     public static function getCycleSentinel(): ?stdClass
     {
-        return (object)[];
+        return (object) [];
     }
     public static function getSecondPassCycleSentinel(): ?stdClass
     {
-        return (object)[];
+        return (object) [];
     }
     public static function GetBoxed(bool $value)
     {

src/Csdl/Internal/Serialization/EdmModelSchemaSeparationSerializationVisitor.php

Spacing +1 added lines, -1 removed lines

@@ -86,7 +86,7 @@
         $schema = null;
         if (!array_key_exists($namespaceName, $this->modelSchemas)) {
             $schema                             = new EdmSchema($namespaceName);
-            $this->modelSchemas[$namespaceName] =  $schema;
+            $this->modelSchemas[$namespaceName] = $schema;
         }
 
         $this->modelSchemas[$namespaceName]->addSchemaElement($element);

src/Csdl/Internal/Serialization/EdmModelCsdlSchemaWriter.php

Spacing +65 added lines, -65 removed lines

@@ -131,27 +131,27 @@ 
     public function WriteAssociationSetElementHeader(IEntitySet $entitySet, INavigationProperty $navigationProperty): void
     {
         $this->xmlWriter->startElement(CsdlConstants::Element_AssociationSet);
-        $this->WriteRequiredAttribute(CsdlConstants::Attribute_Name, $this->model->GetAssociationSetName($entitySet, $navigationProperty), [EdmValueWriter::class,'StringAsXml']);
-        $this->WriteRequiredAttribute(CsdlConstants::Attribute_Association, $this->model->GetAssociationFullName($navigationProperty), [EdmValueWriter::class,'StringAsXml']);
+        $this->WriteRequiredAttribute(CsdlConstants::Attribute_Name, $this->model->GetAssociationSetName($entitySet, $navigationProperty), [EdmValueWriter::class, 'StringAsXml']);
+        $this->WriteRequiredAttribute(CsdlConstants::Attribute_Association, $this->model->GetAssociationFullName($navigationProperty), [EdmValueWriter::class, 'StringAsXml']);
     }
 
     public function WriteComplexTypeElementHeader(IComplexType $complexType): void
     {
         $this->xmlWriter->startElement(CsdlConstants::Element_ComplexType);
-        $this->WriteRequiredAttribute(CsdlConstants::Attribute_Name, $complexType->getName(), [EdmValueWriter::class,'StringAsXml']);
+        $this->WriteRequiredAttribute(CsdlConstants::Attribute_Name, $complexType->getName(), [EdmValueWriter::class, 'StringAsXml']);
         $this->WriteOptionalAttribute(CsdlConstants::Attribute_BaseType, $complexType->BaseComplexType(), null, [$this, 'TypeDefinitionAsXml']);
-        $this->WriteOptionalAttribute(CsdlConstants::Attribute_Abstract, $complexType->isAbstract(), CsdlConstants::Default_Abstract, [EdmValueWriter::class,'BooleanAsXml']);
+        $this->WriteOptionalAttribute(CsdlConstants::Attribute_Abstract, $complexType->isAbstract(), CsdlConstants::Default_Abstract, [EdmValueWriter::class, 'BooleanAsXml']);
     }
 
     public function WriteEnumTypeElementHeader(IEnumType $enumType): void
     {
         $this->xmlWriter->startElement(CsdlConstants::Element_EnumType);
-        $this->WriteRequiredAttribute(CsdlConstants::Attribute_Name, $enumType->getName(), [EdmValueWriter::class,'StringAsXml']);
+        $this->WriteRequiredAttribute(CsdlConstants::Attribute_Name, $enumType->getName(), [EdmValueWriter::class, 'StringAsXml']);
         if ($enumType->getUnderlyingType()->getPrimitiveKind() != PrimitiveTypeKind::Int32()) {
             $this->WriteRequiredAttribute(CsdlConstants::Attribute_UnderlyingType, $enumType->getUnderlyingType(), [$this, 'TypeDefinitionAsXml']);
         }
 
-        $this->WriteOptionalAttribute(CsdlConstants::Attribute_IsFlags, $enumType->isFlags(), CsdlConstants::Default_IsFlags, [EdmValueWriter::class,'BooleanAsXml']);
+        $this->WriteOptionalAttribute(CsdlConstants::Attribute_IsFlags, $enumType->isFlags(), CsdlConstants::Default_IsFlags, [EdmValueWriter::class, 'BooleanAsXml']);
     }
 
     public function WriteDocumentationElement(IDocumentation $documentation): void
@@ -175,8 +175,8 @@ 
     public function WriteAssociationSetEndElementHeader(IEntitySet $entitySet, INavigationProperty $property): void
     {
         $this->xmlWriter->startElement(CsdlConstants::Element_End);
-        $this->WriteRequiredAttribute(CsdlConstants::Attribute_Role, $this->model->GetAssociationEndName($property), [EdmValueWriter::class,'StringAsXml']);
-        $this->WriteRequiredAttribute(CsdlConstants::Attribute_EntitySet, $entitySet->getName(), [EdmValueWriter::class,'StringAsXml']);
+        $this->WriteRequiredAttribute(CsdlConstants::Attribute_Role, $this->model->GetAssociationEndName($property), [EdmValueWriter::class, 'StringAsXml']);
+        $this->WriteRequiredAttribute(CsdlConstants::Attribute_EntitySet, $entitySet->getName(), [EdmValueWriter::class, 'StringAsXml']);
     }
 
     public function WriteAssociationEndElementHeader(INavigationProperty $associationEnd): void
@@ -184,15 +184,15 @@ 
         $this->xmlWriter->startElement(CsdlConstants::Element_End);
         $declaringType = $associationEnd->getDeclaringType();
         assert($declaringType instanceof IEntityType);
-        $this->WriteRequiredAttribute(CsdlConstants::Attribute_Type, $declaringType->FullName(), [EdmValueWriter::class,'StringAsXml']);
-        $this->WriteRequiredAttribute(CsdlConstants::Attribute_Role, $this->model->GetAssociationEndName($associationEnd), [EdmValueWriter::class,'StringAsXml']);
+        $this->WriteRequiredAttribute(CsdlConstants::Attribute_Type, $declaringType->FullName(), [EdmValueWriter::class, 'StringAsXml']);
+        $this->WriteRequiredAttribute(CsdlConstants::Attribute_Role, $this->model->GetAssociationEndName($associationEnd), [EdmValueWriter::class, 'StringAsXml']);
         $this->WriteRequiredAttribute(CsdlConstants::Attribute_Multiplicity, $associationEnd->Multiplicity(), [self::class, 'MultiplicityAsXml']);
     }
 
     public function WriteEntityContainerElementHeader(IEntityContainer $container): void
     {
         $this->xmlWriter->startElement(CsdlConstants::Element_EntityContainer);
-        $this->WriteRequiredAttribute(CsdlConstants::Attribute_Name, $container->getName(), [EdmValueWriter::class,'StringAsXml']);
+        $this->WriteRequiredAttribute(CsdlConstants::Attribute_Name, $container->getName(), [EdmValueWriter::class, 'StringAsXml']);
         if ($container->isDefault()) {
             $this->xmlWriter->writeAttributeNs(CsdlConstants::Prefix_ODataMetadata, CsdlConstants::Attribute_IsDefaultEntityContainer, null, 'true');
         }
@@ -204,17 +204,17 @@ 
     public function WriteEntitySetElementHeader(IEntitySet $entitySet): void
     {
         $this->xmlWriter->startElement(CsdlConstants::Element_EntitySet);
-        $this->WriteRequiredAttribute(CsdlConstants::Attribute_Name, $entitySet->getName(), [EdmValueWriter::class,'StringAsXml']);
-        $this->WriteRequiredAttribute(CsdlConstants::Attribute_EntityType, $entitySet->getElementType()->FullName(), [EdmValueWriter::class,'StringAsXml']);
+        $this->WriteRequiredAttribute(CsdlConstants::Attribute_Name, $entitySet->getName(), [EdmValueWriter::class, 'StringAsXml']);
+        $this->WriteRequiredAttribute(CsdlConstants::Attribute_EntityType, $entitySet->getElementType()->FullName(), [EdmValueWriter::class, 'StringAsXml']);
     }
 
     public function WriteEntityTypeElementHeader(IEntityType $entityType): void
     {
         $this->xmlWriter->startElement(CsdlConstants::Element_EntityType);
-        $this->WriteRequiredAttribute(CsdlConstants::Attribute_Name, $entityType->getName(), [EdmValueWriter::class,'StringAsXml']);
+        $this->WriteRequiredAttribute(CsdlConstants::Attribute_Name, $entityType->getName(), [EdmValueWriter::class, 'StringAsXml']);
         $this->WriteOptionalAttribute(CsdlConstants::Attribute_BaseType, $entityType->BaseEntityType(), null, [$this, 'TypeDefinitionAsXml']);
         $this->WriteOptionalAttribute(CsdlConstants::Attribute_Abstract, $entityType->isAbstract(), CsdlConstants::Default_Abstract, [EdmValueWriter::class, 'BooleanAsXml']);
-        $this->WriteOptionalAttribute(CsdlConstants::Attribute_OpenType, $entityType->isOpen(), CsdlConstants::Default_OpenType, [EdmValueWriter::class,'BooleanAsXml']);
+        $this->WriteOptionalAttribute(CsdlConstants::Attribute_OpenType, $entityType->isOpen(), CsdlConstants::Default_OpenType, [EdmValueWriter::class, 'BooleanAsXml']);
     }
 
     public function WriteDeclaredKeyPropertiesElementHeader(): void
@@ -225,24 +225,24 @@ 
     public function WritePropertyRefElement(IStructuralProperty $property): void
     {
         $this->xmlWriter->startElement(CsdlConstants::Element_PropertyRef);
-        $this->WriteRequiredAttribute(CsdlConstants::Attribute_Name, $property->getName(), [EdmValueWriter::class,'StringAsXml']);
+        $this->WriteRequiredAttribute(CsdlConstants::Attribute_Name, $property->getName(), [EdmValueWriter::class, 'StringAsXml']);
         $this->WriteEndElement();
     }
 
     public function WriteNavigationPropertyElementHeader(INavigationProperty $member): void
     {
         $this->xmlWriter->startElement(CsdlConstants::Element_NavigationProperty);
-        $this->WriteRequiredAttribute(CsdlConstants::Attribute_Name, $member->getName(), [EdmValueWriter::class,'StringAsXml']);
-        $this->WriteRequiredAttribute(CsdlConstants::Attribute_Relationship, $this->model->GetAssociationFullName($member), [EdmValueWriter::class,'StringAsXml']);
-        $this->WriteRequiredAttribute(CsdlConstants::Attribute_ToRole, $this->model->GetAssociationEndName($member->getPartner()), [EdmValueWriter::class,'StringAsXml']);
-        $this->WriteRequiredAttribute(CsdlConstants::Attribute_FromRole, $this->model->GetAssociationEndName($member), [EdmValueWriter::class,'StringAsXml']);
-        $this->WriteOptionalAttribute(CsdlConstants::Attribute_ContainsTarget, $member->containsTarget(), CsdlConstants::Default_ContainsTarget, [EdmValueWriter::class,'BooleanAsXml']);
+        $this->WriteRequiredAttribute(CsdlConstants::Attribute_Name, $member->getName(), [EdmValueWriter::class, 'StringAsXml']);
+        $this->WriteRequiredAttribute(CsdlConstants::Attribute_Relationship, $this->model->GetAssociationFullName($member), [EdmValueWriter::class, 'StringAsXml']);
+        $this->WriteRequiredAttribute(CsdlConstants::Attribute_ToRole, $this->model->GetAssociationEndName($member->getPartner()), [EdmValueWriter::class, 'StringAsXml']);
+        $this->WriteRequiredAttribute(CsdlConstants::Attribute_FromRole, $this->model->GetAssociationEndName($member), [EdmValueWriter::class, 'StringAsXml']);
+        $this->WriteOptionalAttribute(CsdlConstants::Attribute_ContainsTarget, $member->containsTarget(), CsdlConstants::Default_ContainsTarget, [EdmValueWriter::class, 'BooleanAsXml']);
     }
 
     public function WriteOperationActionElement(string $elementName, OnDeleteAction $operationAction): void
     {
         $this->xmlWriter->startElement($elementName);
-        $this->WriteRequiredAttribute(CsdlConstants::Attribute_Action, strval($operationAction), [EdmValueWriter::class,'StringAsXml']);
+        $this->WriteRequiredAttribute(CsdlConstants::Attribute_Action, strval($operationAction), [EdmValueWriter::class, 'StringAsXml']);
         $this->WriteEndElement();
     }
 
@@ -250,8 +250,8 @@ 
     {
         $xmlNamespace = self::GetCsdlNamespace($this->version);
         $this->xmlWriter->startElement(CsdlConstants::Element_Schema);
-        $this->WriteOptionalAttribute(CsdlConstants::Attribute_Namespace, $schema->getNamespace(), '', [EdmValueWriter::class,'StringAsXml']);
-        $this->WriteOptionalAttribute(CsdlConstants::Attribute_Alias, $alias, null, [EdmValueWriter::class,'StringAsXml']);
+        $this->WriteOptionalAttribute(CsdlConstants::Attribute_Namespace, $schema->getNamespace(), '', [EdmValueWriter::class, 'StringAsXml']);
+        $this->WriteOptionalAttribute(CsdlConstants::Attribute_Alias, $alias, null, [EdmValueWriter::class, 'StringAsXml']);
         foreach ($mappings as $mappingKey => $mappingValue) {
             $this->xmlWriter->writeAttributeNs(EdmConstants::XmlNamespacePrefix, $mappingKey, null, $mappingValue);
         }
@@ -260,25 +260,25 @@ 
     public function WriteAnnotationsElementHeader(string $annotationsTarget): void
     {
         $this->xmlWriter->startElement(CsdlConstants::Element_Annotations);
-        $this->WriteRequiredAttribute(CsdlConstants::Attribute_Target, $annotationsTarget, [EdmValueWriter::class,'StringAsXml']);
+        $this->WriteRequiredAttribute(CsdlConstants::Attribute_Target, $annotationsTarget, [EdmValueWriter::class, 'StringAsXml']);
     }
 
     public function WriteStructuralPropertyElementHeader(IStructuralProperty $property, bool $inlineType): void
     {
         $this->xmlWriter->startElement(CsdlConstants::Element_Property);
-        $this->WriteRequiredAttribute(CsdlConstants::Attribute_Name, $property->getName(), [EdmValueWriter::class,'StringAsXml']);
+        $this->WriteRequiredAttribute(CsdlConstants::Attribute_Name, $property->getName(), [EdmValueWriter::class, 'StringAsXml']);
         if ($inlineType) {
             $this->WriteRequiredAttribute(CsdlConstants::Attribute_Type, $property->getType(), [$this, 'TypeReferenceAsXml']);
         }
 
         $this->WriteOptionalAttribute(CsdlConstants::Attribute_ConcurrencyMode, $property->getConcurrencyMode(), CsdlConstants::$Default_ConcurrencyMode, [self::class, 'ConcurrencyModeAsXml']);
-        $this->WriteOptionalAttribute(CsdlConstants::Attribute_DefaultValue, $property->getDefaultValueString(), null, [EdmValueWriter::class,'StringAsXml']);
+        $this->WriteOptionalAttribute(CsdlConstants::Attribute_DefaultValue, $property->getDefaultValueString(), null, [EdmValueWriter::class, 'StringAsXml']);
     }
 
     public function WriteEnumMemberElementHeader(IEnumMember $member): void
     {
         $this->xmlWriter->startElement(CsdlConstants::Element_Member);
-        $this->WriteRequiredAttribute(CsdlConstants::Attribute_Name, $member->getName(), [EdmValueWriter::class,'StringAsXml']);
+        $this->WriteRequiredAttribute(CsdlConstants::Attribute_Name, $member->getName(), [EdmValueWriter::class, 'StringAsXml']);
         $isExplicit = $member->IsValueExplicit($this->model);
         if (null === $isExplicit || $isExplicit) {
             $this->WriteRequiredAttribute(CsdlConstants::Attribute_Value, $member->getValue(), [EdmValueWriter::class, 'PrimitiveValueAsXml']);
@@ -287,24 +287,24 @@ 
 
     public function WriteNullableAttribute(ITypeReference $reference): void
     {
-        $this->WriteOptionalAttribute(CsdlConstants::Attribute_Nullable, $reference->getNullable(), CsdlConstants::Default_Nullable, [EdmValueWriter::class,'BooleanAsXml']);
+        $this->WriteOptionalAttribute(CsdlConstants::Attribute_Nullable, $reference->getNullable(), CsdlConstants::Default_Nullable, [EdmValueWriter::class, 'BooleanAsXml']);
     }
 
     public function WriteBinaryTypeAttributes(IBinaryTypeReference $reference): void
     {
         if ($reference->isUnBounded()) {
-            $this->WriteRequiredAttribute(CsdlConstants::Attribute_MaxLength, CsdlConstants::Value_Max, [EdmValueWriter::class,'StringAsXml']);
+            $this->WriteRequiredAttribute(CsdlConstants::Attribute_MaxLength, CsdlConstants::Value_Max, [EdmValueWriter::class, 'StringAsXml']);
         } else {
             $this->WriteOptionalAttribute(CsdlConstants::Attribute_MaxLength, $reference->getMaxLength(), null, [EdmValueWriter::class, 'IntAsXml']);
         }
 
-        $this->WriteOptionalAttribute(CsdlConstants::Attribute_FixedLength, $reference->isFixedLength(), null, [EdmValueWriter::class,'BooleanAsXml']);
+        $this->WriteOptionalAttribute(CsdlConstants::Attribute_FixedLength, $reference->isFixedLength(), null, [EdmValueWriter::class, 'BooleanAsXml']);
     }
 
     public function WriteDecimalTypeAttributes(IDecimalTypeReference $reference): void
     {
-        $this->WriteOptionalAttribute(CsdlConstants::Attribute_Precision, $reference->getPrecision(), null, [EdmValueWriter::class,'IntAsXml']);
-        $this->WriteOptionalAttribute(CsdlConstants::Attribute_Scale, $reference->getScale(), null, [EdmValueWriter::class,'IntAsXml']);
+        $this->WriteOptionalAttribute(CsdlConstants::Attribute_Precision, $reference->getPrecision(), null, [EdmValueWriter::class, 'IntAsXml']);
+        $this->WriteOptionalAttribute(CsdlConstants::Attribute_Scale, $reference->getScale(), null, [EdmValueWriter::class, 'IntAsXml']);
     }
 
     public function WriteSpatialTypeAttributes(ISpatialTypeReference $reference): void
@@ -314,20 +314,20 @@ 
 
     public function WriteStringTypeAttributes(IStringTypeReference $reference): void
     {
-        $this->WriteOptionalAttribute(CsdlConstants::Attribute_Collation, $reference->getCollation(), null, [EdmValueWriter::class,'StringAsXml']);
+        $this->WriteOptionalAttribute(CsdlConstants::Attribute_Collation, $reference->getCollation(), null, [EdmValueWriter::class, 'StringAsXml']);
         if ($reference->isUnbounded()) {
-            $this->WriteRequiredAttribute(CsdlConstants::Attribute_MaxLength, CsdlConstants::Value_Max, [EdmValueWriter::class,'StringAsXml']);
+            $this->WriteRequiredAttribute(CsdlConstants::Attribute_MaxLength, CsdlConstants::Value_Max, [EdmValueWriter::class, 'StringAsXml']);
         } else {
-            $this->WriteOptionalAttribute(CsdlConstants::Attribute_MaxLength, $reference->getMaxLength(), null, [EdmValueWriter::class,'IntAsXml']);
+            $this->WriteOptionalAttribute(CsdlConstants::Attribute_MaxLength, $reference->getMaxLength(), null, [EdmValueWriter::class, 'IntAsXml']);
         }
 
-        $this->WriteOptionalAttribute(CsdlConstants::Attribute_FixedLength, $reference->isFixedLength(), null, [EdmValueWriter::class,'BooleanAsXml']);
-        $this->WriteOptionalAttribute(CsdlConstants::Attribute_Unicode, $reference->isUnicode(), null, [EdmValueWriter::class,'BooleanAsXml']);
+        $this->WriteOptionalAttribute(CsdlConstants::Attribute_FixedLength, $reference->isFixedLength(), null, [EdmValueWriter::class, 'BooleanAsXml']);
+        $this->WriteOptionalAttribute(CsdlConstants::Attribute_Unicode, $reference->isUnicode(), null, [EdmValueWriter::class, 'BooleanAsXml']);
     }
 
     public function WriteTemporalTypeAttributes(ITemporalTypeReference $reference): void
     {
-        $this->WriteOptionalAttribute(CsdlConstants::Attribute_Precision, $reference->getPrecision(), null, [EdmValueWriter::class,'IntAsXml']);
+        $this->WriteOptionalAttribute(CsdlConstants::Attribute_Precision, $reference->getPrecision(), null, [EdmValueWriter::class, 'IntAsXml']);
     }
 
     public function WriteReferentialConstraintElementHeader(INavigationProperty $constraint): void
@@ -338,20 +338,20 @@ 
     public function WriteReferentialConstraintPrincipalEndElementHeader(INavigationProperty $end): void
     {
         $this->xmlWriter->startElement(CsdlConstants::Element_Principal);
-        $this->WriteRequiredAttribute(CsdlConstants::Attribute_Role, $this->model->GetAssociationEndName($end), [EdmValueWriter::class,'StringAsXml']);
+        $this->WriteRequiredAttribute(CsdlConstants::Attribute_Role, $this->model->GetAssociationEndName($end), [EdmValueWriter::class, 'StringAsXml']);
     }
 
     public function WriteReferentialConstraintDependentEndElementHeader(INavigationProperty $end): void
     {
         $this->xmlWriter->startElement(CsdlConstants::Element_Dependent);
-        $this->WriteRequiredAttribute(CsdlConstants::Attribute_Role, $this->model->GetAssociationEndName($end), [EdmValueWriter::class,'StringAsXml']);
+        $this->WriteRequiredAttribute(CsdlConstants::Attribute_Role, $this->model->GetAssociationEndName($end), [EdmValueWriter::class, 'StringAsXml']);
     }
 
     public function WriteNamespaceUsingElement(string $usingNamespace, string $alias): void
     {
         $this->xmlWriter->startElement(CsdlConstants::Element_Using);
-        $this->WriteRequiredAttribute(CsdlConstants::Attribute_Namespace, $usingNamespace, [EdmValueWriter::class,'StringAsXml']);
-        $this->WriteRequiredAttribute(CsdlConstants::Attribute_Alias, $alias, [EdmValueWriter::class,'StringAsXml']);
+        $this->WriteRequiredAttribute(CsdlConstants::Attribute_Namespace, $usingNamespace, [EdmValueWriter::class, 'StringAsXml']);
+        $this->WriteRequiredAttribute(CsdlConstants::Attribute_Alias, $alias, [EdmValueWriter::class, 'StringAsXml']);
         $this->WriteEndElement();
     }
 
@@ -374,7 +374,7 @@ 
     public function WriteFunctionElementHeader(IFunction $function, bool $inlineReturnType): void
     {
         $this->xmlWriter->startElement(CsdlConstants::Element_Function);
-        $this->WriteRequiredAttribute(CsdlConstants::Attribute_Name, $function->getName(), [EdmValueWriter::class,'StringAsXml']);
+        $this->WriteRequiredAttribute(CsdlConstants::Attribute_Name, $function->getName(), [EdmValueWriter::class, 'StringAsXml']);
         if ($inlineReturnType) {
             $this->WriteRequiredAttribute(CsdlConstants::Attribute_ReturnType, $function->getReturnType(), [$this, 'TypeReferenceAsXml']);
         }
@@ -400,21 +400,21 @@ 
         }
 
         $this->xmlWriter->startElement(CsdlConstants::Element_FunctionImport);
-        $this->WriteRequiredAttribute(CsdlConstants::Attribute_Name, $functionImport->getName(), [EdmValueWriter::class,'StringAsXml']);
-        $this->WriteOptionalAttribute(CsdlConstants::Attribute_ReturnType, $functionImport->getReturnType(), null, [$this,'TypeReferenceAsXml']);
+        $this->WriteRequiredAttribute(CsdlConstants::Attribute_Name, $functionImport->getName(), [EdmValueWriter::class, 'StringAsXml']);
+        $this->WriteOptionalAttribute(CsdlConstants::Attribute_ReturnType, $functionImport->getReturnType(), null, [$this, 'TypeReferenceAsXml']);
 
         // IsSideEffecting is optional, however its default applies to non-composable function imports only.
         // Composable function imports can't be side-effecting, so we don't emit false.
         if (!$functionImport->isComposable() && $functionImport->isSideEffecting() != CsdlConstants::Default_IsSideEffecting) {
-            $this->WriteRequiredAttribute(CsdlConstants::Attribute_IsSideEffecting, $functionImport->isSideEffecting(), [EdmValueWriter::class,'BooleanAsXml']);
+            $this->WriteRequiredAttribute(CsdlConstants::Attribute_IsSideEffecting, $functionImport->isSideEffecting(), [EdmValueWriter::class, 'BooleanAsXml']);
         }
 
-        $this->WriteOptionalAttribute(CsdlConstants::Attribute_IsComposable, $functionImport->isComposable(), CsdlConstants::Default_IsComposable, [EdmValueWriter::class,'BooleanAsXml']);
-        $this->WriteOptionalAttribute(CsdlConstants::Attribute_IsBindable, $functionImport->isBindable(), CsdlConstants::Default_IsBindable, [EdmValueWriter::class,'BooleanAsXml']);
+        $this->WriteOptionalAttribute(CsdlConstants::Attribute_IsComposable, $functionImport->isComposable(), CsdlConstants::Default_IsComposable, [EdmValueWriter::class, 'BooleanAsXml']);
+        $this->WriteOptionalAttribute(CsdlConstants::Attribute_IsBindable, $functionImport->isBindable(), CsdlConstants::Default_IsBindable, [EdmValueWriter::class, 'BooleanAsXml']);
         $entitySetReference = $functionImport->getEntitySet();
         if ($functionImport->getEntitySet() != null) {
             if ($entitySetReference instanceof IEntitySetReferenceExpression) {
-                $this->WriteOptionalAttribute(CsdlConstants::Attribute_EntitySet, $entitySetReference->getReferencedEntitySet()->getName(), null, [EdmValueWriter::class,'StringAsXml']);
+                $this->WriteOptionalAttribute(CsdlConstants::Attribute_EntitySet, $entitySetReference->getReferencedEntitySet()->getName(), null, [EdmValueWriter::class, 'StringAsXml']);
             } else {
                 $pathExpression = $functionImport->getEntitySet();
                 if ($pathExpression instanceof IPathExpression) {
@@ -429,9 +429,9 @@ 
     public function WriteFunctionParameterElementHeader(IFunctionParameter $parameter, bool $inlineType): void
     {
         $this->xmlWriter->startElement(CsdlConstants::Element_Parameter);
-        $this->WriteRequiredAttribute(CsdlConstants::Attribute_Name, $parameter->getName(), [EdmValueWriter::class,'StringAsXml']);
+        $this->WriteRequiredAttribute(CsdlConstants::Attribute_Name, $parameter->getName(), [EdmValueWriter::class, 'StringAsXml']);
         if ($inlineType) {
-            $this->WriteRequiredAttribute(CsdlConstants::Attribute_Type, $parameter->getType(), [$this,'TypeReferenceAsXml']);
+            $this->WriteRequiredAttribute(CsdlConstants::Attribute_Type, $parameter->getType(), [$this, 'TypeReferenceAsXml']);
         }
 
         $this->WriteOptionalAttribute(CsdlConstants::Attribute_Mode, $parameter->getMode(), CsdlConstants::$Default_FunctionParameterMode, [self::class, 'FunctionParameterModeAsXml']);
@@ -441,7 +441,7 @@ 
     {
         $this->xmlWriter->startElement(CsdlConstants::Element_CollectionType);
         if ($inlineType) {
-            $this->WriteRequiredAttribute(CsdlConstants::Attribute_ElementType, $collectionType->getElementType(), [$this,'TypeReferenceAsXml']);
+            $this->WriteRequiredAttribute(CsdlConstants::Attribute_ElementType, $collectionType->getElementType(), [$this, 'TypeReferenceAsXml']);
         }
     }
 
@@ -459,7 +459,7 @@ 
                 break;
             case ExpressionKind::BooleanConstant():
                 assert($expression instanceof IBooleanConstantExpression);
-                $this->WriteRequiredAttribute(CsdlConstants::Attribute_Bool, $expression->getValue(), [EdmValueWriter::class,'BooleanAsXml']);
+                $this->WriteRequiredAttribute(CsdlConstants::Attribute_Bool, $expression->getValue(), [EdmValueWriter::class, 'BooleanAsXml']);
                 break;
             case ExpressionKind::DateTimeConstant():
                 assert($expression instanceof IDateTimeConstantExpression);
@@ -475,7 +475,7 @@ 
                 break;
             case ExpressionKind::FloatingConstant():
                 assert($expression instanceof IFloatingConstantExpression);
-                $this->WriteRequiredAttribute(CsdlConstants::Attribute_Float, $expression->getValue(), [EdmValueWriter::class,  'FloatAsXml']);
+                $this->WriteRequiredAttribute(CsdlConstants::Attribute_Float, $expression->getValue(), [EdmValueWriter::class, 'FloatAsXml']);
                 break;
             case ExpressionKind::GuidConstant():
                 assert($expression instanceof IGuidConstantExpression);
@@ -491,7 +491,7 @@ 
                 break;
             case ExpressionKind::StringConstant():
                 assert($expression instanceof IStringConstantExpression);
-                $this->WriteRequiredAttribute(CsdlConstants::Attribute_String, $expression->getValue(), [EdmValueWriter::class,'StringAsXml']);
+                $this->WriteRequiredAttribute(CsdlConstants::Attribute_String, $expression->getValue(), [EdmValueWriter::class, 'StringAsXml']);
                 break;
             case ExpressionKind::TimeConstant():
                 assert($expression instanceof ITimeConstantExpression);
@@ -507,7 +507,7 @@ 
     {
         $this->xmlWriter->startElement(CsdlConstants::Element_ValueAnnotation);
         $this->WriteRequiredAttribute(CsdlConstants::Attribute_Term, $annotation->getTerm(), [$this, 'TermAsXml']);
-        $this->WriteOptionalAttribute(CsdlConstants::Attribute_Qualifier, $annotation->getQualifier(), null, [EdmValueWriter::class,'StringAsXml']);
+        $this->WriteOptionalAttribute(CsdlConstants::Attribute_Qualifier, $annotation->getQualifier(), null, [EdmValueWriter::class, 'StringAsXml']);
         if ($isInline) {
             $this->WriteInlineExpression($annotation->getValue());
         }
@@ -517,13 +517,13 @@ 
     {
         $this->xmlWriter->startElement(CsdlConstants::Element_TypeAnnotation);
         $this->WriteRequiredAttribute(CsdlConstants::Attribute_Term, $annotation->getTerm(), [$this, 'TermAsXml']);
-        $this->WriteOptionalAttribute(CsdlConstants::Attribute_Qualifier, $annotation->getQualifier(), null, [EdmValueWriter::class,'StringAsXml']);
+        $this->WriteOptionalAttribute(CsdlConstants::Attribute_Qualifier, $annotation->getQualifier(), null, [EdmValueWriter::class, 'StringAsXml']);
     }
 
     public function WritePropertyValueElementHeader(IPropertyValueBinding $value, bool $isInline): void
     {
         $this->xmlWriter->startElement(CsdlConstants::Element_PropertyValue);
-        $this->WriteRequiredAttribute(CsdlConstants::Attribute_Property, $value->getBoundProperty()->getName(), [EdmValueWriter::class,'StringAsXml']);
+        $this->WriteRequiredAttribute(CsdlConstants::Attribute_Property, $value->getBoundProperty()->getName(), [EdmValueWriter::class, 'StringAsXml']);
         if ($isInline) {
             $this->WriteInlineExpression($value->getValue());
         }
@@ -532,13 +532,13 @@ 
     public function WriteRecordExpressionElementHeader(IRecordExpression $expression)
     {
         $this->xmlWriter->startElement(CsdlConstants::Element_Record);
-        $this->WriteOptionalAttribute(CsdlConstants::Attribute_Type, $expression->getDeclaredType(), null, [$this,'TypeReferenceAsXml']);
+        $this->WriteOptionalAttribute(CsdlConstants::Attribute_Type, $expression->getDeclaredType(), null, [$this, 'TypeReferenceAsXml']);
     }
 
     public function WritePropertyConstructorElementHeader(IPropertyConstructor $constructor, bool $isInline): void
     {
         $this->xmlWriter->startElement(CsdlConstants::Element_PropertyValue);
-        $this->WriteRequiredAttribute(CsdlConstants::Attribute_Property, $constructor->getName(), [EdmValueWriter::class,'StringAsXml']);
+        $this->WriteRequiredAttribute(CsdlConstants::Attribute_Property, $constructor->getName(), [EdmValueWriter::class, 'StringAsXml']);
         if ($isInline) {
             $this->WriteInlineExpression($constructor->getValue());
         }
@@ -643,14 +643,14 @@ 
     public function WriteLabeledElementHeader(ILabeledExpression $labeledElement): void
     {
         $this->xmlWriter->startElement(CsdlConstants::Element_LabeledElement);
-        $this->WriteRequiredAttribute(CsdlConstants::Attribute_Name, $labeledElement->getName(), [EdmValueWriter::class,'StringAsXml']);
+        $this->WriteRequiredAttribute(CsdlConstants::Attribute_Name, $labeledElement->getName(), [EdmValueWriter::class, 'StringAsXml']);
     }
 
     public function WriteIsTypeExpressionElementHeader(IIsTypeExpression $expression, bool $inlineType): void
     {
         $this->xmlWriter->startElement(CsdlConstants::Element_IsType);
         if ($inlineType) {
-            $this->WriteRequiredAttribute(CsdlConstants::Attribute_Type, $expression->getType(), [$this,'TypeReferenceAsXml']);
+            $this->WriteRequiredAttribute(CsdlConstants::Attribute_Type, $expression->getType(), [$this, 'TypeReferenceAsXml']);
         }
     }
 
@@ -658,7 +658,7 @@ 
     {
         $this->xmlWriter->startElement(CsdlConstants::Element_AssertType);
         if ($inlineType) {
-            $this->WriteRequiredAttribute(CsdlConstants::Attribute_Type, $expression->getType(), [$this,'TypeReferenceAsXml']);
+            $this->WriteRequiredAttribute(CsdlConstants::Attribute_Type, $expression->getType(), [$this, 'TypeReferenceAsXml']);
         }
     }
 
@@ -806,7 +806,7 @@ 
 
     private static function SridAsXml(?int $i): string
     {
-        return $i !== null ? strval($i) :  CsdlConstants::Value_SridVariable;
+        return $i !== null ? strval($i) : CsdlConstants::Value_SridVariable;
     }
 
     private static function GetCsdlNamespace(Version $edmVersion): string

src/Csdl/Internal/Serialization/Helpers/AssociationSetAnnotations.php

Spacing +1 added lines, -1 removed lines

@@ -11,5 +11,5 @@
 
     public $End1Annotations;
 
-    public $End2Annotations ;
+    public $End2Annotations;
 }

src/Csdl/Internal/Serialization/Helpers/AssociationAnnotations.php

Spacing +3 added lines, -3 removed lines

@@ -12,11 +12,11 @@ 
     /**
      * @var IDirectValueAnnotation
      */
-    public $Annotations ;
+    public $Annotations;
     /**
      * @var IDirectValueAnnotation
      */
-    public $End1Annotations ;
+    public $End1Annotations;
     /**
      * @var IDirectValueAnnotation
      */
@@ -24,5 +24,5 @@ 
     /**
      * @var IDirectValueAnnotation
      */
-    public $ConstraintAnnotations ;
+    public $ConstraintAnnotations;
 }