| public static Default ( Action, action ) : CaseInfo, | ||
| action | Action, | |
| return | CaseInfo, | |
private void RegisterMultipleComponentsRegistration(ComponentRegistryDefinition componentRegistryDefinition, ComponentRegistryDefinition.ComponentSetRegistrationDefinition componentSetRegistrationDefinition)
{
if (componentSetRegistrationDefinition.RegistrationsDefinition == null)
{
return;
}
foreach (var registration in componentSetRegistrationDefinition.RegistrationsDefinition)
{
TypeSwitch.Do(registration,
TypeSwitch.Case <ComponentRegistryDefinition.ComponentRegistrationDefinition>(componentRegistration => {
componentRegistration.Interface = componentSetRegistrationDefinition.Interface;
RegisterMutipleComponentComponentRegistration(
componentRegistryDefinition,
componentRegistration
);
}),
TypeSwitch.Case <ComponentRegistryDefinition.ProxyInterfaceRegistrationDefinition>(proxyRegistration => {
proxyRegistration.Interface = componentSetRegistrationDefinition.Interface;
RegisterMultipleComponentProxyRegistration(
componentRegistryDefinition,
proxyRegistration
);
}),
TypeSwitch.Default(() => { throw new NotSupportedException(registration.GetType().FullName); })
);
}
}
private void ValidateRequestSettings(IRequestSettings <T> config, IContactRequest typeRequest)
{
TypeSwitch.Do(
config.mailingProvider,
TypeSwitch.Case <IIContactRequest>(() => { IContactValidateRequestSettings(config, typeRequest); }),
TypeSwitch.Default(() => { }));
}
public override ISQLBuilder Literal(object value)
{
if (value != null)
{
TypeSwitch.Do(
value,
TypeSwitch.Case <byte[]>(x => Emit("X'").Emit(x.ToHexString(true)).Emit("'")),
TypeSwitch.Case <Guid>(x => this.Literal(x.ToByteArray())),
TypeSwitch.Case <Guid?>(x => {
if (x.HasValue)
{
this.Literal(x.Value.ToByteArray());
}
else
{
base.Literal(null);
}
}),
TypeSwitch.Default(() => base.Literal(value))
);
}
else
{
base.Literal(null);
}
return(this);
}
public static string Beautify(object obj)
{
var val = string.Empty;
if (obj != null)
{
TypeSwitch.Do(obj,
TypeSwitch.Case <string>(s => val = s),
TypeSwitch.Case <DateTime?>(dt => val = string.Format("{0:yyyy-MM-dd HH:mm:ss}", dt)),
TypeSwitch.Case <DateTime>(dt => val = string.Format("{0:yyyy-MM-dd HH:mm:ss}", dt)),
//TypeSwitch.Case<byte[]>(b => val = BitcoinProtocolHelper.BytesToString(b)),
TypeSwitch.Case <decimal?>(d => val = string.Format("{0:0.#############################}", d)),
TypeSwitch.Case <decimal>(d => val = string.Format("{0:0.#############################}", d)),
TypeSwitch.Case <double?>(d => val = string.Format("{0:0.#############################}", d)),
TypeSwitch.Case <double>(d => val = string.Format("{0:0.#############################}", d)),
TypeSwitch.Case <float?>(d => val = string.Format("{0:0.#############################}", d)),
TypeSwitch.Case <float>(d => val = string.Format("{0:0.#############################}", d)),
TypeSwitch.Default(() => val = obj.ToString())
);
}
else
{
val = string.Empty;
}
return(val);
}
private static void Traverse(IGenericObject genericObject, IApp app)
{
if (genericObject == null)
{
return;
}
// Check if the object is an extensions of a master object.
if (genericObject.Properties.ExtendsObject != null)
{
var masterObject = (IMasterObject)genericObject.Properties.ExtendsObject;
TextHelper.WriteLine(4, "MasterObject version " + masterObject.Properties.MasterVersion);
}
// The information to print for each object depends on the type of the object. The TypeSwitch class can be used
// for this purpose. For extensions of master objects, property values will automatically be retrieved from the
// master object.
TypeSwitch.Do(genericObject,
TypeSwitch.Case <Table>(o => TextHelper.Print(o.GetType().Name, o.Properties.HyperCubeDef, o.Title, app)),
TypeSwitch.Case <Barchart>(o => TextHelper.Print(o.GetType().Name, o.Properties.HyperCubeDef, o.Title, app)),
TypeSwitch.Case <Linechart>(o => TextHelper.Print(o.GetType().Name, o.Properties.HyperCubeDef, o.Title, app)),
TypeSwitch.Case <Piechart>(o => TextHelper.Print(o.GetType().Name, o.Properties.HyperCubeDef, o.Title, app)),
TypeSwitch.Case <Scatterplot>(o => TextHelper.Print(o.GetType().Name, o.Properties.HyperCubeDef, o.Title, app)),
TypeSwitch.Case <Treemap>(o => TextHelper.Print(o.GetType().Name, o.Properties.HyperCubeDef, o.Title, app)),
TypeSwitch.Case <Gauge>(o => TextHelper.Print(o.GetType().Name, o.Properties.HyperCubeDef, o.Title, app)),
TypeSwitch.Case <Combochart>(o => TextHelper.Print(o.GetType().Name, o.Properties.HyperCubeDef, o.Title, app)),
TypeSwitch.Case <TextImage>(o => TextHelper.Print(o.GetType().Name, o.Properties.HyperCubeDef, o.Title, app)),
TypeSwitch.Case <Listbox>(o => TextHelper.Print(o.GetType().Name, o.Title)),
TypeSwitch.Case <Filterpane>(o => TextHelper.Print(o.GetType().Name, o.Title)),
TypeSwitch.Case <Kpi>(o => TextHelper.Print(o.GetType().Name, o.Title)),
TypeSwitch.Case <Pivottable>(o => TextHelper.Print(o.GetType().Name, o.Title)),
TypeSwitch.Case <Map>(o => TextHelper.Print(o.GetType().Name, o.Title)),
TypeSwitch.Default(() => TextHelper.WriteLine(4, "Unknown type: " + genericObject.GetType().FullName))
);
}
public void TypeSwitch_Default_ActionNull_Success()
{
var result = TypeSwitch.Default(null);
result.Action.Invoke(null);
Assert.AreEqual(null, result.Target);
Assert.IsTrue(result.IsDefault);
}
public void TypeSwitch_Do_WhenDefault_ExpectDefaultAndTargetNull()
{
//------------Execute Test---------------------------
var result = TypeSwitch.Default(delegate() { });
//------------Assert Results-------------------------
Assert.AreEqual(null, result.Target);
Assert.IsTrue(result.IsDefault);
}
public static IDev2TOFn CreateNewDTO(IDev2TOFn dto, int index = 0, bool inserted = false, string initializeWith = "")
{
IDev2TOFn toReturn = null;
TypeSwitch.Do(dto,
// ReSharper disable ImplicitlyCapturedClosure
TypeSwitch.Case <ActivityDTO>(x => toReturn = new ActivityDTO(initializeWith, "", index, inserted)),
// ReSharper restore ImplicitlyCapturedClosure
TypeSwitch.Case <DataSplitDTO>(x =>
{
var dataSplitDto = dto as DataSplitDTO;
if (dataSplitDto != null)
{
toReturn = new DataSplitDTO(initializeWith, dataSplitDto.SplitType, dataSplitDto.At, index, false, inserted);
}
}),
TypeSwitch.Case <DataMergeDTO>(x =>
{
var dataMergeDto = dto as DataMergeDTO;
if (dataMergeDto != null)
{
toReturn = new DataMergeDTO(initializeWith, dataMergeDto.MergeType, dataMergeDto.At, index, dataMergeDto.Padding, dataMergeDto.Alignment, inserted);
}
}),
TypeSwitch.Case <CaseConvertTO>(x =>
{
var caseConvertTO = dto as CaseConvertTO;
if (caseConvertTO != null)
{
toReturn = CaseConverterFactory.CreateCaseConverterTO(initializeWith, caseConvertTO.ConvertType, caseConvertTO.Result, index);
}
}),
TypeSwitch.Case <BaseConvertTO>(x =>
{
var baseConvertTO = dto as BaseConvertTO;
if (baseConvertTO != null)
{
toReturn = new BaseConvertTO(initializeWith, baseConvertTO.FromType, baseConvertTO.ToType, baseConvertTO.ToExpression, index, inserted);
}
}),
// ReSharper disable ImplicitlyCapturedClosure
TypeSwitch.Case <GatherSystemInformationTO>(x => toReturn =
// ReSharper restore ImplicitlyCapturedClosure
new GatherSystemInformationTO(enTypeOfSystemInformationToGather.FullDateTime,
initializeWith, index, inserted)),
// ReSharper disable ImplicitlyCapturedClosure
TypeSwitch.Case <XPathDTO>(x => toReturn = new XPathDTO(initializeWith, "", index, inserted)),
// ReSharper restore ImplicitlyCapturedClosure
// ReSharper disable ImplicitlyCapturedClosure
TypeSwitch.Case <FindRecordsTO>(() => toReturn = new FindRecordsTO("", "", index, inserted)),
// ReSharper restore ImplicitlyCapturedClosure
// ReSharper disable ImplicitlyCapturedClosure
TypeSwitch.Default(() => toReturn = null));
// ReSharper restore ImplicitlyCapturedClosure
return(toReturn);
}
public void TypeSwitch_Do_WhenDefault_ExpectActionCalled()
{
var wasCalled = false;
var case1 = TypeSwitch.Default(delegate { wasCalled = true; });
TypeSwitch.Do(typeof(object), case1);
Assert.IsTrue(wasCalled, "expected action to be called");
}
public void DefaultCreatesCaseInfoObjectCorrectly()
{
Action action = () => {};
var result = TypeSwitch.Default(action);
Assert.AreEqual(result.IsDefault, true);
Assert.Throws <NullReferenceException>(() => Assert.AreEqual(result.Target, null));
Assert.AreEqual(result.Action, action);
}
private void ConfigureRequest(HttpWebRequest request, IRequestSettings <T> config)
{
TypeSwitch.Do(
config.mailingProvider,
TypeSwitch.Case <IIContactRequest>(() => {
//IContactConfigureRequest(request, config);
IContactConfigureRequestJson(request, config);
}),
TypeSwitch.Default(() => { }));
}
private string CreatetUriRequest(T mailingProvider, IContactRequest typeRequest)
{
string uri = string.Empty;
TypeSwitch.Do(
mailingProvider,
TypeSwitch.Case <IIContactRequest>(() => { uri = IContactCreatetUriRequest(mailingProvider, typeRequest); }),
TypeSwitch.Default(() => { uri = string.Empty; }));
return(uri);
}
void OnReturnInstanceSignalDispatched(PoolableView view)
{
TypeSwitch.Do(
view,
TypeSwitch.Case <PlayerShipLaserView>(x => playerLaserPool.ReturnInstance(x)),
TypeSwitch.Case <AsteroidView>(x => asteroidPool.ReturnInstance(x)),
TypeSwitch.Case <EnemyShipView>(x => enemyShipPool.ReturnInstance(x)),
TypeSwitch.Default(() => {
throw new NotSupportedException("This view can not supported!!!!!");
})
);
}
private IDataType GetDataType()
{
var dataType = string.Empty;
TypeSwitch.Do(
CurrentColumnInfo.Column.FieldNameType,
TypeSwitch.Case <string>(() => dataType = "StringDataType"),
TypeSwitch.Case <DateTime>(() => dataType = "DatetimeDataType"),
TypeSwitch.Case <DateTime?>(() => dataType = "DatetimeDataType"),
TypeSwitch.Default(() => dataType = "DefaultType")
);
return(DataTypeFactory.GetInstance().CreateInstance(dataType));
}
public virtual ISQLBuilder Literal(object value)
{
if (value == null || value == DBNull.Value)
{
return(Emit("NULL"));
}
TypeSwitch.Do(value,
TypeSwitch.Case <SQLBuilderCommand>(c => { c.Execute(this.LeafBuilder); }),
TypeSwitch.Default(() => Emit(value.ToSQLString()))
);
return(this);
}
public static IDev2TOFn CreateNewDTO(IDev2TOFn dto, int index, bool inserted, string initializeWith)
{
IDev2TOFn toReturn = null;
TypeSwitch.Do(dto,
TypeSwitch.Case <ActivityDTO>(x => toReturn = new ActivityDTO(initializeWith, "", index, inserted)),
TypeSwitch.Case <DataSplitDTO>(x =>
{
if (dto is DataSplitDTO dataSplitDto)
{
toReturn = new DataSplitDTO(initializeWith, dataSplitDto.SplitType, dataSplitDto.At, index, false, inserted);
}
}),
TypeSwitch.Case <DataMergeDTO>(x =>
{
if (dto is DataMergeDTO dataMergeDto)
{
toReturn = new DataMergeDTO(initializeWith, dataMergeDto.MergeType, dataMergeDto.At, index, dataMergeDto.Padding, dataMergeDto.Alignment, inserted);
}
}),
TypeSwitch.Case <CaseConvertTO>(x =>
{
if (dto is CaseConvertTO caseConvertTO)
{
toReturn = CaseConverterFactory.CreateCaseConverterTO(initializeWith, caseConvertTO.ConvertType, caseConvertTO.Result, index);
}
}),
TypeSwitch.Case <BaseConvertTO>(x =>
{
if (dto is BaseConvertTO baseConvertTO)
{
toReturn = new BaseConvertTO(initializeWith, baseConvertTO.FromType, baseConvertTO.ToType, baseConvertTO.ToExpression, index, inserted);
}
}),
TypeSwitch.Case <GatherSystemInformationTO>(x => toReturn =
new GatherSystemInformationTO(enTypeOfSystemInformationToGather.FullDateTime,
initializeWith, index, inserted)),
TypeSwitch.Case <XPathDTO>(x => toReturn = new XPathDTO(initializeWith, "", index, inserted)),
TypeSwitch.Case <FindRecordsTO>(() => toReturn = new FindRecordsTO("", "", index, inserted)),
TypeSwitch.Case <DecisionTO>(() => toReturn = new DecisionTO(initializeWith, "", "", index, inserted)),
TypeSwitch.Case <JsonMappingTo>(() => toReturn = new JsonMappingTo(initializeWith, index, inserted)),
TypeSwitch.Case <SharepointSearchTo>(() => toReturn = new SharepointSearchTo(initializeWith, "=", "", index, inserted)),
TypeSwitch.Case <SharepointReadListTo>(() => toReturn = new SharepointReadListTo("", initializeWith, "", "")),
TypeSwitch.Case <AssignObjectDTO>(x => toReturn = new AssignObjectDTO(initializeWith, "", index, inserted)),
TypeSwitch.Default(() => toReturn = null));
return(toReturn);
}
private StorageClass GetStorageClass(Type type)
{
var retval = StorageClass.XMLSerialized;
TypeSwitch.DoType(type,
TypeSwitch.Case <string>(() => retval = StorageClass.String),
TypeSwitch.Case <int>(() => retval = StorageClass.Integer),
TypeSwitch.Case <bool>(() => retval = StorageClass.Bool),
TypeSwitch.Case <float>(() => retval = StorageClass.Float),
TypeSwitch.Case <double>(() => retval = StorageClass.Double),
TypeSwitch.Default(() => retval = StorageClass.XMLSerialized)
);
return(retval);
}
public void DoSelectsDefaultCaseIfTypesDoNotMatch()
{
var result = false;
TypeSwitch.Do <object>(
TypeSwitch.Case <string>(() => Assert.That(false, "Expected default case, got string")),
TypeSwitch.Case <bool>(() => Assert.That(false, "Expected default case, got bool")),
TypeSwitch.Case <int>(() => Assert.That(false, "Expected default case, got int")),
TypeSwitch.Case <float>(() => Assert.That(false, "Expected default case, got float")),
TypeSwitch.Default(() => result = true)
);
Assert.That(result, "Default case was not invoked!");
}
public void OnException(ExceptionContext context)
{
TypeSwitch.Do(context.Exception,
TypeSwitch.Case <HypermediaException>(() => this.HandleHypermediaException(context)),
TypeSwitch.Case <HypermediaFormatterException>(() => this.HandleHypermediaException(context)),
TypeSwitch.Case <UnauthorizedAccessException>(() => this.HandleUnauthorizedAccessException(context)),
TypeSwitch.Default(() => GenericResponse(context))
);
if (this.logger != null)
{
this.logger.LogError("GlobalExceptionFilter", context.Exception);
}
}
private object GetObjectInstance(Type t, Canvas cv, object obj = null)
{
object o = null;
TypeSwitch.CaseInfo[] cinfo =
{
TypeSwitch.Case <CollapsibleCategory>(() =>
{
o = Activator.CreateInstance(t, new CollapsibleList(new ScrollControl(cv)));
}),
TypeSwitch.Case <DownArrow>(() =>
{
o = Activator.CreateInstance(t, new ComboBox(cv));
}),
TypeSwitch.Case <PropertyRow>(() =>
{
o = Activator.CreateInstance(t, new object[]{ cv, new Gwen.Control.Property.PropertyBase(cv) });
}),
TypeSwitch.Case <PropertyRowLabel>(() =>
{
o = Activator.CreateInstance(t, new PropertyRow(cv, new Gwen.Control.Property.PropertyBase(cv)));
}),
TypeSwitch.Case <Margin>(() =>
{
o = Activator.CreateInstance(t, new object[]{ 0, 0, 0, 0 });
}),
TypeSwitch.Case <Padding>(() =>
{
o = Activator.CreateInstance(t, new object[]{ 0, 0, 0, 0 });
}),
TypeSwitch.Default(() =>
{
o = Activator.CreateInstance(t, cv);
})
};
if (obj == null)
{
TypeSwitch.Do(t, cinfo);
}
else
{
TypeSwitch.Do(obj, cinfo);
}
return(o);
}
private static string TypeName <T>() where T : NeoValue
{
string name = null;
TypeSwitch.Do <T>(
TypeSwitch.Case <NeoProcedure>(() => name = "procedure"),
TypeSwitch.Case <NeoObject>(() => name = "object"),
TypeSwitch.Case <NeoArray>(() => name = "array"),
TypeSwitch.Case <NeoFloat>(() => name = "float"),
TypeSwitch.Case <NeoNumber>(() => name = "number"),
TypeSwitch.Case <NeoInt>(() => name = "int"),
TypeSwitch.Case <NeoBool>(() => name = "bool"),
TypeSwitch.Default(() => name = typeof(T).ToString())
);
return(name);
}
public void RemoveStateChangedHandler(Control control, EventHandler eventHandler)
{
TypeSwitch.Do(
control,
TypeSwitch.Case <ApplicationControl>(c => c.StateChanged -= eventHandler),
TypeSwitch.Case <NumericUpDown>(c => c.ValueChanged -= eventHandler),
TypeSwitch.Case <TextBox>(c => c.TextChanged -= eventHandler),
TypeSwitch.Case <ComboBox>(c => c.SelectedIndexChanged -= eventHandler),
TypeSwitch.Case <RadioButton>(c => c.CheckedChanged -= eventHandler),
TypeSwitch.Case <CheckBox>(c => c.CheckedChanged -= eventHandler),
TypeSwitch.Case <CheckedListBox>(c => c.SelectedIndexChanged -= eventHandler),
TypeSwitch.Case <DateTimePicker>(c => c.TextChanged -= eventHandler),
TypeSwitch.Case <ListBox>(c => c.SelectedIndexChanged -= eventHandler),
TypeSwitch.Default(() => {
throw new SoftwareException($"Control '{control.GetType().Name}' is not supported");
})
);
}
public override ISQLBuilder Literal(object value)
{
if (value == null || value == DBNull.Value)
{
return(Emit("NULL"));
}
TypeSwitch.Do(
value,
TypeSwitch.Case <byte[]>(x => {
Emit("CONVERT(varbinary(max), ");
base.Literal(value);
Emit(" , 1)");
}),
TypeSwitch.Default(() => base.Literal(value))
);
return(this);
}
private static void SetPresentationAnchorInternal(UIPopoverPresentationController ppc, NSObject target, NSObject targetOwner)
{
TypeSwitch.Do(target,
TypeSwitch.Case <UIToolbar>(b => {
ppc.SourceView = b;
ppc.SourceRect = b.Bounds;
ppc.PermittedArrowDirections = UIPopoverArrowDirection.Any;
}),
TypeSwitch.Case <UITabBar>(b => {
ppc.SourceView = b;
ppc.SourceRect = b.Bounds;
ppc.PermittedArrowDirections = UIPopoverArrowDirection.Any;
}),
TypeSwitch.Case <UITableViewCell>(cvc => {
if (targetOwner == null || !(targetOwner is UITableView))
{
throw new ArgumentNullException("UITargetReference to UITableViewCell did not contain the UITableView in TargetOwner field ", "targetOwner");
}
ppc.SourceView = targetOwner as UITableView;
ppc.SourceRect = cvc.Frame;
ppc.PermittedArrowDirections = UIPopoverArrowDirection.Any;
}),
TypeSwitch.Case <UICollectionViewCell>(cvc => {
if (targetOwner == null || !(targetOwner is UICollectionView))
{
throw new ArgumentNullException("UITargetReference to UICollectionViewCell did not contain the UICollectionView in TargetOwner field ", "targetOwner");
}
ppc.SourceView = targetOwner as UICollectionView;
ppc.SourceRect = cvc.Frame;
ppc.PermittedArrowDirections = UIPopoverArrowDirection.Any;
}),
TypeSwitch.Case <UIView>(v => {
ppc.SourceView = v;
ppc.SourceRect = v.Bounds;
ppc.PermittedArrowDirections = UIPopoverArrowDirection.Any;
}),
TypeSwitch.Case <UIBarButtonItem>((Action <UIBarButtonItem>)(b => {
ppc.BarButtonItem = b;
ppc.PermittedArrowDirections = UIPopoverArrowDirection.Any;
})),
TypeSwitch.Default(() => { throw new NotSupportedException(target.GetType().ToString()); })
);
}
public bool CanObserve(object source)
{
bool canObserve = false;
TypeSwitch.Do(source,
TypeSwitch.Case <IStateChangeEventSource>(() => canObserve = true),
TypeSwitch.Case <NumericUpDown>(() => canObserve = true),
TypeSwitch.Case <IStateChangeEventSource>(() => canObserve = true),
TypeSwitch.Case <TextBox>(() => canObserve = true),
TypeSwitch.Case <ComboBox>(() => canObserve = true),
TypeSwitch.Case <RadioButton>(() => canObserve = true),
TypeSwitch.Case <CheckBox>(() => canObserve = true),
TypeSwitch.Case <CheckedListBox>(() => canObserve = true),
TypeSwitch.Case <DateTimePicker>(() => canObserve = true),
TypeSwitch.Case <ListBox>(() => canObserve = true),
TypeSwitch.Default(() => canObserve = false)
);
return(canObserve);
}
public override ISQLBuilder Literal(object value)
{
if (value == null || value == DBNull.Value)
{
return(Emit("NULL"));
}
TypeSwitch.Do(
value,
TypeSwitch.Case <Guid>(g => Emit("CHAR_TO_UUID('{0}')", g.ToString().ToUpper())),
TypeSwitch.Case <byte[]>(x => {
Emit("CONVERT(varbinary(max), ");
base.Literal(value);
Emit(" , 1)");
}),
TypeSwitch.Default(() => base.Literal(value))
);
return(this);
}
/// <summary>
/// Handles the exception.
/// </summary>
/// <returns></returns>
public HandledResponseModel HandleException()
{
var response = new HandledResponseModel();
TypeSwitch.Eval(Exception,
TypeSwitch.Case <HandledException>(ex =>
{
response = new HandledResponseModel()
{
StatusCode = (int)ex.StatusCode,
Descriptor = BadRequestDescriptor,
Exceptions = ToExResponse(ex)
};
}),
TypeSwitch.Case <HandledExceptionCollection>((ex) =>
{
response = new HandledResponseModel()
{
StatusCode = (int)ex.StatusCode,
Descriptor = BadRequestDescriptor,
Exceptions = ToExResponse(ex)
};
}),
TypeSwitch.Case <Exception>((ex) =>
{
response = new HandledResponseModel()
{
StatusCode = (int)HttpStatusCode.InternalServerError,
Descriptor = BadRequestDescriptor,
Exceptions = ToExResponse(ex)
};
}),
TypeSwitch.Default(() => { })
);
return(response);
}
public static DeployViewModel GetDeployViewModel(object input)
{
DeployViewModel deployViewModel = null;
if (input != null)
{
TypeSwitch.Do(input,
TypeSwitch.Case <ExplorerItemModel>(
x => deployViewModel = new DeployViewModel(x.ResourceId, x.EnvironmentId)),
TypeSwitch.Case <ResourceModel>(
x => deployViewModel = new DeployViewModel(x.ID, x.Environment.ID)),
TypeSwitch.Default(() => deployViewModel = new DeployViewModel()));
}
else
{
deployViewModel = new DeployViewModel();
}
return(deployViewModel);
}
protected virtual VariableStorageClass TypeToStorageClass(Type type)
{
var storageClass = VariableStorageClass.Integer;
if (type.IsIntegerNumeric())
{
storageClass = VariableStorageClass.Integer;
}
else
{
TypeSwitch.ForType(
type,
TypeSwitch.Case <Guid>(() => storageClass = VariableStorageClass.Uuid),
TypeSwitch.Case <string>(() => storageClass = VariableStorageClass.Text),
TypeSwitch.Case <DateTime>(() => storageClass = VariableStorageClass.DateTime),
TypeSwitch.Case <byte[]>(() => storageClass = VariableStorageClass.Blob),
TypeSwitch.Default(() => { throw new SoftwareException("Unable to map type to variable storage class '{0}'", type.Name); })
);
}
return(storageClass);
}
public void TestTypeSwitch()
{
object v = null;
object node = null;
DoubleNode doubleNode = new DoubleNode(1.2);
node = doubleNode;
TypeSwitch.Do(
node,
TypeSwitch.Case <IntNode>(n => v = n.Value),
TypeSwitch.Case <DoubleNode>(n => v = n.Value),
TypeSwitch.Case <BooleanNode>(n => v = n.Value),
TypeSwitch.Case <StringNode>(n => v = n.Value),
TypeSwitch.Default(() => v = null));
Assert.AreEqual(v, 1.2);
IntNode intNode = new IntNode(42);
node = intNode;
TypeSwitch.Do(
node,
TypeSwitch.Case <IntNode>(n => v = n.Value),
TypeSwitch.Case <DoubleNode>(n => v = n.Value),
TypeSwitch.Case <BooleanNode>(n => v = n.Value),
TypeSwitch.Case <StringNode>(n => v = n.Value),
TypeSwitch.Default(() => v = null));
Assert.AreEqual(v, 42);
StringNode sNode = new StringNode();
node = sNode;
TypeSwitch.Do(
node,
TypeSwitch.Case <IntNode>(n => v = n.Value),
TypeSwitch.Case <DoubleNode>(n => v = n.Value),
TypeSwitch.Case <BooleanNode>(n => v = n.Value),
TypeSwitch.Default(() => v = 24));
Assert.AreEqual(v, 24);
}
