/// <exception cref="TjsException"></exception>
protected internal override int Process(Variant result, Variant[] param, Dispatch2
objthis)
{
ArrayNI ni = (ArrayNI)objthis.GetNativeInstance(ArrayClass.ClassID);
if (ni == null)
{
return(Error.E_NATIVECLASSCRASH);
}
if (param.Length < 1)
{
return(Error.E_BADPARAMCOUNT);
}
((ArrayObject)objthis).Clear(ni);
AList <Dispatch2> stack = new AList <Dispatch2>();
VariantClosure clo = param[0].AsObjectClosure();
if (clo.mObjThis != null)
{
ni.AssignStructure(clo.mObjThis, stack);
}
else
{
if (clo.mObject != null)
{
ni.AssignStructure(clo.mObject, stack);
}
else
{
throw new TjsException(Error.NullAccess);
}
}
return(Error.S_OK);
}
/// <exception cref="VariantException"></exception>
public override int Set(Variant param, Dispatch2 objthis)
{
ArrayNI ni = (ArrayNI)objthis.GetNativeInstance(ArrayClass.ClassID);
// インスタンス所得
if (ni == null)
{
return(Error.E_NATIVECLASSCRASH);
}
int resize = param.AsInteger();
int count = ni.mItems.Count;
if (count < resize)
{
int addcount = resize - count;
ni.mItems.EnsureCapacity(count);
for (int i = 0; i < addcount; i++)
{
ni.mItems.AddItem(new Variant());
}
}
else
{
if (count > resize)
{
for (int i = count - 1; i >= resize; i--)
{
ni.mItems.Remove(i);
}
}
}
return(Error.S_OK);
}
/// <exception cref="VariantException"></exception>
protected internal override int Process(Variant result, Variant[] param, Dispatch2
objthis)
{
ArrayNI ni = (ArrayNI)objthis.GetNativeInstance(ArrayClass.ClassID);
if (ni == null)
{
return(Error.E_NATIVECLASSCRASH);
}
if (param.Length < 1)
{
return(Error.E_BADPARAMCOUNT);
}
bool eraseall;
if (param.Length >= 2)
{
eraseall = param[1].AsBoolean();
}
else
{
eraseall = true;
}
Variant val = param[0];
int count = ((ArrayObject)objthis).Remove(ni, val, eraseall);
if (result != null)
{
result.Set(count);
}
return(Error.S_OK);
}
/// <exception cref="TjsException"></exception>
protected internal override int Process(Variant result, Variant[] param, Dispatch2
objthis)
{
ArrayNI ni = (ArrayNI)objthis.GetNativeInstance(ArrayClass.ClassID);
if (ni == null)
{
return(Error.E_NATIVECLASSCRASH);
}
if (ni.mItems.IsEmpty())
{
if (result != null)
{
result.Clear();
}
}
else
{
if (result != null)
{
result.Set(ni.mItems[0]);
}
((ArrayObject)objthis).Erase(ni, 0);
}
return(Error.S_OK);
}
/// <exception cref="VariantException"></exception>
/// <exception cref="TjsException"></exception>
public virtual bool Callback(string name, int flags, Variant value)
{
if ((flags & Interface.HIDDENMEMBER) != 0)
{
return(true);
}
if (mCalled)
{
mStream.Write(",\n");
}
mCalled = true;
mStream.Write(mIndentStr);
mStream.Write("\"");
mStream.Write(LexBase.EscapeC(name));
mStream.Write("\" => ");
if (value.IsObject())
{
// object
VariantClosure clo = value.AsObjectClosure();
ArrayNI.SaveStructuredDataForObject(clo.SelectObject(), mStack, mStream, mIndentStr
);
}
else
{
mStream.Write(Utils.VariantToExpressionString(value));
}
return(true);
}
/// <exception cref="VariantException"></exception>
/// <exception cref="TjsException"></exception>
public virtual void Assign(Dispatch2 dsp)
{
// copy members from "dsp" to "Owner"
// determin dsp's object type
//Holder<ArrayNI> arrayni = new Holder<ArrayNI>(null);
ArrayNI array = (ArrayNI)dsp.GetNativeInstance(ArrayClass.ClassID);
if (array != null)
{
// copy from array
mItems.Clear();
int count = array.mItems.Count;
for (int i = 0; i < count; i++)
{
mItems.AddItem(new Variant(array.mItems[i]));
}
}
else
{
//mItems.addAll( array.mItems );
// convert from dictionary or others
mItems.Clear();
ArrayNI.DictionaryEnumCallback callback = new ArrayNI.DictionaryEnumCallback(mItems
);
dsp.EnumMembers(Interface.IGNOREPROP, callback, dsp);
}
}
// class instance matching by index number
/// <exception cref="VariantException"></exception>
/// <exception cref="TjsException"></exception>
public override int IsInstanceOfByNum(int flag, int num, string className, Dispatch2
objthis)
{
if (!GetValidity())
{
return(Error.E_INVALIDOBJECT);
}
ArrayNI ni = (ArrayNI)objthis.GetNativeInstance(ArrayClass.ClassID);
if (ni == null)
{
return(Error.E_NATIVECLASSCRASH);
}
int membercount = ni.mItems.Count;
if (num < 0)
{
num = membercount + num;
}
if ((flag & Interface.MEMBERMUSTEXIST) != 0 && (num < 0 || membercount <= num))
{
return(Error.E_MEMBERNOTFOUND);
}
Variant val = new Variant((membercount <= num || num < 0) ? VoidValue : ni.mItems
[num]);
return(DefaultIsInstanceOf(flag, val, className, objthis));
}
/// <exception cref="TjsException"></exception>
public static int CopyArrayElementTo(Dispatch2 dsp, Variant[] dest, int dest_offset
, int start, int count)
{
// copy array elements to specified variant array.
// returns copied element count.
ArrayNI ni = (ArrayNI)dsp.GetNativeInstance(ClassID);
if (ni == null)
{
throw new TjsException(Error.SpecifyArray);
}
if (count < 0)
{
count = ni.mItems.Count;
}
if (start >= ni.mItems.Count)
{
return(0);
}
int limit = start + count;
int d = dest_offset;
for (int i = start; i < limit; i++)
{
dest[d] = ni.mItems[i];
d++;
}
return(limit - start);
}
/// <exception cref="VariantException"></exception>
protected internal override int Process(Variant result, Variant[] param, Dispatch2
objthis)
{
ArrayNI ni = (ArrayNI)objthis.GetNativeInstance(ArrayClass.ClassID);
((ArrayObject)objthis).Clear(ni);
return(Error.S_OK);
}
/// <exception cref="VariantException"></exception>
protected internal override int Process(Variant result, Variant[] param, Dispatch2
objthis)
{
ArrayNI ni = (ArrayNI)objthis.GetNativeInstance(ArrayClass.ClassID);
if (ni == null)
{
return(Error.E_NATIVECLASSCRASH);
}
if (param.Length < 1)
{
return(Error.E_BADPARAMCOUNT);
}
if (result != null)
{
Variant val = param[0];
int start = 0;
if (param.Length >= 2)
{
start = param[1].AsInteger();
}
if (start < 0)
{
start += ni.mItems.Count;
}
if (start < 0)
{
start = 0;
}
if (start >= ni.mItems.Count)
{
result.Set(-1);
return(Error.S_OK);
}
int count = ni.mItems.Count;
int i;
for (i = start; i < count; i++)
{
Variant v = ni.mItems[i];
if (val.DiscernCompareInternal(v))
{
break;
}
}
if (i == count)
{
result.Set(-1);
}
else
{
result.Set(i);
}
}
return(Error.S_OK);
}
/// <exception cref="TjsException"></exception>
public static int GetArrayElementCount(Dispatch2 dsp)
{
// returns array element count
ArrayNI ni = (ArrayNI)dsp.GetNativeInstance(ClassID);
if (ni == null)
{
throw new TjsException(Error.SpecifyArray);
}
return(ni.mItems.Count);
}
/// <exception cref="TjsException"></exception>
protected internal override void FinalizeObject()
{
ArrayNI ni = (ArrayNI)GetNativeInstance(ArrayClass.ClassID);
if (ni == null)
{
throw new TjsException(Error.NativeClassCrash);
}
Clear(ni);
base.FinalizeObject();
}
/// <exception cref="VariantException"></exception>
protected internal override int Process(Variant result, Variant[] param, Dispatch2
objthis)
{
ArrayNI ni = (ArrayNI)objthis.GetNativeInstance(ArrayClass.ClassID);
if (ni == null)
{
return(Error.E_NATIVECLASSCRASH);
}
Collections.Reverse(ni.mItems);
return(Error.S_OK);
}
public virtual void Clear(ArrayNI ni)
{
// clear members
int count = ni.mItems.Count;
for (int i = 0; i < count; i++)
{
Variant v = ni.mItems[i];
v.Clear();
}
ni.mItems.Clear();
}
public override int Get(Variant result, Dispatch2 objthis)
{
ArrayNI ni = (ArrayNI)objthis.GetNativeInstance(ArrayClass.ClassID);
if (ni == null)
{
return(Error.E_NATIVECLASSCRASH);
}
if (result != null)
{
result.Set(ni.mItems.Count);
}
return(Error.S_OK);
}
/// <exception cref="TjsException"></exception>
protected internal override int Process(Variant result, Variant[] param, Dispatch2
objthis)
{
ArrayNI ni = (ArrayNI)objthis.GetNativeInstance(ArrayClass.ClassID);
if (ni == null)
{
return(Error.E_NATIVECLASSCRASH);
}
((ArrayObject)objthis).Insert(ni, param, 0);
if (result != null)
{
result.Set(ni.mItems.Count);
}
return(Error.S_OK);
}
/// <exception cref="TjsException"></exception>
public virtual void Erase(ArrayNI ni, int num)
{
if (num < 0)
{
num += ni.mItems.Count;
}
if (num < 0)
{
throw new TjsException(Error.RangeError);
}
if (num >= ni.mItems.Count)
{
throw new TjsException(Error.RangeError);
}
ni.mItems.Remove(num);
}
/// <exception cref="VariantException"></exception>
protected internal override int Process(Variant result, Variant[] param, Dispatch2
objthis)
{
ArrayNI ni = (ArrayNI)objthis.GetNativeInstance(ArrayClass.ClassID);
if (ni == null)
{
return(Error.E_NATIVECLASSCRASH);
}
if (param.Length < 1)
{
return(Error.E_BADPARAMCOUNT);
}
string delimiter = param[0].AsString();
bool purgeempty = false;
if (param.Length >= 3 && param[2].IsVoid() != true)
{
purgeempty = param[2].AsBoolean();
}
bool first = true;
StringBuilder builer = new StringBuilder(1024);
int count = ni.mItems.Count;
for (int i = 0; i < count; i++)
{
Variant v = ni.mItems[i];
if (purgeempty && v.IsVoid())
{
}
else
{
if (!first)
{
builer.Append(delimiter);
}
first = false;
builer.Append(v.AsString());
}
}
if (result != null)
{
result.Set(builer.ToString());
}
return(Error.S_OK);
}
/// <exception cref="TjsException"></exception>
protected internal override int Process(Variant result, Variant[] param, Dispatch2
objthis)
{
ArrayNI ni = (ArrayNI)objthis.GetNativeInstance(ArrayClass.ClassID);
if (ni == null)
{
return(Error.E_NATIVECLASSCRASH);
}
if (param.Length < 1)
{
return(Error.E_BADPARAMCOUNT);
}
string name = param[0].AsString();
string mode = null;
if (param.Length >= 2 && param[1].IsVoid() == false)
{
mode = param[1].AsString();
}
TextWriteStreamInterface stream = Tjs.mStorage.CreateTextWriteStream(name, mode);
try
{
Iterator <Variant> i = ni.mItems.Iterator();
while (i.HasNext())
{
Variant o = i.Next();
if (o != null && (o.IsString() || o.IsNumber()))
{
stream.Write(o.AsString());
}
stream.Write("\n");
}
}
finally
{
stream.Destruct();
}
if (result != null)
{
result.Set(new Variant(objthis, objthis));
}
return(Error.S_OK);
}
/// <exception cref="TjsException"></exception>
public virtual void Insert(ArrayNI ni, Variant val, int num)
{
if (num < 0)
{
num += ni.mItems.Count;
}
if (num < 0)
{
throw new TjsException(Error.RangeError);
}
int count = ni.mItems.Count;
if (num > count)
{
throw new TjsException(Error.RangeError);
}
ni.mItems.Add(num, new Variant(val));
}
protected internal override int Process(Variant result, Variant[] param, Dispatch2
objthis)
{
ArrayNI _this = (ArrayNI)objthis.GetNativeInstance(ArrayClass.ClassID
);
if (_this == null)
{
return(Error.E_NATIVECLASSCRASH);
}
int hr = _this.Construct(param, objthis);
if (hr < 0)
{
return(hr);
}
return(Error.S_OK);
}
/// <exception cref="TjsException"></exception>
protected internal override int Process(Variant result, Variant[] param, Dispatch2
objthis)
{
ArrayNI ni = (ArrayNI)objthis.GetNativeInstance(ArrayClass.ClassID);
if (ni == null)
{
return(Error.E_NATIVECLASSCRASH);
}
if (param.Length < 2)
{
return(Error.E_BADPARAMCOUNT);
}
int num = param[0].AsInteger();
((ArrayObject)objthis).Insert(ni, param[1], num);
return(Error.S_OK);
}
/// <exception cref="VariantException"></exception>
protected internal override int Process(Variant result, Variant[] param, Dispatch2
objthis)
{
ArrayNI ni = (ArrayNI)objthis.GetNativeInstance(ArrayClass.ClassID);
if (ni == null)
{
return(Error.E_NATIVECLASSCRASH);
}
if (param.Length < 1)
{
return(Error.E_BADPARAMCOUNT);
}
((ArrayObject)objthis).Add(ni, param[0]);
if (result != null)
{
result.Set(ni.mItems.Count - 1);
}
return(Error.S_OK);
}
/// <exception cref="VariantException"></exception>
/// <exception cref="TjsException"></exception>
public virtual void Assign(Dispatch2 dsp, bool clear)
{
// copy members from "dsp" to "Owner"
// determin dsp's object type
ArrayNI arrayni = null;
CustomObject owner = mOwner.Get();
if (dsp != null && (arrayni = (ArrayNI)dsp.GetNativeInstance(ArrayClass.ClassID))
!= null)
{
// convert from array
if (clear)
{
owner.Clear();
}
int count = arrayni.mItems.Count;
for (int i = 0; i < count; i++)
{
Variant v = arrayni.mItems[i];
string name = v.AsString();
i++;
if (i >= count)
{
break;
}
Variant v2 = arrayni.mItems[i];
owner.PropSet(Interface.MEMBERENSURE | Interface.IGNOREPROP, name, v2, owner);
}
}
else
{
// otherwise
if (clear)
{
owner.Clear();
}
DictionaryNI.AssignCallback callback = new DictionaryNI.AssignCallback(owner);
dsp.EnumMembers(Interface.IGNOREPROP, callback, dsp);
}
}
/// <exception cref="TjsException"></exception>
protected internal override int Process(Variant result, Variant[] param, Dispatch2
objthis)
{
ArrayNI ni = (ArrayNI)objthis.GetNativeInstance(ArrayClass.ClassID);
if (ni == null)
{
return(Error.E_NATIVECLASSCRASH);
}
if (param.Length < 1)
{
return(Error.E_BADPARAMCOUNT);
}
string name = param[0].AsString();
string mode = null;
if (param.Length >= 2 && param[1].IsVoid() == false)
{
mode = param[1].AsString();
}
TextWriteStreamInterface stream = Tjs.mStorage.CreateTextWriteStream(name, mode);
try
{
AList <Dispatch2> stack = new AList <Dispatch2>();
stack.AddItem(objthis);
ni.SaveStructuredData(stack, stream, string.Empty);
}
finally
{
stream.Destruct();
}
if (result != null)
{
result.Set(new Variant(objthis, objthis));
}
return(Error.S_OK);
}
// delete member by index number
/// <exception cref="VariantException"></exception>
/// <exception cref="TjsException"></exception>
public override int DeleteMemberByNum(int flag, int num, Dispatch2 objthis)
{
if (!GetValidity())
{
return(Error.E_INVALIDOBJECT);
}
ArrayNI ni = (ArrayNI)objthis.GetNativeInstance(ArrayClass.ClassID);
if (ni == null)
{
return(Error.E_NATIVECLASSCRASH);
}
if (num < 0)
{
num += ni.mItems.Count;
}
if (num < 0 || num >= ni.mItems.Count)
{
return(Error.E_MEMBERNOTFOUND);
}
ni.mItems.Remove(num);
return(Error.S_OK);
}
// operation with member by index number
/// <exception cref="VariantException"></exception>
/// <exception cref="TjsException"></exception>
public override int OperationByNum(int flag, int num, Variant result, Variant param
, Dispatch2 objthis)
{
if (!GetValidity())
{
return(Error.E_INVALIDOBJECT);
}
ArrayNI ni = (ArrayNI)objthis.GetNativeInstance(ArrayClass.ClassID);
if (ni == null)
{
return(Error.E_NATIVECLASSCRASH);
}
if (num < 0)
{
num += ni.mItems.Count;
}
if (num >= ni.mItems.Count)
{
if ((flag & Interface.MEMBERMUSTEXIST) != 0)
{
return(Error.E_MEMBERNOTFOUND);
}
//ni.mItems.resize(num+1);
for (int i = ni.mItems.Count; i <= num; i++)
{
ni.mItems.AddItem(new Variant());
}
}
if (num < 0)
{
return(Error.E_MEMBERNOTFOUND);
}
Variant val = ni.mItems[num];
return(DefaultOperation(flag, val, result, param, objthis));
}
/// <exception cref="TjsException"></exception>
public virtual void Insert(ArrayNI ni, Variant[] val, int num)
{
if (num < 0)
{
num += ni.mItems.Count;
}
if (num < 0)
{
throw new TjsException(Error.RangeError);
}
int count = ni.mItems.Count;
if (num > count)
{
throw new TjsException(Error.RangeError);
}
int end = val.Length;
ni.mItems.EnsureCapacity(count + end);
for (int i = 0; i < end; i++)
{
ni.mItems.Add(num + i, new Variant(val[i]));
}
}
public virtual int Remove(ArrayNI ni, Variant @ref, bool removeall)
{
int count = 0;
IntVector todelete = new IntVector();
int arrayCount = ni.mItems.Count;
for (int i = 0; i < arrayCount; i++)
{
Variant v = ni.mItems[i];
if (@ref.DiscernCompareInternal(v))
{
count++;
todelete.Add(i);
if (!removeall)
{
break;
}
}
}
// list objects up
int delCount = todelete.Size();
for (int i_1 = 0; i_1 < delCount; i_1++)
{
int pos = todelete.Get(i_1);
Variant v = ni.mItems[pos];
v.Clear();
}
// remove items found
for (int i_2 = delCount - 1; i_2 >= 0; i_2--)
{
ni.mItems.Remove(todelete.Get(i_2));
}
todelete = null;
return(count);
}
/// <exception cref="VariantException"></exception>
protected internal override int Process(Variant result, Variant[] param, Dispatch2
objthis)
{
ArrayNI ni = (ArrayNI)objthis.GetNativeInstance(ArrayClass.ClassID);
if (ni == null)
{
return(Error.E_NATIVECLASSCRASH);
}
int method = '+';
VariantClosure closure = null;
if (param.Length >= 1 && param[0].IsVoid() != true)
{
if (param[0].IsObject())
{
closure = param[0].AsObjectClosure();
method = (char)0;
}
else
{
string me = param[0].AsString();
method = me[0];
switch (method)
{
case '+':
case '-':
case '0':
case '9':
case 'a':
case 'z':
{
break;
}
default:
{
method = '+';
break;
}
}
}
}
switch (method)
{
case '+':
{
ni.mItems.Sort(new ArrayClass.ArraySortCompare_NormalAscending());
break;
}
case '-':
{
ni.mItems.Sort(new ArrayClass.ArraySortCompare_NormalDescending());
break;
}
case '0':
{
ni.mItems.Sort(new ArrayClass.ArraySortCompare_NumericAscending());
break;
}
case '9':
{
ni.mItems.Sort(new ArrayClass.ArraySortCompare_NumericDescending());
break;
}
case 'a':
{
ni.mItems.Sort(new ArrayClass.ArraySortCompare_StringAscending());
break;
}
case 'z':
{
ni.mItems.Sort(new ArrayClass.ArraySortCompare_StringDescending());
break;
}
case 0:
{
ni.mItems.Sort(new ArrayClass.ArraySortCompare_Functional(closure));
break;
}
}
return(Error.S_OK);
}
