public ParameterValue CreateDefaultParameterValue(int idx)
{
IParameter p = null;
if (_method != null && _method.Parameters != null)
{
if (idx >= 0 && idx < _method.Parameters.Count)
{
p = _method.Parameters[idx];
}
}
if (p != null)
{
ParameterValue pv = new ParameterValue(this.Action);
pv.Name = p.Name;
pv.ParameterID = p.ParameterID;
ParameterClass pc = p as ParameterClass;
if (pc != null)
{
pv.SetDataType(pc);
}
else
{
pv.SetDataType(p.ParameterLibType);
}
pv.SetOwnerAction(_act);
pv.ValueType = EnumValueType.ConstantValue;
return(pv);
}
return(null);
}
public void callingMethod(ParameterClass p)
{
p.Name = "DR";
System.Console.WriteLine(p.Name);
System.Console.WriteLine(p.method(10));
}
public ConstructorClass(ClassPointer owner, ConstructorInfo info)
: base(owner)
{
_info = info;
StringBuilder sb = new StringBuilder("(");
List <ParameterClass> ps = new List <ParameterClass>();
ParameterInfo[] pifs = info.GetParameters();
if (pifs != null && pifs.Length > 0)
{
for (int i = 0; i < pifs.Length; i++)
{
if (i > 0)
{
sb.Append(",");
}
sb.Append(pifs[i].ParameterType.Name);
ParameterClass p = new ParameterClass(pifs[i].ParameterType, pifs[i].Name, this);
ps.Add(p);
}
this.Parameters = ps;
_fixedParameterCount = ps.Count;
}
else
{
_fixedParameterCount = 0;
}
sb.Append(")");
_display = sb.ToString();
}
private void hsNew_Click(object sender, EventArgs e)
{
UserDefinedFunctionObject = new UserDefinedFunctionClass();
UserDefinedFunctionObject.Name = "NEW_UserDefinedFunction";
var pc = new ParameterClass();
pc.Name = "";
pc.RawType = "INTEGER";
pc.FieldType = "LONG";
pc.TypeNumber = 8;
pc.Length = 4;
pc.Precision = 0;
UserDefinedFunctionObject.ParameterOut.Add(pc);
pc = new ParameterClass();
pc.Name = "XX";
pc.RawType = "INTEGER";
pc.FieldType = "LONG";
pc.TypeNumber = 8;
pc.Length = 4;
pc.Precision = 0;
UserDefinedFunctionObject.ParameterIn.Add(pc);
UserDefinedFunctionObject.Description = "";
OldUserDefinedFunctionObject = (UserDefinedFunctionClass)UserDefinedFunctionObject.Clone();
BearbeitenMode = StateClasses.EditStateClass.eBearbeiten.eInsert;
DataToEdit();
MakeSQL();
}
/// <summary>
/// Processes data asynchronously
/// </summary>
/// <param name="myClass"></param>
private void ProcessDataAsync(ParameterClass myClass)
{
// Background worker
var myWorker = new BackgroundWorker
{
WorkerReportsProgress = true,
};
// Do Work
myWorker.DoWork += delegate(object sender, DoWorkEventArgs e)
{
// Set result
e.Result = MyLongCalculations(myClass);
// Update progress (50 is just an example or your percentage as a double)
myWorker.ReportProgress(50);
};
// Progress Changed
myWorker.ProgressChanged += delegate(object sender, ProgressChangedEventArgs e)
{
myProgressBar.Value = e.ProgressPercentage;
};
// Work has been completed
myWorker.RunWorkerCompleted += delegate(object sender, RunWorkerCompletedEventArgs e)
{
// Work completed, you are back in the UI thread.
TextBox1.Text = (int)e.Result;
};
// Run Worker
myWorker.RunWorkerAsync();
}
private void hsNew_Click(object sender, EventArgs e)
{
_procedureObject = new ProcedureClass();
_procedureObject.Name = "NEW_PROCEDURE";
_procedureObject.Description = "";
var pc = new ParameterClass();
pc.Name = "X";
pc.RawType = "INTEGER";
pc.FieldType = "LONG";
pc.TypeNumber = 8;
pc.Length = 4;
pc.Precision = 0;
_procedureObject.ParameterOut.Add(pc);
pc = new ParameterClass();
pc.Name = "XX";
pc.RawType = "INTEGER";
pc.FieldType = "LONG";
pc.TypeNumber = 8;
pc.Length = 4;
pc.Precision = 0;
_procedureObject.ParameterIn.Add(pc);
_procedureObjectOld = (ProcedureClass)_procedureObject.Clone();
BearbeitenMode = StateClasses.EditStateClass.eBearbeiten.eInsert;
DataToEdit();
MakeSQL();
}
private ConstantDeclaration ReadConstantDeclaration(BinaryReader ctabReader)
{
var ctabStream = ctabReader.BaseStream;
// D3DXSHADER_CONSTANTINFO
int nameOffset = ctabReader.ReadInt32();
RegisterSet registerSet = (RegisterSet)ctabReader.ReadInt16();
short registerIndex = ctabReader.ReadInt16();
short registerCount = ctabReader.ReadInt16();
ctabStream.Position += sizeof(short); // Reserved
int typeInfoOffset = ctabReader.ReadInt32();
int defaultValueOffset = ctabReader.ReadInt32();
System.Diagnostics.Debug.Assert(defaultValueOffset == 0);
ctabStream.Position = nameOffset;
string name = ReadStringNullTerminated(ctabStream);
// D3DXSHADER_TYPEINFO
ctabStream.Position = typeInfoOffset;
ParameterClass cl = (ParameterClass)ctabReader.ReadInt16();
ParameterType type = (ParameterType)ctabReader.ReadInt16();
short rows = ctabReader.ReadInt16();
short columns = ctabReader.ReadInt16();
short numElements = ctabReader.ReadInt16();
short numStructMembers = ctabReader.ReadInt16();
int structMemberInfoOffset = ctabReader.ReadInt32();
//System.Diagnostics.Debug.Assert(numElements == 1);
System.Diagnostics.Debug.Assert(structMemberInfoOffset == 0);
return(new ConstantDeclaration(name, registerSet, registerIndex, registerCount, cl, type, rows, columns));
}
public string[] GetChainData(ParameterClass data)
{
MultiChain chain = new MultiChain();
var verified = chain.VerifyMessage(new MessageData {
address = data.Address, signature = data.Signature, message = data.PhysicianId
}) == "true";
var res = chain.GetStreamKeys(data.Streamname);
var autorisatieStream = this.GetChainName(data.PatientId, data.PhysicianId, authorisation);
var streamitems = chain.GetStreamItemByKey(autorisatieStream, authorisation);
var result = streamitems == null ? new StreamItem[0] : streamitems.streamitems.ToArray();
if (result.Any() && this.DeEncryptHexData(result.Last().data).Split(';').Select(f => data.PhysicianId)
.ToArray().Any())
{
var linkarray = new List <string>();
foreach (var i in res.streamkeys)
{
linkarray.AddRange(chain.GetStreamItemByKey(data.Streamname, i.key).streamitems.Select(f => this.DeEncryptHexData(f.data)).ToArray());
}
var datalist = linkarray.Select(f => File.ReadAllText(f.Split('|')[0])).ToArray();
return(datalist.ToArray());
}
return(null);
}
static IEnumerable Caller(
ParameterClass parameter
)
{
CalleeOfParameterized();
yield return(null);
}
public static Parameter GetParameter(this Element element, string name, ParameterClass set)
{
var parameters = element.
GetParameters(set).
Where(x => x.Definition.Name == name);
return(parameters.FirstOrDefault(x => !x.IsReadOnly) ?? parameters.FirstOrDefault());
}
public void ItShouldRequestAConstructor()
{
constructorResolver.Setup(r => r.GetConstructor(It.IsAny <Type>())).Returns(ParameterClass.GetParameterlessConstructor()).Verifiable();
dependencyResolver.Setup(r => r.Resolve(ParameterClass.GetParameterlessConstructor())).Returns(new object[] { });
var factory = new TransientFactory(typeof(ParameterClass), constructorResolver.Object, dependencyResolver.Object);
factory.Build();
constructorResolver.Verify(r => r.GetConstructor(typeof(ParameterClass)));
}
public override PropertyDescriptorCollection GetProperties(Attribute[] attributes)
{
ParameterClass pc = ClassPointer as ParameterClass;
if (pc != null)
{
return(pc.GetProperties(attributes));
}
return(base.GetProperties(attributes));
}
public virtual PropertyDescriptorCollection GetProperties(Attribute[] attributes)
{
PropertyDescriptorCollection baseProps;
ParameterClass pc = _componentPointer as ParameterClass;
if (pc != null)
{
baseProps = pc.GetProperties(attributes);
}
else
{
baseProps = TypeDescriptor.GetProperties(_componentPointer, attributes, true);
if (ReadOnly)
{
List <PropertyDescriptor> ps = new List <PropertyDescriptor>();
foreach (PropertyDescriptor p in baseProps)
{
List <Attribute> aa = new List <Attribute>();
if (p.Attributes != null)
{
foreach (Attribute a in p.Attributes)
{
if (!(a is EditorAttribute))
{
aa.Add(a);
}
}
}
object v = p.GetValue(_componentPointer);
string s;
if (v == null)
{
s = "";
}
else
{
s = v.ToString();
}
PropertyDescriptorForDisplay r = new PropertyDescriptorForDisplay(_componentPointer.GetType(), p.Name, s, aa.ToArray());
ps.Add(r);
}
baseProps = new PropertyDescriptorCollection(ps.ToArray());
}
}
IList <PropertyDescriptor> lst = OnGetProperties(attributes);
if (lst != null && lst.Count > 0)
{
PropertyDescriptor[] pa = new PropertyDescriptor[baseProps.Count + lst.Count];
baseProps.CopyTo(pa, 0);
lst.CopyTo(pa, baseProps.Count);
baseProps = new PropertyDescriptorCollection(pa);
}
return(baseProps);
}
public static IEnumerable <Parameter> GetParameters(this Element element, ParameterClass set)
{
switch (set)
{
case ParameterClass.Any:
return(Enum.GetValues(typeof(BuiltInParameter)).
Cast <BuiltInParameter>().
Select
(
x =>
{
try { return element.get_Parameter(x); }
catch (Autodesk.Revit.Exceptions.InternalException) { return null; }
}
).
Where(x => x is object).
Union(element.Parameters.Cast <Parameter>().OrderBy(x => x.Id.IntegerValue)).
GroupBy(x => x.Id).
Select(x => x.First()));
case ParameterClass.BuiltIn:
return(Enum.GetValues(typeof(BuiltInParameter)).
Cast <BuiltInParameter>().
GroupBy(x => x).
Select(x => x.First()).
Select
(
x =>
{
try { return element.get_Parameter(x); }
catch (Autodesk.Revit.Exceptions.InternalException) { return null; }
}
).
Where(x => x is object));
case ParameterClass.Project:
return(element.Parameters.Cast <Parameter>().
Where(p => !p.IsShared && p.Id.IntegerValue > 0).
Where(p => (p.Element.Document.GetElement(p.Id) as ParameterElement)?.get_Parameter(BuiltInParameter.ELEM_DELETABLE_IN_FAMILY)?.AsInteger() == 1).
OrderBy(x => x.Id.IntegerValue));
case ParameterClass.Family:
return(element.Parameters.Cast <Parameter>().
Where(p => !p.IsShared && p.Id.IntegerValue > 0).
Where(p => (p.Element.Document.GetElement(p.Id) as ParameterElement)?.get_Parameter(BuiltInParameter.ELEM_DELETABLE_IN_FAMILY)?.AsInteger() == 0).
OrderBy(x => x.Id.IntegerValue));
case ParameterClass.Shared:
return(element.Parameters.Cast <Parameter>().
Where(p => p.IsShared).
OrderBy(x => x.Id.IntegerValue));
}
return(Enumerable.Empty <Parameter>());
}
/// <summary>
/// use name and type to match an event argument to this event parameter
/// </summary>
/// <param name="p">the value representing an event argument</param>
/// <returns></returns>
public bool IsSameParameter(ParameterClass p)
{
if (p.Name == this.MemberName)
{
if (this.ObjectType.Equals(p.ObjectType))
{
return(true);
}
}
return(false);
}
public void ItShouldReturnANewInstance()
{
constructorResolver.Setup(r => r.GetConstructor(It.IsAny <Type>())).Returns(ParameterClass.GetParameterlessConstructor());
dependencyResolver.Setup(r => r.Resolve(ParameterClass.GetParameterlessConstructor())).Returns(new object[] { });
var factory = new TransientFactory(typeof(ParamaterLessClass), constructorResolver.Object, dependencyResolver.Object);
var object1 = factory.Build();
var object2 = factory.Build();
Assert.NotSame(object1, object2);
}
/// <inheritdoc/>
public string ToDelimitedString()
{
System.Globalization.CultureInfo culture = System.Globalization.CultureInfo.CurrentCulture;
string separator = IsSubcomponent ? Configuration.SubcomponentSeparator : Configuration.ComponentSeparator;
return(string.Format(
culture,
StringHelper.StringFormatSequence(0, 2, separator),
ParameterClass?.ToDelimitedString(),
ParameterValue
).TrimEnd(separator.ToCharArray()));
}
public ConstantDeclaration(string name, RegisterSet registerSet, short registerIndex, short registerCount,
ParameterClass parameterClass, ParameterType parameterType, int rows, int columns)
{
Name = name;
RegisterSet = registerSet;
RegisterIndex = registerIndex;
RegisterCount = registerCount;
ParameterClass = parameterClass;
ParameterType = parameterType;
Rows = rows;
Columns = columns;
}
public ConstantDeclaration(string name, RegisterSet registerSet, short registerIndex, short registerCount,
ParameterClass parameterClass, ParameterType parameterType, int rows, int columns, int elements, List <float> defaultValue)
{
Name = name;
RegisterSet = registerSet;
RegisterIndex = registerIndex;
RegisterCount = registerCount;
ParameterClass = parameterClass;
ParameterType = parameterType;
Rows = rows;
Columns = columns;
Elements = elements;
DefaultValue = defaultValue;
}
public ConstantDeclaration(string name, RegisterSet registerSet, short registerIndex, short registerCount,
ParameterClass parameterClass, ParameterType parameterType, int rows, int columns, int elements, List <float> defaultValue)
{
Name = name;
RegisterSet = registerSet;
RegisterIndex = (ushort)registerIndex;
RegisterCount = (ushort)registerCount;
Type = new ConstantType()
{
ParameterClass = parameterClass,
ParameterType = parameterType,
Rows = (uint)rows,
Columns = (uint)columns,
Elements = (uint)elements,
};
DefaultValue = defaultValue;
}
public override Type GetDefaultChildType(int i)
{
if (_methodPointer != null && i >= 0 && i < ChildNodeCount)
{
object vt = _methodPointer.GetParameterTypeByIndex(i);
if (vt != null)
{
Type ptp = null;
ParameterInfo pif = vt as ParameterInfo;
if (pif != null)
{
ptp = pif.ParameterType;
}
else
{
ParameterClass pc = vt as ParameterClass;
if (pc != null)
{
ptp = pc.BaseClassType;
}
else
{
DataTypePointer dt = vt as DataTypePointer;
if (dt != null)
{
ptp = dt.BaseClassType;
}
else
{
IParameter ip = vt as IParameter;
if (ip != null)
{
ptp = ip.ParameterLibType;
}
}
}
}
if (ptp != null)
{
return(ptp);
}
}
}
return(this.DataType.Type);
}
void win_AddOptionClosed(object sender, WindowClosedEventArgs e)
{
RadWindow dlg = (RadWindow)sender;
ParameterClass p = (ParameterClass)dlg.DataContext;
if (p != null)
{
EstimateDetails pag = p.SelectedPAG;
bool?result = dlg.DialogResult;
if (result.HasValue && result.Value)
{
if (p.SelectedItemID != "" || p.SelectedStandardInclusionID != "")
{
//((EstimateViewModel)LayoutRoot.DataContext).SaveSelectedOptionsFromTreeToEstimate(p.SelectedItemID,
// p.SelectedStandardInclusionID,
// EstimateList.SelectedEstimateRevisionId.ToString(),
// p.StudioMQANDA,
// (App.Current as App).CurrentUserId.ToString(),
// p.SelectedDerivedCosts,
// p.SelectedCostExcGSTs,
// p.SelectedQuantities,
// p.SelectedPrices,
// p.SelectedIsAccepteds,
// p.SelectedAreaIds,
// p.SelectedGroupIds,
// p.SelectedPriceDisplayCodeIds,
// p.SelectedIsSiteWorks,
// p.SelectedProductDescriptions,
// p.SelectedAdditionalNotes,
// p.SelectedExtraDescriptions,
// p.SelectedInternalDescriptions);
RadWindow window = this.ParentOfType <RadWindow>();
if (window != null)
{
window.DataContext = p;
window.DialogResult = true;
window.Close();
}
}
}
}
}
private ConstantDeclaration ReadConstantDeclaration(BinaryReader ctabReader)
{
var ctabStream = ctabReader.BaseStream;
// D3DXSHADER_CONSTANTINFO
int nameOffset = ctabReader.ReadInt32();
RegisterSet registerSet = (RegisterSet)ctabReader.ReadInt16();
short registerIndex = ctabReader.ReadInt16();
short registerCount = ctabReader.ReadInt16();
ctabStream.Position += sizeof(short); // Reserved
int typeInfoOffset = ctabReader.ReadInt32();
int defaultValueOffset = ctabReader.ReadInt32();
List <float> defaultValue = new List <float>();;
ctabStream.Position = nameOffset;
string name = ReadStringNullTerminated(ctabStream);
if (defaultValueOffset != 0)
{
//Note: thre are corrisponding def instructions. TODO: check that they are the same
ctabStream.Position = defaultValueOffset;
for (int i = 0; i < 4; i++)
{
defaultValue.Add(ctabReader.ReadSingle());
}
}
// D3DXSHADER_TYPEINFO
ctabStream.Position = typeInfoOffset;
ParameterClass cl = (ParameterClass)ctabReader.ReadInt16();
ParameterType type = (ParameterType)ctabReader.ReadInt16();
short rows = ctabReader.ReadInt16();
short columns = ctabReader.ReadInt16();
short numElements = ctabReader.ReadInt16();
short numStructMembers = ctabReader.ReadInt16();
int structMemberInfoOffset = ctabReader.ReadInt32();
//System.Diagnostics.Debug.Assert(numElements == 1);
System.Diagnostics.Debug.Assert(structMemberInfoOffset == 0);
return(new ConstantDeclaration(name, registerSet, registerIndex, registerCount, cl, type, rows, columns, numElements, defaultValue));
}
void win_AddOptionClosed(object sender, WindowClosedEventArgs e)
{
RadWindow dlg = (RadWindow)sender;
ParameterClass p = (ParameterClass)dlg.DataContext;
if (p != null)
{
EstimateDetails pag = p.SelectedPAG;
bool?result = dlg.DialogResult;
if (result.HasValue && result.Value)
{
if (p.SelectedItemID != "" || p.SelectedStandardInclusionID != "")
{
SaveData(p, p.Action);
}
}
}
}
public void CreateSqlCommandWithClass()
{
string sql = "select * from Test";
var date = new DateTime(1995, 5, 4);
var parameter = new ParameterClass
{
Id = 1,
Amount = 2.2d,
Name = "Kubing",
Date = date
};
var command = SqlCommandUtil.CreateCommand(sql, parameter);
Assert.AreEqual(sql, command.CommandText);
Assert.AreEqual(1, int.Parse(command.Parameters["@Id"].Value.ToString()));
Assert.AreEqual(2.2d, double.Parse(command.Parameters["@Amount"].Value.ToString()), .01);
Assert.AreEqual("Kubing", command.Parameters["@Name"].Value);
Assert.AreEqual(date, DateTime.Parse(command.Parameters["@Date"].Value.ToString()));
}
public string[] SetChainData(ParameterClass data)
{
MultiChain chain = new MultiChain();
var verified = chain.VerifyMessage(new MessageData {
address = data.Address, signature = data.Signature, message = data.PhysicianId
}) == "true";
var datalocation = this.CreateFileBackup(data.DataToStore);
chain.PublishMessage(new PublishMessageData
{
Key = "entry",
HexString = this.EncryptHexData(datalocation + "|" +
("NogGeenKey").Replace("-", string.Empty)
.Replace(" ", string.Empty)),
StreamName = data.Streamname
});
return(null);
}
public SetterClass(PropertyClass property)
: base((ClassPointer)(property.Owner))
{
_property = property;
ReturnValue = new ParameterClass(new TypePointer(typeof(void)), this);
PropertyOverride po = property as PropertyOverride;
bool hasBaseVersion = (po != null && po.HasBaseImplementation);
//
List <ParameterClass> pl = new List <ParameterClass>();
PropertyValueClass p = new PropertyValueClass(this);
p.SetDataType(_property.PropertyType);
pl.Add(p);
//
if (hasBaseVersion)
{
ParameterClassBaseProperty pc = new ParameterClassBaseProperty(this);
pl.Add(pc);
}
this.Parameters = pl;
}
public List <ParameterClass> GetParameters(IMethod method)
{
List <ParameterClass> pcList = new List <ParameterClass>();
ParameterInfo[] ps = Parameters;
if (ps != null && ps.Length > 0)
{
IWithProject p = null;
if (Owner != null)
{
p = Owner.RootPointer;
}
for (int i = 0; i < ps.Length; i++)
{
ParameterClass pc;
pc = new ParameterClass(ps[i].ParameterType, ps[i].Name, p, method);
pcList.Add(pc);
}
}
return(pcList);
}
public ParameterValue CreateDefaultParameterValue(int i)
{
IParameter p = MethodParameterTypes[i];
ParameterValue pv = new ParameterValue(_action);
pv.Name = p.Name;
pv.ParameterID = p.ParameterID;
ParameterClass pc = p as ParameterClass;
if (pc != null)
{
pv.SetDataType(pc);
}
else
{
pv.SetDataType(p.ParameterLibType);
}
pv.SetOwnerAction(_action);
pv.ValueType = EnumValueType.ConstantValue;
return(pv);
}
public string GetChildNameByIndex(int idx)
{
if (_methodPointer != null && idx >= 0 && idx < ChildNodeCount)
{
object vt = _methodPointer.GetParameterTypeByIndex(idx);
if (vt != null)
{
ParameterInfo pif = vt as ParameterInfo;
if (pif != null)
{
return(pif.Name);
}
else
{
ParameterClass pc = vt as ParameterClass;
if (pc != null)
{
return(pc.Name);
}
else
{
NamedDataType dt = vt as NamedDataType;
if (dt != null)
{
return(dt.Name);
}
else
{
IParameter ip = vt as IParameter;
if (ip != null)
{
return(ip.Name);
}
}
}
}
}
}
return(string.Empty);
}
public static extern IntPtr cgGetParameterClassString(ParameterClass pc);
public static string GetParameterClassString(ParameterClass pc)
{
return Marshal.PtrToStringAnsi(NativeMethods.cgGetParameterClassString(pc));
}
