public static void RunTest() { ITypeConfig typeConfig = Core.FindOrCreateTypeConfig <IPerson, NoType>("Person1234"); typeConfig.SetEventBuilder(PropertyChangedEventBuilder.ThePropertyChangedEventBuilder, "PropertyChanged"); typeConfig.SetPropBuilder ( PropertyChangedPropBuilder.ThePropertyChangedPropBuilder, nameof(IPerson.Age), nameof(IPerson.Profession) ); typeConfig.ConfigurationCompleted(); IPerson person = typeConfig.CreateInstanceOfType <IPerson>(); person.FirstName = "Joe"; person.LastName = "Doe"; person.Age = 35; person.Profession = "Astronaut"; Console.WriteLine($"Name='{person.FirstName} {person.LastName}'; Age='{person.Age}'; Profession='{person.Profession}'"); Core.Save("GeneratedCode"); }
public ITypeConfig FindOrCreateTypeConf ( string className, INamedTypeSymbol typeToImplementSymbol, INamedTypeSymbol implementorSymbol ) { implementorSymbol = implementorSymbol.GetNoTypeForNull(TheCompilation); if (className == null) { className = typeToImplementSymbol.CreateClassName(implementorSymbol); } ITypeConfig typeConfig = FindTypeConfig(className); if (typeConfig != null) { typeConfig.CheckMatches(typeToImplementSymbol, implementorSymbol); return(typeConfig); } return(CreateTypeConf(className, typeToImplementSymbol, implementorSymbol)); }
public string GetType(ITypeConfig type) { var handler = default(SqlQueryTypesHandler); if (!Types.TryGetValue(type.Type, out handler)) { throw new NotImplementedException(); } var name = handler(this); var builder = new StringBuilder(name); var arguments = this.GetArguments(name, type); if (arguments.Any()) { builder.AppendFormat("{0} ", this.Database.QueryFactory.Dialect.OPEN_PARENTHESES); var first = true; foreach (var argument in arguments) { if (first) { first = false; } else { builder.AppendFormat("{0} ", this.Database.QueryFactory.Dialect.LIST_DELIMITER); } builder.AppendFormat("{0}", argument); } builder.AppendFormat("{0} ", this.Database.QueryFactory.Dialect.CLOSE_PARENTHESES); } return(builder.ToString()); }
public static object GetDefaultValue(ITypeConfig type) { switch (type.Type) { case DbType.Byte: return(new Byte()); case DbType.Single: return(new Single()); case DbType.Int16: return(new Int16()); case DbType.Int32: return(new Int32()); case DbType.Int64: return(new Int64()); case DbType.Guid: return(Guid.Empty); case DbType.Binary: return(new byte[type.Size]); default: throw new NotImplementedException(); } }
static void Main(string[] args) { #region CONCRETIZATION SAMPLE //MyDataImplementorClass classConcretization = // Core.GetClassConcretization<MyDataImplementorClass>(); #endregion CONCRETIZATION SAMPLE #region WRAPPED CLASS CONCRETIZATION WITH INHERITANCE FROM ABSTRACT CLASS //ITypeConfig<IMyData, MyData, WrapperInterface> typeConfig = // Core.CreateTypeConfig<IMyData, MyData, WrapperInterface>("MyType"); //typeConfig.ConfigurationCompleted(); //MyData myData = Core.GetInstanceOfGeneratedType<MyData>("MyType"); //myData.FirstName = "Joe"; //myData.LastName = "Doe"; //Console.WriteLine(myData.GetFullName()); #endregion WRAPPED CLASS CONCRETIZATION WITH INHERITANCE FROM ABSTRACT CLASS ITypeConfig <IMyData, NoClass, WrapperInterface1> typeConfig1 = Core.FindOrCreateTypeConfig <IMyData, WrapperInterface1>("MyType1"); typeConfig1.ConfigurationCompleted(); IMyData myData1 = Core.GetInstanceOfGeneratedType <IMyData>("MyType1"); myData1.FirstName = "Joe"; myData1.LastName = "Doe"; Console.WriteLine(myData1.GetFullName()); }
public static void AssembleSelectableRemovableBusinessGroup() { ITypeConfig typeConfig = Core.FindOrCreateTypeConfig <ISelectableRemovableBusinessGroup, ISelectableRemovableBusinessGroupWrapper>(); typeConfig.SetInit <SingleSelectionObservableCollection <ISelectableRemovablePerson> >(nameof(IBusinessGroup.People)); typeConfig.SetEventArgThisIdx(nameof(INotifyPropertyChanged.PropertyChanged), 0); typeConfig.SetThisMemberMap ( nameof(ISelectableRemovableBusinessGroupWrapper.TheParentChildSelectionBehavior), nameof(ParentChildSelectionBehavior <ISelectableRemovableBusinessGroup, ISelectableRemovablePerson> .Parent) ); typeConfig.SetMemberMap ( nameof(ISelectableRemovableBusinessGroupWrapper.TheParentChildSelectionBehavior), nameof(ParentChildSelectionBehavior <ISelectableRemovableBusinessGroup, ISelectableRemovablePerson> .Children), nameof(IBusinessGroup.People) ); typeConfig.SetMemberMap ( nameof(ISelectableRemovableBusinessGroupWrapper.TheRemovableCollectionBehavior), nameof(RemovableCollectionBehavior.TheCollection), nameof(IBusinessGroup.People) ); typeConfig.ConfigurationCompleted(); }
public ITypeConfig FindOrCreateTypeConfByTypeToImpl ( string className, INamedTypeSymbol typeToImplSymbol, // can be either an interface or a class INamedTypeSymbol wrappedInterfaceSymbol = null ) { INamedTypeSymbol implInterfaceSymbol, superClassSymbol; if (typeToImplSymbol.TypeKind == TypeKind.Interface) { implInterfaceSymbol = typeToImplSymbol; superClassSymbol = NoClassSymbol; } else if (typeToImplSymbol.TypeKind == TypeKind.Class) { implInterfaceSymbol = NoInterfaceSymbol; superClassSymbol = typeToImplSymbol; } else { throw new Exception($"Roxy Usage Error: Symbol '{typeToImplSymbol.Name}' is neither a class nor an interface"); } if (wrappedInterfaceSymbol == null) { wrappedInterfaceSymbol = NoInterfaceSymbol; } ITypeConfig typeConfig = this.FindOrCreateTypeConf(className, implInterfaceSymbol, superClassSymbol, wrappedInterfaceSymbol); return(typeConfig); }
static void Main(string[] args) { ITypeConfig typeConfig = Core.FindOrCreateTypeConfigByTypeToImpl <IPerson>("Person"); typeConfig.SetEventBuilder(PropertyChangedEventBuilder.ThePropertyChangedEventBuilder, "PropertyChanged"); typeConfig.SetPropBuilder ( PropertyChangedPropBuilder.ThePropertyChangedPropBuilder, nameof(IPerson.Age), nameof(IPerson.Profession) ); typeConfig.ConfigurationCompleted(); IPerson person = Core.GetInstanceOfGeneratedType <IPerson>("Person"); person.FirstName = "Joe"; person.LastName = "Doe"; person.Age = 35; person.Profession = "Astronaut"; Console.WriteLine($"Name='{person.FirstName} {person.LastName}'; Age='{person.Age}'; Profession='{person.Profession}'"); Core.Save("GeneratedCode"); }
public void CreateEnumAdaptor <T, EnumType>(Type staticEnumExtensionsType, bool allowNonPublic = true) { ITypeConfig adapterTypeConfig = FindOrCreateEnumWrapperTypeConfig <T, EnumType>(staticEnumExtensionsType, allowNonPublic); adapterTypeConfig.ConfigurationCompleted(); }
public static void RunTest() { #region WRAPPED CLASS CONCRETIZATION WITH INHERITANCE FROM ABSTRACT CLASS ITypeConfig typeConfig = Core.FindOrCreateTypeConfig <IMyData, WrapperInterface>("MyType5"); typeConfig.AddStaticUtilsClass ( nameof(StaticMethodsTests.WrapperInterface.TheClass), typeof(MyDataUtils) ); typeConfig.SetAllowNonPublicForAllMembers(nameof(WrapperInterface.TheClass)); //typeConfig.SetPropMap //( // nameof(WrapperInterface.TheClass), // "GetTheFullName", // nameof(IMyData.GetFullName), // true); typeConfig.ConfigurationCompleted(); IMyData myData = Core.GetInstanceOfGeneratedType <IMyData>("MyType5"); myData.FirstName = "Joe"; myData.LastName = "Doe"; Assert.Equal("Joe Doe", myData.GetFullName()); #endregion WRAPPED CLASS CONCRETIZATION WITH INHERITANCE FROM ABSTRACT CLASS }
static void Main(string[] args) { #region WRAPPED CLASS CONCRETIZATION WITH INHERITANCE FROM ABSTRACT CLASS ITypeConfig <IMyData, NoClass, WrapperInterface> typeConfig = Core.FindOrCreateTypeConfig <IMyData, NoClass, WrapperInterface>("MyType"); typeConfig.SetMemberMap ( nameof(WrapperInterface.TheClass), "TheLastName", nameof(IMyData.LastName), true ); typeConfig.SetPropMapAllowNonPublic(nameof(WrapperInterface.TheClass), nameof(IMyData.GetFullName)); typeConfig.ConfigurationCompleted(); IMyData myData = Core.GetInstanceOfGeneratedType <IMyData>("MyType"); myData.FirstName = "Joe"; myData.LastName = "Doe"; Console.WriteLine(myData.GetFullName()); #endregion WRAPPED CLASS CONCRETIZATION WITH INHERITANCE FROM ABSTRACT CLASS }
public bool Equals(ITypeConfig other) { if (other == null) { return(false); } if (this.Type != other.Type) { return(false); } if (this.Size != other.Size) { return(false); } if (this.Precision != other.Precision) { return(false); } if (this.Scale != other.Scale) { return(false); } if (this.IsNullable != other.IsNullable) { return(false); } return(true); }
public static void RunTest() { Core.SetSaveOnErrorPath("GeneratedCode"); ITypeConfig typeConfig = Core.FindOrCreateTypeConfig <ISelectableData, SelectableWrapperInterface>(); typeConfig.SetEventArgThisIdx(nameof(ISelectableData.IsSelectedChanged), 0); typeConfig.ConfigurationCompleted(); ISelectableData myInterfaceObj = typeConfig.CreateInstanceOfType <ISelectableData>(); myInterfaceObj.FirstName = "Nick"; myInterfaceObj.LastName = "Polyak"; bool isSelectedChanged = false; myInterfaceObj.IsSelectedChanged += (selectableItem) => { isSelectedChanged = true; }; myInterfaceObj.IsSelected = true; Assert.Equal("Nick", myInterfaceObj.FirstName); Assert.Equal("Polyak", myInterfaceObj.LastName); Assert.True(isSelectedChanged); }
public static void RunTest() { #region WRAPPED CLASS CONCRETIZATION WITH INHERITANCE FROM ABSTRACT CLASS Core.SetSaveOnErrorPath("GeneratedCode"); ITypeConfig typeConfig = Core.FindOrCreateTypeConfig <IMyData, Implementor>("MyType10"); typeConfig.SetMemberMap ( nameof(Implementor.TheClass), "TheLastName", nameof(IMyData.LastName), true ); typeConfig.SetMemberMapAllowNonPublic(nameof(Implementor.TheClass), nameof(IMyData.GetFullName)); typeConfig.ConfigurationCompleted(); IMyData myData = typeConfig.CreateInstanceOfType <IMyData>(); myData.FirstName = "Joe"; myData.LastName = "Doe"; Assert.Equal("Joe Doe", myData.GetFullName()); Core.Save("GeneratedCode"); #endregion WRAPPED CLASS CONCRETIZATION WITH INHERITANCE FROM ABSTRACT CLASS }
public ITypeConfig FindOrCreateTypeConfigUsingImplementorWithAttrs ( INamedTypeSymbol typeToImplementSymbol, INamedTypeSymbol implementorTypeSymbol) { ImplementationClassNameAttribute implementationClassNameAttribute = implementorTypeSymbol.GetAttrObject <ImplementationClassNameAttribute>(); string className; if (implementationClassNameAttribute != null) { className = implementationClassNameAttribute.ClassName; } else { className = typeToImplementSymbol.CreateClassName(implementorTypeSymbol); } ITypeConfig typeConfig = FindOrCreateTypeConf(className, typeToImplementSymbol, implementorTypeSymbol); if (implementorTypeSymbol.IsNoTypeOrNull()) { throw new Exception("Roxy Usage Error: CreateWrapper should have a non-trivial Wrapper argument passed to it."); } if (!typeConfig.ConfigurationHasBeenCompleted) { typeConfig.ConfigurationCompleted(); } return(typeConfig); }
internal void AddClass(ITypeConfig typeConfig) { this.UpdateCompilation(typeConfig.ClassName, typeConfig.TheGeneratedCode); AllTypesAddedToCompilation.Add(typeConfig); GeneratedAssemblyUpToDate = false; }
internal ITypeConfig FindTypeConfigOfGeneratedType(string className) { ITypeConfig typeConfig = this.AllTypesAddedToCompilation .Where(tConfig => tConfig.ClassName == className).SingleOrDefault(); return(typeConfig); }
public static void AssembleSelectableRemovablePerson() { ITypeConfig typeConfig = Core.FindOrCreateTypeConfig <ISelectableRemovablePerson, PersonDataVM, ISelectableRemovablePersonWrapper>(); typeConfig.SetEventArgThisIdx(nameof(INotifyPropertyChanged.PropertyChanged), 0); typeConfig.ConfigurationCompleted(); }
public T ConcretizeType <T>() { ITypeConfig typeConfig = this.FindOrCreateConcretizationTypeConf <T>(); if (typeConfig.TheGeneratedType == null) { this.RegenerateAssembly(); } return(GetInstanceOfType <T>(typeConfig)); }
public T GetInstOfGeneratedType <T, TWrapper>(string className = null, params object[] args) { ITypeConfig typeConfig = FindTypeConfig <T, TWrapper>(className); if (typeConfig.TheGeneratedType == null) { this.RegenerateAssembly(); } return(GetInstanceOfType <T>(typeConfig, args)); }
public static IColumnSelector By(string identifier, string columnName, ITypeConfig columnType, ColumnFlags?flags) { return(new ColumnSelector() { Identifier = identifier, ColumnName = columnName, ColumnType = columnType, Flags = flags, SelectorType = ColumnSelectorType.ColumnName }); }
static void Main(string[] args) { ITypeConfig typeConfig = Core.FindOrCreateTypeConfig <IMyInterface, WrapperInterface>("MyGeneratedClass"); typeConfig.SetPropBuilder(DelegatePropBuilder.TheDelegatePropBuilder, nameof(IMyInterface.TheStr)); typeConfig.ConfigurationCompleted(); IMyInterface myObj = Core.GetInstanceOfGeneratedType <IMyInterface>(); }
static void Main(string[] args) { Core.SetSaveOnErrorPath("GeneratedCode"); #region create the generated type configuration object // get the type configuration object. The class that it is going to generate // will be called "MyPersonImplementation" ITypeConfig typeConfig = Core.FindOrCreateTypeConfig <IPerson, PersonImplementationWrapperInterface>("MyPersonImplementation"); // allow access to non-public members of // PersonImplementationWrapperInterface.ThePersonImplementation object. typeConfig.SetAllowNonPublicForAllMembers ( nameof(PersonImplementationWrapperInterface.ThePersonImplementation) ); // map TheProfession property of the wrapped object // into Profession property of the IPerson interface. typeConfig.SetMemberMap ( nameof(PersonImplementationWrapperInterface.ThePersonImplementation), "TheProfession", nameof(IPerson.Profession) ); // Signal that the configuration is completed, // after ConfigurationCompleted() method is called // TypeConfig object for this class cannot be modified. typeConfig.ConfigurationCompleted(); #endregion create the generated type configuration object // get the instance of the generated type "MyPersonImplementation" IPerson person = Core.GetInstanceOfGeneratedType <IPerson>("MyPersonImplementation"); //IPerson person = Core.CreateWrapperWithNonPublicMembers<IPerson, PersonImplementationWrapperInterface>("MyPersonImplementation"); // set the properties person.FirstName = "Joe"; person.LastName = "Doe"; person.Age = 35; person.Profession = "Astronaut"; // test that the wrapped properties and the method work Console.WriteLine($"Name/Profession='{person.GetFullNameAndProfession()}'; Age='{person.Age}'"); Core.Save("GeneratedCode"); }
public T BuildEnumWrapper <T, EnumType>(EnumType enumVal) where EnumType : struct { string className = typeof(EnumType).GetTypeAdapterClassName(typeof(T)); ITypeConfig enumWrapperTypeConfig = FindTypeConfig <T, SingleWrapperInterface <EnumType> >(className); if (enumWrapperTypeConfig == null) { throw new Exception($"Roxy Usage Error: Adapter {className} has not been created. You should call CreateEnumAdaptor method first."); } return(GetInstOfGeneratedType <T>(className, enumVal)); }
public static void AssembleBusinessGroupsCollection() { ITypeConfig typeConfig = Core.FindOrCreateTypeConfig <SingleSelectionObservableCollection <ISelectableRemovableBusinessGroup>, NoType, IRemovableCollectionBehaviorWrapper>(); typeConfig.SetThisMemberMap ( nameof(IRemovableCollectionBehaviorWrapper.TheRemovableCollectionBehavior), nameof(RemovableCollectionBehavior.TheCollection) ); typeConfig.ConfigurationCompleted(); }
public TToImplement CreateImplInstance <TToImplement, TImplementor> ( params object[] args) { ITypeConfig typeConfig = FindOrCreateTypeConfigUsingImplementorWithAttrs ( typeof(TToImplement), typeof(TImplementor) ); return(typeConfig.CreateInstanceOfType <TToImplement>(args)); }
public static void RunTest() { Core.SetSaveOnErrorPath("GeneratedCode"); #region CONCRETIZATION SAMPLE //MyDataImplementorClass classConcretization = // Core.Concretize<MyDataImplementorClass>(); #endregion CONCRETIZATION SAMPLE #region WRAPPED CLASS CONCRETIZATION WITH INHERITANCE FROM ABSTRACT CLASS ITypeConfig typeConfig = Core.FindOrCreateTypeConfig <IMyData, ImplementorClass>("MyType7"); typeConfig.ConfigurationCompleted(); MyData myData = typeConfig.CreateInstanceOfType <MyData>(); myData.FirstName = "Joe"; myData.LastName = "Doe"; Assert.Equal("Doe, Joe", myData.GetFullName()); #endregion WRAPPED CLASS CONCRETIZATION WITH INHERITANCE FROM ABSTRACT CLASS ITypeConfig typeConfig1 = Core.FindOrCreateTypeConfig <IMyData, WrapperInterface1>("MyType9"); typeConfig1.ConfigurationCompleted(); IMyData myData1 = typeConfig1.CreateInstanceOfType <IMyData>(); myData1.FirstName = "Joe"; myData1.LastName = "Doe"; Core.Save("GeneratedCode"); Assert.Equal("Doe, Joe", myData1.GetFullName()); ITypeConfig typeConfig2 = Core.FindOrCreateTypeConfig <IMyData, ImplementorClass>(); typeConfig2.ConfigurationCompleted(); IMyData myData2 = typeConfig2.CreateInstanceOfType <IMyData>(); myData2.FirstName = "Joe"; myData2.LastName = "Doe"; Assert.Equal("Doe, Joe", myData2.GetFullName()); }
static void Main(string[] args) { // saves the generated files in case of a compilation error Core.SetSaveOnErrorPath("GeneratedCode"); // created the ITypeConfig for configuring the IMyData implementation // using IWrapper interface ITypeConfig <IWrapper> typeConfig = Core.FindOrCreateTypeConfig <IMyData, IWrapper>(); // sets the GetGreetings method of IMyData // interface to MydataImplGet.GreetingImpl implementation // the two last type arguments signify the string argument that is // passed to the method and the string output argument. typeConfig.SetReturningMethodMap <IMyData, MyDataImpl, string, string> ( // specifies the interface method to implement (data, inputStr) => data.GetGreeting(inputStr), // specifies the wrapper object that used // to implement the interface method (wrapper) => wrapper.TheDataImpl, // specifies the method implementation (dataImpl, inputStr) => dataImpl.GetGreetingImpl(inputStr) ); // code is generated typeConfig.ConfigurationCompleted(); // we get the instance of the generated class // that implements IMyData interface IMyData myData = Core.GetInstanceOfGeneratedType <IMyData>(); // set the first and last names myData.FirstName = "Joe"; myData.LastName = "Doe"; // get the greeting by calling IMyData.GetGreeting method of // the interface, passing "Hello" string to it string greetingStr = myData.GetGreeting("Hello"); // Prints the resulting string // "Hello Joe Doe!" Console.WriteLine(greetingStr); // saves the generated code in case of successful // completion. Core.Save("GeneratedCode"); }
public static bool IsNumeric(ITypeConfig type) { switch (type.Type) { case DbType.Byte: case DbType.Single: case DbType.Int16: case DbType.Int32: case DbType.Int64: return(true); default: return(false); } }
public TClass CreateClassObj <TClass>(string className, params object[] args) { ITypeConfig typeConfig = FindTypeConfigOfGeneratedType(className); if (typeConfig == null) { return((TClass)Activator.CreateInstance(typeof(TClass), args)); } if (typeConfig.TheGeneratedType == null) { RegenerateAssembly(); } return(GetInstanceOfType <TClass>(typeConfig, args)); }