public void ShouldEqualSimilarUuidObject()
{
var uuid = new Uuid(1, 2);
object other = new Uuid(1, 2);
Assert.IsTrue(uuid.Equals(other));
}
public void ShouldNotEqualOtherUuidObject()
{
var uuid = new Uuid(1, 2);
object other = new Uuid(3, 4);
Assert.IsFalse(uuid.Equals(other));
}
public void TestConstructor()
{
var uuid = new Uuid(1, 2);
Assert.AreEqual(1, uuid.MostSignificantBits);
Assert.AreEqual(2, uuid.LeastSignificantBits);
}
public void TestConstruct1()
{
var uuid = new Uuid("f81d4fae-7dec-11d0-a765-00a0c91e6bf6");
Assert.AreEqual(0xf81d4fae, uuid.TimeLow);
Assert.AreEqual(0x7dec, uuid.TimeMid);
Assert.AreEqual(0x11d0, uuid.TimeHighAndVersion);
Assert.AreEqual(0xa7, uuid.ClockSeqHighAndReserved);
Assert.AreEqual(0x65, uuid.ClockSeqLow);
Assert.AreEqual(new byte[] {0x00, 0xa0, 0xc9, 0x1e, 0x6b, 0xf6}, uuid.Node);
Assert.AreEqual(UuidVersion.Version1, uuid.Version);
Assert.AreEqual(Uuid.Variant.RFC4122, uuid.VariantField);
Assert.AreEqual((new DateTime(1997, 2, 3, 17, 43, 12, 216, DateTimeKind.Utc)).AddTicks(8750), uuid.Timestamp);
Assert.AreEqual(10085, uuid.Clock);
Assert.AreEqual("00:a0:c9:1e:6b:f6", uuid.IEEE802MacAddress);
}
public void TestConstruct2()
{
var uuid = new Uuid("01c47915-4777-11d8-bc70-0090272ff725");
Assert.AreEqual(0x01c47915, uuid.TimeLow);
Assert.AreEqual(0x4777, uuid.TimeMid);
Assert.AreEqual(0x11d8, uuid.TimeHighAndVersion);
Assert.AreEqual(0xbc, uuid.ClockSeqHighAndReserved);
Assert.AreEqual(0x70, uuid.ClockSeqLow);
Assert.AreEqual(new byte[] {0x00, 0x90, 0x27, 0x2f, 0xf7, 0x25}, uuid.Node);
Assert.AreEqual(UuidVersion.Version1, uuid.Version);
Assert.AreEqual(Uuid.Variant.RFC4122, uuid.VariantField);
Assert.AreEqual((new DateTime(2004, 1, 15, 16, 22, 26, 376, DateTimeKind.Utc)).AddTicks(3221), uuid.Timestamp);
Assert.AreEqual(15472, uuid.Clock);
Assert.AreEqual("00:90:27:2f:f7:25", uuid.IEEE802MacAddress);
Assert.AreEqual(PhysicalAddress.Parse("00-90-27-2F-F7-25"), uuid.PhysicalAddress);
}
public Type128BitUUIDs( int type, byte[] data, int pos, int len) {
this.Type = type;
int items = len / 16;
Uuids = new Uuid[items];
int ptr = pos;
for( int i = 0 ; i < items ; ++i ) {
long vl = ((long)data[ptr]) & 0xFF;
ptr++;
vl |= (((long)data[ptr]) & 0xFF ) << 8;
ptr++;
vl |= (((long)data[ptr]) & 0xFF ) << 16;
ptr++;
vl |= (((long)data[ptr]) & 0xFF ) << 24;
ptr++;
vl |= (((long)data[ptr]) & 0xFF ) << 32;
ptr++;
vl |= (((long)data[ptr]) & 0xFF ) << 40;
ptr++;
vl |= (((long)data[ptr]) & 0xFF ) << 48;
ptr++;
vl |= (((long)data[ptr]) & 0xFF ) << 56;
ptr++;
long vh = ((long)data[ptr]) & 0xFF;
ptr++;
vh |= (((long)data[ptr]) & 0xFF ) << 8;
ptr++;
vh |= (((long)data[ptr]) & 0xFF ) << 16;
ptr++;
vh |= (((long)data[ptr]) & 0xFF ) << 24;
ptr++;
vh |= (((long)data[ptr]) & 0xFF ) << 32;
ptr++;
vh |= (((long)data[ptr]) & 0xFF ) << 40;
ptr++;
vh |= (((long)data[ptr]) & 0xFF ) << 48;
ptr++;
vh |= (((long)data[ptr]) & 0xFF ) << 56;
ptr++;
Uuids[i] = new Uuid(vh,vl);
}
}
public single_batch()
{
_correlationId = Uuid.NewUuid();
}
private void _read()
{
_type = ((BtrfsStream.Attribute)m_io.ReadU2le());
_length = m_io.ReadU2le();
switch (Type)
{
case BtrfsStream.Attribute.Ctransid: {
_value = m_io.ReadU8le();
break;
}
case BtrfsStream.Attribute.Size: {
_value = m_io.ReadU8le();
break;
}
case BtrfsStream.Attribute.CloneUuid: {
__raw_value = m_io.ReadBytes(Length);
var io___raw_value = new KaitaiStream(__raw_value);
_value = new Uuid(io___raw_value, this, m_root);
break;
}
case BtrfsStream.Attribute.FileOffset: {
_value = m_io.ReadU8le();
break;
}
case BtrfsStream.Attribute.Otime: {
__raw_value = m_io.ReadBytes(Length);
var io___raw_value = new KaitaiStream(__raw_value);
_value = new Timespec(io___raw_value, this, m_root);
break;
}
case BtrfsStream.Attribute.Uid: {
_value = m_io.ReadU8le();
break;
}
case BtrfsStream.Attribute.Atime: {
__raw_value = m_io.ReadBytes(Length);
var io___raw_value = new KaitaiStream(__raw_value);
_value = new Timespec(io___raw_value, this, m_root);
break;
}
case BtrfsStream.Attribute.Ctime: {
__raw_value = m_io.ReadBytes(Length);
var io___raw_value = new KaitaiStream(__raw_value);
_value = new Timespec(io___raw_value, this, m_root);
break;
}
case BtrfsStream.Attribute.Uuid: {
__raw_value = m_io.ReadBytes(Length);
var io___raw_value = new KaitaiStream(__raw_value);
_value = new Uuid(io___raw_value, this, m_root);
break;
}
case BtrfsStream.Attribute.CloneLen: {
_value = m_io.ReadU8le();
break;
}
case BtrfsStream.Attribute.XattrName: {
__raw_value = m_io.ReadBytes(Length);
var io___raw_value = new KaitaiStream(__raw_value);
_value = new String(io___raw_value, this, m_root);
break;
}
case BtrfsStream.Attribute.CloneCtransid: {
_value = m_io.ReadU8le();
break;
}
case BtrfsStream.Attribute.Mode: {
_value = m_io.ReadU8le();
break;
}
case BtrfsStream.Attribute.Mtime: {
__raw_value = m_io.ReadBytes(Length);
var io___raw_value = new KaitaiStream(__raw_value);
_value = new Timespec(io___raw_value, this, m_root);
break;
}
case BtrfsStream.Attribute.PathLink: {
__raw_value = m_io.ReadBytes(Length);
var io___raw_value = new KaitaiStream(__raw_value);
_value = new String(io___raw_value, this, m_root);
break;
}
case BtrfsStream.Attribute.Rdev: {
_value = m_io.ReadU8le();
break;
}
case BtrfsStream.Attribute.PathTo: {
__raw_value = m_io.ReadBytes(Length);
var io___raw_value = new KaitaiStream(__raw_value);
_value = new String(io___raw_value, this, m_root);
break;
}
case BtrfsStream.Attribute.Path: {
__raw_value = m_io.ReadBytes(Length);
var io___raw_value = new KaitaiStream(__raw_value);
_value = new String(io___raw_value, this, m_root);
break;
}
case BtrfsStream.Attribute.CloneOffset: {
_value = m_io.ReadU8le();
break;
}
case BtrfsStream.Attribute.Gid: {
_value = m_io.ReadU8le();
break;
}
case BtrfsStream.Attribute.ClonePath: {
__raw_value = m_io.ReadBytes(Length);
var io___raw_value = new KaitaiStream(__raw_value);
_value = new String(io___raw_value, this, m_root);
break;
}
default: {
_value = m_io.ReadBytes(Length);
break;
}
}
}
protected DomainEvent(string aggregateId, string eventId, string occurredOn)
{
AggregateId = aggregateId;
EventId = eventId ?? Uuid.Random().Value;
OccurredOn = occurredOn ?? Utils.DateToString(DateTime.Now);
}
private async Task <AcknowledgeMessageExt> ReconnectInvokeAckAsync(string pageUrl, string swfUrl, string tcUrl)
{
InvokeAmf0 invokeAmf0_1 = new InvokeAmf0();
InvokeAmf0 invokeAmf0_2 = invokeAmf0_1;
string methodName = "connect";
object[] parameters = new object[4] {
(object)false, (object)this.ClientId, (object)this._reconnectData, null
};
int index = 3;
CommandMessage commandMessage = new CommandMessage();
commandMessage.Operation = CommandOperation.Login;
string str1 = "";
commandMessage.CorrelationId = str1;
string str2 = Uuid.NewUuid();
commandMessage.MessageId = str2;
string str3 = "";
commandMessage.Destination = str3;
string reconnectData = this._reconnectData;
commandMessage.Body = (object)reconnectData;
commandMessage.Headers = new AsObject()
{
{
"DSMessagingVersion",
(object)1.0
},
{
"DSId",
(object)"my-rtmps"
}
};
parameters[index] = (object)commandMessage;
int num1 = 1;
int num2 = 0;
Method method = new Method(methodName, parameters, num1 != 0, (CallStatus)num2);
invokeAmf0_2.MethodCall = method;
invokeAmf0_1.ConnectionParameters = (object)new AsObject()
{
{
"pageUrl",
(object)pageUrl
},
{
"objectEncoding",
(object)(double)this._objectEncoding
},
{
"capabilities",
(object)239.0
},
{
"audioCodecs",
(object)3575.0
},
{
"flashVer",
(object)"WIN 11,7,700,169"
},
{
"swfUrl",
(object)swfUrl
},
{
"videoFunction",
(object)1.0
},
{
"fpad",
(object)false
},
{
"videoCodecs",
(object)252.0
},
{
"tcUrl",
(object)tcUrl
},
{
"app",
(object)""
}
};
invokeAmf0_1.InvokeId = this.GetNextInvokeId();
return(await this.QueueCommandAsTask((Command)invokeAmf0_1, 3, 0, false));
}
public Uuid uuid_NewMySqlOptimized()
{
return(Uuid.NewMySqlOptimized());
}
/// <summary>
/// 初始化
/// </summary>
public override void Init()
{
this.Id = Uuid.Next();
base.Init();
}
public void ShouldNotEqualNull()
{
var uuid = new Uuid(1, 2);
Assert.IsFalse(uuid.Equals(null));
}
public void ToStringShouldReturnCorrectString()
{
var uuid = new Uuid(-1714729031470661412L, -8577612382363445748L);
Assert.AreEqual("e8340f07-e924-40dc-88f6-32fc003c160c", uuid.ToString());
}
public void ConvertToGuidShouldReturnCorrectGuid()
{
var uuid = new Uuid(-1714729031470661412L, -8577612382363445748L);
Assert.AreEqual(new Guid("e8340f07-e924-40dc-88f6-32fc003c160c"), (Guid)uuid);
}
public void OperationOverloadUnequal_ShouldNotUnequalSimilarUuid()
{
var uuid = new Uuid(1, 2);
Assert.IsFalse(uuid != new Uuid(1, 2));
}
/// <summary>
/// Initializes the basic properties for adding a gatt characteristic
/// notification trigger
/// </summary>
private void ToastInit()
{
_toastName = string.Format("{0}{1}{2}", TOAST_STRING_PREFIX,
_characteristic.Service.Device.DeviceId.GetHashCode(), Uuid.GetHashCode());
Toastable = (_characteristic.CharacteristicProperties & GattCharacteristicProperties.Notify) != 0;
ToastRegistered = ApplicationData.Current.LocalSettings.Values.ContainsKey(_toastName);
ToastButtonActive = true;
if (ToastRegistered)
{
// We need to add ourselves to the list of active toasts
GlobalSettings.AddToast(this);
}
}
/// <summary>
/// Creates instance transform substorages in the output.
/// </summary>
/// <param name="output">Output containing instance transform definitions.</param>
private void CreateInstanceTransforms(Output output)
{
// Create and add substorages for instance transforms.
Table wixInstanceTransformsTable = output.Tables["WixInstanceTransforms"];
if (null != wixInstanceTransformsTable && 0 <= wixInstanceTransformsTable.Rows.Count)
{
string targetProductCode = null;
string targetUpgradeCode = null;
string targetProductVersion = null;
Table targetSummaryInformationTable = output.Tables["_SummaryInformation"];
Table targetPropertyTable = output.Tables["Property"];
// Get the data from target database
foreach (Row propertyRow in targetPropertyTable.Rows)
{
if ("ProductCode" == (string)propertyRow[0])
{
targetProductCode = (string)propertyRow[1];
}
else if ("ProductVersion" == (string)propertyRow[0])
{
targetProductVersion = (string)propertyRow[1];
}
else if ("UpgradeCode" == (string)propertyRow[0])
{
targetUpgradeCode = (string)propertyRow[1];
}
}
// Index the Instance Component Rows.
Dictionary <string, ComponentRow> instanceComponentGuids = new Dictionary <string, ComponentRow>();
Table targetInstanceComponentTable = output.Tables["WixInstanceComponent"];
if (null != targetInstanceComponentTable && 0 < targetInstanceComponentTable.Rows.Count)
{
foreach (Row row in targetInstanceComponentTable.Rows)
{
// Build up all the instances, we'll get the Components rows from the real Component table.
instanceComponentGuids.Add((string)row[0], null);
}
Table targetComponentTable = output.Tables["Component"];
foreach (ComponentRow componentRow in targetComponentTable.Rows)
{
string component = (string)componentRow[0];
if (instanceComponentGuids.ContainsKey(component))
{
instanceComponentGuids[component] = componentRow;
}
}
}
// Generate the instance transforms
foreach (Row instanceRow in wixInstanceTransformsTable.Rows)
{
string instanceId = (string)instanceRow[0];
Output instanceTransform = new Output(instanceRow.SourceLineNumbers);
instanceTransform.Type = OutputType.Transform;
instanceTransform.Codepage = output.Codepage;
Table instanceSummaryInformationTable = instanceTransform.EnsureTable(this.TableDefinitions["_SummaryInformation"]);
string targetPlatformAndLanguage = null;
foreach (Row summaryInformationRow in targetSummaryInformationTable.Rows)
{
if (7 == (int)summaryInformationRow[0]) // PID_TEMPLATE
{
targetPlatformAndLanguage = (string)summaryInformationRow[1];
}
// Copy the row's data to the transform.
Row copyOfSummaryRow = instanceSummaryInformationTable.CreateRow(null);
copyOfSummaryRow[0] = summaryInformationRow[0];
copyOfSummaryRow[1] = summaryInformationRow[1];
}
// Modify the appropriate properties.
Table propertyTable = instanceTransform.EnsureTable(this.TableDefinitions["Property"]);
// Change the ProductCode property
string productCode = (string)instanceRow[2];
if ("*" == productCode)
{
productCode = Common.GenerateGuid();
}
Row productCodeRow = propertyTable.CreateRow(instanceRow.SourceLineNumbers);
productCodeRow.Operation = RowOperation.Modify;
productCodeRow.Fields[1].Modified = true;
productCodeRow[0] = "ProductCode";
productCodeRow[1] = productCode;
// Change the instance property
Row instanceIdRow = propertyTable.CreateRow(instanceRow.SourceLineNumbers);
instanceIdRow.Operation = RowOperation.Modify;
instanceIdRow.Fields[1].Modified = true;
instanceIdRow[0] = (string)instanceRow[1];
instanceIdRow[1] = instanceId;
if (null != instanceRow[3])
{
// Change the ProductName property
Row productNameRow = propertyTable.CreateRow(instanceRow.SourceLineNumbers);
productNameRow.Operation = RowOperation.Modify;
productNameRow.Fields[1].Modified = true;
productNameRow[0] = "ProductName";
productNameRow[1] = (string)instanceRow[3];
}
if (null != instanceRow[4])
{
// Change the UpgradeCode property
Row upgradeCodeRow = propertyTable.CreateRow(instanceRow.SourceLineNumbers);
upgradeCodeRow.Operation = RowOperation.Modify;
upgradeCodeRow.Fields[1].Modified = true;
upgradeCodeRow[0] = "UpgradeCode";
upgradeCodeRow[1] = instanceRow[4];
// Change the Upgrade table
Table targetUpgradeTable = output.Tables["Upgrade"];
if (null != targetUpgradeTable && 0 <= targetUpgradeTable.Rows.Count)
{
string upgradeId = (string)instanceRow[4];
Table upgradeTable = instanceTransform.EnsureTable(this.TableDefinitions["Upgrade"]);
foreach (Row row in targetUpgradeTable.Rows)
{
// In case they are upgrading other codes to this new product, leave the ones that don't match the
// Product.UpgradeCode intact.
if (targetUpgradeCode == (string)row[0])
{
Row upgradeRow = upgradeTable.CreateRow(null);
upgradeRow.Operation = RowOperation.Add;
upgradeRow.Fields[0].Modified = true;
// I was hoping to be able to RowOperation.Modify, but that didn't appear to function.
// upgradeRow.Fields[0].PreviousData = (string)row[0];
// Inserting a new Upgrade record with the updated UpgradeCode
upgradeRow[0] = upgradeId;
upgradeRow[1] = row[1];
upgradeRow[2] = row[2];
upgradeRow[3] = row[3];
upgradeRow[4] = row[4];
upgradeRow[5] = row[5];
upgradeRow[6] = row[6];
// Delete the old row
Row upgradeRemoveRow = upgradeTable.CreateRow(null);
upgradeRemoveRow.Operation = RowOperation.Delete;
upgradeRemoveRow[0] = row[0];
upgradeRemoveRow[1] = row[1];
upgradeRemoveRow[2] = row[2];
upgradeRemoveRow[3] = row[3];
upgradeRemoveRow[4] = row[4];
upgradeRemoveRow[5] = row[5];
upgradeRemoveRow[6] = row[6];
}
}
}
}
// If there are instance Components generate new GUIDs for them.
if (0 < instanceComponentGuids.Count)
{
Table componentTable = instanceTransform.EnsureTable(this.TableDefinitions["Component"]);
foreach (ComponentRow targetComponentRow in instanceComponentGuids.Values)
{
string guid = targetComponentRow.Guid;
if (!String.IsNullOrEmpty(guid))
{
Row instanceComponentRow = componentTable.CreateRow(targetComponentRow.SourceLineNumbers);
instanceComponentRow.Operation = RowOperation.Modify;
instanceComponentRow.Fields[1].Modified = true;
instanceComponentRow[0] = targetComponentRow[0];
instanceComponentRow[1] = Uuid.NewUuid(BindDatabaseCommand.WixComponentGuidNamespace, String.Concat(guid, instanceId)).ToString("B").ToUpper(CultureInfo.InvariantCulture);
instanceComponentRow[2] = targetComponentRow[2];
instanceComponentRow[3] = targetComponentRow[3];
instanceComponentRow[4] = targetComponentRow[4];
instanceComponentRow[5] = targetComponentRow[5];
}
}
}
// Update the summary information
Hashtable summaryRows = new Hashtable(instanceSummaryInformationTable.Rows.Count);
foreach (Row row in instanceSummaryInformationTable.Rows)
{
summaryRows[row[0]] = row;
if ((int)SummaryInformation.Transform.UpdatedPlatformAndLanguage == (int)row[0])
{
row[1] = targetPlatformAndLanguage;
}
else if ((int)SummaryInformation.Transform.ProductCodes == (int)row[0])
{
row[1] = String.Concat(targetProductCode, targetProductVersion, ';', productCode, targetProductVersion, ';', targetUpgradeCode);
}
else if ((int)SummaryInformation.Transform.ValidationFlags == (int)row[0])
{
row[1] = 0;
}
else if ((int)SummaryInformation.Transform.Security == (int)row[0])
{
row[1] = "4";
}
}
if (!summaryRows.Contains((int)SummaryInformation.Transform.UpdatedPlatformAndLanguage))
{
Row summaryRow = instanceSummaryInformationTable.CreateRow(null);
summaryRow[0] = (int)SummaryInformation.Transform.UpdatedPlatformAndLanguage;
summaryRow[1] = targetPlatformAndLanguage;
}
else if (!summaryRows.Contains((int)SummaryInformation.Transform.ValidationFlags))
{
Row summaryRow = instanceSummaryInformationTable.CreateRow(null);
summaryRow[0] = (int)SummaryInformation.Transform.ValidationFlags;
summaryRow[1] = "0";
}
else if (!summaryRows.Contains((int)SummaryInformation.Transform.Security))
{
Row summaryRow = instanceSummaryInformationTable.CreateRow(null);
summaryRow[0] = (int)SummaryInformation.Transform.Security;
summaryRow[1] = "4";
}
output.SubStorages.Add(new SubStorage(instanceId, instanceTransform));
}
}
}
public void ShouldNotEqualOtherType()
{
var uuid = new Uuid(1, 2);
Assert.IsFalse(uuid.Equals(new object()));
}
public override int GetHashCode()
{
return(Uuid?.GetHashCode() ?? 0);
}
private ServiceResult OnUserScalarValue2(
ISystemContext context,
MethodState method,
NodeId objectId,
DateTime dateTimeIn,
Uuid guidIn,
byte[] byteStringIn,
XmlElement xmlElementIn,
NodeId nodeIdIn,
ExpandedNodeId expandedNodeIdIn,
QualifiedName qualifiedNameIn,
LocalizedText localizedTextIn,
StatusCode statusCodeIn,
object variantIn,
ref DateTime dateTimeOut,
ref Uuid guidOut,
ref byte[] byteStringOut,
ref XmlElement xmlElementOut,
ref NodeId nodeIdOut,
ref ExpandedNodeId expandedNodeIdOut,
ref QualifiedName qualifiedNameOut,
ref LocalizedText localizedTextOut,
ref StatusCode statusCodeOut,
ref object variantOut)
{
dateTimeOut = dateTimeIn;
guidOut = guidIn;
byteStringOut = byteStringIn;
xmlElementOut = xmlElementIn;
nodeIdOut = nodeIdIn;
expandedNodeIdOut = expandedNodeIdIn;
qualifiedNameOut = qualifiedNameIn;
localizedTextOut = localizedTextIn;
statusCodeOut = statusCodeIn;
variantOut = variantIn;
return ServiceResult.Good;
}
/// <summary>
/// Send message.
/// </summary>
/// <param name="message">Message.</param>
protected override void OnSendInMessage(Message message)
{
switch (message.Type)
{
case MessageTypes.Reset:
{
_subscriptions.Clear();
if (_client != null)
{
try
{
DisposeClient();
}
catch (Exception ex)
{
SendOutError(ex);
}
_client = null;
}
SendOutMessage(new ResetMessage());
break;
}
case MessageTypes.Connect:
{
if (_client != null)
{
throw new InvalidOperationException(LocalizedStrings.Str1619);
}
_subscriptions.Clear();
switch (Remoting)
{
case OpenECryRemoting.None:
case OpenECryRemoting.Primary:
_client = new OECClient(new InPlaceThreadPolicy())
{
UUID = Uuid.To <string>(),
EventBatchInterval = 0,
RemoteHostingEnabled = Remoting == OpenECryRemoting.Primary,
//PriceHost = "",
//AutoSubscribe = false
};
break;
case OpenECryRemoting.Secondary:
_client = OECClient.CreateInstance(true);
break;
default:
throw new ArgumentOutOfRangeException();
}
if (EnableOECLogging)
{
if (Remoting == OpenECryRemoting.Secondary)
{
this.AddWarningLog(LocalizedStrings.Str2552);
}
else
{
OEC.Log.ConsoleOutput = false;
_client.SetLoggingConfig(new LoggingConfiguration {
Level = OEC.API.LogLevel.All
});
OEC.Log.Initialize(new OECLogger(this));
OEC.Log.Start();
}
}
_client.OnLoginComplete += SessionOnLoginComplete;
_client.OnLoginFailed += SessionOnLoginFailed;
_client.OnDisconnected += SessionOnDisconnected;
_client.OnBeginEvents += SessionOnBeginEvents;
_client.OnEndEvents += SessionOnEndEvents;
_client.OnError += SessionOnError;
_client.OnAccountRiskLimitChanged += SessionOnAccountRiskLimitChanged;
_client.OnAccountSummaryChanged += SessionOnAccountSummaryChanged;
_client.OnAllocationBlocksChanged += SessionOnAllocationBlocksChanged;
_client.OnAvgPositionChanged += SessionOnAvgPositionChanged;
_client.OnBalanceChanged += SessionOnBalanceChanged;
_client.OnCommandUpdated += SessionOnCommandUpdated;
_client.OnCompoundPositionGroupChanged += SessionOnCompoundPositionGroupChanged;
_client.OnOrderConfirmed += SessionOnOrderConfirmed;
_client.OnOrderFilled += SessionOnOrderFilled;
_client.OnOrderStateChanged += SessionOnOrderStateChanged;
_client.OnDetailedPositionChanged += SessionOnDetailedPositionChanged;
_client.OnMarginCalculationCompleted += SessionOnMarginCalculationCompleted;
_client.OnPortfolioMarginChanged += SessionOnPortfolioMarginChanged;
_client.OnPostAllocation += SessionOnPostAllocation;
_client.OnRiskLimitDetailsReceived += SessionOnRiskLimitDetailsReceived;
_client.OnBarsReceived += SessionOnBarsReceived;
_client.OnContinuousContractRuleChanged += SessionOnContinuousContractRuleChanged;
_client.OnContractChanged += SessionOnContractChanged;
_client.OnContractCreated += SessionOnContractCreated;
_client.OnContractRiskLimitChanged += SessionOnContractRiskLimitChanged;
_client.OnContractsChanged += SessionOnContractsChanged;
_client.OnCurrencyPriceChanged += SessionOnCurrencyPriceChanged;
_client.OnDOMChanged += SessionOnDomChanged;
_client.OnDealQuoteUpdated += SessionOnDealQuoteUpdated;
_client.OnHistogramReceived += SessionOnHistogramReceived;
_client.OnHistoryReceived += SessionOnHistoryReceived;
_client.OnIndexComponentsReceived += SessionOnIndexComponentsReceived;
_client.OnLoggedUserClientsChanged += SessionOnLoggedUserClientsChanged;
_client.OnNewsMessage += SessionOnNewsMessage;
_client.OnOsmAlgoListLoaded += SessionOnOsmAlgoListLoaded;
_client.OnOsmAlgoListUpdated += SessionOnOsmAlgoListUpdated;
_client.OnPitGroupsChanged += SessionOnPitGroupsChanged;
_client.OnPriceChanged += SessionOnPriceChanged;
_client.OnPriceTick += SessionOnPriceTick;
_client.OnProductCalendarUpdated += SessionOnProductCalendarUpdated;
_client.OnQuoteDetailsChanged += SessionOnQuoteDetailsChanged;
_client.OnRelationsChanged += SessionOnRelationsChanged;
_client.OnSymbolLookupReceived += SessionOnSymbolLookupReceived;
_client.OnTicksReceived += SessionOnTicksReceived;
_client.OnTradersChanged += SessionOnTradersChanged;
_client.OnUserMessage += SessionOnUserMessage;
_client.OnUserStatusChanged += SessionOnUserStatusChanged;
_client.Connect(Address.GetHost(), Address.GetPort(), Login, Password.To <string>(), UseNativeReconnect);
break;
}
case MessageTypes.Disconnect:
{
if (_client == null)
{
throw new InvalidOperationException(LocalizedStrings.Str1856);
}
DisposeClient();
_client.Disconnect();
break;
}
case MessageTypes.SecurityLookup:
{
ProcessSecurityLookup((SecurityLookupMessage)message);
break;
}
case MessageTypes.OrderRegister:
{
ProcessOrderRegister((OrderRegisterMessage)message);
break;
}
case MessageTypes.OrderCancel:
{
ProcessOrderCancel((OrderCancelMessage)message);
break;
}
case MessageTypes.OrderReplace:
{
ProcessOrderReplace((OrderReplaceMessage)message);
break;
}
case MessageTypes.PortfolioLookup:
{
ProcessPortfolioLookupMessage((PortfolioLookupMessage)message);
break;
}
case MessageTypes.OrderStatus:
{
ProcessOrderStatusMessage();
break;
}
case MessageTypes.MarketData:
{
ProcessMarketDataMessage((MarketDataMessage)message);
break;
}
case MessageTypes.News:
{
var newsMsg = (Messages.NewsMessage)message;
_client.SendMessage(_client.Users[newsMsg.Source], newsMsg.Headline);
break;
}
}
}
public async Task <(bool CanAcknowledge, Bundle?Bundle)> CanAcknowledgeAsync(ActorId recipient, Uuid bundleId)
{
var bundle = await _bundleRepository.GetNextUnacknowledgedAsync(recipient).ConfigureAwait(false);
return(bundle != null && bundle.BundleId == bundleId
? (true, bundle)
: (false, null));
}
/// <summary>
/// Sets the UUID in payload.
/// </summary>
/// <param name="payloadIndex">The payload index.</param>
/// <param name="uuid">The UUID.</param>
protected void SetUuidInPayload(int payloadIndex, Uuid uuid)
{
SetUnsignedShortInPayload(payloadIndex, (ushort)uuid);
}
public void ShouldEqualSimilarUuid()
{
var uuid = new Uuid(1, 2);
Assert.IsTrue(uuid.Equals(new Uuid(1, 2)));
}
/// <summary>
/// Reads a GUID from the stream.
/// </summary>
public Uuid ReadGuid(string fieldName)
{
Uuid value = new Uuid();
if (BeginField(fieldName, true))
{
PushNamespace(Namespaces.OpcUaXsd);
value.GuidString = ReadString("String");
PopNamespace();
EndField(fieldName);
}
return value;
}
public void ShouldNotEqualOtherUuid()
{
var uuid = new Uuid(1, 2);
Assert.IsFalse(uuid.Equals(new Uuid(3, 4)));
}
public override int GetHashCode()
{
return(Uuid.GetHashCode());
}
public void OperationOverloadEqual_ShouldEqualSimilarUuid()
{
var uuid = new Uuid(1, 2);
Assert.IsTrue(uuid == new Uuid(1, 2));
}
public Nide8TokenAuthenticator(string nide8ID, string token, Uuid selectedProfileUUID, UserData userData) : base(token, selectedProfileUUID, userData)
{
Nide8ID = nide8ID;
ProxyAuthServerAddress = string.Format("https://auth2.nide8.com:233/{0}/authserver", Nide8ID);
}
public void OperationOverloadEqual_ShouldNotEqualOtherUuid()
{
var uuid = new Uuid(1, 2);
Assert.IsFalse(uuid == new Uuid(3, 4));
}
/// <summary>
/// Downloads a file from a URL
/// </summary>
/// <param name="url">The URL to download from</param>
/// <returns>True if it was successful, false if not</returns>
private async Task <bool> DownloadUrl(string url)
{
//Get the info
DownloadInfo info = await Downloader.GetDownloadInfoFromUrl(url);
//Validate
if (info == null)
{
return(false);
}
if (info.VideoCodec == null && info.AudioCodec == null)
{
return(false);
}
if (info.RequestedUrls == null && info.Url == null)
{
return(false);
}
//Create a new file object
string httpVideoUrl = "";
string httpAudioUrl = "";
int uuid = Uuid.GetUuid();
if (!string.IsNullOrEmpty(info.VideoCodec) && info.VideoCodec != "none")
{
httpVideoUrl = "http://" + MediaserverIp + ":" + MediaserverPort + "/download/" + uuid + "." + info.Extension;
}
else
{
httpAudioUrl = "http://" + MediaserverIp + ":" + MediaserverPort + "/download/" + uuid + "." + info.Extension;
}
PlayableFile newFile = new PlayableFile(httpVideoUrl, httpAudioUrl, info.Title, null, new SubtitleInfo[0], info.Duration, false, FileType.Downloaded);
//Add it to the list of files
Files.Add(newFile);
//Send available files updated message
WebServer.SendRawData("AvailableFilesUpdated", new byte[0]);
//Download the file to the temporary folder
bool isSuccess = await Downloader.DownloadFileFromUrl(url, DownloadFilesPath + "\\incomplete\\" + uuid + "." + info.Extension);
//If it was a success, change the availability to true, and add to the http server
if (isSuccess)
{
File.Move(DownloadFilesPath + "\\incomplete\\" + uuid + "." + info.Extension, DownloadFilesPath + "\\" + uuid + "." + info.Extension);
//SetHttpServerFiles();
}
//If it wasn't a success, remove it from the list of files
else
{
Files.Remove(newFile);
newFile.IsAvailable = true;
WebServer.SendRawData("AvailableFilesUpdated", new byte[0]);
}
//Send available files updated message
//WebServer.SendRawData("AvailableFilesUpdated", new byte[0]);
//Return whether it was success
return(isSuccess);
}
public void OperationOverloadUnequal_ShouldUnequalOtherUuid()
{
var uuid = new Uuid(1, 2);
Assert.IsTrue(uuid != new Uuid(3, 4));
}
/// <inheritdoc />
public void WriteGuid(string fieldName, Uuid value)
{
_wrapped.WriteGuid(fieldName, value);
}
public Task <AppendEventsResult> AppendEvents(
StreamName stream,
ExpectedStreamVersion expectedVersion,
IReadOnlyCollection <StreamEvent> events,
CancellationToken cancellationToken
)
{
var proposedEvents = events.Select(ToEventData);
var resultTask = expectedVersion == ExpectedStreamVersion.NoStream
? _client.AppendToStreamAsync(
stream,
StreamState.NoStream,
proposedEvents,
cancellationToken: cancellationToken
) : AnyOrNot(
expectedVersion,
() => _client.AppendToStreamAsync(
stream,
StreamState.Any,
proposedEvents,
cancellationToken: cancellationToken
),
() => _client.AppendToStreamAsync(
stream,
expectedVersion.AsStreamRevision(),
proposedEvents,
cancellationToken: cancellationToken
)
);
return(TryExecute(
async() => {
var result = await resultTask.NoContext();
return new AppendEventsResult(
result.LogPosition.CommitPosition,
result.NextExpectedStreamRevision.ToInt64()
);
},
stream,
() => new ErrorInfo("Unable to appends events to {Stream}", stream),
(s, ex) => {
EventuousEventSource.Log.UnableToAppendEvents(stream, ex);
return new AppendToStreamException(s, ex);
}
));
EventData ToEventData(StreamEvent streamEvent)
{
var(eventType, contentType, payload) = _serializer.SerializeEvent(streamEvent.Payload !);
return(new EventData(
Uuid.FromGuid(streamEvent.Id),
eventType,
payload,
_metaSerializer.Serialize(streamEvent.Metadata),
contentType
));
}
}
/// <summary>
/// Returns a guid array.
/// </summary>
public Uuid[] GetUuidArray()
{
int length = GetInt32Range(-1, m_context.MaxArrayLength);
if (length < 0)
{
return null;
}
Uuid[] value = new Uuid[length];
for (int ii = 0; ii < value.Length; ii++)
{
value[ii] = (Uuid)GetGuid();
}
return value;
}
public void Setup()
{
_guid1 = Guid.NewGuid();
_uuid1 = (Uuid)_guid1;
}
async Task <AsObject> ReconnectInvokeAsync(string pageUrl, string swfUrl, string tcUrl, string token)
{
var connect = new InvokeAmf0
{
MethodCall = new Method("connect", new object[] { false, ClientId, token, new CommandMessage
{
Operation = CommandOperation.Login,
CorrelationId = "",
MessageId = Uuid.NewUuid(),
Destination = "",
Body = token,
Headers = new AsObject
{
{ FlexMessageHeaders.FlexMessagingVersion, 1.0 },
{ FlexMessageHeaders.FlexClientId, "my-rtmps" },
}
} }),
ConnectionParameters =
new AsObject
{
{ "pageUrl", pageUrl },
{ "objectEncoding", (double)objectEncoding },
{ "capabilities", 239.0 },
{ "audioCodecs", 3575.0 },
{ "flashVer", "WIN 16,0,0,228" },
{ "swfUrl", "app:/LolClient.swf/[[DYNAMIC]]/47" },
{ "videoFunction", 1.0 },
{ "fpad", false },
{ "videoCodecs", 252.0 },
{ "tcUrl", tcUrl },
{ "app", "" }
},
InvokeId = GetNextInvokeId()
};
return((AsObject) await QueueCommandAsTask(connect, 3, 0, requireConnected : false));
}
public Address(AggregateRoot parent, Uuid entityId)
: base(parent, entityId)
{
}
public override string ToString()
{
return(Uuid.ToString());
}
public void GetById_returns_no_aggregate_with_a_different_ID_than_defined()
{
Given("a set of events with different aggregate ids in an event store",
testContext =>
{
var eventStore = new InMemoryEventStore();
eventStore.Insert(Uuid.NewId(), "Customer", new List <DomainEvent> {
new CustomerCreated(), new CustomerNameChanged()
});
eventStore.Insert(Uuid.NewId(), "Customer", new List <DomainEvent> {
new CustomerCreated()
});
eventStore.Insert(Uuid.NewId(), "Customer", new List <DomainEvent> {
new CustomerCreated()
});
testContext.State.EventStore = eventStore;
})
.And("an empty snapshot store",
testContext =>
{
testContext.State.SnapshotStore = new InMemorySnapshotStore();
})
.And("a configured domain context",
testContext =>
{
var eventBus = new Mock <IEventBus>().Object;
IEventStore eventStore = testContext.State.EventStore;
ISnapshotStore snapshotStore = testContext.State.SnapshotStore;
var domainRepository = new DomainRepository(eventStore, snapshotStore);
var domainContext = new DomainContext(eventBus, eventStore, snapshotStore, domainRepository);
testContext.State.DomainContext = domainContext;
})
.When("GetById for an aggregate with unknown id is called",
testContext =>
{
var aggregate =
((DomainContext)testContext.State.DomainContext).GetById <Customer>(Uuid.NewId());
testContext.State.Aggregate = aggregate;
})
.Then("it should return null",
testContext =>
{
object obj = testContext.State.Aggregate;
obj.Should().BeNull();
});
}
public Uuid uuid_NewTimeBased()
{
return(Uuid.NewTimeBased());
}
public override int GetHashCode()
{
return(Uuid != null ? Uuid.GetHashCode() : 0);
}
/// <summary>
/// Converts a local value to a remote value.
/// </summary>
/// <param name="srcValue">The local value.</param>
/// <param name="srcType">The data type of the local value.</param>
/// <param name="dstType">The data type of the remote value.</param>
/// <returns>The remote value.</returns>
private object ConvertLocalToRemote(object srcValue, BuiltInType srcType, BuiltInType dstType)
{
// must determine the type from the source if the containing array is a variant.
if (srcType == BuiltInType.Variant)
{
TypeInfo typeInfo = TypeInfo.Construct(srcValue);
srcType = typeInfo.BuiltInType;
}
// no conversion by default.
object dstValue = srcValue;
// apply different conversions depending on the data type.
switch (dstType)
{
case BuiltInType.Guid:
{
dstValue = new Uuid((string)srcValue);
break;
}
case BuiltInType.XmlElement:
{
XmlDocument document = new XmlDocument();
document.InnerXml = (string)srcValue;
dstValue = document.DocumentElement;
break;
}
case BuiltInType.NodeId:
{
dstValue = GetRemoteNodeId((string)srcValue);
break;
}
case BuiltInType.ExpandedNodeId:
{
ExpandedNodeId nodeId = ExpandedNodeId.Parse((string)srcValue);
dstValue = GetRemoteExpandedNodeId(nodeId);
break;
}
case BuiltInType.QualifiedName:
{
dstValue = GetRemoteBrowseName((string)srcValue);
break;
}
case BuiltInType.LocalizedText:
{
dstValue = new LocalizedText((string)srcValue);
break;
}
case BuiltInType.StatusCode:
{
dstValue = new StatusCode((uint)srcValue);
break;
}
case BuiltInType.ExtensionObject:
{
BinaryDecoder decoder = new BinaryDecoder((byte[])srcValue, m_localMessageContext);
dstValue = decoder.ReadExtensionObject(null);
decoder.Close();
break;
}
default:
{
if (dstType != srcType && dstType != BuiltInType.Variant && dstType != BuiltInType.Null)
{
throw ComUtils.CreateComException(ResultIds.E_BADTYPE);
}
break;
}
}
// all done.
return(dstValue);
}
/// <summary>
/// Returns a random value of the specified built-in type.
/// </summary>
public object GetRandom(NodeId dataType, int valueRank, IList <uint> arrayDimensions, ITypeTable typeTree)
{
BuiltInType expectedType = TypeInfo.GetBuiltInType(dataType, typeTree);
// calculate total number of dimensions.
int dimensions = 0;
switch (valueRank)
{
case ValueRanks.Any:
{
if (arrayDimensions != null && arrayDimensions.Count > 0)
{
dimensions = arrayDimensions.Count;
break;
}
dimensions = this.GetRandomRange(0, 1);
break;
}
case ValueRanks.ScalarOrOneDimension:
{
dimensions = this.GetRandomRange(0, 1);
break;
}
case ValueRanks.OneOrMoreDimensions:
{
if (arrayDimensions != null && arrayDimensions.Count > 0)
{
dimensions = arrayDimensions.Count;
break;
}
dimensions = this.GetRandomRange(1, 1);
break;
}
case ValueRanks.Scalar:
{
dimensions = 0;
break;
}
default:
{
dimensions = valueRank;
break;
}
}
// return a random scalar.
if (dimensions == 0)
{
if (expectedType == BuiltInType.Variant)
{
// randomly choose a built-in type.
BuiltInType builtInType = BuiltInType.Variant;
while (builtInType == BuiltInType.Variant || builtInType == BuiltInType.DataValue)
{
builtInType = (BuiltInType)m_random.NextInt32((int)BuiltInType.Variant);
}
return(GetRandomVariant(builtInType, false));
}
return(GetRandom(expectedType));
}
// calculate the length of each dimension.
int[] actualDimensions = new int[dimensions];
for (int ii = 0; ii < dimensions; ii++)
{
if (arrayDimensions != null && arrayDimensions.Count > ii)
{
actualDimensions[ii] = (int)arrayDimensions[ii];
}
while (actualDimensions[ii] == 0)
{
actualDimensions[ii] = m_random.NextInt32(m_maxArrayLength);
}
}
// create an array.
Array output = TypeInfo.CreateArray(expectedType, actualDimensions);
// generate random values for each element in the array.
int length = output.Length;
int[] indexes = new int[actualDimensions.Length];
for (int ii = 0; ii < length; ii++)
{
int divisor = output.Length;
for (int jj = 0; jj < indexes.Length; jj++)
{
divisor /= actualDimensions[jj];
indexes[jj] = (ii / divisor) % actualDimensions[jj];
}
object value = GetRandom(dataType, ValueRanks.Scalar, null, typeTree);
if (value != null)
{
if (expectedType == BuiltInType.Guid)
{
value = new Uuid((Guid)value);
}
output.SetValue(value, indexes);
}
}
// return array value.
return(output);
}
private Task <T> LcdsServiceProxyCall <T>(string service, string method, params object[] parameters)
{
return(this.InvokeAsync <T>("lcdsServiceProxy", "call", (object)Uuid.NewUuid(), (object)service, (object)method, (object)parameters));
}
public static ClusterInfo FromGrpcClusterInfo(EventStore.Cluster.ClusterInfo grpcCluster)
{
var receivedMembers = Array.ConvertAll(grpcCluster.Members.ToArray(), x =>
new MemberInfo(
Uuid.FromDto(x.InstanceId).ToGuid(), x.TimeStamp.FromTicksSinceEpoch(), (VNodeState)x.State,
x.IsAlive,
!x.InternalTcpUsesTls ? new IPEndPoint(IPAddress.Parse(x.InternalTcp.Address), (int)x.InternalTcp.Port) : null,
x.InternalTcpUsesTls ? new IPEndPoint(IPAddress.Parse(x.InternalTcp.Address), (int)x.InternalTcp.Port) : null,
!x.ExternalTcpUsesTls && x.ExternalTcp != null ? new IPEndPoint(IPAddress.Parse(x.ExternalTcp.Address), (int)x.ExternalTcp.Port) : null,
x.ExternalTcpUsesTls && x.ExternalTcp != null ? new IPEndPoint(IPAddress.Parse(x.ExternalTcp.Address), (int)x.ExternalTcp.Port) : null,
new IPEndPoint(IPAddress.Parse(x.InternalHttp.Address), (int)x.InternalHttp.Port),
new IPEndPoint(IPAddress.Parse(x.ExternalHttp.Address), (int)x.ExternalHttp.Port),
x.LastCommitPosition, x.WriterCheckpoint, x.ChaserCheckpoint,
x.EpochPosition, x.EpochNumber, Uuid.FromDto(x.EpochId).ToGuid(), x.NodePriority,
x.IsReadOnlyReplica
)).ToArray();
return(new ClusterInfo(receivedMembers));
}
public Variant ReadVariant(string fieldName)
{
// read the encoding byte.
byte encodingByte = m_reader.ReadByte();
Variant value = new Variant();
if ((encodingByte & (byte)VariantArrayEncodingBits.Array) != 0)
{
// read the array length.
int length = m_reader.ReadInt32();
if (length < 0)
{
return value;
}
Array array = null;
BuiltInType builtInType = (BuiltInType)(encodingByte & (byte)VariantArrayEncodingBits.TypeMask);
switch (builtInType)
{
case BuiltInType.Boolean:
{
bool[] values = new bool[length];
for (int ii = 0; ii < values.Length; ii++)
{
values[ii] = ReadBoolean(null);
}
array = values;
break;
}
case BuiltInType.SByte:
{
sbyte[] values = new sbyte[length];
for (int ii = 0; ii < values.Length; ii++)
{
values[ii] = ReadSByte(null);
}
array = values;
break;
}
case BuiltInType.Byte:
{
byte[] values = new byte[length];
for (int ii = 0; ii < values.Length; ii++)
{
values[ii] = ReadByte(null);
}
array = values;
break;
}
case BuiltInType.Int16:
{
short[] values = new short[length];
for (int ii = 0; ii < values.Length; ii++)
{
values[ii] = ReadInt16(null);
}
array = values;
break;
}
case BuiltInType.UInt16:
{
ushort[] values = new ushort[length];
for (int ii = 0; ii < values.Length; ii++)
{
values[ii] = ReadUInt16(null);
}
array = values;
break;
}
case BuiltInType.Int32:
case BuiltInType.Enumeration:
{
int[] values = new int[length];
for (int ii = 0; ii < values.Length; ii++)
{
values[ii] = ReadInt32(null);
}
array = values;
break;
}
case BuiltInType.UInt32:
{
uint[] values = new uint[length];
for (int ii = 0; ii < values.Length; ii++)
{
values[ii] = ReadUInt32(null);
}
array = values;
break;
}
case BuiltInType.Int64:
{
long[] values = new long[length];
for (int ii = 0; ii < values.Length; ii++)
{
values[ii] = ReadInt64(null);
}
array = values;
break;
}
case BuiltInType.UInt64:
{
ulong[] values = new ulong[length];
for (int ii = 0; ii < values.Length; ii++)
{
values[ii] = ReadUInt64(null);
}
array = values;
break;
}
case BuiltInType.Float:
{
float[] values = new float[length];
for (int ii = 0; ii < values.Length; ii++)
{
values[ii] = ReadFloat(null);
}
array = values;
break;
}
case BuiltInType.Double:
{
double[] values = new double[length];
for (int ii = 0; ii < values.Length; ii++)
{
values[ii] = ReadDouble(null);
}
array = values;
break;
}
case BuiltInType.String:
{
string[] values = new string[length];
for (int ii = 0; ii < values.Length; ii++)
{
values[ii] = ReadString(null);
}
array = values;
break;
}
case BuiltInType.DateTime:
{
DateTime[] values = new DateTime[length];
for (int ii = 0; ii < values.Length; ii++)
{
values[ii] = ReadDateTime(null);
}
array = values;
break;
}
case BuiltInType.Guid:
{
Uuid[] values = new Uuid[length];
for (int ii = 0; ii < values.Length; ii++)
{
values[ii] = ReadGuid(null);
}
array = values;
break;
}
case BuiltInType.ByteString:
{
byte[][] values = new byte[length][];
for (int ii = 0; ii < values.Length; ii++)
{
values[ii] = ReadByteString(null);
}
array = values;
break;
}
case BuiltInType.XmlElement:
{
try
{
XmlElement[] values = new XmlElement[length];
for (int ii = 0; ii < values.Length; ii++)
{
values[ii] = ReadXmlElement(null);
}
array = values;
}
catch(Exception ex)
{
Utils.Trace(ex, "Error reading variant.");
}
break;
}
case BuiltInType.NodeId:
{
NodeId[] values = new NodeId[length];
for (int ii = 0; ii < values.Length; ii++)
{
values[ii] = ReadNodeId(null);
}
array = values;
break;
}
case BuiltInType.ExpandedNodeId:
{
ExpandedNodeId[] values = new ExpandedNodeId[length];
for (int ii = 0; ii < values.Length; ii++)
{
values[ii] = ReadExpandedNodeId(null);
}
array = values;
break;
}
case BuiltInType.StatusCode:
{
StatusCode[] values = new StatusCode[length];
for (int ii = 0; ii < values.Length; ii++)
{
values[ii] = ReadStatusCode(null);
}
array = values;
break;
}
case BuiltInType.QualifiedName:
{
QualifiedName[] values = new QualifiedName[length];
for (int ii = 0; ii < values.Length; ii++)
{
values[ii] = ReadQualifiedName(null);
}
array = values;
break;
}
case BuiltInType.LocalizedText:
{
LocalizedText[] values = new LocalizedText[length];
for (int ii = 0; ii < values.Length; ii++)
{
values[ii] = ReadLocalizedText(null);
}
array = values;
break;
}
case BuiltInType.ExtensionObject:
{
ExtensionObject[] values = new ExtensionObject[length];
for (int ii = 0; ii < values.Length; ii++)
{
values[ii] = ReadExtensionObject();
}
array = values;
break;
}
case BuiltInType.DataValue:
{
DataValue[] values = new DataValue[length];
for (int ii = 0; ii < values.Length; ii++)
{
values[ii] = ReadDataValue(null);
}
array = values;
break;
}
case BuiltInType.Variant:
{
Variant[] values = new Variant[length];
for (int ii = 0; ii < values.Length; ii++)
{
values[ii] = ReadVariant(null);
}
array = values;
break;
}
default:
{
throw new ServiceResultException(
StatusCodes.BadDecodingError,
Utils.Format("Cannot decode unknown type in Variant object (0x{0:X2}).", encodingByte));
}
}
if (array == null)
{
value = new Variant(StatusCodes.BadEncodingError);
}
else
{
// check for multi-dimensional arrays.
if ((encodingByte & (byte)VariantArrayEncodingBits.ArrayDimensions) != 0)
{
Int32Collection dimensions = ReadInt32Array(null);
if (dimensions != null && dimensions.Count > 0)
{
value = new Variant(new Matrix(array, builtInType, dimensions.ToArray()));
}
else
{
value = new Variant(new Matrix(array, builtInType));
}
}
else
{
value = new Variant(array);
}
}
}
else
{
switch ((BuiltInType)encodingByte)
{
case BuiltInType.Null:
{
value.Value = null;
break;
}
case BuiltInType.Boolean:
{
value.Set(ReadBoolean(null));
break;
}
case BuiltInType.SByte:
{
value.Set(ReadSByte(null));
break;
}
case BuiltInType.Byte:
{
value.Set(ReadByte(null));
break;
}
case BuiltInType.Int16:
{
value.Set(ReadInt16(null));
break;
}
case BuiltInType.UInt16:
{
value.Set(ReadUInt16(null));
break;
}
case BuiltInType.Int32:
case BuiltInType.Enumeration:
{
value.Set(ReadInt32(null));
break;
}
case BuiltInType.UInt32:
{
value.Set(ReadUInt32(null));
break;
}
case BuiltInType.Int64:
{
value.Set(ReadInt64(null));
break;
}
case BuiltInType.UInt64:
{
value.Set(ReadUInt64(null));
break;
}
case BuiltInType.Float:
{
value.Set(ReadFloat(null));
break;
}
case BuiltInType.Double:
{
value.Set(ReadDouble(null));
break;
}
case BuiltInType.String:
{
value.Set(ReadString(null));
break;
}
case BuiltInType.DateTime:
{
value.Set(ReadDateTime(null));
break;
}
case BuiltInType.Guid:
{
value.Set(ReadGuid(null));
break;
}
case BuiltInType.ByteString:
{
value.Set(ReadByteString(null));
break;
}
case BuiltInType.XmlElement:
{
try
{
value.Set(ReadXmlElement(null));
}
catch(Exception ex)
{
Utils.Trace(ex, "Error reading xml element for variant.");
value.Set(StatusCodes.BadEncodingError);
}
break;
}
case BuiltInType.NodeId:
{
value.Set(ReadNodeId(null));
break;
}
case BuiltInType.ExpandedNodeId:
{
value.Set(ReadExpandedNodeId(null));
break;
}
case BuiltInType.StatusCode:
{
value.Set(ReadStatusCode(null));
break;
}
case BuiltInType.QualifiedName:
{
value.Set(ReadQualifiedName(null));
break;
}
case BuiltInType.LocalizedText:
{
value.Set(ReadLocalizedText(null));
break;
}
case BuiltInType.ExtensionObject:
{
value.Set(ReadExtensionObject());
break;
}
case BuiltInType.DataValue:
{
value.Set(ReadDataValue(null));
break;
}
default:
{
throw new ServiceResultException(
StatusCodes.BadDecodingError,
Utils.Format("Cannot decode unknown type in Variant object (0x{0:X2}).", encodingByte));
}
}
}
return value;
}
protected override async Task WriteEventsToStoreAsync(IEnumerable <IDomainEventDescriptor> events, CancellationToken cancellationToken)
{
var aggregateGroup = events.GroupBy(x => GenerateStreamId(x.AggregateType, x.AggregateId));
var eventDataGroups = aggregateGroup.Select(group =>
{
var eventList = group.ToList();
var eventDatas = eventList.Select(x =>
{
byte[] data;
byte[] metadata;
// serialize data
using (var ms = new MemoryStream())
using (var writer = new BsonDataWriter(ms))
{
JsonSerializer serializer = new JsonSerializer();
serializer.TypeNameHandling = TypeNameHandling.All;
serializer.Serialize(writer, x.Event);
data = ms.ToArray();
}
// serialize metadata
using (var ms = new MemoryStream())
using (var writer = new BsonDataWriter(ms))
{
JsonSerializer serializer = new JsonSerializer();
serializer.Serialize(writer, x.Metadata);
metadata = ms.ToArray();
}
return(new EventData(
Uuid.FromGuid(x.EventId),
x.EventType,
data,
metadata,
"application/octet-stream"
));
});
if (eventList.Any(x => x.IsPublished))
{
throw new InvalidOperationException("Cannot publish events that have been published");
}
var firstEvent = eventList.First();
return(StreamId: group.Key, EventDatas: eventDatas, ExpectedVersionBeforeAppend: firstEvent.Version - 1L);
});
foreach (var group in eventDataGroups)
{
// expect no stream when there is not positive version
if (group.ExpectedVersionBeforeAppend == -1)
{
await EventStoreClient.AppendToStreamAsync(
group.StreamId,
StreamState.NoStream,
group.EventDatas,
cancellationToken : cancellationToken
);
}
// expect stream when there an unknow version
else if (group.ExpectedVersionBeforeAppend == DomainEventDescriptor.UnknowVersion - 1)
{
await EventStoreClient.AppendToStreamAsync(
group.StreamId,
StreamState.StreamExists,
group.EventDatas,
cancellationToken : cancellationToken
);
}
// expect stream when there is a valid version
else
{
await EventStoreClient.AppendToStreamAsync(
group.StreamId,
StreamRevision.FromInt64(group.ExpectedVersionBeforeAppend),
group.EventDatas,
cancellationToken : cancellationToken
);
}
}
}
/// <summary>
/// Writes a GUID to the stream.
/// </summary>
public void WriteGuid(string fieldName, Uuid value)
{
if (value == Uuid.Empty)
{
WriteSimpleField(fieldName, null, false);
}
else
{
WriteSimpleField(fieldName, value.ToString(), true);
}
}
private bool Equals(MemberInfo other)
{
return(Uuid.Equals(other.Uuid));
}
private ServiceResult OnUserArrayValue2(
ISystemContext context,
MethodState method,
NodeId objectId,
DateTime[] dateTimeIn,
Uuid[] guidIn,
byte[][] byteStringIn,
XmlElement[] xmlElementIn,
NodeId[] nodeIdIn,
ExpandedNodeId[] expandedNodeIdIn,
QualifiedName[] qualifiedNameIn,
LocalizedText[] localizedTextIn,
StatusCode[] statusCodeIn,
Variant[] variantIn,
ref DateTime[] dateTimeOut,
ref Uuid[] guidOut,
ref byte[][] byteStringOut,
ref XmlElement[] xmlElementOut,
ref NodeId[] nodeIdOut,
ref ExpandedNodeId[] expandedNodeIdOut,
ref QualifiedName[] qualifiedNameOut,
ref LocalizedText[] localizedTextOut,
ref StatusCode[] statusCodeOut,
ref Variant[] variantOut)
{
dateTimeOut = dateTimeIn;
guidOut = guidIn;
byteStringOut = byteStringIn;
xmlElementOut = xmlElementIn;
nodeIdOut = nodeIdIn;
expandedNodeIdOut = expandedNodeIdIn;
qualifiedNameOut = qualifiedNameIn;
localizedTextOut = localizedTextIn;
statusCodeOut = statusCodeIn;
variantOut = variantIn;
return ServiceResult.Good;
}
public override int GetHashCode() => Uuid.GetHashCode();
/// <summary>
/// Writes a GUID to the stream.
/// </summary>
public void WriteGuid(string fieldName, Uuid value)
{
if (BeginField(fieldName, false, false))
{
PushNamespace(Namespaces.OpcUaXsd);
WriteString("String", value.GuidString);
PopNamespace();
EndField(fieldName);
}
}
/// <summary>
/// Converts a local value to a remote value.
/// </summary>
/// <param name="srcValue">The local value.</param>
/// <param name="srcType">The data type of the local value.</param>
/// <param name="dstType">The data type of the remote value.</param>
/// <returns>The remote value.</returns>
private object ConvertLocalToRemote(object srcValue, BuiltInType srcType, BuiltInType dstType)
{
// must determine the type from the source if the containing array is a variant.
if (srcType == BuiltInType.Variant)
{
TypeInfo typeInfo = TypeInfo.Construct(srcValue);
srcType = typeInfo.BuiltInType;
}
// no conversion by default.
object dstValue = srcValue;
// apply different conversions depending on the data type.
switch (dstType)
{
case BuiltInType.Guid:
{
dstValue = new Uuid((string)srcValue);
break;
}
case BuiltInType.XmlElement:
{
XmlDocument document = new XmlDocument();
document.InnerXml = (string)srcValue;
dstValue = document.DocumentElement;
break;
}
case BuiltInType.NodeId:
{
dstValue = GetRemoteNodeId((string)srcValue);
break;
}
case BuiltInType.ExpandedNodeId:
{
ExpandedNodeId nodeId = ExpandedNodeId.Parse((string)srcValue);
dstValue = GetRemoteExpandedNodeId(nodeId);
break;
}
case BuiltInType.QualifiedName:
{
dstValue = GetRemoteBrowseName((string)srcValue);
break;
}
case BuiltInType.LocalizedText:
{
dstValue = new LocalizedText((string)srcValue);
break;
}
case BuiltInType.StatusCode:
{
dstValue = new StatusCode((uint)srcValue);
break;
}
case BuiltInType.ExtensionObject:
{
BinaryDecoder decoder = new BinaryDecoder((byte[])srcValue, m_localMessageContext);
dstValue = decoder.ReadExtensionObject(null);
decoder.Close();
break;
}
default:
{
if (dstType != srcType && dstType != BuiltInType.Variant && dstType != BuiltInType.Null)
{
throw ComUtils.CreateComException(ResultIds.E_BADTYPE);
}
break;
}
}
// all done.
return dstValue;
}
