1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
|
//---------------------------------------------------------------------
// <copyright file="FacetValueContainer.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
//
// @owner Microsoft
// @backupOwner Microsoft
//---------------------------------------------------------------------
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Diagnostics;
namespace System.Data.Metadata.Edm
{
/// <summary>
/// This Class is never expected to be used except for by the FacetValues class.
///
/// The purpose of this class is to allow strong type checking by the compiler while setting facet values which
/// are typically stored as Object because they can either on of these things
///
/// 1. null
/// 2. scalar type (bool, int, byte)
/// 3. Unbounded object
///
/// without this class it would be very easy to accidentally set precision to an int when it really is supposed to be
/// a byte value. Also you would be able to set the facet value to any Object derived class (ANYTHING!!!) when really only
/// null and Unbounded are allowed besides an actual scalar value. The magic of the class happens in the implicit constructors with
/// allow patterns like
///
/// new FacetValues( MaxLength = EdmConstants.UnboundedValue, Nullable = true};
///
/// and these are type checked at compile time
/// </summary>
/// <typeparam name="T"></typeparam>
internal struct FacetValueContainer<T>
{
T _value;
bool _hasValue;
bool _isUnbounded;
internal T Value
{
set
{
_isUnbounded = false;
_hasValue = true;
_value = value;
}
}
private void SetUnbounded()
{
_isUnbounded = true;
_hasValue = true;
}
// don't add an implicit conversion from object because it will kill the compile time type checking.
public static implicit operator FacetValueContainer<T>(System.Data.Metadata.Edm.EdmConstants.Unbounded unbounded)
{
Debug.Assert(object.ReferenceEquals(unbounded, EdmConstants.UnboundedValue), "you must pass the unbounded value. If you are trying to set null, use the T parameter overload");
FacetValueContainer<T> container = new FacetValueContainer<T>();
container.SetUnbounded();
return container;
}
public static implicit operator FacetValueContainer<T>(T value)
{
FacetValueContainer<T> container = new FacetValueContainer<T>();
container.Value = value;
return container;
}
internal object GetValueAsObject()
{
Debug.Assert(_hasValue, "Don't get the value if it has not been set");
if (_isUnbounded)
{
return EdmConstants.UnboundedValue;
}
else
{
return (object)_value;
}
}
internal bool HasValue
{
get
{
return _hasValue;
}
}
}
}
|
