public VariableDeclaration(Position pos, Symbol name, NameType type, Expression init) { Pos = pos; Name = name; Type = type; Init = init; }
protected ReflectedGetterSetter(MethodInfo[]/*!*/ getter, MethodInfo[]/*!*/ setter, NameType nt) { Debug.Assert(getter != null); Debug.Assert(setter != null); _getter = RemoveNullEntries(getter); _setter = RemoveNullEntries(setter); _nameType = nt; }
/// <summary> /// Prepares help text for given option string <paramref name="name"/> and its <paramref name="type"/>. /// </summary> /// <param name="name">Option string.</param> /// <param name="type">Type of given option string. <see cref="NameType"/> for possible values (Short or Long).</param> /// <returns>Help string for given option.</returns> /// <seealso cref="NameType" /> /// <seealso cref="ParameterName"/> /// <remarks>Uses ParameterName for displaying the required parameter./>. /// <example><para><c>-f</c> is short option string</para><para><c>--format</c> is long option string</para></example></remarks> protected override string GetHelpTextForName(string name, NameType type) { switch (type) { case NameType.Short: return string.Format("-{0} {1}", name, Printer.GetParameterName(ParameterName)); case NameType.Long: return string.Format("--{0}={1}", name, Printer.GetParameterName(ParameterName)); default: throw new NotImplementedException(); } }
public void Init(string name, NameType type, bool stackable = true) { this.name = name; this.Type = type; this.IsStackable = stackable; this.effects = new List<Effect>(); this.prepositions = new List<string>(); }
public FunctionDeclaration(Position pos, Symbol name, FieldList param, NameType result, Expression body, FunctionDeclaration next) { Pos = pos; Name = name; Param = param; Result = result; Body = body; Next = next; }
internal static NameType GetNameFromMethod(TotemType dt, MethodInfo mi, NameType res, ref string name) { string namePrefix = null; if (mi.IsPrivate || (mi.IsAssembly && !mi.IsFamilyOrAssembly)) { // allow explicitly implemented interface if (!(mi.IsPrivate && mi.IsFinal && mi.IsHideBySig && mi.IsVirtual)) { // mangle protectes to private namePrefix = "_" + dt.Name + "__"; } else { // explicitly implemented interface // drop the namespace, leave the interface name, and replace // the dot with an underscore. Eg System.IConvertible.ToBoolean // becomes IConvertible_ToBoolean int lastDot = name.LastIndexOf('.'); if (lastDot != -1) name = name.Substring(lastDot + 1); } } if (namePrefix != null) name = namePrefix + name; if (mi.DeclaringType.GetTypeInfo().IsDefined(typeof(TotemTypeAttribute), false) || !mi.DeclaringType.IsAssignableFrom(dt.UnderlyingSystemType)) { // extension types are all totem names res |= NameType.Totem; } //if (mi.IsDefined(typeof(TotemMethodAttribute), false)) //{ // res = NameType(res & ~NameType.BaseTypeMask) | NameType.Property; //} return res; }
public static string[] PickFullName(NameType nameType, Gender gender) { switch (nameType) { case NameType.RandomName: string firstName = gender == Gender.Male ? Util.GetRandomValue(FirstNamesMale) : Util.GetRandomValue(FirstNamesFemale); return(new string[] { firstName, Util.GetRandomValue(LastNames) }); case NameType.ExistingCombination: NameCombination name = gender == Gender.Male ? Util.GetRandomValue(ExistingCombinationsMale) : Util.GetRandomValue(ExistingCombinationsFemale); return(new string[] { name.FirstName, name.LastName }); default: Logger.Error(Logger.Character, "Not implemented name type {0}", nameType); return(new string[] { }); } }
/// <summary> /// Remove a netbios name. /// </summary> /// <param name="name">The name to remove.</param> /// <param name="type">The type used.</param> /// <param name="suffix">The suffix used.</param> /// <returns>True on success, false on failure.</returns> public bool RemoveName(string name, NameType type, MsSuffix suffix) { Name node = new Name(); node.UncompressedName = UncompressName(name, suffix); node.Type = type; lock (nameList) { int i = 0; for (; i < nameList.Count; i++) { Name n = (Name)nameList[i]; if ((n.UncompressedName == node.UncompressedName) && (n.Type == node.Type)) { break; } } if (i >= nameList.Count) { return(false); // Name not found } nameList.RemoveAt(i); if (nameList.Count == 0) { updateTimer.Change(Timeout.Infinite, Timeout.Infinite); } } // Send request for (int i = 0; i < BCAST_REQ_RETRY_COUNT; i++) { Request(node, HeaderOpcode.Release); Thread.Sleep(BCAST_REQ_RETRY_TIMEOUT); } return(true); }
private Character FindCharacter(string satanisedName, NameType nameType) { List <Character> charactersInGame = CharacterManager.Instance.Characters; Character characterToDelete = null; Logger.Log("Trying to find {0}", satanisedName); if (nameType == NameType.FullName) { characterToDelete = charactersInGame.Find(i => CharacterNameGenerator.GetName(i.CharacterName).ToLower() == satanisedName); } if (characterToDelete == null && (nameType == NameType.FirstName || nameType == NameType.FullName)) { characterToDelete = charactersInGame.Find(i => i.CharacterName.FirstName.ToLower() == satanisedName); } if (characterToDelete == null && (nameType == NameType.LastName || nameType == NameType.FullName)) { characterToDelete = charactersInGame.Find(i => i.CharacterName.LastName.ToLower() == satanisedName); } return(characterToDelete); }
public static NameType TryGetName(DynamicType dt, PropertyInfo pi, MethodInfo prop, out string name) { name = null; string namePrefix = ""; NameType res = NameType.Property; if (prop.IsPrivate || (prop.IsAssembly && !prop.IsFamilyOrAssembly)) { // allow explicitly implemented interface if (!(prop.IsPrivate && prop.IsFinal && prop.IsHideBySig && prop.IsVirtual)) { if (!Options.PrivateBinding) { return(NameType.None); } else { // mangle protectes to private namePrefix = "_" + dt.__name__ + "__"; } } } object[] attribute = prop.GetCustomAttributes(typeof(PythonNameAttribute), false); name = namePrefix + pi.Name; if (attribute.Length > 0) { PythonNameAttribute attr = attribute[0] as PythonNameAttribute; if (attr.name != null && attr.name.Length > 0) { res = NameType.PythonProperty; name = attr.name; } } return(res); }
private async Task RunNamesCommands(IUser User, NameType NameType) { if (User == null) { User = Context.User; } List <NameRecord> Names = UserRecordsService.GetNameRecords(User, NameType).ToList(); Names.Sort((a, b) => b.SetTime.CompareTo(a.SetTime)); EmbedBuilder[] Menu = BuildNicknameEmbeds(Names.ToArray(), $"{NameType} Record for User {User.Username}#{User.Discriminator}"); if (Menu.Length == 1) { await Menu[0].SendEmbed(Context.Channel); } else { await CreateReactionMenu(Menu, Context.Channel); } }
private void AddReflectedUnboundMethod(MethodInfo mi) { if (!mi.IsStatic) { return; } string name; NameType nt = NameConverter.TryGetName(this, mi, out name); if (nt == NameType.None) { return; } FunctionType funcType = FunctionType.Method; if (mi.DeclaringType == typeof(ArrayOps)) { funcType |= FunctionType.SkipThisCheck; } if (nt == NameType.PythonMethod) { funcType |= FunctionType.PythonVisible; } RemoveNonOps(SymbolTable.StringToId(name)); // store Python version StoreMethod <ReflectedUnboundMethod>(name, mi, funcType | FunctionType.OpsFunction); // store CLR version, if different and we don't have a clash (if we do // have a clash our version is still available under the python name) if (name != mi.Name && !ContainsNonOps(SymbolTable.StringToId(mi.Name))) { StoreMethod <ReflectedUnboundMethod>(mi.Name, mi, FunctionType.Method | FunctionType.OpsFunction); } }
private static List <string> GetMixedNameList(NameType type) { List <string> al = new List <string>(); if ((type & NameType.MaleName) == NameType.MaleName) { FillListFromList(al, MaleNames); } if ((type & NameType.FemaleName) == NameType.FemaleName) { FillListFromList(al, FemaleNames); } if ((type & NameType.Surname) == NameType.Surname) { FillListFromList(al, Surnames); } if ((type & NameType.Word) == NameType.Word) { FillListFromList(al, Words); } return(al); }
/// <summary> /// Gets the hash code /// </summary> /// <returns>Hash code</returns> public override int GetHashCode() { unchecked // Overflow is fine, just wrap { var hashCode = 41; // Suitable nullity checks etc, of course :) if (Id != null) { hashCode = hashCode * 59 + Id.GetHashCode(); } if (TradingName != null) { hashCode = hashCode * 59 + TradingName.GetHashCode(); } if (Href != null) { hashCode = hashCode * 59 + Href.GetHashCode(); } if (IsLegalEntity != null) { hashCode = hashCode * 59 + IsLegalEntity.GetHashCode(); } if (OrganizationType != null) { hashCode = hashCode * 59 + OrganizationType.GetHashCode(); } if (NameType != null) { hashCode = hashCode * 59 + NameType.GetHashCode(); } if (Status != null) { hashCode = hashCode * 59 + Status.GetHashCode(); } return(hashCode); } }
/// <summary> /// Removes all names on <paramref name="User"/> following a given <paramref name="Pattern"/> from their records. /// </summary> /// <param name="User">The target user.</param> /// <param name="NameType">Whether to target NICKNAMEs or USERNAMEs.</param> /// <param name="Pattern">The pattern to follow deletion, a regular expression if <paramref name="IsRegex"/>, otherwise the verbatim nickname.</param> /// <param name="IsRegex">Whether <paramref name="Pattern"/> should be interpreted as a regular expression.</param> /// <returns>A List of strings containing all nicknames that fit <paramref name="Pattern"/>.</returns> public List <NameRecord> RemoveNames(IUser User, NameType NameType, string Pattern, bool IsRegex = false) { List <NameRecord> Result = new(); List <NameRecord> Records = ProfilesDB.Names.Where(n => n.Type == NameType && n.UserID == User.Id).ToList(); Pattern = Pattern.Trim(); if (IsRegex) { foreach (NameRecord Record in Records) { if (Regex.Match(Record.Name, Pattern).Success) { ProfilesDB.Names.Remove(Record); Result.Add(Record.Clone()); } } } else { foreach (NameRecord Record in Records) { if (Record.Name == Pattern) { ProfilesDB.Names.Remove(Record); Result = new List <NameRecord>() { Record.Clone() }; break; } } } ProfilesDB.SaveChanges(); return(Result); }
private static Name GetNameFromIdentifiersHelper(List <Identifier> identifiers, NameType nameType, int count) { if (count <= 0) { throw new ArgumentOutOfRangeException(); } if (count == 1) { return(new Name(identifiers[0], null, nameType)); } else { NameType newNameType; switch (nameType) { case NameType.Module: case NameType.Package: case NameType.PackageOrType: case NameType.Ambiguous: newNameType = nameType; break; case NameType.Type: newNameType = NameType.PackageOrType; break; case NameType.Expression: newNameType = NameType.Ambiguous; break; default: // NameType.Method throw new InvalidOperationException(); } Name parent = GetNameFromIdentifiersHelper(identifiers, newNameType, count - 1); return(new Name(identifiers[count - 1], parent, nameType)); } }
private Type ParseDataType(string dt, string dtValues) { string strType = dt; string[] parts = dt.Split(':'); if (parts.Length > 2) { throw ExceptionBuilder.InvalidAttributeValue("type", dt); } else if (parts.Length == 2) { // CONSIDER: check that we have valid prefix strType = parts[1]; } NameType nt = FindNameType(strType); if (nt == s_enumerationNameType && (dtValues == null || dtValues.Length == 0)) { throw ExceptionBuilder.MissingAttribute("type", Keywords.DT_VALUES); } return(nt.type); }
public override string Update(Job job, Phase phase, string body = null, string contentType = null, string accept = null) { job.UpdateState(JobStateType.INPROGRESS, "UPDATE to " + phase.Name); if (!contentType.ToLower().Equals("application/json")) { string msg = "Invalid Content-Type, expecting application/json"; job.UpdatePhaseState(phase.Name, PhaseStateType.FAILED, msg); throw new RejectedException(msg); } LearnerPersonal data; try { data = JsonConvert.DeserializeObject <LearnerPersonal>(body); } catch (Exception e) { string msg = "Error decoding Json data: " + e.Message; job.UpdatePhaseState(phase.Name, PhaseStateType.FAILED, msg); throw new RejectedException(msg, e); } NameType name = data.PersonalInformation.Name; job.UpdatePhaseState(phase.Name, PhaseStateType.COMPLETED, "UPDATE"); return("Got UPDATE message for " + phase.Name + "@" + job.Id + " with content type " + contentType + " and accept " + accept + ".\nGot record for learner:" + name.GivenName + " " + name.FamilyName); }
public string Generate(NameType type = NameType.Both, Gender gender = Gender.Both) { string name; switch (type) { case NameType.Given: name = GenerateGiven(gender); break; case NameType.Surname: name = GenerateSurname(); break; case NameType.Both: name = GenerateFull(gender); break; default: throw new ArgumentOutOfRangeException(nameof(gender)); } return(name); }
private Type ParseDataType(string dt, string dtValues) { string strType = dt; string[] parts = dt.Split(colonArray); // ":" if (parts.Length > 2) { throw ExceptionBuilder.InvalidAttributeValue("type", dt); } else if (parts.Length == 2) { // strType = parts[1]; } NameType nt = FindNameType(strType); if (nt == enumerationNameType && (dtValues == null || dtValues.Length == 0)) { throw ExceptionBuilder.MissingAttribute("type", Keywords.DT_VALUES); } return(nt.type); }
private static void Deactivate(NameType name, int row) { switch (name) { case NameType.ConfirmOptIn: deactivateProcess(row); break; case NameType.ScheduledMessageStatusChange: deactivateProcess(row); break; case NameType.ScheduleMessage: deactivateProcess(row); break; case NameType.SendMessage: deactivateProcess(row); break; default: break; } }
public static string GetName(NameType type, string table, string[] columns = null, string alt = null) { var name = new StringBuilder(); switch (type) { case NameType.PrimaryKey: name.Append("PK_"); break; case NameType.UniqueKey: name.Append("UK_"); break; case NameType.Index: name.Append("IX_"); break; case NameType.ForeignKey: name.Append("FK_"); break; } name.Append(table.Replace('.', '_')); if (columns != null) { name.Append("_").Append(string.Join("_", columns)); } if (alt != null) { name.Append("_").Append(alt.Replace('.', '_')); } return(name.ToString()); }
// define a parameterized constructor public Person(NameType type, string value) { Console.WriteLine("Parameterized person constructor invoked"); }
public ReflectedIndexer(PropertyInfo/*!*/ info, NameType nt, bool privateBinding) : base(new MethodInfo[] { info.GetGetMethod(privateBinding) }, new MethodInfo[] { info.GetSetMethod(privateBinding) }, nt) { Debug.Assert(info != null); _info = info; }
public ReflectedProperty(PropertyInfo info, MethodInfo getter, MethodInfo setter, NameType nt) : base(new MethodInfo[] { getter }, new MethodInfo[] { setter }, nt) { Debug.Assert(info != null); _info = info; }
public ReflectedExtensionProperty(ExtensionPropertyInfo info, NameType nt) : base(new MethodInfo[] { info.Getter }, new MethodInfo[] { info.Setter }, nt) { _extInfo = info; _deleter = info.Deleter; }
/// <summary> /// Gets the name of the contact /// </summary> /// <param name="strSubject">buffer to contain output string</param> /// <param name="nType">NameType to specify which name to retrieve</param> /// <returns>true on success</returns> public bool GetName(StringBuilder strSubject, NameType nType) { return ContactGetName(pObject, strSubject, strSubject.Capacity, (int)nType); }
private static NameType GetNameFromMethod(ReflectedType dt, MethodInfo mi, NameType res, ref string name) { string namePrefix = null; if (mi.IsPrivate || (mi.IsAssembly && !mi.IsFamilyOrAssembly)) { // allow explicitly implemented interface if (!(mi.IsPrivate && mi.IsFinal && mi.IsHideBySig && mi.IsVirtual)) { if (!Options.PrivateBinding) { return NameType.None; } else { // mangle protectes to private namePrefix = "_" + dt.Name + "__"; } } else { // explicitly implemented interface // drop the namespace, leave the interface name, and replace // the dot with an underscore. Eg System.IConvertible.ToBoolean // becomes IConvertible_ToBoolean int lastDot = name.LastIndexOf(Type.Delimiter); if (lastDot != -1) { name = name.Substring(lastDot + 1); } } } object[] attribute = mi.GetCustomAttributes(typeof(PythonNameAttribute), false); if (namePrefix != null) name = namePrefix + name; if (attribute.Length > 0) { PythonNameAttribute attr = attribute[0] as PythonNameAttribute; if (attr.name != null && attr.name.Length > 0) { if (attr is PythonClassMethodAttribute) res |= NameType.ClassMember; res |= NameType.Python; name = attr.name; } } return res; }
protected string generate_string(NameType t) { if (t == BattleName.NameType.First) { NamePattern p = new NamePattern(5, 8); NamePattern.Token[] tp = p.GenerateLogicalPattern (this.rand); return this.from_pattern (tp); } else { NamePattern p = new NamePattern(5, 13); NamePattern.Token[] tp = p.GenerateLogicalPattern (this.rand); return this.from_pattern (tp); } }
internal static ReflectedGetterSetter GetReflectedProperty(PropertyTracker pt, MemberGroup allProperties, bool privateBinding) { ReflectedGetterSetter rp; lock (_propertyCache) { if (_propertyCache.TryGetValue(pt, out rp)) { return(rp); } NameType nt = NameType.PythonProperty; MethodInfo getter = FilterProtectedGetterOrSetter(pt.GetGetMethod(true), privateBinding); MethodInfo setter = FilterProtectedGetterOrSetter(pt.GetSetMethod(true), privateBinding); if ((getter != null && PythonHiddenAttribute.IsHidden(getter, true)) || (setter != null && PythonHiddenAttribute.IsHidden(setter, true))) { nt = NameType.Property; } ExtensionPropertyTracker ept = pt as ExtensionPropertyTracker; if (ept == null) { ReflectedPropertyTracker rpt = pt as ReflectedPropertyTracker; Debug.Assert(rpt != null); if (PythonBinder.IsExtendedType(pt.DeclaringType) || PythonHiddenAttribute.IsHidden(rpt.Property, true)) { nt = NameType.Property; } if (pt.GetIndexParameters().Length == 0) { List <MethodInfo> getters = new List <MethodInfo>(); List <MethodInfo> setters = new List <MethodInfo>(); IList <ExtensionPropertyTracker> overriddenProperties = NewTypeMaker.GetOverriddenProperties((getter ?? setter).DeclaringType, pt.Name); foreach (ExtensionPropertyTracker tracker in overriddenProperties) { MethodInfo method = tracker.GetGetMethod(privateBinding); if (method != null) { getters.Add(method); } method = tracker.GetSetMethod(privateBinding); if (method != null) { setters.Add(method); } } foreach (PropertyTracker propTracker in allProperties) { MethodInfo method = propTracker.GetGetMethod(privateBinding); if (method != null) { getters.Add(method); } method = propTracker.GetSetMethod(privateBinding); if (method != null) { setters.Add(method); } } rp = new ReflectedProperty(rpt.Property, getters.ToArray(), setters.ToArray(), nt); } else { rp = new ReflectedIndexer(((ReflectedPropertyTracker)pt).Property, NameType.Property, privateBinding); } } else { rp = new ReflectedExtensionProperty(new ExtensionPropertyInfo(pt.DeclaringType, getter ?? setter), nt); } _propertyCache[pt] = rp; return(rp); } }
/// <summary> /// Prepares help text for given option string <paramref name="name"/> and its <paramref name="type"/>. /// </summary> /// <param name="name">Option string.</param> /// <param name="type">Type of given option string. <see cref="NameType"/> for possible values (Short or Long).</param> /// <returns>Help string for given option.</returns> /// <seealso cref="NameType" /> /// <example><para><c>-f</c> is short option string</para><para><c>--format</c> is long option string</para></example> protected virtual string GetHelpTextForName(string name, NameType type) { switch (type) { case NameType.Short: return string.Format("-{0}", name); case NameType.Long: return string.Format("--{0}", name); default: throw new NotImplementedException(); } }
protected virtual MetaMetadata FindOrGenerateInheritedMetaMetadata(MetaMetadataRepository repository, InheritanceHandler inheritanceHandler) { MetaMetadata inheritedMmd = this.TypeMmd; if (inheritedMmd == null) { MmdScope mmdScope = this.Scope; String inheritedMmdName = Type ?? Name; if (ExtendsAttribute != null) { // determine new type name if (inheritedMmdName == null) throw new MetaMetadataException("attribute 'name' must be specified: " + this); if (inheritanceHandler.ResolveMmdName(inheritedMmdName) != null) // currently we don't encourage re-using existing name. however, in the future, when package names are available, we can change this. throw new MetaMetadataException("meta-metadata '" + inheritedMmdName + "' already exists! please use another name to prevent name collision. hint: use 'tag' to change the tag if needed."); // determine from which meta-metadata to inherit inheritedMmd = inheritanceHandler.ResolveMmdName(ExtendsAttribute); if (ExtendsAttribute == null || inheritedMmd == null) throw new MetaMetadataException("super type not specified or recognized: " + this + ", super type name: " + ExtendsAttribute); // generate inline mmds and put it into current scope MetaMetadata generatedMmd = this.GenerateMetaMetadata(inheritedMmdName, inheritedMmd); mmdScope.Put(inheritedMmdName, generatedMmd); mmdScope.Put(generatedMmd.Name, generatedMmd); // recursively do inheritance on generated mmd generatedMmd.InheritMetaMetadata(null); // this will set generateClassDescriptor to true if necessary MakeThisFieldUseMmd(inheritedMmdName, generatedMmd); return generatedMmd; } else { // use type / extends if (inheritedMmdName == null) throw new MetaMetadataException("no type / extends defined for " + this + " (note that due to a limitation explicit child_scalar_type is needed for scalar collection fields, even if it has been declared in super field)."); NameType[] nameType = new NameType[1]; inheritedMmd = inheritanceHandler.ResolveMmdName(inheritedMmdName, nameType); if (inheritedMmd == null) throw new MetaMetadataException("meta-metadata not found: " + inheritedMmdName + " (if you want to define new types inline, you need to specify extends/child_extends)."); if (!inheritedMmdName.Equals(inheritedMmd.Name) && nameType[0] == NameType.MMD) { // could be inline mmd this.MakeThisFieldUseMmd(inheritedMmdName, inheritedMmd); } // process normal mmd / field Debug.WriteLine("setting " + this + ".inheritedMmd to " + inheritedMmd); TypeMmd = inheritedMmd; } } return inheritedMmd; }
/// <summary> /// Remove a netbios name. /// </summary> /// <param name="name">The name to remove.</param> /// <param name="type">The type used.</param> /// <param name="suffix">The suffix used.</param> /// <returns>True on success, false on failure.</returns> public bool RemoveName(string name, NameType type, MsSuffix suffix) { Name node = new Name(); node.UncompressedName = UncompressName(name, suffix); node.Type = type; lock (nameList) { int i = 0; for (; i < nameList.Count; i++) { Name n = (Name)nameList[i]; if ((n.UncompressedName == node.UncompressedName) && (n.Type == node.Type)) break; } if (i >= nameList.Count) return false; // Name not found nameList.RemoveAt(i); if (nameList.Count == 0) updateTimer.Change(Timeout.Infinite, Timeout.Infinite); } // Send request for (int i = 0; i < BCAST_REQ_RETRY_COUNT; i++) { Request(node, HeaderOpcode.Release); Thread.Sleep(BCAST_REQ_RETRY_TIMEOUT); } return true; }
/// <summary> /// Add a netbios name. /// </summary> /// <param name="name">The name to add.</param> /// <param name="type">The type to use.</param> /// <param name="suffix">The suffix to use.</param> /// <returns>True on success, false on failure.</returns> public bool AddName(string name, NameType type, MsSuffix suffix) { Name node = new Name(); node.UncompressedName = UncompressName(name, suffix); node.Type = type; // Send request StartCapture(); for (int i = 0; i < BCAST_REQ_RETRY_COUNT; i++) { Request(node, HeaderOpcode.Registration); Thread.Sleep(3 * BCAST_REQ_RETRY_TIMEOUT); // Three times, otherwise FEZ can't follow :( if (denyCaptured) break; } if (!StopCapture()) return false; // Name in use Request(node, HeaderOpcode.Update); lock (nameList) nameList.Add(node); updateTimer.Change(NAME_UPDATE_INTERVAL_MS, Timeout.Infinite); return true; }
/// <summary> /// 创建一个.log文件 /// </summary> /// <param name="tpath"></param> /// <param name="tsn"></param> /// <param name="ttype"></param> public void CreateTXT(string tpath, string tsn, NameType ttype = NameType.None) { Create(tpath, tsn, ".log", ttype); }
public RVVisibility(NameType n, Type v) { this.RVType = n; this.ValueType = v; }
// # Create Account public CreateAccountRequest CreateAccount() { // Request envelope object RequestEnvelope envelopeRequest = new RequestEnvelope(); // The name of the person for whom the PayPal account is created: // // * FirstName // * LastName NameType name = new NameType("John", "David"); // The address to be associated with the PayPal account: // // * Street1 // * countrycode // * city // * state // * postalcode AddressType address = new AddressType("Ape Way", "US"); address.city = "Austin"; address.state = "TX"; address.postalCode ="78750"; // The CreateAccountRequest contains the information required // to create a PayPal account for a business customer // Instantiating createAccountRequest with mandatory arguments: // // * requesteEvelope // * name // * address // * preferredlanguagecode CreateAccountRequest createAccountRequest = new CreateAccountRequest(envelopeRequest, name, address, "en_US"); // The type of account to be created // Allowable values: // // * Personal // * Premier // * Business createAccountRequest.accountType = "Personal"; // The code of the country to be associated with the account createAccountRequest.citizenshipCountryCode = "US"; // Phone Number to be associated with the account createAccountRequest.contactPhoneNumber ="5126914160"; // The three letter code for the currency to be associated with the account createAccountRequest.currencyCode ="USD"; // Email address of person for whom the PayPal account is created createAccountRequest.emailAddress = "*****@*****.**"; // This attribute determines whether a key or a URL is returned for the redirect URL createAccountRequest.registrationType = "Web"; // IPN URL // // * PayPal Instant Payment Notification is a call back system that is initiated when a transaction is completed // * The transaction related IPN variables will be received on the call back URL specified in the request // * The IPN variables have to be sent back to the PayPal system for validation, upon validation PayPal will send a response string "VERIFIED" or "INVALID" // * PayPal would continuously resend IPN if a wrong IPN is sent createAccountRequest.notificationURL = "http://IPNhost"; return createAccountRequest; }
private void ConfirmNameType(String ref1, NameType expectedResult) { NameType actualResult = CellReference.ClassifyCellReference(ref1, SpreadsheetVersion.EXCEL97); Assert.AreEqual(expectedResult, actualResult); }
/// <summary> /// 创建一个.csv文件 /// </summary> /// <param name="cpath"></param> /// <param name="csn"></param> /// <param name="ctype"></param> public void CreateCSV(string cpath, string csn, NameType ctype = NameType.None) { Create(cpath, csn, ".csv", ctype); }
public FlagAttribute(NameType longName = NameType.Default) : this(default(char), longName) { if (longName == NameType.None) throw new ArgumentException("Flags need at least one short or long name."); }
/// <summary> /// Sets the name field /// After setting all name fields you should call UpdateDisplayName /// </summary> /// <param name="strName">string to set</param> /// <param name="nType">NameType to set to</param> /// <returns>true on success</returns> public bool SetName(string strName, NameType nType) { return ContactSetName(pObject, strName, (int)nType); }
public ReflectedField(FieldInfo/*!*/ info, NameType nameType) { Debug.Assert(info != null); this._nameType = nameType; this._info = info; }
/** * Resolves a cell or area reference dynamically. * @param workbookName the name of the workbook Containing the reference. If <code>null</code> * the current workbook is assumed. Note - to Evaluate formulas which use multiple workbooks, * a {@link CollaboratingWorkbooksEnvironment} must be set up. * @param sheetName the name of the sheet Containing the reference. May be <code>null</code> * (when <c>workbookName</c> is also null) in which case the current workbook and sheet is * assumed. * @param refStrPart1 the single cell reference or first part of the area reference. Must not * be <code>null</code>. * @param refStrPart2 the second part of the area reference. For single cell references this * parameter must be <code>null</code> * @param isA1Style specifies the format for <c>refStrPart1</c> and <c>refStrPart2</c>. * Pass <c>true</c> for 'A1' style and <c>false</c> for 'R1C1' style. * TODO - currently POI only supports 'A1' reference style * @return a {@link RefEval} or {@link AreaEval} */ public ValueEval GetDynamicReference(string workbookName, string sheetName, string refStrPart1, string refStrPart2, bool isA1Style) { if (!isA1Style) { throw new Exception("R1C1 style not supported yet"); } SheetRefEvaluator se = CreateExternSheetRefEvaluator(workbookName, sheetName); if (se == null) { return(ErrorEval.REF_INVALID); } SheetRangeEvaluator sre = new SheetRangeEvaluator(_sheetIndex, se); // ugly typecast - TODO - make spReadsheet version more easily accessible SpreadsheetVersion ssVersion = ((IFormulaParsingWorkbook)_workbook).GetSpreadsheetVersion(); NameType part1refType = ClassifyCellReference(refStrPart1, ssVersion); switch (part1refType) { case NameType.BadCellOrNamedRange: return(ErrorEval.REF_INVALID); case NameType.NamedRange: IEvaluationName nm = ((IFormulaParsingWorkbook)_workbook).GetName(refStrPart1, _sheetIndex); if (!nm.IsRange) { throw new Exception("Specified name '" + refStrPart1 + "' is not a range as expected."); } return(_bookEvaluator.EvaluateNameFormula(nm.NameDefinition, this)); } if (refStrPart2 == null) { // no ':' switch (part1refType) { case NameType.Column: case NameType.Row: return(ErrorEval.REF_INVALID); case NameType.Cell: CellReference cr = new CellReference(refStrPart1); return(new LazyRefEval(cr.Row, cr.Col, sre)); } throw new InvalidOperationException("Unexpected reference classification of '" + refStrPart1 + "'."); } NameType part2refType = ClassifyCellReference(refStrPart1, ssVersion); switch (part2refType) { case NameType.BadCellOrNamedRange: return(ErrorEval.REF_INVALID); case NameType.NamedRange: throw new Exception("Cannot Evaluate '" + refStrPart1 + "'. Indirect Evaluation of defined names not supported yet"); } if (part2refType != part1refType) { // LHS and RHS of ':' must be compatible return(ErrorEval.REF_INVALID); } int firstRow, firstCol, lastRow, lastCol; switch (part1refType) { case NameType.Column: firstRow = 0; if (part2refType.Equals(NameType.Column)) { lastRow = ssVersion.LastRowIndex; firstCol = ParseRowRef(refStrPart1); lastCol = ParseRowRef(refStrPart2); } else { lastRow = ssVersion.LastRowIndex; firstCol = ParseColRef(refStrPart1); lastCol = ParseColRef(refStrPart2); } break; case NameType.Row: // support of cell range in the form of integer:integer firstCol = 0; if (part2refType.Equals(NameType.Row)) { firstRow = ParseColRef(refStrPart1); lastRow = ParseColRef(refStrPart2); lastCol = ssVersion.LastColumnIndex; } else { lastCol = ssVersion.LastColumnIndex; firstRow = ParseRowRef(refStrPart1); lastRow = ParseRowRef(refStrPart2); } break; case NameType.Cell: CellReference cr; cr = new CellReference(refStrPart1); firstRow = cr.Row; firstCol = cr.Col; cr = new CellReference(refStrPart2); lastRow = cr.Row; lastCol = cr.Col; break; default: throw new InvalidOperationException("Unexpected reference classification of '" + refStrPart1 + "'."); } return(new LazyAreaEval(firstRow, firstCol, lastRow, lastCol, sre)); }
// //??? don't like this design private void AddProtocolMethod(string pythonName, string methodName, NameType nameType) { if (dict.ContainsKey(SymbolTable.StringToId(pythonName))) return; object meth; FunctionType functionType = FunctionType.Method | FunctionType.SkipThisCheck; MethodInfo methodInfo = typeof(InstanceOps).GetMethod(methodName); if (nameType == NameType.PythonMethod) functionType |= FunctionType.PythonVisible; meth = BuiltinFunction.MakeMethod(pythonName, methodInfo, functionType).GetDescriptor(); Debug.Assert(meth != null); dict[SymbolTable.StringToId(pythonName)] = meth; }
internal void StoreReflectedBaseMethod(string name, MethodInfo mi, NameType nt) { object val; SymbolId methodId = SymbolTable.StringToId(name); if (dict.TryGetValue(methodId, out val)) { // generate a new optimized method that can handle the base class. BuiltinMethodDescriptor bmd = val as BuiltinMethodDescriptor; BuiltinFunction bf = (bmd == null) ? val as BuiltinFunction : bmd.template; if (bf != null) { bf.AddMethod(mi); } } }
internal void StoreReflectedMethod(string name, MethodInfo mi, NameType nt) { FunctionType ft = CompilerHelpers.IsStatic(mi) ? FunctionType.Function : FunctionType.Method; if (nt == NameType.PythonMethod || (!IsPythonType && !clsOnly)) ft |= FunctionType.PythonVisible; StoreMethod(name, mi, ft); }
public ReflectedProperty(PropertyInfo info, MethodInfo[] getters, MethodInfo[] setters, NameType nt) : base(getters, setters, nt) { Debug.Assert(info != null); _info = info; }
public MetaMetadata ResolveMmdName(String mmdName, NameType[] nameType) { if (mmdName == null) return null; Object resultObj = null; MetaMetadata result = null; MetaMetadataField field = mmStack.Peek(); if (nameType != null && nameType.Length > 0) nameType[0] = NameType.NONE; // step 1: try to resolve the name as a concrete meta-metadata name, using the mmdScope. if (field is MetaMetadataNestedField) { MetaMetadataNestedField nested = (MetaMetadataNestedField) field; nested.Scope.TryGetValue(mmdName, out resultObj); result = (MetaMetadata) resultObj; if (result != null) if (nameType != null && nameType.Length > 0) nameType[0] = NameType.MMD; } // step 2: if step 1 failed, try to use it as a generic type var name if (result == null && mmdName.ToUpper().Equals(mmdName)) { List<Object> gtvScopes = scopeStack.Peek().GetAll(GENERIC_TYPE_VAR_SCOPE); foreach (MmdGenericTypeVarScope gtvScope_object in gtvScopes) { if (! (gtvScope_object is MmdGenericTypeVarScope)) throw new MetaMetadataException( "Object is not instance of MmdGenericTypeVarScope"); MmdGenericTypeVarScope gtvScope = gtvScope_object; MmdGenericTypeVar gtv = gtvScope.Get(mmdName); if (gtv != null) { if (gtv.Arg != null) result = ResolveMmdName(gtv.Arg); else if (gtv.ExtendsAttribute != null) result = ResolveMmdName(gtv.ExtendsAttribute); // TODO superAttribute? } } if (result != null) if (nameType != null && nameType.Length > 0) nameType[0] = NameType.GENERIC; } return result; }
protected ReflectedGetterSetter(ReflectedGetterSetter from) { _getter = from._getter; _setter = from._setter; _nameType = from._nameType; }
public FlagAttribute(char shortName, NameType longName = NameType.Default) : base(longName == NameType.None ? "" : null) { _shortName = shortName; }
public Name(NameType type, string value) { this.Type = type; this.Value = value; }
protected ReflectedGetterSetter(MethodInfo[] /*!*/ getter, MethodInfo[] /*!*/ setter, NameType nt) { Debug.Assert(getter != null); Debug.Assert(setter != null); _getter = RemoveNullEntries(getter); _setter = RemoveNullEntries(setter); _nameType = nt; }
/// <summary> /// Generates a new, fully-configured phonetic engine. /// </summary> /// <param name="nameType">The type of names it will use.</param> /// <param name="ruleType">The type of rules it will apply.</param> /// <param name="concat">If it will concatenate multiple encodings.</param> public PhoneticEngine(NameType nameType, RuleType ruleType, bool concat) : this(nameType, ruleType, concat, DEFAULT_MAX_PHONEMES) { }
///<summary>Sets the value of the <c><Name></c> element.</summary> /// <param name="Type">Code that specifies what type of name this is. If unsure, use 04.</param> /// <param name="LastName">The last name.</param> /// <param name="FirstName">The first name.</param> ///<remarks> /// <para>This form of <c>setName</c> is provided as a convenience method /// that is functionally equivalent to the <c>Name</c></para> /// <para>Version: 2.6</para> /// <para>Since: 1.5r1</para> /// </remarks> public void SetName(NameType Type, string LastName, string FirstName) { RemoveChild(StudentDTD.STUDENTSNAPSHOT_NAME); AddChild(StudentDTD.STUDENTSNAPSHOT_NAME, new Name(Type, LastName, FirstName)); }
private static List<string> ReadChildNode(XmlNode nodelist, NameType type) { List<string> actionList = new List<string>(); if (nodelist.HasChildNodes) { XmlNodeList inputList = nodelist.ChildNodes; foreach (XmlNode item in inputList) { if (type == NameType.FullName) { actionList.Add(getFullName(item.InnerText.ToString())); } else if (type == NameType.MethodName) { actionList.Add(getMethodName(item.InnerText.ToString())); } else { actionList.Add(item.InnerText.ToString()); } } } return actionList; }
void prTy(NameType t, int i) { Say("NameType("); Say(t.Name.ToString()); Say(")"); }