/// <summary>
/// Add regions group to region.
/// </summary>
/// <returns>Returns new regions group in current region.</returns>
public RegionGroup Regions()
{
var group = new RegionGroup(Region.Type);
Region.Add(group);
return(group);
}
/// <summary>
/// Add regions group.
/// </summary>
/// <returns>New group instance.</returns>
public RegionGroup Regions()
{
var group = new RegionGroup(Type);
Type.AddMemberGroup(group);
return(group);
}
public void LoadRegionGroupFromState(int pstateid, bool includeRegional = false)
{
client = new SQSAdminServiceClient();
client.Endpoint.Address = new System.ServiceModel.EndpointAddress(CommonVariables.WcfEndpoint);
DataSet ds = client.SQSAdmin_StandardInclusion_GetRegionGroupByState(pstateid);
client.Close();
SQSRegionGroup.Clear();
SQSRegionGroupWithAll.Clear();
RegionGroup rg = null;
if (pstateid == 1)
{
rg = new RegionGroup();
rg.RegionGroupID = 0;
rg.RegionGroupName = "All Regions";
SQSRegionGroupWithAll.Add(rg);
}
foreach (DataRow dr in ds.Tables[0].Rows)
{
rg = new RegionGroup();
rg.RegionGroupID = int.Parse(dr["idregiongroup"].ToString());
rg.RegionGroupName = dr["regiongroupname"].ToString();
SQSRegionGroup.Add(rg);
SQSRegionGroupWithAll.Add(rg);
}
if (pstateid == 1 && includeRegional)
{
rg = new RegionGroup();
rg.RegionGroupID = 12;
rg.RegionGroupName = "Regional";
SQSRegionGroupWithAll.Insert(2, rg);
}
}
/// <summary>
/// Generates mappings for functions and procedures for specific schema (or main context).
/// </summary>
/// <param name="context">Main data context class.</param>
/// <param name="schema">Current schema.</param>
/// <param name="procedureDataContextType">Data context type for stored procedure parameter.</param>
/// <param name="storedProceduresRegion">Region for stored procedure mappings.</param>
/// <param name="aggregatesRegion">Region for aggregates mappings.</param>
/// <param name="scalarFunctionsRegion">Region for scalar functions mappings.</param>
/// <param name="tableFunctionsRegion">Region for table functions mappings.</param>
/// <param name="getSchemaConfigurator">Static mapping schema initializer provider.</param>
private void BuildFunctions(
CodeClass context,
SchemaModelBase schema,
IType procedureDataContextType,
Func <RegionGroup> storedProceduresRegion,
Func <RegionGroup> aggregatesRegion,
Func <RegionGroup> scalarFunctionsRegion,
RegionGroup tableFunctionsRegion,
Func <(BlockBuilder cctorBody, CodeReference schema)> getSchemaConfigurator)
/// <summary>
/// Get rhino breps of underlying regions
/// </summary>
internal static List <Rhino.Geometry.Brep> ToRhino(this RegionGroup regionGroup)
{
List <Rhino.Geometry.Brep> breps = new List <Rhino.Geometry.Brep>();
foreach (Region region in regionGroup.Regions)
{
breps.Add(region.ToRhinoBrep());
}
return(breps);
}
private static RegionGroup[] GetRegionGroups()
{
if (options != null && !options.IncludeRegionGroups)
{
return(null);
}
List <XElement> regionGroupElements = (from i in supplementalDataDocument.Elements("supplementalData")
.Elements("territoryContainment").Elements("group")
select i).ToList();
if (regionGroupElements.Count == 0)
{
return(null);
}
List <RegionGroup> regionGroups = new List <RegionGroup>();
foreach (XElement regionGroupElement in regionGroupElements)
{
string regionGroupId = regionGroupElement.Attribute("type").Value.ToString();
Progress("Adding region group", regionGroupId);
RegionGroup regionGroup = new RegionGroup();
regionGroup.Id = regionGroupId;
regionGroup.RegionIds = regionGroupElement.Attribute("contains").Value.ToString().Split(' ');
if (regionGroupElement.Attribute("status") != null)
{
regionGroup.Status = regionGroupElement.Attribute("status").Value.ToString();
}
regionGroups.Add(regionGroup);
Progress("Added region group", regionGroupId, ProgressEventType.Added, regionGroup);
}
return(regionGroups.ToArray());
}
public static List <RegionGroup> GetRegionGroups(this ScriptPortal.Vegas.Vegas Vegas)
{
Timecode selStart = Vegas.Transport.SelectionStart;
Timecode selEnd = Vegas.Transport.SelectionStart + Vegas.Transport.SelectionLength;
if (selStart > selEnd)
{
Ext.SwapTimecode(ref selStart, ref selEnd);
}
bool selection = Vegas.SelectionLength != Timecode.FromNanos(0) && (Vegas.Transport.CursorPosition == selStart || Vegas.Transport.CursorPosition == selEnd);
var rGrps = new List <RegionGroup>();
foreach (var r in Vegas.Project.Regions)
{
if (selection && (r.Position < selStart || r.End > selEnd))
{
continue;
}
var rgr = new RegionGroup(r);
foreach (Track t in Vegas.Project.Tracks)
{
foreach (TrackEvent ev in t.Events)
{
if (ev.Start < r.End && ev.End > r.Position)
{
rgr.AddEvent(ev);
}
}
}
rGrps.Add(rgr);
}
return(rGrps);
}
/// <summary>
/// Generates table function mapping.
/// </summary>
/// <param name="tableFunction">Function model.</param>
/// <param name="functionsGroup">Functions region.</param>
/// <param name="context">Data context class.</param>
private void BuildTableFunction(
TableFunctionModel tableFunction,
RegionGroup functionsGroup,
CodeClass context)
{
// generated code sample:
/*
* #region Function1
* private static readonly MethodInfo _function1 = MemberHelper.MethodOf<DataContext>(ctx => ctx.Function1(default));
*
* [Sql.TableFunction("Function1")]
* public IQueryable<Parent> Function1(int? id)
* {
* return this.GetTable<Parent>(this, _function1, id);
* }
* #endregion
*/
// create function region
var region = functionsGroup.New(tableFunction.Method.Name);
// if function schema load failed, generate error pragma with exception details
if (tableFunction.Error != null)
{
if (_options.DataModel.GenerateProceduresSchemaError)
{
region.Pragmas().Add(AST.Error($"Failed to load return table schema: {tableFunction.Error}"));
}
// as we cannot generate table function without knowing it's schema, we skip failed function
return;
}
// if function result schema matches known entity, we use entity class for result
// otherwise we generate custom record mapping
if (tableFunction.Result == null || tableFunction.Result.CustomTable == null && tableFunction.Result.Entity == null)
{
throw new InvalidOperationException($"Table function {tableFunction.Name} result record type not set");
}
// GetTable API for table functions need MethodInfo instance of generated method as parameter
// to not load it on each call, we cache MethodInfo instance in static field
var methodInfo = region
.Fields(false)
.New(AST.Name(tableFunction.MethodInfoFieldName), WellKnownTypes.System.Reflection.MethodInfo)
.Private()
.Static()
.ReadOnly();
// generate mapping method with metadata
var method = DefineMethod(region.Methods(false), tableFunction.Method);
_metadataBuilder.BuildTableFunctionMetadata(tableFunction.Metadata, method);
// generate method parameters, return type and body
// table record type
IType returnEntity;
if (tableFunction.Result.Entity != null)
{
returnEntity = _entityBuilders[tableFunction.Result.Entity].Type.Type;
}
else
{
returnEntity = BuildCustomResultClass(tableFunction.Result.CustomTable !, region.Classes(), true).resultClassType;
}
// set return type
// T4 used ITable<T> for return type, but there is no reason to use ITable<T> over IQueryable<T>
// Even more: ITable<T> is not correct return type here
var returnType = _options.DataModel.TableFunctionReturnsTable
? WellKnownTypes.LinqToDB.ITable(returnEntity)
: WellKnownTypes.System.Linq.IQueryable(returnEntity);
method.Returns(returnType);
// parameters for GetTable call in mapping body
var parameters = new ICodeExpression[3 + tableFunction.Parameters.Count];
parameters[0] = context.This; // `this` extension method parameter
parameters[1] = context.This; // context parameter
parameters[2] = methodInfo.Field.Reference; // method info field
// add table function parameters (if any)
var fieldInitParameters = new ICodeExpression[tableFunction.Parameters.Count];
for (var i = 0; i < tableFunction.Parameters.Count; i++)
{
var param = tableFunction.Parameters[i];
// parameters added to 3 places:
// - to mapping method
// - to GetTable call in mapping
// - to mapping call in MethodInfo initializer we add parameter's default value
var parameter = DefineParameter(method, param.Parameter);
parameters[i + 3] = parameter.Reference;
// TODO: potential issue: target-typed `default` could cause errors with overloads
fieldInitParameters[i] = AST.Default(param.Parameter.Type, true);
}
// generate mapping body
method.Body()
.Append(
AST.Return(
AST.ExtCall(
WellKnownTypes.LinqToDB.DataExtensions,
WellKnownTypes.LinqToDB.DataExtensions_GetTable,
WellKnownTypes.LinqToDB.ITable(returnEntity),
new[] { returnEntity },
false,
parameters)));
// generate MethodInfo field initializer
var lambdaParam = AST.LambdaParameter(AST.Name(TABLE_FUNCTION_METHOD_INFO_CONTEXT_PARAMETER), context.Type);
// Expression<Func<context, returnType>>
var lambda = AST
.Lambda(WellKnownTypes.System.Linq.Expressions.Expression(WellKnownTypes.System.Func(returnType, context.Type)), true)
.Parameter(lambdaParam);
lambda.Body()
.Append(
AST.Return(
AST.Call(
lambdaParam.Reference,
method.Method.Name,
returnType,
fieldInitParameters)));
methodInfo.AddInitializer(
AST.Call(
new CodeTypeReference(WellKnownTypes.LinqToDB.Expressions.MemberHelper),
WellKnownTypes.LinqToDB.Expressions.MemberHelper_MethodOf,
WellKnownTypes.System.Reflection.MethodInfo,
new[] { functionsGroup.OwnerType.Type },
false,
lambda.Method));
// TODO: similar tables
}
protected override void Visit(RegionGroup group)
{
VisitList(group.Members);
}
