Esempio n. 1
0
 public IteratorStateMachine(JsBlockStatement mainBlock, IEnumerable <JsVariableDeclaration> variables, IEnumerable <Tuple <string, JsFunctionDefinitionExpression> > finallyHandlers, JsBlockStatement disposer)
 {
     MainBlock       = mainBlock;
     Variables       = variables.AsReadOnly();
     FinallyHandlers = finallyHandlers.AsReadOnly();
     Disposer        = disposer;
 }
Esempio n. 2
0
 public DbDeclaration(IEnumerable <DbVariableDeclaration> variables,
                      DbSelectExpression source)
     : base(DbExpressionType.Declaration, typeof(void))
 {
     _variables = variables.AsReadOnly();
     _source    = source;
 }
 public DbFunctionExpression(Type type, string name, 
     IEnumerable<Expression> arguments)
     : base(DbExpressionType.Function, type)
 {
     _name = name;
     _arguments = arguments.AsReadOnly();
 }
Esempio n. 4
0
 public JsMethod(IMember csharpMember, string name, IEnumerable <string> typeParameterNames, JsFunctionDefinitionExpression definition)
 {
     CSharpMember       = csharpMember;
     Name               = name;
     TypeParameterNames = typeParameterNames.AsReadOnly();
     Definition         = definition;
 }
 public QueryCommand(string commandText, IEnumerable<QueryParameter> parameters, 
     IEnumerable<DbColumnExpression> columns)
 {
     this.commandText = commandText;
     this.parameters = parameters.AsReadOnly();
     this.columns = columns.AsReadOnly();
 }
            /// <summary>
            /// Get struct PriceResult from active trade agreement.
            /// Struct PriceResult contains India MaxRetailPrice. Currently there is a field �Max. retail price� in the form price/discount agreement journal
            /// (Navigation path: Main Menu > Sales and marketing > Journal > price/discount agreement journal).
            /// The field will be visible only when the logged on company is an India company. And it is optional.
            /// User can use this field to specify different MRP values on different sites and warehouses for the same item. And when the trade agreement applies to a transaction,
            /// the MRP value should flow to the MRP field of the transaction as the default value.
            /// So current change is when fetching the superset of trade agreements which could apply to all of these items and customer for the given date,
            /// also takes field MAXIMUMRETAILPRICE_IN through the stored procedures GETALLDISCOUNTTRADEAGREEMENTS/ GETALLTRADEAGREEMENTS/ GETTRADEAGREEMENTS.
            /// Then return the whole struct PriceResult  rather than PriceResult.Price.
            /// </summary>
            /// <param name="tradeAgreementRules">The trade agreement rules.</param>
            /// <param name="priceParameters">The price parameters.</param>
            /// <param name="currencyCode">The currency code.</param>
            /// <param name="itemId">The item Id.</param>
            /// <param name="defaultSalesUnit">The default sales unit.</param>
            /// <param name="salesUnit">The sales unit.</param>
            /// <param name="variantLine">The variant line.</param>
            /// <param name="unitOfMeasureConversion">The UnitOfMeasure Conversion.</param>
            /// <param name="quantity">The quantity.</param>
            /// <param name="customerId">The customer Id.</param>
            /// <param name="customerPriceGroup">The customer price group.</param>
            /// <param name="channelPriceGroupIds">The channel price group Ids.</param>
            /// <param name="salesLines">Optional sales lines.</param>
            /// <param name="priceContext">Price context.</param>
            /// <param name="activeDate">The active date.</param>
            /// <returns>The PriceResult of active trade agreement.</returns>
            internal static PriceResult GetPriceResultOfActiveTradeAgreement(
                IDictionary <string, IList <TradeAgreement> > tradeAgreementRules,
                DiscountParameters priceParameters,
                string currencyCode,
                string itemId,
                string defaultSalesUnit,
                string salesUnit,
                ProductVariant variantLine,
                UnitOfMeasureConversion unitOfMeasureConversion,
                decimal quantity,
                string customerId,
                string customerPriceGroup,
                IEnumerable <string> channelPriceGroupIds,
                IEnumerable <SalesLine> salesLines,
                PriceContext priceContext,
                DateTimeOffset activeDate)
            {
                PriceResult result;

                variantLine = variantLine ?? new ProductVariant();

                // Get basic arguments for Price evaluation
                RetailPriceArgs args = new RetailPriceArgs()
                {
                    Barcode      = string.Empty,
                    CurrencyCode = currencyCode,
                    CustomerId   = customerId,
                    Dimensions   = variantLine,
                    DefaultSalesUnitOfMeasure = defaultSalesUnit,
                    ItemId                  = itemId,
                    PriceGroups             = channelPriceGroupIds.AsReadOnly(),
                    Quantity                = quantity,
                    SalesUOM                = salesUnit,
                    UnitOfMeasureConversion = unitOfMeasureConversion,
                };

                // Get the active retail price - checks following prices brackets in order: Customer TAs, Store price group TAs, 'All' TAs.
                // First bracket to return a price 'wins'. Each bracket returns the lowest price it can find.
                result = FindPriceAgreement(tradeAgreementRules, priceParameters, args, salesLines, priceContext, activeDate);

                // Direct customer TA price would have been caught above.
                // Compare against customer price group TAs now and override if lower than previously found price (or if previously found price was 0).
                if (!string.IsNullOrEmpty(customerId) &&
                    !string.IsNullOrEmpty(customerPriceGroup) &&
                    !channelPriceGroupIds.Contains(customerPriceGroup))
                {
                    // Customer price group
                    args.PriceGroups = new ReadOnlyCollection <string>(new[] { customerPriceGroup });
                    PriceResult customerResult = FindPriceAgreement(tradeAgreementRules, priceParameters, args, salesLines, priceContext, activeDate);

                    // Pick the Customer price if either the Retail price is ZERO, or the Customer Price is non-zero AND lower
                    if ((result.Price == decimal.Zero) ||
                        ((customerResult.Price > decimal.Zero) && (customerResult.Price <= result.Price)))
                    {
                        result = customerResult;
                    }
                }

                return(result);
            }
Esempio n. 7
0
 public QueryCommand(string commandText, IEnumerable <QueryParameter> parameters,
                     IEnumerable <DbColumnExpression> columns)
 {
     this.commandText = commandText;
     this.parameters  = parameters.AsReadOnly();
     this.columns     = columns.AsReadOnly();
 }
		public JsSwitchSection(IEnumerable<JsExpression> values, JsStatement body) {
			if (values == null) throw new ArgumentNullException("values");
			if (body == null) throw new ArgumentNullException("body");
			Values = values.AsReadOnly();
			if (Values.Count == 0) throw new ArgumentException("Values cannot be empty", "values");
			Body = JsStatement.EnsureBlock(body);
		}
Esempio n. 9
0
 public JsMethod(IMember csharpMember, string name, IEnumerable<string> typeParameterNames, JsFunctionDefinitionExpression definition)
 {
     CSharpMember       = csharpMember;
     Name               = name;
     TypeParameterNames = typeParameterNames.AsReadOnly();
     Definition         = definition;
 }
 public DbInsertExpression(DbTableExpression table, 
     IEnumerable<DbColumnAssignment> assignments)
     : base(DbExpressionType.Insert, typeof(int))
 {
     _table = table;
     _assignments = assignments.AsReadOnly();
 }
Esempio n. 11
0
 public DbDeclaration(IEnumerable<DbVariableDeclaration> variables, 
     DbSelectExpression source)
     : base(DbExpressionType.Declaration, typeof(void))
 {
     _variables = variables.AsReadOnly();
     _source = source;
 }
Esempio n. 12
0
 public DbInsertExpression(DbTableExpression table,
                           IEnumerable <DbColumnAssignment> assignments)
     : base(DbExpressionType.Insert, typeof(int))
 {
     _table       = table;
     _assignments = assignments.AsReadOnly();
 }
Esempio n. 13
0
 public DbFunctionExpression(Type type, string name,
                             IEnumerable <Expression> arguments)
     : base(DbExpressionType.Function, type)
 {
     _name      = name;
     _arguments = arguments.AsReadOnly();
 }
Esempio n. 14
0
 public JsMethod(IMember csharpMember, string name, IEnumerable <string> typeParameterNames, JsFunctionDefinitionExpression definition)
 {
     Require.ValidJavaScriptIdentifier(name, "name");
     CSharpMember       = csharpMember;
     Name               = name;
     TypeParameterNames = typeParameterNames.AsReadOnly();
     Definition         = definition;
 }
 public DbUpdateExpression(DbTableExpression table, 
     Expression where, IEnumerable<DbColumnAssignment> assignments)
     : base(DbExpressionType.Update, typeof(int))
 {
     _table = table;
     _where = where;
     _assignments = assignments.AsReadOnly();
 }
Esempio n. 16
0
 public JsMethod(IMember csharpMember, string name, IEnumerable<string> typeParameterNames, JsFunctionDefinitionExpression definition)
 {
     Require.ValidJavaScriptIdentifier(name, "name");
     CSharpMember       = csharpMember;
     Name               = name;
     TypeParameterNames = typeParameterNames.AsReadOnly();
     Definition         = definition;
 }
 public DbClientJoinExpression(DbProjectionExpression projection, 
     IEnumerable<Expression> outerKey, IEnumerable<Expression> innerKey)
     : base(DbExpressionType.ClientJoin, projection.Type)
 {
     _outerKey = outerKey.AsReadOnly();
     _innerKey = innerKey.AsReadOnly();
     _projection = projection;
 }
 internal JsObjectLiteralExpression(IEnumerable <JsObjectLiteralProperty> values) : base(ExpressionNodeType.ObjectLiteral)
 {
     if (values == null)
     {
         throw new ArgumentNullException("values");
     }
     Values = values.AsReadOnly();
 }
 internal JsArrayLiteralExpression(IEnumerable <JsExpression> elements) : base(ExpressionNodeType.ArrayLiteral)
 {
     if (elements == null)
     {
         throw new ArgumentNullException("elements");
     }
     Elements = elements.AsReadOnly();
 }
 public DbUpdateExpression(DbTableExpression table,
                           Expression where, IEnumerable <DbColumnAssignment> assignments)
     : base(DbExpressionType.Update, typeof(int))
 {
     _table       = table;
     _where       = where;
     _assignments = assignments.AsReadOnly();
 }
Esempio n. 21
0
 public JsVariableDeclarationStatement(IEnumerable <JsVariableDeclaration> declarations)
 {
     if (declarations == null)
     {
         throw new ArgumentNullException("declarations");
     }
     Declarations = declarations.AsReadOnly();
 }
 public DbClientJoinExpression(DbProjectionExpression projection,
                               IEnumerable <Expression> outerKey, IEnumerable <Expression> innerKey)
     : base(DbExpressionType.ClientJoin, projection.Type)
 {
     _outerKey   = outerKey.AsReadOnly();
     _innerKey   = innerKey.AsReadOnly();
     _projection = projection;
 }
Esempio n. 23
0
 private ExpressionInfo(IEnumerable <string> tokens, Type type, string[] expressionTokens, string parameterName)
 {
     Tokens           = tokens.AsReadOnly();
     ExpressionTokens = expressionTokens;
     ParameterName    = parameterName;
     ParameterSyntax  = ParameterName + ".";
     Parameter        = Expression.Parameter(type, parameterName);
 }
 internal JsCommaExpression(IEnumerable <JsExpression> expressions) : base(ExpressionNodeType.Comma)
 {
     if (expressions == null)
     {
         throw new ArgumentNullException("expressions");
     }
     Expressions = expressions.AsReadOnly();
 }
Esempio n. 25
0
 public JsBlockStatement(IEnumerable <JsStatement> statements, bool mergeWithParent = false)
 {
     if (statements == null)
     {
         throw new ArgumentNullException("statements");
     }
     Statements      = statements.AsReadOnly();
     MergeWithParent = mergeWithParent;
 }
Esempio n. 26
0
        public SelectClauseExpression(IEnumerable<SelectorExpression> selectors, bool distinct)
        {
            _nodeType = CqlExpressionType.SelectColumns;
            _distinct = distinct;

            _selectors = selectors.AsReadOnly();
            for (int i = 0; i < _selectors.Count; i++)
                _selectors[i].Ordinal = i;
        }
Esempio n. 27
0
        public SelectorExpression(MethodInfo function, IEnumerable<SelectorExpression> arguments)
        {
            if (function.DeclaringType != typeof (CqlFunctions))
                throw new ArgumentException("function must be a valid Cql Function");

            _function = function;
            _arguments = arguments.AsReadOnly();
            _type = function.ReturnType;
            _selectorType = CqlExpressionType.FunctionSelector;
        }
        internal JsNewExpression(JsExpression constructor, IEnumerable <JsExpression> arguments) : base(ExpressionNodeType.New)
        {
            if (constructor == null)
            {
                throw new ArgumentNullException("constructor");
            }

            Constructor = constructor;
            Arguments   = arguments != null?arguments.AsReadOnly() : null;
        }
Esempio n. 29
0
 private static IEnumerable <RichTextNode.Types.TextNode> Join(IEnumerable <RichTextNode.Types.TextNode> list, RichTextNode.Types.TextNode separator)
 {
     return(list.Aggregate(new List <RichTextNode.Types.TextNode>(),
                           (list, next) =>
     {
         if (list.Count > 0)
         {
             list.Add(separator);
         }
         list.Add(next);
         return list;
     }, list => list.AsReadOnly()));
 }
 internal JsInvocationExpression(JsExpression method, IEnumerable <JsExpression> arguments) : base(ExpressionNodeType.Invocation)
 {
     if (method == null)
     {
         throw new ArgumentNullException("method");
     }
     if (arguments == null)
     {
         throw new ArgumentNullException("arguments");
     }
     Method    = method;
     Arguments = arguments.AsReadOnly();
     if (Arguments.Any(a => a == null))
     {
         throw new ArgumentException("All arguments must be non-null", "arguments");
     }
 }
Esempio n. 31
0
 public DbSelectExpression(DbTableAlias alias,
                           IEnumerable <DbColumnDeclaration> columns,
                           Expression from, Expression where,
                           IEnumerable <DbOrderExpression> orderBy,
                           IEnumerable <Expression> groupBy,
                           bool isDistinct, Expression skip, Expression take)
     : base(DbExpressionType.Select, typeof(void), alias)
 {
     _isDistinct = isDistinct;
     _columns    = columns.AsReadOnly();
     _from       = from;
     _where      = where;
     _orderBy    = orderBy.AsReadOnly();
     _groupBy    = groupBy.AsReadOnly();
     _take       = take;
     _skip       = skip;
 }
Esempio n. 32
0
 public JsSwitchSection(IEnumerable <JsExpression> values, JsStatement body)
 {
     if (values == null)
     {
         throw new ArgumentNullException("values");
     }
     if (body == null)
     {
         throw new ArgumentNullException("body");
     }
     Values = values.AsReadOnly();
     if (Values.Count == 0)
     {
         throw new ArgumentException("Values cannot be empty", "values");
     }
     Body = JsStatement.EnsureBlock(body);
 }
 public DbSelectExpression(DbTableAlias alias,
     IEnumerable<DbColumnDeclaration> columns,
     Expression from, Expression where,
     IEnumerable<DbOrderExpression> orderBy,
     IEnumerable<Expression> groupBy,
     bool isDistinct, Expression skip, Expression take)
     : base(DbExpressionType.Select, typeof(void), alias)
 {
     _isDistinct = isDistinct;
     _columns = columns.AsReadOnly();
     _from = from;
     _where = where;
     _orderBy = orderBy.AsReadOnly();
     _groupBy = groupBy.AsReadOnly();
     _take = take;
     _skip = skip;
 }
Esempio n. 34
0
        public JsSwitchStatement(JsExpression expression, IEnumerable <JsSwitchSection> sections)
        {
            if (expression == null)
            {
                throw new ArgumentNullException("test");
            }
            if (sections == null)
            {
                throw new ArgumentNullException("sections");
            }

            Expression = expression;
            Sections   = sections.AsReadOnly();

            if (Sections.SelectMany(c => c.Values).Count(v => v == null) > 1)
            {
                throw new ArgumentException("Can only have one default clause", "sections");
            }
        }
Esempio n. 35
0
        public static IEnumerable <T> Debug <T>(this IEnumerable <T> source)
        {
            source = source.NullCheck();
            if (!(source is IList <T>))
            {
                source = source.AsReadOnly();
            }

            var propertyInfos = typeof(T).GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

            var output       = new string[source.Count() + 1, propertyInfos.Length];
            var columnWidths = new int[propertyInfos.Length];

            for (var columnIndex = 0; columnIndex < propertyInfos.Length; columnIndex++)
            {
                output[0, columnIndex]    = propertyInfos[columnIndex].Name;
                columnWidths[columnIndex] = output[0, columnIndex].Length;
            }

            for (var itemIndex = 0; itemIndex < source.Count(); itemIndex++)
            {
                for (var columnIndex = 0; columnIndex < propertyInfos.Length; columnIndex++)
                {
                    var value = propertyInfos[columnIndex].GetValue(source.ElementAt(itemIndex), null);
                    output[itemIndex + 1, columnIndex] = value is decimal || value is double? "{0:#0.000}".F(value) : value.ToString();
                    columnWidths[columnIndex]          = Math.Max(columnWidths[columnIndex], output[itemIndex + 1, columnIndex].Length);
                }
            }

            for (var row = 0; row < source.Count() + 1; row++)
            {
                for (var col = 0; col < propertyInfos.Length; col++)
                {
                    Console.Write("{0," + (columnWidths[col] + 2) + "}", output[row, col]);
                }
                Console.WriteLine();
            }

            return(source);
        }
        internal JsFunctionDefinitionExpression(IEnumerable <string> parameterNames, JsStatement body, string name = null) : base(ExpressionNodeType.FunctionDefinition)
        {
            if (parameterNames == null)
            {
                throw new ArgumentNullException("parameterNames");
            }
            if (body == null)
            {
                throw new ArgumentNullException("body");
            }
            if (name != null && !name.IsValidJavaScriptIdentifier())
            {
                throw new ArgumentException("name");
            }

            ParameterNames = parameterNames.AsReadOnly();
            if (ParameterNames.Any(n => !n.IsValidJavaScriptIdentifier()))
            {
                throw new ArgumentException("parameterNames");
            }
            Body = JsStatement.EnsureBlock(body);
            Name = name;
        }
Esempio n. 37
0
        public JsFunctionStatement(string name, IEnumerable <string> parameterNames, JsStatement body)
        {
            if (!name.IsValidJavaScriptIdentifier())
            {
                throw new ArgumentException("name");
            }
            if (parameterNames == null)
            {
                throw new ArgumentNullException("parameterNames");
            }
            if (body == null)
            {
                throw new ArgumentNullException("body");
            }

            ParameterNames = parameterNames.AsReadOnly();
            if (ParameterNames.Any(n => !n.IsValidJavaScriptIdentifier()))
            {
                throw new ArgumentException("parameterNames");
            }
            Body = JsBlockStatement.MakeBlock(body);
            Name = name;
        }
        public static IEnumerable <T> Intercalate <T>(this IEnumerable <T> seq, IEnumerable <T> sep)
        {
            IReadOnlyCollection <T> roSep = sep.AsReadOnly();

            if (!seq.Any())
            {
                yield break;
            }

            IEnumerator <T> iter = seq.GetEnumerator();

            iter.MoveNext();
            yield return(iter.Current);

            while (iter.MoveNext())
            {
                foreach (T t in roSep)
                {
                    yield return(t);
                }

                yield return(iter.Current);
            }
        }
		public ExpressionCompileResult(JsExpression expression, IEnumerable<JsStatement> additionalStatements) {
			this.Expression           = expression;
			this.AdditionalStatements = additionalStatements.AsReadOnly();
		}
Esempio n. 40
0
 public GenericSimplifier(ITypeDefinition genericType, IEnumerable <string> typeParameterNames, JsExpression replaceWith)
 {
     _genericType        = genericType;
     _typeParameterNames = typeParameterNames.AsReadOnly();
     _replaceWith        = replaceWith;
 }
Esempio n. 41
0
 private TermExpression(TermExpression original, IEnumerable<TermExpression> terms,
                        IDictionary<TermExpression, TermExpression> dictTerms)
 {
     _function = original.Function;
     _termType = original._termType;
     _type = original.Type;
     _value = original.Value;
     _terms = terms.AsReadOnly();
     _dictionaryTerms = dictTerms.AsReadOnly();
 }
 /// <summary>
 /// Initializes a new instance of <see cref="TransientErrorRegistry"/>.
 /// </summary>
 /// <param name="transientErrorDetectors"></param>
 public TransientErrorRegistry(IEnumerable <IDetectTransientErrors> transientErrorDetectors)
 {
     this.transientErrorDetectors = transientErrorDetectors == null ? new IDetectTransientErrors[0] : transientErrorDetectors.AsReadOnly();
 }
Esempio n. 43
0
 /// <summary>
 ///
 /// </summary>
 /// <param name="errors"></param>
 public ValidationResult(IEnumerable <ValidationFailure> errors)
 {
     this.Errors = errors.AsReadOnly();
 }
Esempio n. 44
0
 public IRCodeBlock(IEnumerable<IIRUnit> units)
 {
     Units = units.AsReadOnly();
 }
Esempio n. 45
0
        public TermExpression(MethodInfo function, IEnumerable<TermExpression> arguments)
        {
            if (arguments == null)
                throw new ArgumentNullException("arguments");

            _function = function;
            _terms = arguments.AsReadOnly();
            _termType = CqlExpressionType.Function;
            _type = function.ReturnType;
        }
		public IteratorStateMachine(JsBlockStatement mainBlock, IEnumerable<JsVariableDeclaration> variables, IEnumerable<Tuple<string, JsFunctionDefinitionExpression>> finallyHandlers, JsBlockStatement disposer) {
			MainBlock       = mainBlock;
			Variables       = variables.AsReadOnly();
			FinallyHandlers = finallyHandlers.AsReadOnly();
			Disposer        = disposer;
		}
 /// <summary>
 /// Initializes a new instance of <see cref="TransientErrorRegistry"/>.
 /// </summary>
 /// <param name="transientErrorDetectors"></param>
 public TransientErrorRegistry(IEnumerable<IDetectTransientErrors> transientErrorDetectors)
 {
     this.transientErrorDetectors = transientErrorDetectors == null ? new IDetectTransientErrors[0] : transientErrorDetectors.AsReadOnly();
 }
Esempio n. 48
0
 public CompositeOptimizer(IEnumerable<IOptimizer> optimizers)
 {
     Optimizers = optimizers.AsReadOnly();
 }
Esempio n. 49
0
 public JsEnum(ITypeDefinition csharpTypeDefinition, string name, IEnumerable<JsEnumValue> values)
     : base(csharpTypeDefinition, name)
 {
     _values = values.AsReadOnly();
 }
 public static ConstructorScriptSemantics Json(IEnumerable<IMember> parameterToMemberMap)
 {
     return new ConstructorScriptSemantics { Type = ImplType.Json, _parameterToMemberMap = parameterToMemberMap.AsReadOnly(), GenerateCode = false };
 }
Esempio n. 51
0
 public IRMultiUnit(IEnumerable<IIRUnit> inner)
 {
     Inner = inner.AsReadOnly();
 }
		private PreparedCompilation(ICompilation compilation, IEnumerable<ParsedSourceFile> sourceFiles) {
			Compilation = compilation;
			SourceFiles = sourceFiles.AsReadOnly();
		}
		public TypeOOPEmulationPhase(IEnumerable<ITypeDefinition> dependentOnTypes, IEnumerable<JsStatement> statements) {
			DependentOnTypes = new ReadOnlySet<ITypeDefinition>(dependentOnTypes != null ? new HashSet<ITypeDefinition>(dependentOnTypes) : new HashSet<ITypeDefinition>());
			Statements = statements.AsReadOnly();
		}
 public DbInExpression(Expression expression, IEnumerable<Expression> values)
     : base(DbExpressionType.In, typeof(bool), null)
 {
     _expression = expression;
     _values = values.AsReadOnly();
 }
 /// <summary>
 /// Returns a new request template with all the same settings as this one
 /// except for the query parameters.
 /// </summary>
 /// <param name="queryParameters">The new query parameters. May be null, in which case
 /// an empty collection will be used.</param>
 /// <returns>A new request template.</returns>
 public RequestTemplate WithQueryParameters(IEnumerable <KeyValuePair <string, IEnumerable <string> > > queryParameters) =>
 new RequestTemplate(Bucket, ObjectName, HttpMethod, RequestHeaders, ContentHeaders, queryParameters.AsReadOnly());
Esempio n. 56
0
 public Code(IEnumerable<string> lines, IEnumerable<string> warnings, IEnumerable<string> errors)
 {
     Lines = lines.AsReadOnly();
     Warnings = warnings.AsReadOnly();
     Errors = errors.AsReadOnly();
 }
		public static ConstructorScriptSemantics Json(IEnumerable<IMember> parameterToMemberMap, bool skipInInitializer = false) {
			return new ConstructorScriptSemantics { Type = ImplType.Json, _parameterToMemberMap = parameterToMemberMap.AsReadOnly(), GenerateCode = false, SkipInInitializer = skipInInitializer };
		}
 public DbRowNumberExpression(IEnumerable<DbOrderExpression> orderBy)
     : base(DbExpressionType.RowCount, typeof(int))
 {
     _orderBy = orderBy.AsReadOnly();
 }