/// <summary>
/// static void r_ivar(VALUE obj, int *has_encoding, struct load_arg *arg)
/// </summary>
/// <param name="obj"></param>
/// <param name="has_encoding"></param>
public void ReadInstanceVariable(object obj, ref bool has_encoding)
{
int len = ReadLong();
FuzzyObject fobj = obj as FuzzyObject;
if (len > 0)
{
do
{
FuzzySymbol id = ReadSymbol();
object val = ReadObject();
Encoding idx = GetEncoding(id, val);
if (idx != null)
{
if (fobj != null)
{
fobj.Encoding = idx;
}
has_encoding = true;
}
else
{
if (fobj != null)
{
fobj.InstanceVariable[id] = val;
}
}
} while (--len > 0);
}
}
public static string GetShortString(FuzzyObject obj)
{
if (obj == null)
{
return("");
}
return("[" + obj.ClassName.Name + "]");
}
/// <summary>
/// static VALUE append_extmod(VALUE obj, VALUE extmod)
/// </summary>
/// <param name="obj"></param>
/// <param name="extmod"></param>
/// <returns></returns>
public object AppendExtendedModule(object obj, List <FuzzyModule> extmod)
{
FuzzyObject fobj = obj as FuzzyObject;
if (fobj != null)
{
fobj.ExtendModules.AddRange(extmod);
}
return(obj);
}
public bool WriteUserClass(object obj, FuzzyClass super)
{
FuzzyObject fobj = obj as FuzzyObject;
if (fobj != null)
{
FuzzyClass klass = fobj.Class;
}
return(false);
}
protected bool AreValuesDifferent <FT>(FuzzyObject <FT> a, FuzzyObject <FT> b) where FT : Enum
{
if (a == null && b == null)
{
return(false);
}
if (a != null && b != null)
{
return(!a.Value.Equals(b.Value) || AreValuesDifferent(a.Degree, b.Degree));
}
return(true);
}
/// <summary>
/// static void w_extended(VALUE klass, struct dump_arg *arg, int check)
/// </summary>
/// <param name="klass"></param>
/// <param name="check"></param>
public void WriteExtended(object klass, bool check)
{
FuzzyObject fobj = klass as FuzzyObject;
if (fobj != null)
{
foreach (FuzzyModule item in fobj.ExtendModules)
{
WriteByte(RubyMarshal.Types.Extended);
WriteUnique(item.Symbol);
}
}
}
protected void Push(AnyTypeWindow atw)
{
object ob = treeViewForAny1.SelectedObject;
Key key = listViewForAny1.SelectedKey;
if (key == null)
{
if (ob is FuzzyArray)
{
(ob as FuzzyArray).Add(atw.Value);
}
else if (ob is FuzzyObject)
{
FuzzyObject fo = ob as FuzzyObject;
FuzzySymbol fs = FuzzySymbol.GetSymbol(atw.TextName);
if (fo.InstanceVariables.ContainsKey(fs))
{
fo.InstanceVariables[fs] = atw.Value;
}
else
{
fo.InstanceVariables.Add(fs, atw.Value);
}
}
else
{
}
}
else
if (key.Type == Key.KeyType.Array)
{
(ob as FuzzyArray)[key.ArrayKey] = atw.Value;
}
else if (key.Type == Key.KeyType.Hash)
{
(ob as FuzzyHash)[key.HashKey] = atw.Value;
}
else if (key.Type == Key.KeyType.Object)
{
if (key.ObjectKey.Name == NAME_VALUE)
{
(ob as FuzzyObject).ClassName = FuzzySymbol.GetSymbol(atw.TextValue);
}
else
{
(ob as FuzzyObject).InstanceVariables[key.ObjectKey] = atw.Value;
}
}
listViewForAny1.ScanObject();
}
/// <summary>
/// 从文档中读取一个 object
/// 注意：焦点没有发生移动。
/// </summary>
/// <returns></returns>
protected FuzzyObject GetObject()
{
FuzzyObject fobj = new FuzzyObject();
x_node = x_node.FirstChild;
if (x_node.Name == "Name")
{
x_node = x_node.FirstChild;
fobj.ClassName = ReadObject() as FuzzySymbol;
if (fobj.ClassName == null)
{
fobj.ClassName = FuzzySymbol.GetSymbol("");
}
x_node = x_node.ParentNode.NextSibling;
}
FuzzySymbol name = null;
if (x_ignoreSymbolEncoding)
{
name = FuzzySymbol.GetSymbol(ReadAttribute("Name"));
fobj.InstanceVariables.Add(name, ReadObject());
while (x_node.NextSibling != null)
{
x_node = x_node.NextSibling;
name = FuzzySymbol.GetSymbol(ReadAttribute("Name"));
fobj.InstanceVariables.Add(name, ReadObject());
}
}
else
{
name = ReadObject() as FuzzySymbol;
while (x_node.NextSibling != null)
{
x_node = x_node.NextSibling;
if (name == null)
{
name = ReadObject() as FuzzySymbol;
}
else
{
fobj.InstanceVariables.Add(name, ReadObject());
name = null;
}
}
}
x_node = x_node.ParentNode;
return(fobj);
}
private void Form1_Load(object sender, EventArgs e)
{
new MainAction().ShowDialog();
Interpreter.Collector.AddAssembly(System.Reflection.Assembly.GetAssembly(typeof(DataEditor.Control.Container.ContainerArgs)));
Interpreter.Collector.AddAssembly(System.Reflection.Assembly.GetAssembly(typeof(DataEditor.Control.Wrapper.WrapNumInput)));
Interpreter.Builder builder = new Interpreter.Builder();
System.Xml.XmlDocument document = new XmlDocument();
document.Load("Xmls/test1.xml");
try
{
builder.Build(document.FirstChild.NextSibling, panel1.Controls);
}
catch (Exception exc)
{
}
System.IO.FileStream file = new System.IO.FileStream("Tests/Data/Items.rvdata", System.IO.FileMode.Open);
System.IO.FileStream filx = new System.IO.FileStream("Tests/Data/Classes.rvdata", System.IO.FileMode.Open);
System.IO.FileStream fily = new System.IO.FileStream("Tests/Data/Actors.rvdata2", System.IO.FileMode.Open);
System.IO.FileStream filz = new System.IO.FileStream("Tests/Data/System.rvdata2", System.IO.FileMode.Open);
FuzzyObject ob = DataEditor.FuzzyData.Serialization.RubyMarshal.RubyMarshal.Load(file) as FuzzyObject;
FuzzyObject op = DataEditor.FuzzyData.Serialization.RubyMarshal.RubyMarshal.Load(filx) as FuzzyObject;
FuzzyObject od = DataEditor.FuzzyData.Serialization.RubyMarshal.RubyMarshal.Load(fily) as FuzzyObject;
FuzzyObject oq = DataEditor.FuzzyData.Serialization.RubyMarshal.RubyMarshal.Load(filz) as FuzzyObject;
FuzzyArray fa = ob as FuzzyArray;
FuzzyArray fb = op as FuzzyArray;
FuzzyArray fc = od as FuzzyArray;
foreach (System.Windows.Forms.Control control in panel1.Controls)
{
if (control is TabControl)
{
TabControl tc = control as TabControl;
try
{
(tc.TabPages[0].Tag as DataEditor.Control.ObjectEditor).Parent = fa;
(tc.TabPages[1].Tag as DataEditor.Control.ObjectEditor).Parent = fb;
(tc.TabPages[2].Tag as DataEditor.Control.ObjectEditor).Parent = oq;
(tc.TabPages[3].Tag as DataEditor.Control.ObjectEditor).Parent = fc;
}
catch (Exception ex)
{
}
}
}
}
/// <summary>
/// static void w_class(char type, VALUE obj, struct dump_arg *arg, int check)
/// </summary>
/// <param name="type"></param>
/// <param name="obj"></param>
/// <param name="check"></param>
public void WriteClass(byte type, object obj, bool check)
{
object real_obj;
if (this.m_compat_tbl.TryGetValue(obj, out real_obj))
{
obj = real_obj;
}
FuzzyObject fobj = obj as FuzzyObject;
if (fobj != null)
{
FuzzyClass klass = FuzzyClass.GetClass(fobj.ClassName);
WriteExtended(klass, check);
WriteByte(type);
WriteUnique(fobj.ClassName);
}
}
public void ScanObject(FuzzyObject Value)
{
Items.Clear();
if (Value == null)
{
return;
}
dictionary.Add(AddItem(AnyTypeEditor.NAME_VALUE, Value.ClassName),
new Key(FuzzySymbol.GetSymbol(AnyTypeEditor.NAME_VALUE), Key.KeyType.Object));
foreach (FuzzySymbol symbol in Value.InstanceVariables.Keys)
{
object Target = Value.InstanceVariables[symbol];
if (Any.SupportedSingle.Contains(Target.GetType()))
{
dictionary.Add(AddItem(symbol.Name, Target), new Key(symbol, Key.KeyType.Object));
}
}
if (Value is FuzzyArray)
{
FuzzyArray fa = Value as FuzzyArray;
for (int i = 0; i < fa.Length; i++)
{
object Target = fa[i];
if (Any.SupportedSingle.Contains(Target.GetType()))
{
dictionary.Add(AddItem("[" + i.ToString() + "]", Target), new Key(i, Key.KeyType.Array));
}
}
}
if (Value is FuzzyHash)
{
FuzzyHash fh = Value as FuzzyHash;
foreach (object key in fh.Keys)
{
object Target = fh[key];
FuzzyObject target = Target as FuzzyObject;
if (Any.SupportedSingle.Contains(Target.GetType()))
{
dictionary.Add(AddItem(key.ToString(), target), new Key(key, Key.KeyType.Hash));
}
}
}
dictionary.Add(AddItem("", null), null);
}
public BaseFuzzyObject multiply(Word item, double mult)
{
var fuzzy = new FuzzyObject();
var typeDictionary = new Dictionary <string, double>();
typeDictionary.Add(item.GetType().Name, mult);
fuzzy.Belongings.Add("type", typeDictionary);
var fields = item.GetType().GetFields().ToList();
foreach (var field in fields)
{
var temp = new Dictionary <string, double>();
temp.Add(field.GetValue(item).ToString(), mult);
fuzzy.Belongings.Add(field.Name, temp);
}
return(fuzzy);
}
/// <summary>
/// static void w_uclass(VALUE obj, VALUE super, struct dump_arg *arg)
/// </summary>
/// <param name="obj"></param>
/// <param name="super"></param>
public void WriteUserClass(object obj, FuzzyClass super)
{
FuzzyObject fobj = obj as FuzzyObject;
if (fobj != null)
{
FuzzyClass klass = fobj.Class;
WriteExtended(klass, true);
if (klass != super)
{
WriteByte(RubyMarshal.Types.UserClass);
WriteUnique(klass.Symbol);
}
}
else
{
throw new InvalidOperationException();
}
}
public void ScanObject(FuzzyObject Value, TreeNode ParentNode)
{
if (Value == null)
{
return;
}
foreach (FuzzySymbol symbol in Value.InstanceVariables.Keys)
{
object Target = Value.InstanceVariables[symbol];
if (Any.SupportedComplex.Contains(Target.GetType()))
{
ScanObject(Target as FuzzyObject, AddNode("[" + symbol.Name + "]", Target, ParentNode));
}
}
if (Value is FuzzyArray)
{
FuzzyArray fa = Value as FuzzyArray;
for (int i = 0; i < fa.Length; i++)
{
object Target = fa[i];
if (Any.SupportedComplex.Contains(Target.GetType()))
{
ScanObject(Target as FuzzyObject, AddNode("[" + i.ToString() + "]", Target, ParentNode));
}
}
}
if (Value is FuzzyHash)
{
FuzzyHash fh = Value as FuzzyHash;
foreach (object key in fh.Keys)
{
object Target = fh[key];
FuzzyObject target = Target as FuzzyObject;
if (Any.SupportedComplex.Contains(Target.GetType()))
{
ScanObject(target, AddNode("[" + Any.GetShortString(target) + "]", target, ParentNode));
}
}
}
}
/// <summary>
/// static void w_ivar(VALUE obj, st_table *tbl, struct dump_call_arg *arg)
/// </summary>
/// <param name="obj"></param>
public void WriteInstanceVariable(FuzzyObject obj, Dictionary <FuzzySymbol, object> tbl)
{
int num = tbl != null ? tbl.Count : 0;
WriteEncoding(obj, num);
if (tbl != null)
{
foreach (KeyValuePair <FuzzySymbol, object> item in tbl)
{
if (item.Key == RubyMarshal.IDs.encoding)
{
continue;
}
if (item.Key == RubyMarshal.IDs.E)
{
continue;
}
WriteSymbol(item.Key);
WriteObject(item.Value);
}
}
}
private static object LoadNext(string name, object node)
{
int num = -1;
if (int.TryParse(name, out num))
{
if (node is Array)
{
if (num > 0 && num < (node as Array).Length)
{
return((node as Array).GetValue(num));
}
}
if (node is FuzzyArray)
{
if (num > 0 && num < (node as FuzzyArray).Count)
{
return((node as FuzzyArray)[num]);
}
}
}
FuzzyObject obj = node as FuzzyObject;
if (obj == null)
{
throw new ArgumentException(" Giving a wrong object when searching " + name);
}
if (!name.StartsWith("@"))
{
name = "@" + name;
}
FuzzySymbol sym = FuzzySymbol.GetSymbol(name);
if (obj.InstanceVariables.ContainsKey(sym))
{
return(obj.InstanceVariables[sym]);
}
throw new ArgumentException(" Not defined : " + name + " in " + node.ToString());
}
public override void Pull()
{
if (base.Value == null || model == null || Binding == null)
{
return;
}
FuzzyArray arr = base.Value as FuzzyArray;
Prototype.ProtoFullListBox origin = Binding as Prototype.ProtoFullListBox;
if (arr == null || arr == null)
{
return;
}
Prototype.ProtoLeftListBox lb = origin.ListBox;
Link.Clear();
TextManager.Clear();
lb.Items.Clear();
int i = -1, j = 0;
foreach (object Child in arr)
{
i++;
if (Child == null || Child is FuzzyNil)
{
continue;
}
FuzzyObject child = Child as FuzzyObject;
if (child == null)
{
continue;
}
Help.TextManager text = new Help.TextManager(model, child);
lb.Items.Add(text);
Link.Add(i, j++);
}
base.Pull();
Help.TaintRecord.Multi[arr] = Taint;
}
/// <summary>
/// static void w_object(VALUE obj, struct dump_arg *arg, int limit)
/// </summary>
/// <param name="obj"></param>
public void WriteObject(object obj)
{
int num;
if (this.m_objects.TryGetValue(obj, out num))
{
WriteByte(RubyMarshal.Types.Link);
WriteLong(num);
return;
}
if (obj == null || obj == FuzzyNil.Instance)
{
WriteByte(RubyMarshal.Types.Nil);
}
else if (obj is bool && (bool)obj == true)
{
WriteByte(RubyMarshal.Types.True);
}
else if (obj is bool && (bool)obj == false)
{
WriteByte(RubyMarshal.Types.False);
}
else if (obj is FuzzyBool && (obj as FuzzyBool).Value)
{
WriteByte(RubyMarshal.Types.True);
}
else if (obj is FuzzyBool && !(obj as FuzzyBool).Value)
{
WriteByte(RubyMarshal.Types.False);
}
else if (obj is int || obj is long || obj is FuzzyFixnum)
{
long v;
if (obj is int | obj is long)
{
v = (long)obj;
}
else
{
v = (obj as FuzzyFixnum).Value;
}
// (2**30).class => Bignum
// (2**30-1).class => Fixnum
// (-2**30-1).class=> Bignum
// (-2**30).class => Fixnum
if (v <= 1073741823 && v >= -1073741824)
{
WriteByte(RubyMarshal.Types.Fixnum);
WriteLong((int)v);
}
else
{
WriteObject(FuzzyBignum.Create(v));
}
}
else if (obj is FuzzySymbol)
{
WriteSymbol(obj as FuzzySymbol);
}
else
{
FuzzyObject fobj = obj as FuzzyObject;
bool hasiv = false;
if (fobj != null)
{
hasiv = (obj as FuzzyObject).InstanceVariables.Count > 0 || fobj.Encoding != null;
}
var factor = Serialization.Factory <byte[]> .Factor(fobj.GetType());
if (factor != null)
{
WriteSymbol(fobj.ClassName);
factor.dump(m_stream, fobj, null);
}
if (obj is IRubyUserdefinedMarshalDumpObject)
{
this.m_objects.Add(obj, this.m_objects.Count);
object result = (obj as IRubyUserdefinedMarshalDumpObject).Dump();
if (hasiv)
{
WriteByte(RubyMarshal.Types.InstanceVariable);
}
WriteClass(RubyMarshal.Types.UserMarshal, obj, false);
WriteObject(result);
if (hasiv)
{
WriteObjectInstanceVariable(fobj);
}
return;
}
if (obj is IRubyUserdefinedDumpObject)
{
byte[] result = (obj as IRubyUserdefinedDumpObject).Dump();
if (hasiv)
{
WriteByte(RubyMarshal.Types.InstanceVariable);
}
WriteClass(RubyMarshal.Types.UserDefined, obj, false);
WriteBytes(result, result.Length);
if (hasiv)
{
WriteObjectInstanceVariable(fobj);
}
this.m_objects.Add(obj, this.m_objects.Count);
return;
}
this.m_objects.Add(obj, this.m_objects.Count);
if (hasiv)
{
WriteByte(RubyMarshal.Types.InstanceVariable);
}
if (obj is FuzzyClass)
{
WriteByte(RubyMarshal.Types.Class);
WriteCString((obj as FuzzyClass).Name);
}
else if (obj is FuzzyModule)
{
WriteByte(RubyMarshal.Types.Module);
WriteCString((obj as FuzzyModule).Name);
}
else if (obj is float)
{
WriteByte(RubyMarshal.Types.Float);
WriteFloat((float)obj);
}
else if (obj is double)
{
WriteByte(RubyMarshal.Types.Float);
WriteFloat((double)obj);
}
else if (obj is FuzzyFloat)
{
WriteByte(RubyMarshal.Types.Float);
WriteFloat((FuzzyFloat)obj);
}
else if (obj is FuzzyBignum || obj is FuzzyBignumAdapter)
{
FuzzyBignum value;
if (obj is FuzzyBignumAdapter)
{
value = (obj as FuzzyBignumAdapter).Value;
}
else
{
value = (FuzzyBignum)obj;
}
char ch;
if (value.Sign > 0)
{
ch = '+';
}
else if (value.Sign < 0)
{
ch = '-';
}
else
{
ch = '0';
}
this.m_writer.Write((byte)ch);
uint[] words = value.GetWords();
int num2 = words.Length * 2;
int index = words.Length - 1;
bool flag = false;
if ((words.Length > 0) && ((words[index] >> 0x10) == 0))
{
num--;
flag = true;
}
this.WriteLong(num2);
for (int i = 0; i < words.Length; i++)
{
if (flag && (i == index))
{
this.m_writer.Write((ushort)words[i]);
}
else
{
this.m_writer.Write(words[i]);
}
}
}
else if (obj is FuzzyString || obj is string)
{
FuzzyString v;
if (obj is string)
{
v = new FuzzyString(obj as string);
}
else
{
v = (FuzzyString)obj;
}
WriteUserClass(v, FuzzyClass.GetClass("String"));
WriteByte(RubyMarshal.Types.String);
WriteBytes(v.Raw);
}
else if (obj is FuzzyRegexp)
{
FuzzyRegexp v = (FuzzyRegexp)obj;
WriteUserClass(obj, FuzzyClass.GetClass("Regexp"));
WriteByte(RubyMarshal.Types.Regexp);
WriteBytes(v.Pattern.Raw);
WriteByte((byte)v.Options);
}
else if (obj is FuzzyArray || obj is List <object> )
{
FuzzyArray v;
if (obj is List <object> )
{
v = new FuzzyArray(obj as List <object>);
}
else
{
v = (FuzzyArray)obj;
}
WriteUserClass(v, FuzzyClass.GetClass("Array"));
WriteByte(RubyMarshal.Types.Array);
WriteLong(v.Length);
for (int i = 0; i < v.Count; i++)
{
WriteObject(v[i]);
}
}
else if (obj is FuzzyHash)
{
FuzzyHash v = (FuzzyHash)obj;
WriteUserClass(obj, FuzzyClass.GetClass("Hash"));
WriteByte(v.DefaultValue != null ? RubyMarshal.Types.HashWithDefault : RubyMarshal.Types.Hash);
WriteLong(v.Length);
foreach (KeyValuePair <object, object> item in v)
{
WriteObject(item.Key);
WriteObject(item.Value);
}
if (v.DefaultValue != null)
{
WriteObject(v.DefaultValue);
}
}
else if (obj is FuzzyStruct)
{
FuzzyStruct v = (FuzzyStruct)obj;
WriteUserClass(obj, FuzzyClass.GetClass("Struct"));
WriteLong(v.InstanceVariables.Count);
foreach (KeyValuePair <FuzzySymbol, object> item in v.InstanceVariables)
{
WriteObject(item.Key);
WriteObject(item.Value);
}
}
else if (obj is FuzzyObject)
{
WriteClass(RubyMarshal.Types.Object, obj, true);
WriteObjectInstanceVariable((FuzzyObject)obj);
}
else
{
throw new InvalidDataException(string.Format("can't dump {0}", obj.GetType().FullName));
}
if (hasiv)
{
WriteInstanceVariable(fobj, fobj.InstanceVariables);
}
}
}
/// <summary>
/// static void w_objivar(VALUE obj, struct dump_call_arg *arg)
/// </summary>
/// <param name="obj"></param>
public void WriteObjectInstanceVariable(FuzzyObject obj)
{
WriteInstanceVariable(obj, obj.InstanceVariables);
}
public void WriteObject(object obj)
{
int num;
if (this.x_objects.TryGetValue(obj, out num))
{
WriteNode(XML.Types.Link, num.ToString());
return;
}
if (obj == null || obj == FuzzyNil.Instance)
{
WriteNode(XML.Types.Nil, "");
}
else if (obj is bool && (bool)obj == true)
{
WriteNode(XML.Types.True, "");
}
else if (obj is bool && (bool)obj == false)
{
WriteNode(XML.Types.False, "");
}
else if (obj is int || obj is long || obj is FuzzyFixnum)
{
long v;
if (obj is FuzzyFixnum)
{
v = (obj as FuzzyFixnum).Value;
}
else
{
v = (long)obj;
}
if (v <= 1073741823 && v >= -1073741824)
{
WriteNode(XML.Types.Fixnum, obj.ToString());
}
else
{
WriteObject(FuzzyBignum.Create(v));
}
}
else if (obj is FuzzySymbol)
{
WriteSymbol(obj as FuzzySymbol);
}
else
{
FuzzyObject fobj = obj as FuzzyObject;
bool hasiv = false;
if (fobj != null)
{
hasiv = (obj as FuzzyObject).InstanceVariables.Count > 0 || fobj.Encoding != null;
}
if (obj is IXMLUserdefinedDumpObject)
{
this.x_objects.Add(obj, this.x_objects.Count);
object result = (obj as IXMLUserdefinedMarshalDumpObject).Dump();
WritePopNode(XML.Types.UserMarshal, "");
WriteObject(result);
x_parent_node.Pop();
return;
}
if (obj is IXMLUserdefinedDumpObject)
{
XmlNode result = (obj as IXMLUserdefinedDumpObject).Dump();
WritePopNode(XML.Types.UserDefined, "").AppendChild(result);
this.x_objects.Add(obj, this.x_objects.Count);
return;
}
this.x_objects.Add(obj, this.x_objects.Count);
if (obj is FuzzyClass)
{
WriteNode(XML.Types.Class, (obj as FuzzyClass).Name);
}
else if (obj is FuzzyModule)
{
WriteNode(XML.Types.Module, (obj as FuzzyClass).Name);
}
else if (obj is float)
{
WriteFloat((float)obj);
}
else if (obj is double)
{
WriteFloat((double)obj);
}
else if (obj is FuzzyFloat)
{
WriteFloat((obj as FuzzyFloat).Value);
}
else if (obj is FuzzyBignum)
{
WriteNode(XML.Types.Bignum, obj.ToString());
}
else if (obj is FuzzyBignumAdapter)
{
WriteNode(XML.Types.Bignum, (obj as FuzzyBignumAdapter).Value.ToString());
}
else if (obj is FuzzyString || obj is string)
{
FuzzyString v;
if (obj is string)
{
v = new FuzzyString(obj as string);
}
else
{
v = (FuzzyString)obj;
}
WritePopNode(XML.Types.String);
WriteString(v.Text, v.Encoding);
x_parent_node.Pop();
}
else if (obj is FuzzyRegexp)
{
FuzzyRegexp v = (FuzzyRegexp)obj;
WritePopNode(XML.Types.Regexp);
WriteString(v.Pattern.Text, v.Pattern.Encoding);
WriteNode("Options", ((int)v.Options).ToString());
}
else if (obj is FuzzyArray || obj is List <object> )
{
FuzzyArray v;
if (obj is List <object> )
{
v = new FuzzyArray(obj as List <object>);
}
else
{
v = (FuzzyArray)obj;
}
WritePopNode(XML.Types.Array);
for (int i = 0; i < v.Count; i++)
{
WriteObject(v[i]);
}
x_parent_node.Pop();
}
else if (obj is FuzzyHash)
{
FuzzyHash v = (FuzzyHash)obj;
if (v.DefaultValue == null)
{
WritePopNode(XML.Types.Hash);
}
else
{
WritePopNode(XML.Types.HashWithDefault);
WritePopNode("Default");
WriteObject(v.DefaultValue);
x_parent_node.Pop();
}
foreach (KeyValuePair <object, object> item in v)
{
WriteObject(item.Key);
WriteObject(item.Value);
}
x_parent_node.Pop();
}
else if (obj is FuzzyObject || obj is FuzzyStruct)
{
FuzzyObject v = fobj;
if (obj is FuzzyObject)
{
WritePopNode(XML.Types.Object);
}
else
{
WritePopNode(XML.Types.Struct);
}
if (XML.Options.IgnoreSymbolEncoding)
{
WriteAttribute("Name", v.ClassName.Name);
foreach (KeyValuePair <FuzzySymbol, object> item in v.InstanceVariables)
{
WritePopNode("Data");
WriteAttribute("Name", item.Key.Name);
WriteObject(item.Value);
x_parent_node.Pop();
}
}
else
{
var factor = Serialization.Factory <XmlNode> .Factor(fobj.GetType());
if (factor == null)
{
factor = Serialization.Factory <XmlNode> .Factor(fobj.ClassName.Name);
}
if (factor != null)
{
WritePopNode(XML.Types.UserDefined);
XmlNode node = factor.dump(x_stream, fobj, null);
node = x_document.ImportNode(node, true);
x_parent_node.Pop().AppendChild(node);
}
else
{
WritePopNode("Name");
WriteObject(v.ClassName);
x_parent_node.Pop();
foreach (KeyValuePair <FuzzySymbol, object> item in v.InstanceVariables)
{
WriteSymbol(item.Key);
WriteObject(item.Value);
}
}
}
x_parent_node.Pop();
}
else
{
throw new InvalidDataException(string.Format("can't dump {0}", obj.GetType().FullName));
}
}
}
public ValueChangedEventArgs(FuzzyObject Value)
{
newValue = Value;
}
static void Main(string[] args)
{
//FuzzyModule fm = new FuzzyModule();
//FuzzyVariable DistToTarget = m_FuzzyModule.CreateFLV("DistToTarget");
//FuzzySetProxy Target_Close = DistToTarget.AddFuzzySet("Target_Close", FuzzySet.CreateLeftShoulderSet(0, 25, 150));
//FuzzySetProxy Target_Medium = DistToTarget.AddFuzzySet("Target_Medium", FuzzySet.CreateTriangularSet(25, 150, 300));
//FuzzySetProxy Target_Far = DistToTarget.AddFuzzySet( "Target_Far", FuzzySet.CreateRightShoulderSet(150, 300, 1000));
//FuzzyVariable Desirability = m_FuzzyModule.CreateFLV("Desirability");
//FuzzySetProxy Undesirable = Desirability.AddFuzzySet("Undesirable", FuzzySet.CreateLeftShoulderSet(0, 25, 50));
//FuzzySetProxy Desirable = Desirability.AddFuzzySet("Desirable", FuzzySet.CreateTriangularSet(25, 50, 75));
//FuzzySetProxy VeryDesirable = Desirability.AddFuzzySet("VeryDesirable", FuzzySet.CreateRightShoulderSet(50, 75, 100));
//FuzzyVariable AmmoStatus = m_FuzzyModule.CreateFLV("AmmoStatus");
//FuzzySetProxy Ammo_Loads = AmmoStatus.AddFuzzySet("Ammo_Loads", FuzzySet.CreateRightShoulderSet(10, 30, 100));
//FuzzySetProxy Ammo_Okay = AmmoStatus.AddFuzzySet("Ammo_Okay", FuzzySet.CreateTriangularSet(0, 10, 30));
//FuzzySetProxy Ammo_Low = AmmoStatus.AddFuzzySet("Ammo_Low", FuzzySet.CreateTriangularSet(0, 0, 10));
//m_FuzzyModule.AddRule(new FuzzyOperatorOR(new FuzzyOperatorAND(Target_Close, Ammo_Low), new FuzzyOperatorOR(new FuzzyOperatorAND(Target_Close, Ammo_Loads), new FuzzyOperatorAND(Target_Close, Ammo_Okay))), Undesirable);
////m_FuzzyModule.AddRule(new FuzzyOperatorAND(Target_Close, Ammo_Okay), Undesirable);
////m_FuzzyModule.AddRule(new FuzzyOperatorAND(Target_Close, Ammo_Low), Undesirable);
//m_FuzzyModule.AddRule(new FuzzyOperatorAND(Target_Medium, Ammo_Loads), VeryDesirable);
//m_FuzzyModule.AddRule(new FuzzyOperatorAND(Target_Medium, Ammo_Okay), VeryDesirable);
//m_FuzzyModule.AddRule(new FuzzyOperatorAND(Target_Medium, Ammo_Low), Desirable);
//m_FuzzyModule.AddRule(new FuzzyOperatorAND(Target_Far, Ammo_Loads), Desirable);
//m_FuzzyModule.AddRule(new FuzzyOperatorAND(Target_Far, Ammo_Okay), Undesirable);
//m_FuzzyModule.AddRule(new FuzzyOperatorAND(Target_Far, Ammo_Low), Undesirable);
//Console.Write("Enter distance: ");
//string distanceString = Console.ReadLine();
//double distance = 0;
//double.TryParse(distanceString, out distance);
//Console.Write("Enter rounds: ");
//string roundsString = Console.ReadLine();
//int numRoundsLeft = 0;
//int.TryParse(roundsString, out numRoundsLeft);
////fuzzify distance and amount of ammo
//m_FuzzyModule.Fuzzify("DistToTarget", distance);
//m_FuzzyModule.Fuzzify("AmmoStatus", (double)numRoundsLeft);
//double desirabilityScore = m_FuzzyModule.DeFuzzify("Desirability", DefuzzifyMethod.MAX_AV);
//Console.WriteLine("Desirability Score: {0}", desirabilityScore);
//Console.ReadLine();
var enemy = new Enemy();
var mod = new FuzzyObject<Enemy>(enemy);
var distanceVariable = mod.DefineVariable(p => p.DistanceToTarget);
var statusVariable = mod.DefineVariable(p => p.AmmoStatus);
var desireability = mod.DefineVariable(p => p.Desireability);
mod.AddFuzzySet("Ammo_Loads", p => p.AmmoStatus, FuzzySet.CreateRightShoulderSet, 10, 20, 100)
.AddFuzzySet("Ammo_Okay", p => p.AmmoStatus, FuzzySet.CreateTriangularSet, 0, 10, 30)
.AddFuzzySet("Ammo_Low", p => p.AmmoStatus, FuzzySet.CreateTriangularSet, 0, 0, 10);
mod.AddFuzzySet("Undesirable", p => p.Desireability, FuzzySet.CreateLeftShoulderSet, 0, 25, 50)
.AddFuzzySet("Desirable", p => p.Desireability, FuzzySet.CreateTriangularSet, 25, 50, 75)
.AddFuzzySet("VeryDesirable", p => p.Desireability, FuzzySet.CreateRightShoulderSet, 50, 75, 100);
mod.AddFuzzySet("Target_Close", p => p.DistanceToTarget, FuzzySet.CreateLeftShoulderSet, 0, 25, 150)
.AddFuzzySet("Target_Medium", p => p.DistanceToTarget, FuzzySet.CreateTriangularSet, 25, 150, 300)
.AddFuzzySet( "Target_Far", p => p.DistanceToTarget, FuzzySet.CreateRightShoulderSet, 150, 300, 1000);
//FuzzyVariable Desirability = m_FuzzyModule.CreateFLV("Desirability");
//FuzzySetProxy Undesirable = Desirability.AddFuzzySet("Undesirable", FuzzySet.CreateLeftShoulderSet(0, 25, 50));
//FuzzySetProxy Desirable = Desirability.AddFuzzySet("Desirable", FuzzySet.CreateTriangularSet(25, 50, 75));
//FuzzySetProxy VeryDesirable = Desirability.AddFuzzySet("VeryDesirable", FuzzySet.CreateRightShoulderSet(50, 75, 100));
//dynamic modwrapper = mod;
dynamic modwrapper = mod.GetDynamic();
//mod.WrapSet("Ammo_Loads").And(mod["Ammo_Okay"]);
//.Or(mod.And(mod["DistanceOkay"], mod["Ammo_Low"])
mod.AddRule(
mod.WrapSet(modwrapper.Ammo_Loads)
.Or(mod["Ammo_Okay"])
.And(mod["Target_Medium"])
, /* antecedent - If */
mod.WrapSet("Desirable") /* consequence - then */
);
//FuzzySetProxy Ammo_Okay = AmmoStatus.AddFuzzySet("Ammo_Okay", FuzzySet.CreateTriangularSet(0, 10, 30));
//FuzzySetProxy Ammo_Low = AmmoStatus.AddFuzzySet("Ammo_Low", FuzzySet.CreateTriangularSet(0, 0, 10));
var ammoLoads = distanceVariable.AddFuzzySet("dont", FuzzySet.CreateTriangularSet(0, 50, 4000));
var desirable = desireability.AddFuzzySet("dont", FuzzySet.CreateTriangularSet(0, 50, 4000));
enemy.DistanceToTarget = 45;
enemy.AmmoStatus = 5;
enemy.Desireability = 23;
// fuzzify some variables to be used
//mod.Fuzzify(p => p.DistanceToTarget);
//mod.Fuzzify(p => p.AmmoStatus);
mod.Compile(
p => p.DistanceToTarget,
p => p.AmmoStatus);
// get result
mod.DeFuzzify(p => p.Desireability, m => m.DeFuzzifyCentroid(15));
//mod.DeFuzzify(p => p.Desireability, m => m.DeFuzzifyMaxAv());
//mod.Module.AddRule(new FuzzyOperatorAND(targetFar, ammoLoads), desirable);
//mod.DeFuzzify(p => p.Desireability, DefuzzifyMethod.CENTROID);
}
/// <summary>
/// static VALUE r_object0(struct load_arg *arg, int *ivp, VALUE extmod)
/// </summary>
/// <param name="hasivp"></param>
/// <param name="ivp"></param>
/// <param name="extmod"></param>
/// <returns></returns>
public object ReadObject0(bool hasivp, ref bool ivp, List <FuzzyModule> extmod)
{
object v = null;
int type = ReadByte();
int id;
object link;
switch (type)
{
case RubyMarshal.Types.Link:
id = ReadLong();
if (!this.m_objects.TryGetValue(id, out link))
{
throw new InvalidDataException("dump format error (unlinked)");
}
v = link;
if (this.m_proc != null)
{
v = this.m_proc(v);
}
break;
case RubyMarshal.Types.InstanceVariable:
{
bool ivar = true;
v = ReadObject0(ref ivar, extmod);
bool hasenc = false;
if (ivar)
{
ReadInstanceVariable(v, ref hasenc);
}
}
break;
case RubyMarshal.Types.Extended:
{
FuzzyModule m = FuzzyModule.GetModule(ReadUnique());
if (extmod == null)
{
extmod = new List <FuzzyModule>();
}
extmod.Add(m);
v = ReadObject0(extmod);
FuzzyObject fobj = v as FuzzyObject;
if (fobj != null)
{
fobj.ExtendModules.AddRange(extmod);
}
}
break;
case RubyMarshal.Types.UserClass:
{
FuzzyClass c = FuzzyClass.GetClass(ReadUnique());
v = ReadObject0(extmod);
if (v is FuzzyObject)
{
(v as FuzzyObject).ClassName = c.Symbol;
}
}
break;
case RubyMarshal.Types.Nil:
v = FuzzyNil.Instance;
v = Leave(v);
break;
case RubyMarshal.Types.True:
v = FuzzyBool.True;
v = Leave(v);
break;
case RubyMarshal.Types.False:
v = FuzzyBool.False;
v = Leave(v);
break;
case RubyMarshal.Types.Fixnum:
v = ReadLong();
v = new FuzzyFixnum(Convert.ToInt64(v));
v = Leave(v);
break;
case RubyMarshal.Types.Float:
{
double d;
FuzzyString fstr = ReadString();
string str = fstr.Text;
if (str == "inf")
{
d = double.PositiveInfinity;
}
else if (str == "-inf")
{
d = double.NegativeInfinity;
}
else if (str == "nan")
{
d = double.NaN;
}
else
{
if (str.Contains("\0"))
{
str = str.Remove(str.IndexOf("\0"));
}
d = Convert.ToDouble(str);
}
v = new FuzzyFloat(d);
v = Entry(v);
v = Leave(v);
}
break;
case RubyMarshal.Types.Bignum:
{
int sign = 0;
switch (ReadByte())
{
case 0x2b:
sign = 1;
break;
case 0x2d:
sign = -1;
break;
default:
sign = 0;
break;
}
int num3 = ReadLong();
int index = num3 / 2;
int num5 = (num3 + 1) / 2;
uint[] data = new uint[num5];
for (int i = 0; i < index; i++)
{
data[i] = m_reader.ReadUInt32();
}
if (index != num5)
{
data[index] = m_reader.ReadUInt16();
}
v = new FuzzyBignum(sign, data);
v = new FuzzyBignumAdapter(v as FuzzyBignum);
v = Entry(v);
v = Leave(v);
}
break;
case RubyMarshal.Types.String:
v = Entry(ReadString());
v = Leave(v);
break;
case RubyMarshal.Types.Regexp:
{
FuzzyString str = ReadString();
int options = ReadByte();
bool has_encoding = false;
int idx = Prepare();
if (hasivp)
{
ReadInstanceVariable(str, ref has_encoding);
ivp = false;
}
if (!has_encoding)
{
// TODO: 1.8 compatibility; remove escapes undefined in 1.8
/*
* char *ptr = RSTRING_PTR(str), *dst = ptr, *src = ptr;
* long len = RSTRING_LEN(str);
* long bs = 0;
* for (; len-- > 0; *dst++ = *src++) {
* switch (*src) {
* case '\\': bs++; break;
* case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
* case 'm': case 'o': case 'p': case 'q': case 'u': case 'y':
* case 'E': case 'F': case 'H': case 'I': case 'J': case 'K':
* case 'L': case 'N': case 'O': case 'P': case 'Q': case 'R':
* case 'S': case 'T': case 'U': case 'V': case 'X': case 'Y':
* if (bs & 1) --dst;
* default: bs = 0; break;
* }
* }
* rb_str_set_len(str, dst - ptr);
*/
}
v = Entry0(new FuzzyRegexp(str, (FuzzyRegexpOptions)options), idx);
v = Leave(v);
}
break;
case RubyMarshal.Types.Array:
{
int len = ReadLong();
FuzzyArray ary = new FuzzyArray();
v = ary;
v = Entry(v);
while (len-- > 0)
{
ary.Push(ReadObject());
}
v = Leave(v);
}
break;
case RubyMarshal.Types.Hash:
case RubyMarshal.Types.HashWithDefault:
{
int len = ReadLong();
FuzzyHash hash = new FuzzyHash();
v = hash;
v = Entry(v);
while (len-- > 0)
{
object key = ReadObject();
object value = ReadObject();
hash.Add(key, value);
}
if (type == RubyMarshal.Types.HashWithDefault)
{
hash.DefaultValue = ReadObject();
}
v = Leave(v);
}
break;
case RubyMarshal.Types.Struct:
{
int idx = Prepare();
FuzzyStruct obj = new FuzzyStruct();
FuzzySymbol klass = ReadUnique();
obj.ClassName = klass;
int len = ReadLong();
v = obj;
v = Entry0(v, idx);
while (len-- > 0)
{
FuzzySymbol key = ReadSymbol();
object value = ReadObject();
obj.InstanceVariable[key] = value;
}
v = Leave(v);
}
break;
case RubyMarshal.Types.UserDefined:
{
FuzzySymbol klass = ReadUnique();
var factor = Factory <byte[]> .Factor(klass.Name);
if (factor == null)
{
FuzzyString data = ReadString();
if (hasivp)
{
ReadInstanceVariable(data);
ivp = false;
}
FuzzyUserdefinedDumpObject obj = new FuzzyUserdefinedDumpObject();
obj.ClassName = klass;
obj.DumpedObject = data.Raw;
v = obj;
v = Entry(v);
v = Leave(v);
}
else
{
object obj = factor._dump(m_stream, null);
v = obj;
v = Entry(v);
v = Leave(v);
}
}
break;
case RubyMarshal.Types.UserMarshal:
{
FuzzySymbol klass = ReadUnique();
FuzzyUserdefinedMarshalDumpObject obj = new FuzzyUserdefinedMarshalDumpObject();
v = obj;
if (extmod != null)
{
AppendExtendedModule(obj, extmod);
}
v = Entry(v);
object data = ReadObject();
obj.ClassName = klass;
obj.DumpedObject = data;
v = Leave(v);
if (extmod != null)
{
extmod.Clear();
}
}
break;
case RubyMarshal.Types.Object:
{
int idx = Prepare();
FuzzyObject obj = new FuzzyObject();
FuzzySymbol klass = ReadUnique();
obj.ClassName = klass;
v = obj;
v = Entry0(v, idx);
ReadInstanceVariable(v);
v = Leave(v);
}
break;
case RubyMarshal.Types.Class:
{
FuzzyString str = ReadString();
v = FuzzyClass.GetClass(FuzzySymbol.GetSymbol(str));
v = Entry(v);
v = Leave(v);
}
break;
case RubyMarshal.Types.Module:
{
FuzzyString str = ReadString();
v = FuzzyModule.GetModule(FuzzySymbol.GetSymbol(str));
v = Entry(v);
v = Leave(v);
}
break;
case RubyMarshal.Types.Symbol:
if (hasivp)
{
v = ReadSymbolReal(ivp);
ivp = false;
}
else
{
v = ReadSymbolReal(false);
}
v = Leave(v);
break;
case RubyMarshal.Types.SymbolLink:
v = ReadSymbolLink();
break;
case RubyMarshal.Types.Data:
/* TODO: Data Support
* {
* VALUE klass = path2class(r_unique(arg));
* VALUE oldclass = 0;
*
* v = obj_alloc_by_klass(klass, arg, &oldclass);
* if (!RB_TYPE_P(v, T_DATA)) {
* rb_raise(rb_eArgError, "dump format error");
* }
* v = r_entry(v, arg);
* if (!rb_respond_to(v, s_load_data)) {
* rb_raise(rb_eTypeError, "class %s needs to have instance method `_load_data'", rb_class2name(klass));
* }
* rb_funcall(v, s_load_data, 1, r_object0(arg, 0, extmod));
* check_load_arg(arg, s_load_data);
* v = r_leave(v, arg);
* }
*/
case RubyMarshal.Types.ModuleOld:
/*
* TODO: ModuleOld Support
* {
* volatile VALUE str = r_bytes(arg);
* v = rb_path_to_class(str);
* v = r_entry(v, arg);
* v = r_leave(v, arg);
* }
*/
default:
throw new InvalidDataException(string.Format("dump format error(0x{0:X2})", type));
}
return(v);
}
protected override void Implication()
{
base.Implication();
// -------------------------------------------------------------------------------------
FuzzyObject <FuzzyInteractionModeTypes> resultOfNoErrorsAndMuchPositves =
If(FuzzyErrorHistoryTypes.NoErrors)
//.And(FuzzyPositiveHistoryTypes.MuchPositives)
.Then(FuzzyInteractionModeTypes.Solving);
FuzzyObject <FuzzyInteractionModeTypes> resultOfMuchErrorsOrNoPositivesOrMuchNeutrals =
If(FuzzyErrorHistoryTypes.MuchErrors)
//.Or(FuzzyPositiveHistoryTypes.NoPositives)
//.Or(FuzzyNeutralHistoryTypes.MuchNeutrals)
.Then(FuzzyInteractionModeTypes.Learning);
_learningModeConditionResults.Clear();
_learningModeConditionResults.Add(resultOfNoErrorsAndMuchPositves);
_learningModeConditionResults.Add(resultOfMuchErrorsOrNoPositivesOrMuchNeutrals);
// ToDo: Think about moving that stuff to base class and use a method like AddConditionResult(...)
_conditionResults.Add(resultOfNoErrorsAndMuchPositves.NeutralType());
_conditionResults.Add(resultOfMuchErrorsOrNoPositivesOrMuchNeutrals.NeutralType());
AddDegree(resultOfNoErrorsAndMuchPositves.Value, resultOfNoErrorsAndMuchPositves.Degree);
AddDegree(resultOfMuchErrorsOrNoPositivesOrMuchNeutrals.Value, resultOfMuchErrorsOrNoPositivesOrMuchNeutrals.Degree);
// -------------------------------------------------------------------------------------
FuzzyObject <FuzzyExpectationFactorTypes> resultOfPositiveLearningPlausibility =
If(FuzzyPlausibilityOfPositiveFeedbackTypes.LearningPlausibility)
.Factor(FuzzyInteractionModeTypes.Learning)
.Then(FuzzyExpectationFactorTypes.PositiveFeedback);
FuzzyObject <FuzzyExpectationFactorTypes> resultOfPositiveSolvingPlausibility =
If(FuzzyPlausibilityOfPositiveFeedbackTypes.SolvingPlausibility)
.Factor(Not(FuzzyInteractionModeTypes.Learning))
.Then(FuzzyExpectationFactorTypes.PositiveFeedback);
FuzzyObject <FuzzyExpectationFactorTypes> resultOfNegativeLearningPlausibility =
If(FuzzyPlausibilityOfNegativeFeedbackTypes.LearningPlausibility)
.Factor(FuzzyInteractionModeTypes.Learning)
.Then(FuzzyExpectationFactorTypes.NegativeFeedback);
FuzzyObject <FuzzyExpectationFactorTypes> resultOfNegativeSolvingPlausibility =
If(FuzzyPlausibilityOfNegativeFeedbackTypes.SolvingPlausibility)
.Factor(Not(FuzzyInteractionModeTypes.Learning))
.Then(FuzzyExpectationFactorTypes.NegativeFeedback);
_expectionFactorConditionResults.Clear();
_expectionFactorConditionResults.Add(resultOfPositiveLearningPlausibility);
_expectionFactorConditionResults.Add(resultOfPositiveSolvingPlausibility);
_expectionFactorConditionResults.Add(resultOfNegativeLearningPlausibility);
_expectionFactorConditionResults.Add(resultOfNegativeSolvingPlausibility);
// ToDo: Think about moving that stuff to base class and use a method like AddConditionResult(...)
_conditionResults.Add(resultOfPositiveLearningPlausibility.NeutralType());
_conditionResults.Add(resultOfPositiveSolvingPlausibility.NeutralType());
_conditionResults.Add(resultOfNegativeLearningPlausibility.NeutralType());
_conditionResults.Add(resultOfNegativeSolvingPlausibility.NeutralType());
// -------------------------------------------------------------------------------------
}