public override long compare(object obj)
{
Version that = (Version)obj;
List a = this.m_segments;
List b = that.m_segments;
for (int i = 0; i < a.sz() && i < b.sz(); i++)
{
long ai = (a.get(i) as Long).longValue();
long bi = (b.get(i) as Long).longValue();
if (ai < bi)
{
return(-1);
}
if (ai > bi)
{
return(+1);
}
}
if (a.sz() < b.sz())
{
return(-1);
}
if (a.sz() > b.sz())
{
return(+1);
}
return(0);
}
public List removeAll(List toRemove)
{
// optimize special cases
modify();
if (toRemove.sz() == 0)
{
return(this);
}
if (toRemove.sz() == 1)
{
remove(toRemove.get(0)); return(this);
}
// rebuild the backing store array, implementation
// assumes that this list is bigger than toRemove list
object[] newValues = new object[m_values.Length];
int newSize = 0;
for (int i = 0; i < m_size; ++i)
{
object val = m_values[i];
if (!toRemove.contains(val))
{
newValues[newSize++] = val;
}
}
this.m_values = newValues;
this.m_size = newSize;
return(this);
}
protected void doReflect()
{
// ensure master type is reflected
Type master = m_base;
master.finish();
List masterSlots = master.slots();
// allocate slot data structures
m_fields = new List(Sys.FieldType, master.fields().sz());
m_methods = new List(Sys.MethodType, master.methods().sz());
m_slots = new List(Sys.SlotType, masterSlots.sz());
m_slotsByName = new Hashtable(masterSlots.sz() * 3);
// parameterize master's slots
for (int i = 0; i < masterSlots.sz(); i++)
{
Slot slot = (Slot)masterSlots.get(i);
if (slot is Method)
{
slot = parameterize((Method)slot);
m_methods.add(slot);
}
else
{
slot = parameterize((Field)slot);
m_fields.add(slot);
}
m_slots.add(slot);
m_slotsByName[slot.m_name] = slot;
}
}
public override void delete()
{
if (!exists())
{
return;
}
if (m_file is DirectoryInfo)
{
List kids = list();
for (int i = 0; i < kids.sz(); i++)
{
(kids.get(i) as File).delete();
}
}
try
{
m_file.Delete();
m_file.Refresh();
}
catch (System.Exception e)
{
throw IOErr.make("Cannot delete: " + m_file, e).val;
}
}
public override List inheritance()
{
if (m_inheritance == null)
{
Hashtable map = new Hashtable();
List acc = new List(Sys.TypeType);
// handle Void as a special case
if (this == Sys.VoidType)
{
acc.add(this);
return(m_inheritance = acc.trim());
}
// add myself
map[m_qname] = this;
acc.add(this);
// add my direct inheritance inheritance
addInheritance(@base(), acc, map);
List m = mixins();
for (int i = 0; i < m.sz(); i++)
{
addInheritance((Type)m.get(i), acc, map);
}
m_inheritance = acc.trim().ro();
}
return(m_inheritance);
}
public static List list()
{
lock (m_podsByName)
{
// TODO - eventually we need a faster way to load
// pod meta-data into memory without actually loading
// every pod into memory
if (m_allPodsList == null)
{
List names = Env.cur().findAllPodNames();
List pods = new List(Sys.PodType);
for (int i = 0; i < names.sz(); ++i)
{
string name = (string)names.get(i);
try
{
pods.add(doFind(name, true, null));
}
catch (Exception e)
{
System.Console.WriteLine("ERROR: Invalid pod file: " + name);
Err.dumpStack(e);
}
}
m_allPodsList = pods.ro();
}
return(m_allPodsList);
}
}
private static object doTrap(object self, string name, List args, Type type)
{
Slot slot = type.slot(name, true);
if (slot is Method)
{
Method m = (Method)slot;
return(m.m_func.callOn(self, args));
}
else
{
Field f = (Field)slot;
int argSize = (args == null) ? 0 : args.sz();
if (argSize == 0)
{
return(FanUtil.box(f.get(self)));
}
if (argSize == 1)
{
object val = args.get(0);
f.set(self, val);
return(FanUtil.box(val));
}
throw ArgErr.make("Invalid number of args to get or set field '" + name + "'").val;
}
}
public virtual object make(List args)
{
Method make = method("make", false);
if (make != null && make.isPublic())
{
int numArgs = args == null ? 0 : args.sz();
List p = make.@params();
if ((numArgs == p.sz()) ||
(numArgs < p.sz() && ((Param)p.get(numArgs)).hasDefault()))
{
return(make.m_func.callList(args));
}
}
Slot defVal = slot("defVal", false);
if (defVal is Field)
{
return(((Field)defVal).get(null));
}
if (defVal is Method)
{
return(((Method)defVal).m_func.callList(null));
}
throw Err.make("Type missing 'make' or 'defVal' slots: " + this).val;
}
public virtual OutStream writeProps(Map props, bool cls)
{
Charset origCharset = charset();
charset(Charset.utf8());
try
{
List keys = props.keys().sort();
int size = keys.sz();
long eq = '=';
long nl = '\n';
for (int i = 0; i < size; ++i)
{
string key = (string)keys.get(i);
string val = (string)props.get(key);
writePropStr(key);
writeChar(eq);
writePropStr(val);
writeChar(nl);
}
return(this);
}
finally
{
try { if (cls)
{
close();
}
} catch (System.Exception e) { Err.dumpStack(e); }
charset(origCharset);
}
}
public override object callList(List args)
{
int argsSize = args == null ? 0 : args.sz();
bool isStatic = _isStatic();
int p = checkArgs(argsSize, isStatic, false);
object[] a = new object[p];
if (isStatic)
{
if (args != null && a.Length > 0)
{
args.toArray(a, 0, a.Length);
}
return(m.invoke(null, a));
}
else
{
object i = args.get(0);
if (a.Length > 0)
{
args.toArray(a, 1, a.Length);
}
return(m.invoke(i, a));
}
}
public bool containsAny(List list)
{
for (int i = 0; i < list.sz(); i++)
{
if (index(list.get(i)) != null)
{
return(true);
}
}
return(false);
}
static Map read(Map defProps, Key key, List files)
{
if (files.isEmpty()) return defProps;
Map acc = defProps.dup();
for (int i=files.sz()-1; i>=0; --i)
{
InStream input = ((File)files.get(i)).@in();
try { acc.setAll(input.readProps()); }
finally { input.close(); }
}
return (Map)acc.toImmutable();
}
static List checkIds(List ids)
{
if (ids.sz() == 0)
{
throw ParseErr.make("No unit ids defined").val;
}
for (int i = 0; i < ids.sz(); ++i)
{
checkId((string)ids.get(i));
}
return((List)ids.toImmutable());
}
public Map addList(List list, Func f)
{
modify();
if (f == null)
{
for (int i = 0; i < list.sz(); ++i)
{
add(list.get(i), list.get(i));
}
}
else if (f.@params().sz() == 1)
{
for (int i = 0; i < list.sz(); ++i)
{
add(f.call(list.get(i)), list.get(i));
}
}
else
{
for (int i = 0; i < list.sz(); ++i)
{
add(f.call(list.get(i), i), list.get(i));
}
}
return(this);
}
/// <summary>
/// Merge the inherit's slots into my slot maps.
/// slots: Slot[] by order
/// nameToSlot: String name -> Slot
/// nameToIndex: String name -> Long index of slots
/// </summary>
private void merge(Type inheritedType, List slots, Hashtable nameToSlot, Hashtable nameToIndex)
{
if (inheritedType == null)
{
return;
}
List inheritedSlots = inheritedType.reflect().slots();
for (int i = 0; i < inheritedSlots.sz(); ++i)
{
merge((Slot)inheritedSlots.get(i), slots, nameToSlot, nameToIndex);
}
}
//////////////////////////////////////////////////////////////////////////
// Construction
//////////////////////////////////////////////////////////////////////////
public static string fromChars(List chars)
{
if (chars.sz() == 0)
{
return("");
}
StringBuilder s = new StringBuilder(chars.sz());
for (int i = 0; i < chars.sz(); ++i)
{
s.Append((char)((Long)chars.get(i)).longValue());
}
return(s.ToString());
}
/**
* Parse an dimension string and intern it:
* dim := <ratio> ["*" <ratio>]*
* ratio := <base> <exp>
* base := "kg" | "m" | "sec" | "K" | "A" | "mol" | "cd"
*/
private static Dimension parseDim(string s)
{
// handle empty string as dimensionless
if (s.Length == 0)
{
return(m_dimensionless);
}
// parse dimension
Dimension dim = new Dimension();
List ratios = FanStr.split(s, Long.valueOf((long)'*'), true);
for (int i = 0; i < ratios.sz(); ++i)
{
string r = (string)ratios.get(i);
if (r.StartsWith("kg"))
{
dim.kg = SByte.Parse(r.Substring(2).Trim()); continue;
}
if (r.StartsWith("sec"))
{
dim.sec = SByte.Parse(r.Substring(3).Trim()); continue;
}
if (r.StartsWith("mol"))
{
dim.mol = SByte.Parse(r.Substring(3).Trim()); continue;
}
if (r.StartsWith("m"))
{
dim.m = SByte.Parse(r.Substring(1).Trim()); continue;
}
if (r.StartsWith("K"))
{
dim.K = SByte.Parse(r.Substring(1).Trim()); continue;
}
if (r.StartsWith("A"))
{
dim.A = SByte.Parse(r.Substring(1).Trim()); continue;
}
if (r.StartsWith("cd"))
{
dim.cd = SByte.Parse(r.Substring(2).Trim()); continue;
}
throw new Exception("Bad ratio '" + r + "'");
}
// intern
return(dim.intern());
}
public virtual List findAllPodNames()
{
List acc = new List(Sys.StrType);
List files = findFile(Uri.fromStr("lib/fan/")).list();
for (int i = 0; i < files.sz(); ++i)
{
File f = (File)files.get(i);
if (f.isDir() || "pod" != f.ext())
{
continue;
}
acc.add(f.basename());
}
return(acc);
}
//////////////////////////////////////////////////////////////////////////
// Lifecycle
//////////////////////////////////////////////////////////////////////////
public static Service install(Service self)
{
try
{
List types = FanObj.@typeof(self).inheritance();
lock (m_lock)
{
// if already installed, short circuit
if (self.isInstalled())
{
return(self);
}
// add to byService map
byService[self] = new State(self);
// add to map for each type service implements
for (int i = 0; i < types.sz(); ++i)
{
Type t = (Type)types.get(i);
if (!isServiceType(t))
{
continue;
}
Node node = new Node(self);
Node x = (Node)byType[t.qname()];
if (x == null)
{
byType[t.qname()] = node;
}
else
{
while (x.next != null)
{
x = x.next;
}
x.next = node;
}
}
}
}
catch (System.Exception e)
{
Err.dumpStack(e);
}
return(self);
}
public static Version make(List segments)
{
bool valid = segments.sz() > 0;
for (int i = 0; i < segments.sz(); i++)
{
if (((Long)segments.get(i)).longValue() < 0)
{
valid = false;
}
}
if (!valid)
{
throw ArgErr.make("Invalid Version: '" + segments + "'").val;
}
return(new Version(segments));
}
private void addInheritance(Type t, List acc, Hashtable map)
{
if (t == null)
{
return;
}
List ti = t.inheritance();
for (int i = 0; i < ti.sz(); i++)
{
Type x = (Type)ti.get(i);
if (map[x.qname()] == null)
{
map[x.qname()] = x;
acc.add(x);
}
}
}
/// <summary>
/// Compute if the method signature contains generic parameter types.
/// </summary>
private static int toMask(Type parent, Type returns, List pars)
{
// we only use generics in Sys
if (parent.pod() != Sys.m_sysPod)
{
return(0);
}
int p = returns.isGenericParameter() ? 1 : 0;
for (int i = 0; i < pars.sz(); ++i)
{
p |= ((Param)pars.get(i)).m_type.isGenericParameter() ? 1 : 0;
}
int mask = 0;
if (p != 0)
{
mask |= GENERIC;
}
return(mask);
}
public override bool @is(Type type)
{
// we don't take nullable into account for fits
if (type is NullableType)
{
type = ((NullableType)type).m_root;
}
if (type == this || (type == Sys.ObjType && this != Sys.VoidType))
{
return(true);
}
List inherit = inheritance();
for (int i = 0; i < inherit.sz(); ++i)
{
if (inherit.get(i) == type)
{
return(true);
}
}
return(false);
}
static string toPathStr(bool isAbs, List path, bool isDir)
{
StringBuilder buf = new StringBuilder();
if (isAbs) buf.Append('/');
for (int i=0; i<path.sz(); ++i)
{
if (i > 0) buf.Append('/');
buf.Append(path.get(i));
}
if (isDir && !(buf.Length > 0 && buf[buf.Length-1] == '/'))
buf.Append('/');
return buf.ToString();
}
/// <summary>
/// Merge the inherited slot into my slot maps. Assume this slot
/// trumps any previous definition (because we process inheritance
/// and my slots in the right order)
/// slots: Slot[] by order
/// nameToSlot: String name -> Slot
/// nameToIndex: String name -> Long index of slots
/// </summary>
private void merge(Slot slot, List slots, Hashtable nameToSlot, Hashtable nameToIndex)
{
// skip constructors which aren't mine
if (slot.isCtor() && slot.m_parent != this) return;
string name = slot.m_name;
if (nameToIndex[name] != null)
{
int dup = (int)nameToIndex[name];
// if the slot is inherited from Obj, then we can
// safely ignore it as an override - the dup is most
// likely already the same Obj method inherited from
// a mixin; but the dup might actually be a more specific
// override in which case we definitely don't want to
// override with the sys::Obj version
if (slot.parent() == Sys.ObjType)
return;
// if given the choice between two *inherited* slots where
// one is concrete and abstract, then choose the concrete one
Slot dupSlot = (Slot)slots.get(dup);
if (slot.parent() != this && slot.isAbstract() && !dupSlot.isAbstract())
return;
// check if this is a Getter or Setter, in which case the Field
// trumps and we need to cache the method on the Field
// Note: this works because we assume the compiler always generates
// the field before the getter and setter in fcode
if ((slot.m_flags & (FConst.Getter|FConst.Setter)) != 0)
{
Field field = (Field)slots.get(dup);
if ((slot.m_flags & FConst.Getter) != 0)
field.m_getter = (Method)slot;
else
field.m_setter = (Method)slot;
return;
}
nameToSlot[name] = slot;
slots.set(dup, slot);
}
else
{
nameToSlot[name] = slot;
slots.add(slot);
nameToIndex[name] = slots.sz()-1;
}
}
private void doReflect()
{
// if the ftype is non-null, that means it was passed in non-hollow
// ftype (in-memory compile), otherwise we need to read it from the pod
if (m_ftype.m_hollow)
{
try
{
m_ftype.read();
}
catch (IOException e)
{
Err.dumpStack(e);
throw IOErr.make("Cannot read " + m_qname + " from pod", e).val;
}
}
// these are working accumulators used to build the
// data structures of my defined and inherited slots
List slots = new List(Sys.SlotType, 64);
Hashtable nameToSlot = new Hashtable(); // String -> Slot
Hashtable nameToIndex = new Hashtable(); // String -> Long
// merge in base class and mixin classes
for (int i=0; i<m_mixins.sz(); i++) merge((Type)m_mixins.get(i), slots, nameToSlot, nameToIndex);
merge(m_base, slots, nameToSlot, nameToIndex);
// merge in all my slots
FPod fpod = this.m_pod.fpod;
FType ftype = this.m_ftype;
for (int i=0; i<ftype.m_fields.Length; i++)
{
Field f = map(fpod, ftype.m_fields[i]);
merge(f, slots, nameToSlot, nameToIndex);
}
for (int i=0; i<ftype.m_methods.Length; i++)
{
Method m = map(fpod, ftype.m_methods[i]);
merge(m, slots, nameToSlot, nameToIndex);
}
// break out into fields and methods
List fields = new List(Sys.FieldType, slots.sz());
List methods = new List(Sys.MethodType, slots.sz());
for (int i=0; i<slots.sz(); i++)
{
Slot slot = (Slot)slots.get(i);
if (slot is Field)
fields.add(slot);
else
methods.add(slot);
}
this.m_slots = slots.trim();
this.m_fields = fields.trim();
this.m_methods = methods.trim();
this.m_slotsByName = nameToSlot;
this.m_facets = Facets.mapFacets(m_pod, ftype.m_attrs.m_facets);
// facets
this.m_lineNum = m_ftype.m_attrs.m_lineNum;
this.m_sourceFile = m_ftype.m_attrs.m_sourceFile;
}
public static Service uninstall(Service self)
{
try
{
List types = FanObj.@typeof(self).inheritance();
lock (m_lock)
{
// ensure service is stopped
stop(self);
// remove from byService map, it not installed short circuit
if (byService[self] == null)
{
return(self);
}
byService.Remove(self);
// remove from map for each type implemented by service
for (int i = 0; i < types.sz(); ++i)
{
// get next type in inheritance and check if service type
Type t = (Type)types.get(i);
if (!isServiceType(t))
{
continue;
}
// lookup linked list for that type
Node node = (Node)byType[t.qname()];
if (node == null)
{
continue;
}
// find this thread in the linked list
Node last = null;
bool cont = false;
while (node.service != self)
{
last = node;
node = node.next;
if (node == null)
{
cont = true; break;
}
}
if (cont)
{
continue;
}
// update the map or linked list
if (last == null)
{
byType[t.qname()] = node.next;
}
else
{
last.next = node.next;
}
}
}
}
catch (System.Exception e)
{
Err.dumpStack(e);
}
return(self);
}
//////////////////////////////////////////////////////////////////////////
// Complex
//////////////////////////////////////////////////////////////////////////
/// <summary>
/// complex := type [fields]
/// fields := "{" field (eos field)* "}"
/// field := name "=" obj
/// </summary>
private object readComplex(int line, Type t, bool root)
{
Map toSet = new Map(Sys.FieldType, Sys.ObjType.toNullable());
List toAdd = new List(Sys.ObjType.toNullable());
// read fields/collection into toSet/toAdd
readComplexFields(t, toSet, toAdd);
// get the make constructor
Method makeCtor = t.method("make", false);
if (makeCtor == null || !makeCtor.isPublic())
throw err("Missing public constructor " + t.qname() + ".make", line);
// get argument lists
List args = null;
if (root && options != null)
args = (List)options.get("makeArgs");
// construct object
object obj = null;
bool setAfterCtor = true;
try
{
// if first parameter is an function then pass toSet
// as an it-block for setting the fields
Param p = (Param)makeCtor.@params().first();
if (args == null && p != null && p.type().fits(Sys.FuncType))
{
args = new List(Sys.ObjType).add(Field.makeSetFunc(toSet));
setAfterCtor = false;
}
// invoke make to construct object
obj = makeCtor.callList(args);
}
catch (System.Exception e)
{
throw err("Cannot make " + t + ": " + e, line, e);
}
// set fields (if not passed to ctor as it-block)
if (setAfterCtor && toSet.size() > 0)
{
IDictionaryEnumerator en = toSet.pairsIterator();
while (en.MoveNext())
{
complexSet(obj, (Field)en.Key, en.Value, line);
}
}
// add
if (toAdd.size() > 0)
{
Method addMethod = t.method("add", false);
if (addMethod == null) throw err("Method not found: " + t.qname() + ".add", line);
for (int i=0; i<toAdd.sz(); ++i)
complexAdd(t, obj, addMethod, toAdd.get(i), line);
}
return obj;
}
/// <summary>
/// Merge the inherited slot into my slot maps. Assume this slot
/// trumps any previous definition (because we process inheritance
/// and my slots in the right order)
/// slots: Slot[] by order
/// nameToSlot: String name -> Slot
/// nameToIndex: String name -> Long index of slots
/// </summary>
private void merge(Slot slot, List slots, Hashtable nameToSlot, Hashtable nameToIndex)
{
// skip constructors which aren't mine
if (slot.isCtor() && slot.m_parent != this)
{
return;
}
string name = slot.m_name;
if (nameToIndex[name] != null)
{
int dup = (int)nameToIndex[name];
// if the slot is inherited from Obj, then we can
// safely ignore it as an override - the dup is most
// likely already the same Obj method inherited from
// a mixin; but the dup might actually be a more specific
// override in which case we definitely don't want to
// override with the sys::Obj version
if (slot.parent() == Sys.ObjType)
{
return;
}
// if given the choice between two *inherited* slots where
// one is concrete and abstract, then choose the concrete one
Slot dupSlot = (Slot)slots.get(dup);
if (slot.parent() != this && slot.isAbstract() && !dupSlot.isAbstract())
{
return;
}
// check if this is a Getter or Setter, in which case the Field
// trumps and we need to cache the method on the Field
// Note: this works because we assume the compiler always generates
// the field before the getter and setter in fcode
if ((slot.m_flags & (FConst.Getter | FConst.Setter)) != 0)
{
Field field = (Field)slots.get(dup);
if ((slot.m_flags & FConst.Getter) != 0)
{
field.m_getter = (Method)slot;
}
else
{
field.m_setter = (Method)slot;
}
return;
}
nameToSlot[name] = slot;
slots.set(dup, slot);
}
else
{
nameToSlot[name] = slot;
slots.add(slot);
nameToIndex[name] = slots.sz() - 1;
}
}
//////////////////////////////////////////////////////////////////////////
// List
//////////////////////////////////////////////////////////////////////////
public void writeList(List list)
{
// get of type
Type of = list.of();
// decide if we're going output as single or multi-line format
bool nl = isMultiLine(of);
// figure out if we can use an inferred type
bool inferred = false;
if (curFieldType != null && curFieldType.fits(Sys.ListType))
{
inferred = true;
}
// clear field type, so it doesn't get used for inference again
curFieldType = null;
// if we don't have an inferred type, then prefix of type
if (!inferred) wType(of);
// handle empty list
int size = list.sz();
if (size == 0) { w("[,]"); return; }
// items
if (nl) w('\n').wIndent();
w('[');
level++;
for (int i=0; i<size; ++i)
{
if (i > 0) w(',');
if (nl) w('\n').wIndent();
writeObj(list.get(i));
}
level--;
if (nl) w('\n').wIndent();
w(']');
}
public bool isStale(List x)
{
if (m_files.sz() != x.sz()) return true;
for (int i=0; i<x.sz(); ++i)
if (m_modified[i] != ((File)x.get(i)).modified().ticks())
return true;
return false;
}
public List removeAll(List toRemove)
{
// optimize special cases
modify();
if (toRemove.sz() == 0) { return this; }
if (toRemove.sz() == 1) { remove(toRemove.get(0)); return this; }
// rebuild the backing store array, implementation
// assumes that this list is bigger than toRemove list
object[] newValues = new object[m_values.Length];
int newSize = 0;
for (int i=0; i<m_size; ++i)
{
object val = m_values[i];
if (!toRemove.contains(val)) newValues[newSize++] = val;
}
this.m_values = newValues;
this.m_size = newSize;
return this;
}
private void loadFiles()
{
lock (m_filesMap)
{
if (m_filesList != null) return;
this.m_filesList = (List)fpod.m_store.podFiles(uri()).toImmutable();
for (int i=0; i<m_filesList.sz(); ++i)
{
Fan.Sys.File f = (Fan.Sys.File)m_filesList.get(i);
m_filesMap[f.uri()] = f;
}
}
}
private void doReflect()
{
// if the ftype is non-null, that means it was passed in non-hollow
// ftype (in-memory compile), otherwise we need to read it from the pod
if (m_ftype.m_hollow)
{
try
{
m_ftype.read();
}
catch (IOException e)
{
Err.dumpStack(e);
throw IOErr.make("Cannot read " + m_qname + " from pod", e).val;
}
}
// these are working accumulators used to build the
// data structures of my defined and inherited slots
List slots = new List(Sys.SlotType, 64);
Hashtable nameToSlot = new Hashtable(); // String -> Slot
Hashtable nameToIndex = new Hashtable(); // String -> Long
// merge in base class and mixin classes
for (int i = 0; i < m_mixins.sz(); i++)
{
merge((Type)m_mixins.get(i), slots, nameToSlot, nameToIndex);
}
merge(m_base, slots, nameToSlot, nameToIndex);
// merge in all my slots
FPod fpod = this.m_pod.fpod;
FType ftype = this.m_ftype;
for (int i = 0; i < ftype.m_fields.Length; i++)
{
Field f = map(fpod, ftype.m_fields[i]);
merge(f, slots, nameToSlot, nameToIndex);
}
for (int i = 0; i < ftype.m_methods.Length; i++)
{
Method m = map(fpod, ftype.m_methods[i]);
merge(m, slots, nameToSlot, nameToIndex);
}
// break out into fields and methods
List fields = new List(Sys.FieldType, slots.sz());
List methods = new List(Sys.MethodType, slots.sz());
for (int i = 0; i < slots.sz(); i++)
{
Slot slot = (Slot)slots.get(i);
if (slot is Field)
{
fields.add(slot);
}
else
{
methods.add(slot);
}
}
this.m_slots = slots.trim();
this.m_fields = fields.trim();
this.m_methods = methods.trim();
this.m_slotsByName = nameToSlot;
this.m_facets = Facets.mapFacets(m_pod, ftype.m_attrs.m_facets);
// facets
this.m_lineNum = m_ftype.m_attrs.m_lineNum;
this.m_sourceFile = m_ftype.m_attrs.m_sourceFile;
}
static List checkIds(List ids)
{
if (ids.sz() == 0) throw ParseErr.make("No unit ids defined").val;
for (int i=0; i<ids.sz(); ++i) checkId((string)ids.get(i));
return (List)ids.toImmutable();
}
//////////////////////////////////////////////////////////////////////////
// Construction
//////////////////////////////////////////////////////////////////////////
public static string fromChars(List chars)
{
if (chars.sz() == 0) return "";
StringBuilder s = new StringBuilder(chars.sz());
for (int i=0; i<chars.sz(); ++i)
s.Append((char)((Long)chars.get(i)).longValue());
return s.ToString();
}
public static Version make(List segments)
{
bool valid = segments.sz() > 0;
for (int i=0; i<segments.sz(); i++)
if (((Long)segments.get(i)).longValue() < 0) valid = false;
if (!valid) throw ArgErr.make("Invalid Version: '" + segments + "'").val;
return new Version(segments);
}
public bool containsAny(List list)
{
for (int i=0; i<list.sz(); i++)
if (index(list.get(i)) != null)
return true;
return false;
}
public long m_read; // Duration.nowTicks when we read
#endregion Fields
#region Constructors
public CachedProps(Key key, List files)
{
this.m_files = files;
this.m_modified = new long[files.sz()];
for (int i=0; i<files.sz(); ++i)
this.m_modified[i] = ((File)files.get(i)).modified().ticks();
this.m_defProps = readDef(key.m_pod, key.m_uri);
this.m_props = read(m_defProps, key, files);
this.m_read = Duration.nowTicks();
}
/// <summary>
/// Compute if the method signature contains generic parameter types.
/// </summary>
private static int toMask(Type parent, Type returns, List pars)
{
// we only use generics in Sys
if (parent.pod() != Sys.m_sysPod) return 0;
int p = returns.isGenericParameter() ? 1 : 0;
for (int i=0; i<pars.sz(); ++i)
p |= ((Param)pars.get(i)).m_type.isGenericParameter() ? 1 : 0;
int mask = 0;
if (p != 0) mask |= GENERIC;
return mask;
}
public override object callList(List args)
{
int argsSize = args == null ? 0 : args.sz();
bool isStatic = _isStatic();
int p = checkArgs(argsSize, isStatic, false);
object[] a = new object[p];
if (isStatic)
{
if (args != null && a.Length > 0) args.toArray(a, 0, a.Length);
return m.invoke(null, a);
}
else
{
object i = args.get(0);
if (a.Length > 0) args.toArray(a, 1, a.Length);
return m.invoke(i, a);
}
}
public Map setList(List list, Func f)
{
modify();
if (f == null)
{
for (int i=0; i<list.sz(); ++i)
set(list.get(i), list.get(i));
}
else if (f.@params().sz() == 1)
{
for (int i=0; i<list.sz(); ++i)
set(f.call(list.get(i)), list.get(i));
}
else
{
for (int i=0; i<list.sz(); ++i)
set(f.call(list.get(i), i), list.get(i));
}
return this;
}
private static object doTrap(object self, string name, List args, Type type)
{
Slot slot = type.slot(name, true);
if (slot is Method)
{
Method m = (Method)slot;
return m.m_func.callOn(self, args);
}
else
{
Field f = (Field)slot;
int argSize = (args == null) ? 0 : args.sz();
if (argSize == 0)
{
return FanUtil.box(f.get(self));
}
if (argSize == 1)
{
object val = args.get(0);
f.set(self, val);
return FanUtil.box(val);
}
throw ArgErr.make("Invalid number of args to get or set field '" + name + "'").val;
}
}
