public override object ToDict(Type rDictType, Type rKeyType, Type rValueType)
{
rDictType = ITypeRedirect.GetRedirectType(rDictType);
if (rDictType.IsGenericType && typeof(IDictionary).IsAssignableFrom(rDictType.GetGenericTypeDefinition()))
{
// 特殊处理IDictionary<,>类型
IDictionary rObject = (IDictionary)ReflectionAssist.CreateInstance(rDictType, BindingFlags.Default);
foreach (var rItem in this.dict)
{
object rKey = GetKey_ByString(rKeyType, rItem.Key);
object rValue = rItem.Value.ToObject(rValueType);
rObject.Add(rKey, rValue);
}
return(rObject);
}
else if (rDictType.IsGenericType && typeof(IDict).IsAssignableFrom(rDictType.GetGenericTypeDefinition()))
{
// 特殊处理IDict<,>的类型
IDict rObject = (IDict)ReflectionAssist.CreateInstance(rDictType, BindingFlags.Default);
foreach (var rItem in this.dict)
{
object rKey = GetKey_ByString(rKeyType, rItem.Key);
object rValue = rItem.Value.ToObject(rValueType);
rObject.AddObject(rKey, rValue);
}
return(rObject);
}
return(null);
}
public PrgState execute(PrgState state)
{
IDict <String, int> symTable = state.getSymTbl();
int file_id = this.exp_file_id.eval(symTable);
MyTuple <String, TextReader> fileTable = state.getFileTable().lookup(file_id);
if (fileTable == null)
{
throw new FileNotOpened();
}
String line = fileTable.getSecond().ReadLine();
int value;
Console.WriteLine("\n\nstart" + line + "aici\n\n");
if (line == null)
{
value = 0;
}
else
{
value = Convert.ToInt32(line);
}
if (symTable.isDefined(var_name))
{
symTable.update(var_name, value);
}
else
{
symTable.add(var_name, value);
}
return(state);
}
public int eval(IDict <string, int> symbolTable)
{
int left = ex1.eval(symbolTable);
int right = ex2.eval(symbolTable);
if (oper == '+')
{
return(left + right);
}
if (oper == '-')
{
return(left - right);
}
if (oper == '*')
{
return(left * right);
}
if (oper == '/')
{
if (right == 0)
{
throw new Exception("Division by 0!");
}
return(left / right);
}
throw new Exception("Wrong operator!");
}
public static T GetChild <T>(IOwner owner, string key, bool isDebug = false) where T : class, IElement
{
if (owner == null)
{
return(null);
}
T child = null;
IDict ownerAsDict = owner as IDict;
if (ownerAsDict != null)
{
child = ownerAsDict.Get <IInDictElement>(key, isDebug) as T;
}
else
{
ITable ownerAsTable = owner as ITable;
if (ownerAsTable != null)
{
child = ownerAsTable.GetByKey <IInTableElement>(key, isDebug) as T;
}
}
if (child == null)
{
owner.ErrorOrDebug(isDebug, "Not Found: {0}", key);
}
return(child);
}
public override int eval(IDict <String, int> dict)
{
int finalResult = 0;
int rez1 = this.firstExp.eval(dict);
int rez2 = this.sndExp.eval(dict);
switch (op)
{
case "+":
finalResult = rez1 + rez2;
break;
case "-":
finalResult = rez1 - rez2;
break;
case "*":
finalResult = rez1 * rez2;
break;
case "//":
if (rez2 == 0)
{
throw new DivisionByZero();
}
finalResult = rez1 / rez2;
break;
default:
throw new OperatorNotFound();
}
return(finalResult);
}
public static T GetOrNewDescendant <TO, T>(IDict owner, string type, string relPath)
where TO : class, IDict, IInDictElement
where T : class, IInDictElement
{
return(GetOrCreateDescendant <TO, T>(owner, relPath,
(IDict parent, String key) => parent.GetOrNew <T>(type, key)));
}
private static T GetOrCreateDescendant <TO, T>(IDict owner, string relPath, Func <IDict, string, T> func)
where TO : class, IDict, IInDictElement
where T : class, IInDictElement
{
string[] keys = relPath.Split(PathConsts.PathSeparator);
IDict current = owner;
for (int i = 0; i < keys.Length; i++)
{
if (i < keys.Length - 1)
{
if (current.Has(keys[i]))
{
current = Object.As <IDict>(current.Get <IInDictElement>(keys[i]));
}
else
{
current = current.Add <TO>(keys[i]);
}
}
else
{
return(func(current, keys[i]));
}
if (current == null)
{
return(null);
}
}
return(null);
}
public static void ForEachDescendants <T>(ITable owner, Action <T> callback)
where T : class, IElement
{
owner.ForEach((IInTableElement element) => {
T elementAsT = element as T;
if (elementAsT != null)
{
callback(elementAsT);
}
IDict elementAsDict = element as IDict;
if (elementAsDict != null)
{
ForEachDescendants <T>(elementAsDict, callback);
}
else
{
ITable elementAsTable = element as ITable;
if (elementAsTable != null)
{
ForEachDescendants <T>(elementAsTable, callback);
}
}
});
}
public override object ToDict(Type rDictType, Type rKeyType, Type rValueType)
{
#if ILRUNTIME_USE
rDictType = rDictType is ILRuntime.Reflection.ILRuntimeWrapperType ? ((ILRuntime.Reflection.ILRuntimeWrapperType)rDictType).CLRType.TypeForCLR : rDictType;
#endif
if (rDictType.IsGenericType && typeof(IDictionary).IsAssignableFrom(rDictType.GetGenericTypeDefinition()))
{
// 特殊处理IDictionary<,>类型
IDictionary rObject = (IDictionary)ReflectionAssist.CreateInstance(rDictType, BindingFlags.Default);
foreach (var rItem in this.dict)
{
object rKey = GetKey_ByString(rKeyType, rItem.Key);
object rValue = rItem.Value.ToObject(rValueType);
rObject.Add(rKey, rValue);
}
return(rObject);
}
else if (rDictType.IsGenericType && typeof(IDict).IsAssignableFrom(rDictType.GetGenericTypeDefinition()))
{
// 特殊处理IDict<,>的类型
IDict rObject = (IDict)ReflectionAssist.CreateInstance(rDictType, BindingFlags.Default);
foreach (var rItem in this.dict)
{
object rKey = GetKey_ByString(rKeyType, rItem.Key);
object rValue = rItem.Value.ToObject(rValueType);
rObject.AddObject(rKey, rValue);
}
return(rObject);
}
return(null);
}
public override int Eval(com.IDict <string, int> dict, IDict <int, int> heap)
{
Console.Write("Give int: ");
int v = GetInputInt();
return(v);
}
public override object ToObject(Type rType)
{
#if ILRUNTIME_USE
rType = rType is ILRuntime.Reflection.ILRuntimeWrapperType ? ((ILRuntime.Reflection.ILRuntimeWrapperType)rType).CLRType.TypeForCLR : rType;
#endif
if (rType.IsGenericType && typeof(IDictionary).IsAssignableFrom(rType.GetGenericTypeDefinition()))
{
// 特殊处理IDictionary<,>类型
IDictionary rObject = (IDictionary)ReflectionAssist.CreateInstance(rType, ReflectionAssist.flags_all);
Type[] rArgsTypes = rType.GetGenericArguments();
foreach (var rItem in this.dict)
{
object rKey = GetKey_ByString(rArgsTypes[0], rItem.Key);
object rValue = rItem.Value.ToObject(rArgsTypes[1]);
rObject.Add(rKey, rValue);
}
return(rObject);
}
else if (rType.IsGenericType && typeof(IDict).IsAssignableFrom(rType.GetGenericTypeDefinition()))
{
// 特殊处理IDict<,>的类型
IDict rObject = (IDict)ReflectionAssist.CreateInstance(rType, ReflectionAssist.flags_all);
Type[] rArgsTypes = rType.GetGenericArguments();
foreach (var rItem in this.dict)
{
object rKey = GetKey_ByString(rArgsTypes[0], rItem.Key);
object rValue = rItem.Value.ToObject(rArgsTypes[1]);
rObject.AddObject(rKey, rValue);
}
return(rObject);
}
else if (rType.IsClass)
{
BindingFlags rBindFlags = ReflectionAssist.flags_all;
object rObject = ReflectionAssist.CreateInstance(rType, rBindFlags);
foreach (var rItem in this.dict)
{
Type rMemberType = null;
FieldInfo rFieldInfo = rType.GetField(rItem.Key, rBindFlags);
if (rFieldInfo != null)
{
rMemberType = rFieldInfo.FieldType;
object rValueObj = rItem.Value.ToObject(rMemberType);
rFieldInfo.SetValue(rObject, rValueObj);
continue;
}
PropertyInfo rPropInfo = rType.GetProperty(rItem.Key, rBindFlags);
if (rPropInfo != null)
{
rMemberType = rPropInfo.PropertyType;
object rValueObj = rItem.Value.ToObject(rMemberType);
rPropInfo.SetValue(rObject, rValueObj, null);
continue;
}
}
return(rObject);
}
return(null);
}
public DictController(IDict dict)
{
bll = dict;
BusinessServices = new List <object>()
{
dict
};
}
public DeltaDict(IDict <TKey, TValue> baseDict, Dict <TKey, TValue> deltaDict)
{
m_baseDict = baseDict;
m_deltaDict = deltaDict;
var dictDepth = baseDict as IDictDepth;
m_depth = dictDepth != null ? dictDepth.Depth + 1 : 1;
}
/**
* Constructor
* @param stk - execution stack
* @param symtbl - symbol table
* @param ot - output list
*/
public ProgState(IList <int> o, IDict <string, int> s, IStack <IStmt> e, IDict <int, int> hp)
{
this.output = o;
this.symTable = s;
this.exeStack = e;
this.heap = hp;
this.id = rnd.Next(1, 1000);
}
public override int eval(IDict <String, int> dict)
{
if (!dict.isDefined(this.id))
{
throw new VariableNotFound();
}
return(dict.lookup(this.id));
}
public int eval(IDict <string, int> symbolTable)
{
if (symbolTable.contains(varName))
{
return(symbolTable.getValue(varName));
}
throw new Exception("Variable not found!");
}
public SingleDeltaDict(IDict <TKey, TValue> baseDict, TKey key, TValue value)
{
m_baseDict = baseDict;
m_key = key;
m_value = value;
var dictDepth = baseDict as IDictDepth;
m_depth = dictDepth != null ? dictDepth.Depth + 1 : 1;
}
public PrgState(IStack <IStmt> stk, IDict <String, int> symtbl, IList <int> output, IDictRandIntKey <MyTuple <String, TextReader> > fileTable, IStmt stmt)
{
this.exeStack = stk;
this.symTable = symtbl;
this.output = output;
this.fileTable = fileTable;
this.originalProgramState = stmt;
this.exeStack.push(stmt);
}
public PrgState execute(PrgState state)
{
IList <int> output = state.getOutput();
IDict <String, int> symTbl = state.getSymTbl();
int val = exp.eval(symTbl);
output.add(val);
return(null);
}
public TranslateWindow()
{
InitializeComponent();
_isShowSource = true;
_isLocked = false;
_gameTextHistory = new Queue <string>();
this.Topmost = true;
UI_Init();
IsOCRingFlag = false;
_wordSpliter = WordSpliterAuto(Common.appSettings.WordSpliter);
_textSpeechHelper = new TextSpeechHelper();
if (Common.appSettings.ttsVoice == "")
{
Growl.InfoGlobal(Application.Current.Resources["TranslateWin_NoTTS_Hint"].ToString());
}
else
{
_textSpeechHelper.SetTTSVoice(Common.appSettings.ttsVoice);
_textSpeechHelper.SetVolume(Common.appSettings.ttsVolume);
_textSpeechHelper.SetRate(Common.appSettings.ttsRate);
}
if (Common.appSettings.xxgPath != string.Empty)
{
_dict = new XxgJpzhDict();
_dict.DictInit(Common.appSettings.xxgPath, string.Empty);
}
IsPauseFlag = true;
_translator1 = TranslatorAuto(Common.appSettings.FirstTranslator);
_translator2 = TranslatorAuto(Common.appSettings.SecondTranslator);
_beforeTransHandle = new BeforeTransHandle(Convert.ToString(Common.GameID), Common.UsingSrcLang, Common.UsingDstLang);
_afterTransHandle = new AfterTransHandle(_beforeTransHandle);
_artificialTransHelper = new ArtificialTransHelper(Convert.ToString(Common.GameID));
if (Common.transMode == 1)
{
Common.textHooker.Sevent += DataRecvEventHandler;
}
else if (Common.transMode == 2)
{
MouseKeyboardHook_Init();
}
toggleRec.ToolTip = Common.appSettings.ATon ? REC_OFF: REC_ON;
updateToggleRecDisplay(false);
}
public UserEmailBuilder(IPsaContextService contextService, IConnClientService ConnClientService, IMasterOrganizationRepository masterOrganizationRepository, IDict dictionary, IAppSettings settings, IFeatureService featureService, IEmailTemplateService emailTemplateService, IDistributorHelperService distributorHelperService)
{
ContextService = contextService;
ConnClientService = ConnClientService;
MasterOrganizationRepository = masterOrganizationRepository;
Dictionary = dictionary;
Settings = settings;
FeatureService = featureService;
EmailTemplateService = emailTemplateService;
DistributorHelperService = distributorHelperService;
}
public static bool RemoveFromOwner(this IContext context)
{
IDict owner = context.OwnerAsDict;
if (owner == null)
{
return(false);
}
return(owner.Remove <IContext>(context.Key) != null);
}
public ProgramState(IStack <IStatement> stack,
IDict <String, int> symb,
ILis <int> outl,
IDict <int, FileData> files,
IStatement original)
{
exeStack = stack;
symbolTable = symb;
outList = outl;
fileTable = files;
originalPrg = original;
}
public static TType GetOrDefault <TType, TValue>(
this IDict <Symbol, TValue> dict, TypedSymbol <TType> key)
where TType : TValue
{
TValue value;
if (dict.TryGetValue(key.Symbol, out value))
{
return((TType)value);
}
return(default(TType));
}
/// <summary>
/// Returns an IDict with the supplied key/value pair added. Internally
/// the supplied dict is not modified, but referenced, and a suitable
/// DeltaDict is built that contains only the changes.
/// </summary>
public static IDict <Symbol, TValue> WithAdded <TValue>(
this IDict <Symbol, TValue> dict,
Symbol key, TValue value)
{
var sd = dict as SingleDeltaSymbolDict <TValue>;
if (sd != null && key == sd.m_key)
{
return(new SingleDeltaSymbolDict <TValue>(sd.m_baseDict, key, value));
}
return(new SingleDeltaSymbolDict <TValue>(dict, key, value));
}
/// <summary>
/// Returns an IDict with the supplied key/value pair added. Internally
/// the supplied dict is not modified, but referenced, and a suitable
/// DeltaDict is built that contains only the changes.
/// </summary>
public static IDict <TKey, TValue> WithAdded <TKey, TValue>(
this IDict <TKey, TValue> dict,
TKey key, TValue value)
{
var sd = dict as SingleDeltaDict <TKey, TValue>;
if (sd != null && key.Equals(sd.m_key))
{
return(new SingleDeltaDict <TKey, TValue>(sd.m_baseDict, key, value));
}
return(new SingleDeltaDict <TKey, TValue>(dict, key, value));
}
private static void SetCachedBounds(IArrangedElement element, Rectangle bounds)
{
if (bounds != GetCachedBounds(element))
{
IDict dictionary = (IDict)element.Container.Properties.GetObject(_cachedBoundsProperty);
if (dictionary == null)
{
dictionary = new HybridDictionary();
element.Container.Properties.SetObject(_cachedBoundsProperty, dictionary);
}
dictionary[element] = bounds;
}
}
public Task <ServerResponse> GetAsync(string query, IDict variables = null, string operationName = null,
CancellationToken cancellationToken = default)
{
var request = new GraphQLRequest()
{
Query = query, Variables = variables, OperationName = operationName
};
var reqData = new ClientRequest()
{
HttpMethod = "GET", CoreRequest = request, CancellationToken = cancellationToken
};
return(SendAsync(reqData));
}
public static List <T> GetDescendants <T>(IDict owner)
where T : class, IElement
{
List <T> result = null;
ForEachDescendants <T>(owner, (T element) => {
if (result == null)
{
result = new List <T>();
}
result.Add(element);
});
return(result);
}
public static bool TryGetValue <TType, TValue>(
this IDict <Symbol, TValue> dict, TypedSymbol <TType> key, out TType typedValue)
where TType : TValue
{
TValue value;
if (dict.TryGetValue(key.Symbol, out value))
{
typedValue = (TType)value;
return(true);
}
typedValue = default(TType);
return(false);
}
