public FormatSML(Stream stream, List<DocXsdFormat> formats)
{
this.m_stream = stream;
this.m_writer = new StreamWriter(this.m_stream);
this.m_gen = new ObjectIDGenerator();
this.m_xsdformats = formats;
}
public DataSetPopulator(string xmlSchema)
{
_xmlSchema = xmlSchema;
_generator = new ObjectIDGenerator();
_dataSet = new DataSet();
_dataSet.ReadXmlSchema(new StringReader(_xmlSchema));
}
public PropertyTreeObjectReader(object graph)
{
if (graph == null)
throw new ArgumentNullException("graph");
this.generator = new ObjectIDGenerator();
this.graph = graph;
}
// Constructor.
public BinaryValueContext(BinaryFormatter formatter,
BinaryWriter writer)
{
this.formatter = formatter;
this.writer = writer;
this.gen = new ObjectIDGenerator();
this.queue = new Queue();
this.assemblyQueue = new Queue();
}
public CGraphManager(Form1 parent, CLog log)
{
m_log = log;
m_parentForm = parent;
m_idGen = new ObjectIDGenerator();
m_serializer = new JsonSerializer();
m_itemMap = new Dictionary<String, NodeItem>();
m_idNameMap = new Dictionary<String, String>();
}
public static void Dump(object value, string name, TextWriter writer)
{
if (StringEx.IsNullOrWhiteSpace(name))
throw new ArgumentNullException("name");
if (writer == null)
throw new ArgumentNullException("writer");
var idGenerator = new ObjectIDGenerator();
InternalDump(0, name, value, writer, idGenerator, true);
}
public long Add(object item)
{
if (item == null)
{
throw new ArgumentNullException("item");
}
Type objectType = item.GetType();
if (!_store.ContainsKey(objectType))
{
_store[objectType] = new ObjectIDGenerator();
}
bool firstTime;
return _store[objectType].GetId(item, out firstTime);
}
internal object Deserialize(HeaderHandler handler, ISerParser serParser)
{
if (serParser == null)
{
throw new ArgumentNullException("serParser", string.Format(CultureInfo.CurrentCulture, SoapUtil.GetResourceString("ArgumentNull_WithParamName"), new object[] { serParser }));
}
this.deserializationSecurityException = null;
try
{
serializationPermission.Demand();
}
catch (Exception exception)
{
this.deserializationSecurityException = exception;
}
this.handler = handler;
this.isTopObjectSecondPass = false;
this.isHeaderHandlerCalled = false;
if (handler != null)
{
this.IsFakeTopObject = true;
}
this.m_idGenerator = new ObjectIDGenerator();
this.m_objectManager = this.GetObjectManager();
this.serObjectInfoInit = new SerObjectInfoInit();
this.objectIdTable.Clear();
this.objectIds = 0L;
serParser.Run();
if (handler != null)
{
this.m_objectManager.DoFixups();
if (this.handlerObject == null)
{
this.handlerObject = handler(this.newheaders);
}
if ((this.soapFaultId > 0L) && (this.handlerObject != null))
{
this.topStack = new SerStack("Top ParseRecords");
ParseRecord record = new ParseRecord {
PRparseTypeEnum = InternalParseTypeE.Object,
PRobjectPositionEnum = InternalObjectPositionE.Top,
PRparseStateEnum = InternalParseStateE.Object,
PRname = "Response"
};
this.topStack.Push(record);
record = new ParseRecord {
PRparseTypeEnum = InternalParseTypeE.Member,
PRobjectPositionEnum = InternalObjectPositionE.Child,
PRmemberTypeEnum = InternalMemberTypeE.Field,
PRmemberValueEnum = InternalMemberValueE.Reference,
PRparseStateEnum = InternalParseStateE.Member,
PRname = "__fault",
PRidRef = this.soapFaultId
};
this.topStack.Push(record);
record = new ParseRecord {
PRparseTypeEnum = InternalParseTypeE.ObjectEnd,
PRobjectPositionEnum = InternalObjectPositionE.Top,
PRparseStateEnum = InternalParseStateE.Object,
PRname = "Response"
};
this.topStack.Push(record);
this.isTopObjectResolved = false;
}
}
if (!this.isTopObjectResolved)
{
this.isTopObjectSecondPass = true;
this.topStack.Reverse();
int num = this.topStack.Count();
ParseRecord pr = null;
for (int i = 0; i < num; i++)
{
pr = (ParseRecord) this.topStack.Pop();
this.Parse(pr);
}
}
this.m_objectManager.DoFixups();
if (this.topObject == null)
{
throw new SerializationException(SoapUtil.GetResourceString("Serialization_TopObject"));
}
if (this.HasSurrogate(this.topObject.GetType()) && (this.topId != 0L))
{
this.topObject = this.m_objectManager.GetObject(this.topId);
}
if (this.topObject is IObjectReference)
{
this.topObject = ((IObjectReference) this.topObject).GetRealObject(this.m_context);
}
this.m_objectManager.RaiseDeserializationEvent();
if ((this.formatterEnums.FEtopObject != null) && (this.topObject is InternalSoapMessage))
{
InternalSoapMessage topObject = (InternalSoapMessage) this.topObject;
ISoapMessage fEtopObject = this.formatterEnums.FEtopObject;
fEtopObject.MethodName = topObject.methodName;
fEtopObject.XmlNameSpace = topObject.xmlNameSpace;
fEtopObject.ParamNames = topObject.paramNames;
fEtopObject.ParamValues = topObject.paramValues;
fEtopObject.Headers = this.headers;
this.topObject = fEtopObject;
this.isTopObjectResolved = true;
}
return this.topObject;
}
// Deserialize the stream into an object graph.
internal Object Deserialize(HeaderHandler handler, ISerParser serParser)
{
InternalST.Soap( this, "Deserialize Entry handler", handler);
if (serParser == null)
throw new ArgumentNullException("serParser", String.Format(SoapUtil.GetResourceString("ArgumentNull_WithParamName"), serParser));
deserializationSecurityException = null;
try {
serializationPermission.Demand();
} catch(Exception e ) {
deserializationSecurityException = e;
}
this.handler = handler;
isTopObjectSecondPass = false;
isHeaderHandlerCalled = false;
if (handler != null)
IsFakeTopObject = true;
m_idGenerator = new ObjectIDGenerator();
m_objectManager = GetObjectManager();
serObjectInfoInit = new SerObjectInfoInit();
objectIdTable.Clear();
objectIds = 0;
// Will call back to ParseObject, ParseHeader for each object found
serParser.Run();
if (handler != null)
{
InternalST.Soap( this, "Deserialize Fixup Before Delegate Invoke");
m_objectManager.DoFixups(); // Fixup for headers
// Header handler isn't invoked until method name is known from body fake record
// Except for SoapFault, in which case it is invoked below
if (handlerObject == null)
{
InternalST.Soap( this, "Deserialize Before SoapFault Delegate Invoke ");
handlerObject = handler(newheaders);
InternalST.Soap( this, "Deserialize after SoapFault Delegate Invoke");
}
// SoapFault creation Create a fake Pr for the handlerObject to use.
// Create a member for the fake pr with name __fault;
if ((soapFaultId > 0) && (handlerObject != null))
{
InternalST.Soap( this, "Deserialize SoapFault ");
topStack = new SerStack("Top ParseRecords");
ParseRecord pr = new ParseRecord();
pr.PRparseTypeEnum = InternalParseTypeE.Object;
pr.PRobjectPositionEnum = InternalObjectPositionE.Top;
pr.PRparseStateEnum = InternalParseStateE.Object;
pr.PRname = "Response";
topStack.Push(pr);
pr = new ParseRecord();
pr.PRparseTypeEnum = InternalParseTypeE.Member;
pr.PRobjectPositionEnum = InternalObjectPositionE.Child;
pr.PRmemberTypeEnum = InternalMemberTypeE.Field;
pr.PRmemberValueEnum = InternalMemberValueE.Reference;
pr.PRparseStateEnum = InternalParseStateE.Member;
pr.PRname = "__fault";
pr.PRidRef = soapFaultId;
topStack.Push(pr);
pr = new ParseRecord();
pr.PRparseTypeEnum = InternalParseTypeE.ObjectEnd;
pr.PRobjectPositionEnum = InternalObjectPositionE.Top;
pr.PRparseStateEnum = InternalParseStateE.Object;
pr.PRname = "Response";
topStack.Push(pr);
isTopObjectResolved = false;
}
}
// Resolve fake top object if necessary
if (!isTopObjectResolved)
{
//resolve top object
InternalST.Soap( this, "Deserialize TopObject Second Pass");
isTopObjectSecondPass = true;
topStack.Reverse();
// The top of the stack now contains the fake record
// When it is Parsed, the handler object will be substituted
// for it in ParseObject.
int topStackLength = topStack.Count();
ParseRecord pr = null;
for (int i=0; i<topStackLength; i++)
{
pr = (ParseRecord)topStack.Pop();
Parse(pr);
}
}
InternalST.Soap( this, "Deserialize Finished Parsing DoFixups");
m_objectManager.DoFixups();
if (topObject == null)
throw new SerializationException(SoapUtil.GetResourceString("Serialization_TopObject"));
if (topObject is IObjectReference) {
topObject = ((IObjectReference)topObject).GetRealObject(m_context);
}
InternalST.Soap( this, "Deserialize Exit ",topObject);
m_objectManager.RaiseDeserializationEvent();
if ((formatterEnums.FEtopObject != null) &&
(topObject is InternalSoapMessage))
{
// Convert InternalSoapMessage to SoapMessage
InternalST.Soap( this, "Deserialize SoapMessage Entry ");
InternalSoapMessage ismc = (InternalSoapMessage)topObject;
ISoapMessage smc = (ISoapMessage)formatterEnums.FEtopObject;
smc.MethodName = ismc.methodName;
smc.XmlNameSpace = ismc.xmlNameSpace;
smc.ParamNames = ismc.paramNames;
smc.ParamValues = ismc.paramValues;
smc.Headers = headers;
topObject = smc;
isTopObjectResolved = true;
InternalST.Soap( this, "Deserialize SoapMessage Exit topObject ",topObject," method name ",smc.MethodName);
}
return topObject;
}
private static void InternalDump(int indentationLevel, string name, object value, TextWriter writer,
ObjectIDGenerator idGenerator, bool recursiveDump)
{
var indentation = new string(' ', indentationLevel*3);
if (value == null)
{
writer.WriteLine("{0}{1} = <null>", indentation, name);
return;
}
Type type = value.GetType();
// figure out if this is an object that has already been dumped, or is currently being dumped
string keyRef = string.Empty;
string keyPrefix = string.Empty;
if (!type.IsValueType)
{
bool firstTime;
long key = idGenerator.GetId(value, out firstTime);
if (!firstTime)
keyRef = string.Format(CultureInfo.InvariantCulture, " (see #{0})", key);
else
{
keyPrefix = string.Format(CultureInfo.InvariantCulture, "#{0}: ", key);
}
}
// work out how a simple dump of the value should be done
bool isString = value is string;
string typeName = value.GetType().FullName;
string formattedValue = value.ToString();
var exception = value as Exception;
if (exception != null)
{
formattedValue = exception.GetType().Name + ": " + exception.Message;
}
if (formattedValue == typeName)
formattedValue = string.Empty;
else
{
// escape tabs and line feeds
formattedValue = formattedValue.Replace("\t", "\\t").Replace("\n", "\\n").Replace("\r", "\\r");
// chop at 80 characters
int length = formattedValue.Length;
if (length > 80)
formattedValue = formattedValue.Substring(0, 80);
if (isString)
formattedValue = string.Format(CultureInfo.InvariantCulture, "\"{0}\"", formattedValue);
if (length > 80)
formattedValue += " (+" + (length - 80) + " chars)";
formattedValue = " = " + formattedValue;
}
writer.WriteLine("{0}{1}{2}{3} [{4}]{5}", indentation, keyPrefix, name, formattedValue, value.GetType(),
keyRef);
// Avoid dumping objects we've already dumped, or is already in the process of dumping
if (keyRef.Length > 0)
return;
// don't dump strings, we already got at around 80 characters of those dumped
if (isString)
return;
// don't dump value-types in the System namespace
if (type.IsValueType && type.FullName == "System." + type.Name)
return;
// Avoid certain types that will result in endless recursion
if (type.FullName == "System.Reflection." + type.Name)
return;
if (value is SecurityIdentifier)
return;
if (!recursiveDump)
return;
PropertyInfo[] properties =
(from property in
type.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
where property.GetIndexParameters().Length == 0
&& property.CanRead
select property).ToArray();
FieldInfo[] fields =
type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).ToArray();
if (properties.Length == 0 && fields.Length == 0)
return;
writer.WriteLine(string.Format(CultureInfo.InvariantCulture, "{0}{{", indentation));
if (properties.Length > 0)
{
writer.WriteLine(string.Format(CultureInfo.InvariantCulture, "{0} properties {{", indentation));
foreach (PropertyInfo pi in properties)
{
try
{
object propertyValue = pi.GetValue(value, null);
InternalDump(indentationLevel + 2, pi.Name, propertyValue, writer, idGenerator, true);
}
catch (TargetInvocationException ex)
{
InternalDump(indentationLevel + 2, pi.Name, ex, writer, idGenerator, false);
}
catch (ArgumentException ex)
{
InternalDump(indentationLevel + 2, pi.Name, ex, writer, idGenerator, false);
}
catch (RemotingException ex)
{
InternalDump(indentationLevel + 2, pi.Name, ex, writer, idGenerator, false);
}
}
writer.WriteLine(string.Format(CultureInfo.InvariantCulture, "{0} }}", indentation));
}
if (fields.Length > 0)
{
writer.WriteLine(string.Format(CultureInfo.InvariantCulture, "{0} fields {{", indentation));
foreach (FieldInfo field in fields)
{
try
{
object fieldValue = field.GetValue(value);
InternalDump(indentationLevel + 2, field.Name, fieldValue, writer, idGenerator, true);
}
catch (TargetInvocationException ex)
{
InternalDump(indentationLevel + 2, field.Name, ex, writer, idGenerator, false);
}
}
writer.WriteLine(string.Format(CultureInfo.InvariantCulture, "{0} }}", indentation));
}
writer.WriteLine(string.Format(CultureInfo.InvariantCulture, "{0}}}", indentation));
}
internal void Serialize(object graph, Header[] inHeaders, __BinaryWriter serWriter, bool fCheck)
{
if (graph == null)
{
throw new ArgumentNullException("graph", Environment.GetResourceString("ArgumentNull_Graph"));
}
if (serWriter == null)
{
throw new ArgumentNullException("serWriter", Environment.GetResourceString("ArgumentNull_WithParamName", new object[] { "serWriter" }));
}
if (fCheck)
{
CodeAccessPermission.Demand(PermissionType.SecuritySerialization);
}
this.serWriter = serWriter;
this.headers = inHeaders;
serWriter.WriteBegin();
long headerId = 0L;
bool flag2 = false;
bool flag3 = false;
IMethodCallMessage mcm = graph as IMethodCallMessage;
if (mcm != null)
{
flag2 = true;
graph = this.WriteMethodCall(mcm);
}
else
{
IMethodReturnMessage mrm = graph as IMethodReturnMessage;
if (mrm != null)
{
flag3 = true;
graph = this.WriteMethodReturn(mrm);
}
}
if (graph == null)
{
this.WriteSerializedStreamHeader(this.topId, headerId);
if (flag2)
{
serWriter.WriteMethodCall();
}
else if (flag3)
{
serWriter.WriteMethodReturn();
}
serWriter.WriteSerializationHeaderEnd();
serWriter.WriteEnd();
}
else
{
object obj2;
long num2;
bool flag;
this.m_idGenerator = new ObjectIDGenerator();
this.m_objectQueue = new Queue();
this.m_formatterConverter = new FormatterConverter();
this.serObjectInfoInit = new SerObjectInfoInit();
this.topId = this.InternalGetId(graph, false, null, out flag);
if (this.headers != null)
{
headerId = this.InternalGetId(this.headers, false, null, out flag);
}
else
{
headerId = -1L;
}
this.WriteSerializedStreamHeader(this.topId, headerId);
if (flag2)
{
serWriter.WriteMethodCall();
}
else if (flag3)
{
serWriter.WriteMethodReturn();
}
if ((this.headers != null) && (this.headers.Length > 0))
{
this.m_objectQueue.Enqueue(this.headers);
}
if (graph != null)
{
this.m_objectQueue.Enqueue(graph);
}
while ((obj2 = this.GetNext(out num2)) != null)
{
WriteObjectInfo objectInfo = null;
if (obj2 is WriteObjectInfo)
{
objectInfo = (WriteObjectInfo) obj2;
}
else
{
objectInfo = WriteObjectInfo.Serialize(obj2, this.m_surrogates, this.m_context, this.serObjectInfoInit, this.m_formatterConverter, this, this.m_binder);
objectInfo.assemId = this.GetAssemblyId(objectInfo);
}
objectInfo.objectId = num2;
NameInfo memberNameInfo = this.TypeToNameInfo(objectInfo);
this.Write(objectInfo, memberNameInfo, memberNameInfo);
this.PutNameInfo(memberNameInfo);
objectInfo.ObjectEnd();
}
serWriter.WriteSerializationHeaderEnd();
serWriter.WriteEnd();
this.m_objectManager.RaiseOnSerializedEvent();
}
}
public AmfWriter(BinaryWriter writer, AmfRegistry registry)
{
_writer = writer;
_registry = registry;
_stringTable = new Dictionary<string, int>();
_idGenerator = new ObjectIDGenerator();
_dateTimeTable = new Dictionary<DateTime, int>();
_objectTable = new Dictionary<long, int>();
_traitsTable = new Dictionary<long, int>();
}
static Debug()
{
IDGenerator = new ObjectIDGenerator();
}
/// <summary>
/// Initializes a new instance of the <see cref="AntMicro.Migrant.ObjectIdentifier"/> class.
/// </summary>
public ObjectIdentifier()
{
generator = new ObjectIDGenerator();
consecutiveIds = new Dictionary<long, int>();
objects = new List<object>();
}
public CGraphFields(GraphControl control, ObjectIDGenerator idGen)
{
Dictionary<String, CNodeItemFields> idFieldMap = new Dictionary<String, CNodeItemFields>();
Dictionary<NodeItem, String> idItemMap = new Dictionary<NodeItem, String>();
bool first = false;
id = idGen.GetId(control, out first).ToString();
name = control.Name;
Nodes = new List<CNodeFields>();
List<Node> nodes = (List<Node>)control.Nodes;
foreach (Node node in nodes)
{
CNodeFields nFields = new CNodeFields();
nFields.Title = node.Title;
nFields.name = getNodeName(node);
nFields.Location = node.Location;
nFields.Items = new List<CNodeItemFields>();
bool nfirst = false;
nFields.id = idGen.GetId(nFields, out nfirst).ToString();
foreach(NodeItem item in node.Items)
{
CNodeItemFields iFields = new CNodeItemFields();
bool ifirst = false;
iFields.id = idGen.GetId(iFields, out ifirst).ToString();
String fName = nFields.name + ":" + (item.Name == null ? iFields.id : item.Name);
idFieldMap.Add(fName, iFields);
idItemMap.Add(item, fName);
iFields.Input = new List<CConnectionFields>();
iFields.Output = new List<CConnectionFields>();
iFields.ItemParts = new List<CItemPartFields>();
iFields.name = fName;
iFields.ParentNode = nFields.id;
if(item.Tag != null)
iFields.Tag = item.Tag.GetType().ToString();
iFields.IOMode = getIOMode(item);
iFields.ItemType = item.GetType().ToString();
switch(iFields.ItemType)
{
case "Graph.Items.NodeTextBoxItem":
{
NodeTextBoxItem temp = item as NodeTextBoxItem;
iFields.Text = temp.Text;
}
break;
case "Graph.Items.NodeLabelItem":
{
NodeLabelItem temp = item as NodeLabelItem;
iFields.Text = temp.Text;
}
break;
case "Graph.Items.NodeCompositeItem":
{
NodeCompositeItem temp = item as NodeCompositeItem;
foreach(ItemPart part in temp.Parts)
{
CItemPartFields pFields = new CItemPartFields();
bool pfirst = false;
pFields.id = idGen.GetId(pFields, out pfirst).ToString();
pFields.name = part.Name;
pFields.PartType = part.GetType().ToString();
switch(pFields.PartType)
{
case "Graph.Items.ItemTextBoxPart":
{
ItemTextBoxPart tempPart = part as ItemTextBoxPart;
pFields.Text = tempPart.Text;
}
break;
default:
break;
}
iFields.ItemParts.Add(pFields);
}
}
break;
}
nFields.Items.Add(iFields);
}
foreach(NodeItem item in node.Items)
{
// now get connection info
String iid = idItemMap[item];
if (item.Input.Enabled && item.Input.HasConnection)
{
foreach (NodeConnection conn in item.Input.Connectors)
{
CConnectionFields cFields = new CConnectionFields();
bool cfirst = false;
cFields.id = idGen.GetId(cFields, out cfirst).ToString();
Node nFrom = conn.From.Node;
String fromName = "";
foreach(NodeItem nItem in nFrom.Items)
{
if(nItem.Name == "NodeName")
{
if(nItem.GetType().ToString() == "Graph.Items.NodeTextBoxItem")
{
NodeTextBoxItem i = nItem as NodeTextBoxItem;
fromName = i.Text;
}
if (nItem.GetType().ToString() == "Graph.Items.NodeLabelItem")
{
NodeLabelItem i = nItem as NodeLabelItem;
fromName = i.Text;
}
}
}
Node nTo = conn.To.Node;
String toName = "";
foreach (NodeItem nItem in nTo.Items)
{
if (nItem.Name == "NodeName")
{
if (nItem.GetType().ToString() == "Graph.Items.NodeTextBoxItem")
{
NodeTextBoxItem i = nItem as NodeTextBoxItem;
toName = i.Text;
}
if (nItem.GetType().ToString() == "Graph.Items.NodeLabelItem")
{
NodeLabelItem i = nItem as NodeLabelItem;
toName = i.Text;
}
}
}
if (conn.Tag != null)
cFields.Tag = conn.Tag.GetType().ToString();
else if (item.Tag != null)
cFields.Tag = item.Tag.GetType().ToString();
cFields.name = (conn.Name == null ? cFields.id : conn.Name);
cFields.From = fromName + ":" + conn.From.Item.Name;
cFields.To = toName + ":" + conn.To.Item.Name;
idFieldMap[iid].Input.Add(cFields);
}
}
if (item.Output.Enabled && item.Output.HasConnection)
{
foreach (NodeConnection conn in item.Output.Connectors)
{
CConnectionFields cFields = new CConnectionFields();
bool cfirst = false;
cFields.id = idGen.GetId(cFields, out cfirst).ToString();
Node nFrom = conn.From.Node;
String fromName = "";
foreach (NodeItem nItem in nFrom.Items)
{
if (nItem.Name == "NodeName")
{
if (nItem.GetType().ToString() == "Graph.Items.NodeTextBoxItem")
{
NodeTextBoxItem i = nItem as NodeTextBoxItem;
fromName = i.Text;
}
if (nItem.GetType().ToString() == "Graph.Items.NodeLabelItem")
{
NodeLabelItem i = nItem as NodeLabelItem;
fromName = i.Text;
}
}
}
Node nTo = conn.To.Node;
String toName = "";
foreach (NodeItem nItem in nTo.Items)
{
if (nItem.Name == "NodeName")
{
if (nItem.GetType().ToString() == "Graph.Items.NodeTextBoxItem")
{
NodeTextBoxItem i = nItem as NodeTextBoxItem;
toName = i.Text;
}
if (nItem.GetType().ToString() == "Graph.Items.NodeLabelItem")
{
NodeLabelItem i = nItem as NodeLabelItem;
toName = i.Text;
}
}
}
if (conn.Tag != null)
cFields.Tag = conn.Tag.GetType().ToString();
else if (item.Tag != null)
cFields.Tag = item.Tag.GetType().ToString();
cFields.name = (conn.Name == null ? cFields.id : conn.Name);
cFields.From = fromName + ":" + conn.From.Item.Name;
cFields.To = toName + ":" + conn.To.Item.Name;
idFieldMap[iid].Input.Add(cFields);
}
}
}
Nodes.Add(nFields);
}
}
// Commences the process of serializing the entire graph.
// initialize the graph walker.
internal void Serialize(Object graph, Header[] inHeaders, SoapWriter serWriter)
{
InternalST.Soap( this, "Serialize Entry 2 ",graph,((headers == null)?" no headers ": "headers"));
serializationPermission.Demand();
if (graph == null)
throw new ArgumentNullException("graph",SoapUtil.GetResourceString("ArgumentNull_Graph"));
if (serWriter == null)
throw new ArgumentNullException("serWriter",String.Format(SoapUtil.GetResourceString("ArgumentNull_WithParamName"), "serWriter"));
serObjectInfoInit = new SerObjectInfoInit();
this.serWriter = serWriter;
this.headers = inHeaders;
if (graph is IMethodMessage)
{
bRemoting = true;
MethodBase methodBase = ((IMethodMessage)graph).MethodBase;
if (methodBase != null)
serWriter.WriteXsdVersion(ProcessTypeAttributes(methodBase.ReflectedType));
else
serWriter.WriteXsdVersion(XsdVersion.V2001);
}
else
serWriter.WriteXsdVersion(XsdVersion.V2001);
m_idGenerator = new ObjectIDGenerator();
m_objectQueue = new Queue();
if (graph is ISoapMessage)
{
// Fake method call is to be written
bRemoting = true;
ISoapMessage ismc = (ISoapMessage)graph;
graph = new InternalSoapMessage(ismc.MethodName, ismc.XmlNameSpace, ismc.ParamNames, ismc.ParamValues, ismc.ParamTypes);
headers = ismc.Headers;
}
InternalST.Soap( this, "Serialize New SerializedTypeTable");
m_serializedTypeTable = new Hashtable();
serWriter.WriteBegin();
long headerId = 0;
Object obj;
long objectId;
bool isNew;
topId = m_idGenerator.GetId(graph, out isNew);
if (headers != null)
headerId = m_idGenerator.GetId(headers, out isNew);
else
headerId = -1;
WriteSerializedStreamHeader(topId, headerId);
InternalST.Soap( this, "Serialize Schedule 0");
// Write out SerializedStream header
if (!((headers == null) || (headers.Length == 0)))
{
ProcessHeaders(headerId);
}
m_objectQueue.Enqueue(graph);
while ((obj = GetNext(out objectId))!=null)
{
InternalST.Soap( this, "Serialize GetNext ",obj);
WriteObjectInfo objectInfo = null;
// GetNext will return either an object or a WriteObjectInfo.
// A WriteObjectInfo is returned if this object was member of another object
if (obj is WriteObjectInfo)
{
InternalST.Soap( this, "Serialize GetNext recognizes WriteObjectInfo");
objectInfo = (WriteObjectInfo)obj;
}
else
{
objectInfo = WriteObjectInfo.Serialize(obj, m_surrogates, m_context, serObjectInfoInit, m_formatterConverter, null);
objectInfo.assemId = GetAssemblyId(objectInfo);
}
objectInfo.objectId = objectId;
NameInfo typeNameInfo = TypeToNameInfo(objectInfo);
typeNameInfo.NIisTopLevelObject = true;
if (bRemoting && obj == graph)
typeNameInfo.NIisRemoteRecord = true;
Write(objectInfo, typeNameInfo, typeNameInfo);
PutNameInfo(typeNameInfo);
objectInfo.ObjectEnd();
}
serWriter.WriteSerializationHeaderEnd();
serWriter.WriteEnd();
m_idGenerator = new ObjectIDGenerator();
InternalST.Soap( this, "*************Serialize New SerializedTypeTable 2");
m_serializedTypeTable = new System.Collections.Hashtable();
InternalST.Soap( this, "Serialize Exit ");
}
private string GetId (object o, bool addToReferencesList)
{
if (idGenerator == null) idGenerator = new ObjectIDGenerator ();
bool firstTime;
long lid = idGenerator.GetId (o, out firstTime);
return String.Format (CultureInfo.InvariantCulture, "id{0}", lid);
}
protected void SetUp ()
{
generator = new ObjectIDGenerator ();
}
private static DateTime GetMaxAllowedStartTime(ITask task, Collection<ITask> taskCollection, ObjectIDGenerator oidGen, IDictionary<long, int> indexDict)
{
bool firstTime;
int taskIndex = indexDict[oidGen.GetId(task, out firstTime)];
for (int i = taskIndex + 1; i < taskCollection.Count; i++)
{
if (taskCollection[i].TaskType == task.TaskType)
return taskCollection[i].DateRange.StartTime;
}
return DateTime.MaxValue;
}
protected override void SetUp ()
{
generator = new ObjectIDGenerator ();
}
/// <summary>
/// Serializes an object, or graph of objects with the given root to the provided stream.
/// </summary>
/// <param name="serializationStream">
/// The stream where the formatter puts the serialized data. This stream can reference a variety
/// of backing stores (such as files, network, memory, and so on).
/// </param>
/// <param name="graph">
/// The object, or root of the object graph, to serialize. All child objects of this root object
/// are automatically serialized.
/// </param>
/// <exception cref="T:System.ArgumentNullException">The <para>serializationStream</para> cannot be null.</exception>
/// <exception cref="T:System.ArgumentNullException">The <para>graph</para> cannot be null.</exception>
public void Serialize(Stream serializationStream, object graph)
{
if (null == serializationStream)
throw new ArgumentNullException("serializationStream", "Stream serializationStream cannot be null.");
if (null == graph)
throw new ArgumentNullException("graph", "Object graph cannot be null.");
XmlWriter xmlWriter = null;
try {
xmlWriter = XmlWriter.Create(serializationStream, this.createXmlWriterSettings());
this.registeredReferenceObjects.Clear();
this.idGenerator = new ObjectIDGenerator();
IFormatterConverter converter = new FormatterConverter();
SerializationEntry graphEntry = this.createSerializationEntry(this.getName(graph.GetType()), graph, converter);
this.serializeEntry(xmlWriter, graphEntry, converter);
xmlWriter.WriteWhitespace(Environment.NewLine);
}
finally {
if (null != xmlWriter)
xmlWriter.Flush();
}
}
public static IEnumerable<ITask> TryToMakeTasksComply(this IEnumerable<ITask> taskCollection, double minLevel, double maxLevel, double initialValue)
{
//Check if initial value is inside allowed range
if ((initialValue > maxLevel) || (initialValue < minLevel))
throw new ArgumentException(string.Format("InitialValue: {0}, must be between MinLevel: {1} and MaxLevel: {2}", initialValue, minLevel, maxLevel));
//Check if final quantity cannot be inside allowed range
double finalQuantity = initialValue + taskCollection.Sum(task => task.Quantity);
if ((finalQuantity > maxLevel) || (finalQuantity < minLevel))
return null;
var dataPoints = taskCollection.GetDataPoints(initialValue);
//Find the first point that is outside of allowed range
KeyValuePair<DateTime, double> outOfRangePoint;
if (!FindOutOfRangePoint(dataPoints, minLevel, maxLevel, out outOfRangePoint))
return taskCollection;
//Calculate how much quantity overshoot/undershoot we have
double diffQ = CalcQuantityDifference(outOfRangePoint, minLevel, maxLevel);
//Find where to move the end time of the tasks
DateTime moveToTime;
if (!FindMoveToTime(dataPoints, outOfRangePoint, minLevel, maxLevel, out moveToTime))
return null;
Collection<ITask> newTaskCollection = new Collection<ITask>(taskCollection.ToList());
//Cache indexes of the collection for fast retrieval
ObjectIDGenerator oidGen = new ObjectIDGenerator();
bool firstTime;
Dictionary<long, int> indexDict = new Dictionary<long, int>();
for (int i = 0; i < newTaskCollection.Count; i++)
indexDict.Add(oidGen.GetId(newTaskCollection[i], out firstTime), i);
int iterations = 0;
//Loop until the overshoot/undershoot quantity is zero
while (diffQ != 0)
{
//check for infinite iterations
if (iterations >= MAX_ITER)
return null;
int sign = diffQ > 0 ? 1 : -1;
//Find the tasks that should be moved
var tasksToMove = newTaskCollection.Where(task => (task.Quantity * sign > 0) && (task.DateRange.StartTime < outOfRangePoint.Key))
.OrderByDescending(task => task.DateRange.StartTime);
if (!tasksToMove.Any())
return null;
//Loop through found tasks to decrease the overshoot/undershoot quantity
foreach (Task task in tasksToMove)
{
//Last task cannot be moved
if (indexDict[oidGen.GetId(task, out firstTime)] == newTaskCollection.Count - 1)
continue;
double oldQuantity = task.GetQuantity(outOfRangePoint.Key);
Task newTask;
DateTime newStartTime;
if (task.DateRange.EndTime < moveToTime)
newStartTime = moveToTime.AddHours(-1 * task.DateRange.Duration.TotalHours);
else
if (oldQuantity * sign <= diffQ * sign)
newStartTime = outOfRangePoint.Key;
else
newStartTime = task.DateRange.StartTime.AddHours(diffQ / task.QuantityPerHour);
//Do not move task further than the next task of the same type in sequence
DateTime maxAllowedStartTime = GetMaxAllowedStartTime(task, newTaskCollection, oidGen, indexDict);
if (newStartTime > maxAllowedStartTime)
newStartTime = maxAllowedStartTime;
if (newStartTime > task.DateRange.StartTime)
{
newTask = task.ChangeTimes(newStartTime);
diffQ -= oldQuantity - newTask.GetQuantity(outOfRangePoint.Key);
//Replace the old task with the new one
long oldTaskId = oidGen.GetId(task, out firstTime);
int index = indexDict[oldTaskId];
newTaskCollection[index] = newTask;
indexDict.Remove(oldTaskId);
indexDict.Add(oidGen.GetId(newTask, out firstTime), index);
//If overshoot/undershoot quantity is zero then exit loop
if (diffQ * sign <= 0)
break;
}
}
//Recalculate new graph and prepare for next iteration
dataPoints = newTaskCollection.GetDataPoints(initialValue);
if (!FindOutOfRangePoint(dataPoints, minLevel, maxLevel, out outOfRangePoint))
return newTaskCollection;
diffQ = CalcQuantityDifference(outOfRangePoint, minLevel, maxLevel);
if (!FindMoveToTime(dataPoints, outOfRangePoint, minLevel, maxLevel, out moveToTime))
return null;
iterations++;
}
return newTaskCollection;
}
// The default constructor instantiates the queue for objects
// to be serialized and creates a new instance of the
// ObjectIDGenerator.
protected Formatter()
{
m_objectQueue = new Queue();
m_idGenerator = new ObjectIDGenerator();
}
protected override void Initialize()
{
objectIdGen = new ObjectIDGenerator();
input = new Input();
damageTexts = new DamageTexts();
int seed = 507450343;
Random = new Random(seed);
pickups = new Pickups();
base.Initialize();
}
[System.Security.SecurityCritical] // auto-generated
internal void Serialize(Object graph, Header[] inHeaders, __BinaryWriter serWriter, bool fCheck)
{
if (graph == null)
throw new ArgumentNullException("graph", Environment.GetResourceString("ArgumentNull_Graph"));
if (serWriter == null)
throw new ArgumentNullException("serWriter", Environment.GetResourceString("ArgumentNull_WithParamName", "serWriter"));
Contract.EndContractBlock();
SerTrace.Log(this, "Serialize Entry 2 ", graph, ((headers == null) ? " no headers " : "headers "));
if (fCheck)
{
CodeAccessPermission.Demand(PermissionType.SecuritySerialization);
}
this.serWriter = serWriter;
this.headers = inHeaders;
SerTrace.Log( this, "Serialize New SerializedTypeTable");
serWriter.WriteBegin();
long headerId = 0;
Object obj;
long objectId;
bool isNew;
bool bMethodCall = false;
bool bMethodReturn = false;
#if FEATURE_REMOTING
// Special case IMethodCallMessage and IMethodReturnMessage for performance
IMethodCallMessage mess = graph as IMethodCallMessage;
if (mess != null)
{
bMethodCall = true;
graph = WriteMethodCall(mess);
}
else
{
IMethodReturnMessage mr = graph as IMethodReturnMessage;
if (mr != null)
{
bMethodReturn = true;
graph = WriteMethodReturn(mr);
}
}
#endif // FEATURE_REMOTING
if (graph == null)
{
WriteSerializedStreamHeader(topId, headerId);
if (bMethodCall)
serWriter.WriteMethodCall();
else if (bMethodReturn)
serWriter.WriteMethodReturn();
serWriter.WriteSerializationHeaderEnd();
serWriter.WriteEnd();
return;
}
// allocations if methodCall or methodResponse and no graph
m_idGenerator = new ObjectIDGenerator();
m_objectQueue = new Queue();
m_formatterConverter = new FormatterConverter();
serObjectInfoInit = new SerObjectInfoInit();
topId = InternalGetId(graph, false, null, out isNew);
if (headers != null)
headerId = InternalGetId(headers, false, null, out isNew);
else
headerId = -1;
WriteSerializedStreamHeader(topId, headerId);
if (bMethodCall)
serWriter.WriteMethodCall();
else if (bMethodReturn)
serWriter.WriteMethodReturn();
SerTrace.Log( this, "Serialize Schedule 0");
// Write out SerializedStream header
if ((headers != null) && (headers.Length > 0))
m_objectQueue.Enqueue(headers);
if (graph != null)
m_objectQueue.Enqueue(graph);
while ((obj = GetNext(out objectId))!=null)
{
SerTrace.Log( this, "Serialize GetNext ",obj);
WriteObjectInfo objectInfo = null;
// GetNext will return either an object or a WriteObjectInfo.
// A WriteObjectInfo is returned if this object was member of another object
if (obj is WriteObjectInfo)
{
SerTrace.Log( this, "Serialize GetNext recognizes WriteObjectInfo");
objectInfo = (WriteObjectInfo)obj;
}
else
{
objectInfo = WriteObjectInfo.Serialize(obj, m_surrogates, m_context, serObjectInfoInit, m_formatterConverter, this, m_binder);
objectInfo.assemId = GetAssemblyId(objectInfo);
}
objectInfo.objectId = objectId;
NameInfo typeNameInfo = TypeToNameInfo(objectInfo);
Write(objectInfo, typeNameInfo, typeNameInfo);
PutNameInfo(typeNameInfo);
objectInfo.ObjectEnd();
}
serWriter.WriteSerializationHeaderEnd();
serWriter.WriteEnd();
// Invoke OnSerialized Event
m_objectManager.RaiseOnSerializedEvent();
SerTrace.Log( this, "Serialize Exit ");
}
internal void Serialize(object graph, Header[] inHeaders, SoapWriter serWriter)
{
object obj2;
long num2;
bool flag;
serializationPermission.Demand();
if (graph == null)
{
throw new ArgumentNullException("graph", SoapUtil.GetResourceString("ArgumentNull_Graph"));
}
if (serWriter == null)
{
throw new ArgumentNullException("serWriter", string.Format(CultureInfo.CurrentCulture, SoapUtil.GetResourceString("ArgumentNull_WithParamName"), new object[] { "serWriter" }));
}
this.serObjectInfoInit = new SerObjectInfoInit();
this.serWriter = serWriter;
this.headers = inHeaders;
if (graph is IMethodMessage)
{
this.bRemoting = true;
MethodBase methodBase = ((IMethodMessage) graph).MethodBase;
if (methodBase != null)
{
serWriter.WriteXsdVersion(this.ProcessTypeAttributes(methodBase.ReflectedType));
}
else
{
serWriter.WriteXsdVersion(XsdVersion.V2001);
}
}
else
{
serWriter.WriteXsdVersion(XsdVersion.V2001);
}
this.m_idGenerator = new ObjectIDGenerator();
this.m_objectQueue = new Queue();
if (graph is ISoapMessage)
{
this.bRemoting = true;
ISoapMessage message = (ISoapMessage) graph;
graph = new InternalSoapMessage(message.MethodName, message.XmlNameSpace, message.ParamNames, message.ParamValues, message.ParamTypes);
this.headers = message.Headers;
}
this.m_serializedTypeTable = new Hashtable();
serWriter.WriteBegin();
long headerId = 0L;
this.topId = this.m_idGenerator.GetId(graph, out flag);
if (this.headers != null)
{
headerId = this.m_idGenerator.GetId(this.headers, out flag);
}
else
{
headerId = -1L;
}
this.WriteSerializedStreamHeader(this.topId, headerId);
if ((this.headers != null) && (this.headers.Length != 0))
{
this.ProcessHeaders(headerId);
}
this.m_objectQueue.Enqueue(graph);
while ((obj2 = this.GetNext(out num2)) != null)
{
WriteObjectInfo objectInfo = null;
if (obj2 is WriteObjectInfo)
{
objectInfo = (WriteObjectInfo) obj2;
}
else
{
objectInfo = WriteObjectInfo.Serialize(obj2, this.m_surrogates, this.m_context, this.serObjectInfoInit, this.m_formatterConverter, null, this);
objectInfo.assemId = this.GetAssemblyId(objectInfo);
}
objectInfo.objectId = num2;
NameInfo memberNameInfo = this.TypeToNameInfo(objectInfo);
memberNameInfo.NIisTopLevelObject = true;
if (this.bRemoting && (obj2 == graph))
{
memberNameInfo.NIisRemoteRecord = true;
}
this.Write(objectInfo, memberNameInfo, memberNameInfo);
this.PutNameInfo(memberNameInfo);
objectInfo.ObjectEnd();
}
serWriter.WriteSerializationHeaderEnd();
serWriter.WriteEnd();
this.m_idGenerator = new ObjectIDGenerator();
this.m_serializedTypeTable = new Hashtable();
this.m_objectManager.RaiseOnSerializedEvent();
}
// The default constructor instantiates the queue for objects
// to be serialized and creates a new instance of the
// ObjectIDGenerator.
protected Formatter() {
m_objectQueue = new Queue();
m_idGenerator = new ObjectIDGenerator();
}
private readonly ObjectIDGenerator objectIdGenerator; // crucial
#endregion Fields
#region Constructors
public NaiveTokenRemover()
{
this.objectIdGenerator = new ObjectIDGenerator();
}
