public override void Trigger(ObjectMetaData reciever)
{
base.Trigger(reciever);
InstantiateProjectile();
AddEffects();
}
public NetworkObjectListObjectMetaDataList Serialize()
{
var list = new NetworkObjectListObjectMetaDataList();
var sortedTypes = _types.Values.ToList();
sortedTypes.Sort((lhs, rhs) => Comparer <uint> .Default.Compare(lhs.Id, rhs.Id));
foreach (var type in sortedTypes)
{
var metaData = new ObjectMetaData
{
TypeId = type.Id,
TypeName = type.Type.FullName
};
foreach (var member in type.Members)
{
metaData.Members.Add(new ObjectMember
{
TypeId = member.MetaData.Id
});
}
list.MetaData.Add(metaData);
}
return(list);
}
public CSharpCodeProviderForProxyOjectSerialization(Type type)
{
if (type.IsSimple())
{
throw new ArgumentException();
}
Type = type;
ObjectMetaData = ObjectMetaData.GetEntityMetaData(type);
}
public override BinaryConverterBase Copy(Type type)
{
var binaryConverter = new ArrayBinaryConverter();
binaryConverter.Init(type);
binaryConverter.ElementType = binaryConverter.CurrentType.GetElementType();
binaryConverter.EntityMetaData = ObjectMetaData.GetEntityMetaData(type);
return(binaryConverter);
}
public override BinaryConverterBase Copy(Type type)
{
var binaryConverter = new UserDefinedTypeBinaryConverter();
binaryConverter.Init(type);
binaryConverter.ObjectType = type;
binaryConverter.EntityMetaData = ObjectMetaData.GetEntityMetaData(type);
return(binaryConverter);
}
public override BinaryConverterBase Copy(Type type)
{
var binaryConverter = new HashSetBinaryConverter <T>();
binaryConverter.Init(type);
binaryConverter.ElementType = type.GetGenericArguments().First();
binaryConverter.EntityMetaData = ObjectMetaData.GetEntityMetaData(type);
return(binaryConverter);
}
public override BinaryConverterBase Copy(Type type)
{
var binaryConverter = new DictionaryBinaryConverter();
binaryConverter.Init(type);
binaryConverter.KeyType = binaryConverter.CurrentType.GetGenericArguments().First();
binaryConverter.ValueType = binaryConverter.CurrentType.GetGenericArguments().Last();
binaryConverter.EntityMetaData = ObjectMetaData.GetEntityMetaData(type);
return(binaryConverter);
}
// ******************************************************************
// * *
// * Public Methods *
// * *
// ******************************************************************
/// <summary>
/// Decomposes an object into a metadata tree expression that describes the structure
/// and contents of the specified object
/// </summary>
/// <param name="obj">
/// An object that must be decomposed
/// </param>
/// <returns>
/// An ObjectMetaData instance that holds the metadata structure and contents of the
/// specified object
/// </returns>
public static ObjectMetaData DecomposeObject(object obj)
{
// Create root entry
var entry = ObjectMetaData.CreateRootType(obj);
// Recurse down object's metadata structure
DecomposeObjectRecurse(obj, entry, new List <object>());
// Return root entry
return(entry);
}
protected override void BeforSerialize(SerializableEntity obj, BinaryWriter writer, SerializeContext context)
{
if (SerializeItems == null)
{
ObjectType = obj.GetEntityMetaData.ObjectType;
CurrentType = ObjectType;
EntityMetaData = ObjectMetaData.GetEntityMetaData(ObjectType);
SerializeItems = EntityMetaData.SerializeItemList;
SerializableEntity = Activator.CreateInstance(ObjectType) as SerializableEntity;
}
}
protected override void BeforDeserialize(BinaryReader reader, Type objectType, DeserializeContext context)
{
if (SerializeItems == null)
{
ObjectType = objectType;
CurrentType = ObjectType;
EntityMetaData = ObjectMetaData.GetEntityMetaData(ObjectType);
SerializeItems = EntityMetaData.SerializeItemList;
SerializableEntity = Activator.CreateInstance(objectType) as SerializableEntity;
}
}
public override void OnUpdate(float input, ObjectMetaData reciever)
{
base.OnUpdate(input, reciever);
if (projectile.instantiatedObject != null)
{
foreach (Projectiles.ProjectileEffect PE in projectileEffects)
{
PE.OnUpdate();
}
}
}
public override void Trigger(ObjectMetaData reciever)
{
base.Trigger(reciever);
foreach (ObjectAffect item in toReciever)
{
reciever.AddAffect(item);
}
foreach (ObjectAffect item in toSender)
{
sender.AddAffect(item);
}
}
public void SyncViewPath()
{
if (SCUtility.m_AppDef == null || SCUtility.m_AppDef.ArrClients == null)
{
return;
}
ArrayList meta = null;
var vm = this.DataContext as MainViewModel;
if (vm != null && vm.CurrentViewItem != null && vm.CurrentViewItem.ObjectViewer != null)
{
meta = vm.CurrentViewItem.ObjectViewer.GetMetaData();
}
QueryData StatusQueryData = new QueryData();
StatusQueryData.Type = Consts.SectionType.DoAction;
ObjectMetaData obj = new ObjectMetaData();
obj.Text = bar.Path.Clone().ToString();
obj.Tag = "Path";
StatusQueryData.ArrCounter.Add(obj);
if (meta != null)
{
foreach (var itm in meta)
{
StatusQueryData.ArrCounter.Add(itm);
}
}
foreach (BaseClass.ClientInfo row in SCUtility.m_AppDef.ArrClients)
{
// this.Text = "Waiting for reply...";
string strPath = bar.Path.Clone().ToString();
ClientInfo CliInfoS = new ClientInfo(row.IP, row.Name);
Thread ClientStatusQuery = new Thread(delegate() { ExecutingPathQueries(StatusQueryData, CliInfoS); });
// Thread ClientStatusQuery = new Thread(UpdateStatusDelegate() {});
ClientStatusQuery.Start();
}
}
public override void AtStart(ObjectMetaData objectData)
{
base.AtStart(objectData);
// record the check distance, and set the check distance to negative
// in order for
originalStickHeight = objectData.GetComponent <UnityStandardAssets.Characters.FirstPerson.RigidbodyFirstPersonController>().advancedSettings.groundCheckDistance;
objectData.GetComponent <UnityStandardAssets.Characters.FirstPerson.RigidbodyFirstPersonController>().advancedSettings.groundCheckDistance = -10;
//add force
if (space == Space.World)
{
objectData.GetComponent <Rigidbody>().AddForce(direction * force);
}
else
{
objectData.GetComponent <Rigidbody>().AddRelativeForce(direction * force);
}
}
public override void AtStart(ObjectMetaData objectData)
{
base.AtStart(objectData);
if (lifeTime == 0 && !oneTime)
{
Debug.Log("<color=olive>Warning ! Lifetime too short</color>\n" +
"Add some lifetime to health over time or remove oneTime");
}
if (oneTime)
{
objectData.GiveResource(amount);
resourcePerSecond = 0;
}
else
{
resourcePerSecond = amount / lifeTime;
}
}
private void tsbtnShutdownPC_Click(object sender, EventArgs e)
{
QueryData StatusQueryData = new QueryData();
StatusQueryData.Type = Consts.SectionType.DoAction;
ObjectMetaData obj = new ObjectMetaData();
obj.Text = "";
obj.Tag = "Shutdown";
StatusQueryData.ArrCounter.Add(obj);
Collection <BaseClass.ClientInfo> AllCliecnt = new Collection <ClientInfo>();
foreach (DataGridViewRow itm in dataGridClients.SelectedRows)
{
BaseClass.ClientInfo ClientInfoTemp = null;
foreach (ClientInfo CurrClient in SCUtility.m_AppDef.ArrClients)
{
if (CurrClient.IP.CompareTo(itm.Cells["IP"].Value.ToString()) == 0)
{
ClientInfoTemp = CurrClient;
}
}
if (ClientInfoTemp != null)
{
AllCliecnt.Add(ClientInfoTemp);
}
}
foreach (BaseClass.ClientInfo row in AllCliecnt)//SCUtility.m_AppDef.ArrClients)
{
// this.Text = "Waiting for reply...";
ClientInfo CliInfoS = new ClientInfo(row.IP, row.Name);
Thread ClientStatusQuery = new Thread(delegate() { ExecutingPathQueries(StatusQueryData, CliInfoS); });
// Thread ClientStatusQuery = new Thread(UpdateStatusDelegate() {});
ClientStatusQuery.Start();
}
}
/// <summary>
/// Creates a new ObjectMetaData for the specified type
/// </summary>
/// <param name="obj">
/// An object reference
/// </param>
/// <param name="field">
/// A FieldInfo instance that holds details about the public field
/// </param>
/// <returns>
/// A new ObjectMetaData instance
/// </returns>
public static ObjectMetaData CreateFieldType(object obj, FieldInfo field)
{
// Create 'Property' entry
var entry = new ObjectMetaData(ObjectMetaDataType.FieldType);
try
{
// Try to resolve value properties
entry.Field = field;
entry.ValueType = field.FieldType;
entry.ValueIsEnumerable = entry.Value is IEnumerable;
entry.Value = field.GetValue(obj);
}
catch (Exception ex)
{
// Store exception that occured while resolving value
entry.ValueException = ex;
}
// Return reference to new entry
return(entry);
}
// ******************************************************************
// * *
// * Public Methods *
// * *
// ******************************************************************
/// <summary>
/// Creates a new ObjectMetaData instance for the class type of the specified object
/// </summary>
/// <param name="obj">
/// An object reference
/// </param>
/// <returns>
/// A new ObjectMetaData instance
/// </returns>
public static ObjectMetaData CreateRootType(object obj)
{
// Create 'RootType' entry
var entry = new ObjectMetaData(ObjectMetaDataType.RootType);
try
{
// Try to resolve value properties
entry.Value = obj;
entry.ValueType = obj != null?obj.GetType() : null;
entry.ValueIsEnumerable = obj is IEnumerable;
}
catch (Exception ex)
{
// Store exception that occured while resolving value
entry.ValueException = ex;
}
// Return reference to new entry
return(entry);
}
/// <summary>
/// Creates a new ObjectMetaData instance for the class type of the specified object
/// </summary>
/// <param name="obj">
/// An object reference
/// </param>
/// <param name="property">
/// A PropertyInfo instance that holds details about the public property
/// </param>
/// <returns>
/// A new ObjectMetaData instance
/// </returns>
public static ObjectMetaData CreatePropertyType(object obj, PropertyInfo property)
{
// Create 'Property' entry
var entry = new ObjectMetaData(ObjectMetaDataType.PropertyType);
try
{
// Try to resolve value properties
entry.Property = property;
entry.ValueType = property.PropertyType;
entry.ValueIsEnumerable = entry.Value is IEnumerable;
entry.Value = property.GetValue(obj, null);
}
catch (Exception ex)
{
// Store exception that occured while resolving value
entry.ValueException = ex;
}
// Return reference to new entry
return(entry);
}
public override BinaryConverterBase Copy(Type type)
{
var binaryConverter = new ISerializableTypeBinaryConverter();
binaryConverter.ObjectType = type;
binaryConverter.Init(type);
var createInstanceReturnType = typeof(object);
var createInstanceParamsTypes = new[] { typeof(SerializationInfo), typeof(StreamingContext) };
binaryConverter.TargetCreateInstanceMethod = binaryConverter.CurrentType.GetConstructor(createInstanceParamsTypes);
if (binaryConverter.TargetCreateInstanceMethod == null)
{
binaryConverter.TargetCreateInstanceMethod = binaryConverter.CurrentType.GetConstructor(
BindingFlags.NonPublic | BindingFlags.CreateInstance | BindingFlags.Instance,
null,
createInstanceParamsTypes,
null
);
}
binaryConverter.EntityMetaData = ObjectMetaData.GetEntityMetaData(type);
binaryConverter.UserDefinedObject = Activator.CreateInstance(type);
return(binaryConverter);
}
// ******************************************************************
// * *
// * Private Methods *
// * *
// ******************************************************************
/// <summary>
/// Recursively decomposes the specified object into a metadata instance
/// </summary>
/// <param name="obj">
/// An object reference to the instance to decompose
/// </param>
/// <param name="parentEntry">
/// A ObjectMetaData to the parent of the specified object
/// </param>
/// <param name="processedReferences">
/// A collection of processed objects that is used to avoid infinite recursions
/// </param>
private static void DecomposeObjectRecurse(
object obj,
ObjectMetaData parentEntry,
List <object> processedReferences)
{
// We do not recurse down certain value types
if (obj == null ||
obj is string ||
obj is Type ||
obj is IConvertible)
{
return;
}
// Are we recursing reference type?
if (!(obj is ValueType))
{
// Avoid re-processing same objects
if (processedReferences.Contains(obj))
{
// Add to parent list
var entry = ObjectMetaData.CreateDuplicateType(obj);
parentEntry.ChildEntries.Add(entry);
return;
}
// Add object to list of processed ones
processedReferences.Add(obj);
}
// Check if object is reference type
var props = obj.GetType().GetProperties(
BindingFlags.Instance |
BindingFlags.GetProperty |
BindingFlags.Public |
BindingFlags.FlattenHierarchy);
props = props.OrderBy(o => o.Name).ToArray();
foreach (var prop in props)
{
// Skip accessor properties
if (prop.GetIndexParameters().Length == 0)
{
// Add to parent list
var entry = ObjectMetaData.CreatePropertyType(obj, prop);
parentEntry.ChildEntries.Add(entry);
// Recurse down
DecomposeObjectRecurse(entry.Value, entry, processedReferences);
}
}
// Check if object is reference type
var fields = obj.GetType().GetFields(
BindingFlags.Instance |
BindingFlags.GetProperty |
BindingFlags.Public |
BindingFlags.FlattenHierarchy);
fields = fields.OrderBy(o => o.Name).ToArray();
foreach (var field in fields)
{
// Add to parent list
var entry = ObjectMetaData.CreateFieldType(obj, field);
parentEntry.ChildEntries.Add(entry);
// Recurse down
DecomposeObjectRecurse(entry.Value, entry, processedReferences);
}
// Check if object is enumerable type
var iEnumerable = obj as IEnumerable;
if (iEnumerable != null)
{
// Iterate
int i = 0;
foreach (var o in iEnumerable)
{
// Add to parent list
var entry = ObjectMetaData.CreateEnumerableType(o, i++);
parentEntry.ChildEntries.Add(entry);
// Recurse down
DecomposeObjectRecurse(entry.Value, entry, processedReferences);
}
}
}
public override void AtDestroy(ObjectMetaData objectData)
{
objectData.Targetable(!state);
base.AtDestroy(objectData);
}
private void StartVoting()
{
var govSessionMemOpinion = new Sbn.Products.GEP.GEPObject.GovSessionMemberOpinion();
govSessionMemOpinion.CorrelateOffer = new Sbn.Products.GEP.GEPObject.Offer();
govSessionMemOpinion.CorrelateOffer.ID = 1;
govSessionMemOpinion.CorrelateOffer.AliasCode = "54471";
govSessionMemOpinion.CorrelateOffer.Title = "پیشنهاد تستی";
var xmlString = govSessionMemOpinion.GetXML("GovSessionMemberOpinion");
if (SCUtility.m_AppDef == null || SCUtility.m_AppDef.ArrClients == null)
{
return;
}
CurrentModel.Session = new Session();
//Register Voting
// CurrentModel.VotingSubject = govSessionMemOpinion.CorrelateOffer.Title;
// CurrentModel.VotingSubjectMetaData = SessionItem.ObjectViewer.GetVotingMetaData();// govSessionMemOpinion.CorrelateOffer.GetXML("Offer");
CurrentModel.VotingDate = new DateTime(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day);
CurrentModel.VotingTime = DateTime.Now.TimeOfDay;
var ballot = new Model.Ballot();
ballot.Voting = CurrentModel;
// ballot.BollotMetaData = SessionItem.ObjectViewer.GetBallotMetaData();// xmlString;
ballot.OpinionType = OpinionType.NoneIdea;
ballot.RefrenceAssemblly = SessionItem.RefrenceAssemblly;
ballot.BallotViewerClassName = SessionItem.BallotViewerClassName;
var StatusQueryData = new QueryData();
StatusQueryData.Type = Consts.SectionType.DoAction;
var obj = new ObjectMetaData();
obj.Tag = "Voting";
var XmlDoc = new XmlDocument();
var type = typeof(Ballot);
var XmlSerializer = new XmlSerializer(type);
using (var ms = new MemoryStream())
{
XmlSerializer.Serialize(ms, ballot);
ms.Position = 0;
XmlDoc.Load(ms);
obj.Text = XmlDoc.InnerXml;
}
StatusQueryData.ArrCounter.Add(obj);
foreach (BaseClass.ClientInfo row in SCUtility.m_AppDef.ArrClients)
{
// this.Text = "Waiting for reply...";
ClientInfo CliInfoS = new ClientInfo(row.IP, row.Name);
Thread ClientStatusQuery = new Thread(delegate()
{
ReplyData ReplyDataObj;
try
{
string QueryString = StatusQueryData.Serialize();
String ReplyString = MonitorInfoViewer.Comm.SendQuery(CliInfoS.IP, SCUtility.m_AppDef.m_Port, QueryString);
ReplyDataObj = ReplyData.Deserialize(ReplyString);
}
catch (Exception)
{
ReplyDataObj = null;
}
});
// Thread ClientStatusQuery = new Thread(UpdateStatusDelegate() {});
ClientStatusQuery.Start();
}
}
public override void AtUpdate(ObjectMetaData objectData)
{
base.AtUpdate(objectData);
objectData.GiveResource(resourcePerSecond * Time.deltaTime);
}
public override void OnUpdate(float input, ObjectMetaData reciever)
{
base.OnUpdate(input, reciever);
}
public override void Trigger(ObjectMetaData reciever)
{
base.Trigger(reciever);
}
public override void AtDestroy(ObjectMetaData objectData)
{
objectData.GetComponent <UnityStandardAssets.Characters.FirstPerson.RigidbodyFirstPersonController>().advancedSettings.groundCheckDistance = originalStickHeight;
base.AtDestroy(objectData);
}
public override void AtUpdate(ObjectMetaData objectData)
{
base.AtUpdate(objectData);
objectData.GiveHealth(healthPerSecond * Time.deltaTime);
}
public void SerializablePropertiesGetterIsCorrectForUserEntity()
{
Assert.AreEqual(ObjectMetaData.GetEntityMetaData(typeof(ObjectMetadataTests.User <UserRole>)).WritablePropertyList.Count, 12);
Assert.AreEqual(ObjectMetaData.GetEntityMetaData(typeof(ObjectMetadataTests.User <UserRole>)).WritablePropertyList.First().Name, "Active");
}
public static ReplyData executeQuery(QueryData receivedQueryData)
{
ReplyData returnedReplyData = new ReplyData();
ObjectMetaData ProcessNameCounter = (ObjectMetaData)receivedQueryData.ArrCounter[0];
Process CurrProcess = Process.GetProcessById(Convert.ToInt32(ProcessNameCounter.Tag));
if (CurrProcess != null)
{
StringDictionary Vars = CurrProcess.StartInfo.EnvironmentVariables;
DataContainer EnvsDataContianer = new DataContainer();
EnvsDataContianer.Name = "EnvironmentVariables";
foreach (string s in Vars.Keys)
{
EnvsDataContianer.ArrCounters.Add(new Counter(s, Vars[s]));
}
returnedReplyData.ArrDataContainers.Add(EnvsDataContianer);
foreach (ProcessThread CurrThread in CurrProcess.Threads)
{
DataContainer ThreadDataContianer = new DataContainer();
ThreadDataContianer.Name = CurrThread.Id.ToString();
try
{
ThreadDataContianer.ArrCounters.Add(new Counter("CPU", CurrThread.TotalProcessorTime.ToString()));
ThreadDataContianer.ArrCounters.Add(new Counter("StartTime", CurrThread.StartTime.ToString()));
ThreadDataContianer.ArrCounters.Add(new Counter("UserProcessorTime", CurrThread.UserProcessorTime.ToString()));
}
catch (Exception)
{
ThreadDataContianer.ArrCounters.Add(new Counter("CPU", Convert.ToString(0)));
ThreadDataContianer.ArrCounters.Add(new Counter("StartTime", DateTime.MinValue.ToString()));
ThreadDataContianer.ArrCounters.Add(new Counter("UserProcessorTime", ""));
}
ThreadDataContianer.ArrCounters.Add(new Counter("StartAddress", CurrThread.StartAddress.ToString()));
ThreadDataContianer.ArrCounters.Add(new Counter("ThreadState", CurrThread.ThreadState.ToString()));
ThreadDataContianer.ArrCounters.Add(new Counter("BasePriority", CurrThread.BasePriority.ToString()));
ThreadDataContianer.ArrCounters.Add(new Counter("CurrentPriority", CurrThread.CurrentPriority.ToString()));
if (CurrThread.ThreadState == ThreadState.Wait)
{
ThreadDataContianer.ArrCounters.Add(new Counter("WaitReason", CurrThread.WaitReason.ToString()));
}
else
{
ThreadDataContianer.ArrCounters.Add(new Counter("WaitReason", ""));
}
returnedReplyData.ArrDataContainers.Add(ThreadDataContianer);
}
}
else
{
Log.WriteToLog(string.Format("Process {0} does not exists.", ProcessNameCounter.Tag));
}
return(returnedReplyData);
}
