protected override void RegisterMethods(RefactorType type)
{
type.Register<string, object>("op_Add", this.DoAdd);
type.Register<string, string>("Contains", this.DoContains);
type.Register<string, string>("EndsWith", this.DoEndsWith);
type.Register<string>("get_IsEmpty", this.DoIsEmpty);
type.Register<string, object[]>("Join", this.DoJoin);
type.Register<string, string, string>("Replace", this.DoReplace);
type.Register<string, string>("StartsWith", this.DoStartsWith);
}
protected override void RegisterMethods(RefactorType type)
{
type.Register<object[], object>("Contains", this.DoContains);
type.Register<object[]>("get_Fifth", o => DoGetNth(o, 4));
type.Register<object[]>("get_First", o => DoGetNth(o, 0));
type.Register<object[]>("get_Fourth", o => DoGetNth(o, 3));
type.Register<object[]>("get_Head", o => DoGetNth(o, 0));
type.Register<object[]>("get_IsEmpty", this.DoGetIsEmpty);
type.Register<object[]>("get_Last", this.DoGetLast);
type.Register<object[]>("get_Second", o => DoGetNth(o, 1));
type.Register<object[]>("get_Tail", this.DoGetTail);
type.Register<object[]>("get_Third", o => DoGetNth(o, 2));
}
protected override void RegisterMethods(RefactorType type)
{
type.Register<CsBody, string>("InsertFirst", this.DoInsertFirst);
type.Register<CsBody, string>("InsertLast", this.DoInsertLast);
}
protected override void RegisterMethods(RefactorType type)
{
type.Register<CsType>("get_Access", this.DoGetAccess);
type.Register<CsType, string>("AddBase", this.DoAddBase);
type.Register<CsType, string>("AddMember", this.DoAddMember);
type.Register<CsType>("get_Attributes", this.DoGetAttributes);
type.Register<CsType>("get_Bases", this.DoGetBases);
type.Register<CsType>("get_Constraints", this.DoGetConstraints);
type.Register<CsType>("get_DeclaringType", this.DoGetDeclaringType);
type.Register<CsType>("get_Events", this.DoGetEvents);
type.Register<CsType>("get_Fields", this.DoGetFields);
type.Register<CsType>("get_FullName", this.DoGetFullName);
type.Register<CsType>("get_GenericArguments", this.DoGetGenericArguments);
type.Register<CsType>("get_Indexers", this.DoGetIndexers);
type.Register<CsType>("get_IsAbstract", this.DoGetIsAbstract);
type.Register<CsType>("get_IsInternal", this.DoGetIsInternal);
type.Register<CsType>("get_IsPartial", this.DoGetIsPartial);
type.Register<CsType>("get_IsPrivate", this.DoGetIsPrivate);
type.Register<CsType>("get_IsProtected", this.DoGetIsProtected);
type.Register<CsType>("get_IsPublic", this.DoGetIsPublic);
type.Register<CsType>("get_IsSealed", this.DoGetIsSealed);
type.Register<CsType>("get_IsStatic", this.DoGetIsStatic);
type.Register<CsType>("get_Members", this.DoGetMembers);
type.Register<CsType>("get_Methods", this.DoGetMethods);
type.Register<CsType>("get_Modifiers", this.DoGetModifiers);
type.Register<CsType>("get_Name", this.DoGetName);
type.Register<CsType>("get_Operators", this.DoGetOperators);
type.Register<CsType>("get_Properties", this.DoGetProperties);
type.Register<CsType, string, string>("GetFieldName", this.DoGetFieldName);
type.Register<CsType, string>("GetUniqueName", this.DoGetUniqueName);
type.Register<CsType, string, object[]>("HasMember", this.DoHasMember);
}
protected override void RegisterMethods(RefactorType type)
{
type.Register<object, object>("op_Equals", this.DoEquals);
type.Register<object, string>("op_IsType", this.DoIsType);
type.Register<object, object>("op_NotEquals", this.DoNotEquals);
}
protected override void RegisterMethods(RefactorType type)
{
type.Register<CsIndexer>("get_GetterAccess", this.DoGetGetterAccess);
type.Register<CsIndexer>("get_GetterAttributes", this.DoGetGetterAttributes);
type.Register<CsIndexer>("get_GetterBody", this.DoGetGetterBody);
type.Register<CsIndexer>("get_HasGetter", this.DoGetHasGetter);
type.Register<CsIndexer>("get_HasSetter", this.DoGetHasSetter);
type.Register<CsIndexer>("get_Parameters", this.DoGetParameters);
type.Register<CsIndexer>("get_ReturnType", this.DoGetReturnType);
type.Register<CsIndexer>("get_SetterAccess", this.DoGetSetterAccess);
type.Register<CsIndexer>("get_SetterAttributes", this.DoGetSetterAttributes);
type.Register<CsIndexer>("get_SetterBody", this.DoGetSetterBody);
}
protected override void RegisterMethods(RefactorType type)
{
type.Register<CsEvent>("get_Type", this.DoGetType);
}
protected override void RegisterMethods(RefactorType type)
{
type.Register<CsMember, string>("AddMemberAfter", this.DoAddMethodAfter);
type.Register<CsMember, string>("AddMemberBefore", this.DoAddMethodBefore);
type.Register<CsMember, string>("ChangeAccess", this.DoChangeAccess);
type.Register<CsMember>("get_Access", this.DoGetAccess);
type.Register<CsMember>("get_Attributes", this.DoGetAttributes);
type.Register<CsMember>("get_DeclaringType", this.DoGetDeclaringType);
type.Register<CsMember>("get_FullName", this.DoGetFullName);
type.Register<CsMember>("get_IsAbstract", this.DoGetIsAbstract);
type.Register<CsMember>("get_IsConst", this.DoGetIsConst);
type.Register<CsMember>("get_IsInternal", this.DoGetIsInternal);
type.Register<CsMember>("get_IsOverride", this.DoGetIsOverride);
type.Register<CsMember>("get_IsProtected", this.DoGetIsProtected);
type.Register<CsMember>("get_IsPrivate", this.DoGetIsPrivate);
type.Register<CsMember>("get_IsPublic", this.DoGetIsPublic);
type.Register<CsMember>("get_IsReadonly", this.DoGetIsReadonly);
type.Register<CsMember>("get_IsSealed", this.DoGetIsSealed);
type.Register<CsMember>("get_IsStatic", this.DoGetIsStatic);
type.Register<CsMember>("get_IsVirtual", this.DoGetIsVirtual);
type.Register<CsMember>("get_IsVolatile", this.DoGetIsVolatile);
type.Register<CsMember>("get_Modifiers", this.DoGetModifiers);
type.Register<CsMember>("get_Name", this.DoGetName);
}
protected override void RegisterMethods(RefactorType type)
{
type.Register<CsEnum>("get_BaseType", this.DoGetBaseType);
type.Register<CsEnum>("get_Names", this.DoGetNames);
}
protected override void RegisterMethods(RefactorType type)
{
type.Register<CsOperator>("get_Body", this.DoGetBody);
type.Register<CsOperator>("get_IsConversion", this.DoGetIsConversion);
type.Register<CsOperator>("get_IsExplicit", this.DoGetIsExplicit);
type.Register<CsOperator>("get_IsImplicit", this.DoGetIsImplicit);
type.Register<CsOperator>("get_Parameters", this.DoGetParameters);
type.Register<CsOperator>("get_ReturnType", this.DoGetReturnType);
}
protected override void RegisterMethods(RefactorType type)
{
type.Register<CsNamespace, string>("AddUsing", this.DoAddUsing);
type.Register<CsNamespace>("get_Aliases", this.DoGetAliases);
type.Register<CsNamespace>("get_Externs", this.DoGetExterns);
type.Register<CsNamespace>("get_Name", this.DoGetName);
type.Register<CsNamespace>("get_Namespaces", this.DoGetNamespaces);
type.Register<CsNamespace>("get_Uses", this.DoGetUses);
type.Register<CsNamespace, string, string>("TypeMatches", this.DoTypeMatches);
}
protected override void RegisterMethods(RefactorType type)
{
type.Register<CsDelegate>("get_Parameters", this.DoGetParameters);
type.Register<CsDelegate>("get_ReturnType", this.DoGetReturnType);
}
protected override void RegisterMethods(RefactorType type)
{
type.Register<Script, string, object>("Ask", this.DoAsk);
type.Register<Script>("get_HasSelection", this.DoGetHasSelection);
type.Register<Script>("get_Globals", this.DoGetGlobals);
type.Register<Script>("get_Selection", this.DoGetSelection);
type.Register<Script, string>("GetUniqueName", this.DoGetUniqueName);
type.Register<Script, string>("Indent", this.DoIndent);
type.Register<Script, string>("InsertAfterSelection", this.DoInsertAfterSelection);
type.Register<Script, string>("InsertBeforeSelection", this.DoInsertBeforeSelection);
type.Register<Script, string>("Raise", this.DoRaise);
type.Register<Script>("get_Scope", this.DoGetScope);
type.Register<Script, object>("Write", this.DoWrite);
type.Register<Script, object>("WriteLine", this.DoWriteLine);
}
protected override void RegisterMethods(RefactorType type)
{
type.Register<CsParameter>("get_Attributes", this.DoGetAttributes);
type.Register<CsParameter>("get_IsParams", this.DoGetIsParams);
type.Register<CsParameter>("get_Modifier", this.DoGetModifier);
type.Register<CsParameter>("get_Name", this.DoGetName);
type.Register<CsParameter>("get_Type", this.DoGetType);
}
protected override void RegisterMethods(RefactorType type)
{
type.Register<CsExternAlias>("get_Name", this.DoGetName);
}
protected override void RegisterMethods(RefactorType type)
{
type.Register<CsUsingAlias>("get_Alias", this.DoGetAlias);
type.Register<CsUsingAlias>("get_Value", this.DoGetValue);
}
protected override void RegisterMethods(RefactorType type)
{
type.Register<CsField>("get_Type", this.DoGetType);
type.Register<CsField>("get_Value", this.DoGetValue);
}
protected override void RegisterMethods(RefactorType type)
{
type.Register<CsTypeScope>("get_Body", this.DoGetBody);
type.Register<CsTypeScope>("get_Classes", this.DoGetClasses);
type.Register<CsTypeScope>("get_Declarations", this.DoGetDeclarations);
type.Register<CsTypeScope>("get_Delegates", this.DoGetDelegates);
type.Register<CsTypeScope>("get_Enums", this.DoGetEnums);
type.Register<CsTypeScope>("get_Interfaces", this.DoGetInterfaces);
type.Register<CsTypeScope>("get_Namespace", this.DoGetNamespace);
type.Register<CsTypeScope>("get_Structs", this.DoGetStructs);
type.Register<CsTypeScope>("get_Types", this.DoGetTypes);
}
protected override void RegisterMethods(RefactorType type)
{
type.Register<CsGlobalNamespace>("get_Attributes", this.DoGetAttributes);
}
protected override void RegisterMethods(RefactorType type)
{
type.Register<bool, bool>("op_LogicalAnd", this.DoAnd);
type.Register<bool>("op_LogicalComplement", this.DoComplement);
type.Register<bool, bool>("op_LogicalOr", this.DoOr);
}
protected override void RegisterMethods(RefactorType type)
{
type.Register<CsUsingDirective>("get_Namespace", this.DoGetNamespace);
}
protected override void RegisterMethods(RefactorType type)
{
type.Register<CsAttribute>("get_Arguments", this.DoGetArguments);
type.Register<CsAttribute>("get_Name", this.DoGetName);
type.Register<CsAttribute>("get_Target", this.DoGetTarget);
}