partial void OnConstructor()
{
get_variable_context = new OperationCache <DOMEContext>("get_variable_context", delegate() {
DOMEContext variable_context;
if (this.GetTopicalChildren <DOMElement_RuleAtom_Variable>()
.Convert(v => v.GetVariableContext())
.AreAllSame(out variable_context))
{
return(variable_context);
}
return(null);
});
get_default_variable_type_context = new OperationCache <DOMEVariableTypeConcept>("get_default_variable_type_context", delegate() {
DOMEVariableTypeConcept variable_type;
if (this.GetTopicalChildren <DOMElement_RuleAtom_Variable>()
.Convert(v => v.GetVariableTypeConcept())
.AreAllSame(out variable_type))
{
return(variable_type);
}
return(null);
});
}
public void Init()
{
this.testSubject = new OperationCache();
this.testSubject.Add(this.actionWithBindingParameterWrapper1);
this.testSubject.Add(this.actionWithBindingParameterWrapper2);
this.testSubject.Add(this.serviceOperationWrapper);
}
private InputDevice_Joystick(int di)
{
device_index = di;
axises = new OperationCache <InputAtom_Axis, int>("axises", i => new InputAtom_Axis_Native_Joystick(device_index, i));
buttons = new OperationCache <InputAtom_Button, int>("buttons", i => new InputAtom_Button_Native_Joystick(device_index, i));
int_sticks = new OperationCache <InputAtom_IntStick, int>("int_sticks", i => new InputAtom_IntStick_Native_JoystickHat(device_index, i));
}
public DOMEVariableType_Multiple_RuleDefinition_NoParent_List(DOMEClass p, DOMEVariableTypeConcept t) : base(p, t)
{
get_type_name = new OperationCache <string>("get_type_name", delegate() {
return(CSLine.Single("List<?INNER_TYPE>",
"INNER_TYPE", GetTypeConcept().GetStoreTypeName()
));
});
}
public DOMEVariableType_Multiple_Primitive_List(DOMEVariableTypeConcept t) : base(t)
{
get_type_name = new OperationCache <string>("get_type_name", delegate() {
return(CSLine.Single("List<?INNER_TYPE>",
"INNER_TYPE", GetTypeConcept().GetStoreTypeName()
));
});
}
partial void OnConstructor()
{
resolve = new OperationCache <DOMElement_TokenDefinition>("resolve", delegate() {
return(GetGrammarDefinition().GetDefinitions()
.Convert <DOMElement_Definition, DOMElement_Definition_TokenDefinition>()
.Convert <DOMElement_Definition_TokenDefinition, DOMElement_TokenDefinition>(d => d.GetTokenDefinition())
.FindFirst(d => d.IsToken(GetTokenId())));
});
}
public DOMEVariableType_Single_RuleDefinition_AutoParent(DOMEClass p, DOMEVariableTypeConcept t) : base(p, t)
{
get_type_name = new OperationCache <string>("get_type_name", delegate() {
return(CSLine.Single("HoldingSingle<?PARENT_TYPE, ?INNER_TYPE>",
"PARENT_TYPE", GetParentType().GetTypeName(),
"INNER_TYPE", GetTypeConcept().GetStoreTypeName()
));
});
}
private TyonTypeHandler_Deconstructable()
{
deconstruction_invokers = new OperationCache <BasicConversionInvoker, Type>(
"deconstruction_invokers",
t => MarkedMethods <DefinitionDeconstructionAttribute>
.GetFilteredMarkedStaticMethods(Filterer_MethodInfo.CanEffectiveParametersHold(t))
.GetFirst()
.IfNotNull(m => m.GetBasicConversionInvoker())
);
}
public ClassLibrary()
{
class_providers = new List <ClassProvider>();
manual_classes = new Dictionary <Tuple <Type, string>, CmlClass>();
class_cache = new OperationCache <CmlClass, Type, string>("class_cache", delegate(Type type, string layout) {
return(manual_classes.GetValue(Tuple.New(type, layout)) ??
class_providers.Convert(p => p.GetClass(type, layout)).GetFirstNonNull());
});
}
partial void OnConstructor()
{
get_context_default_variable_name = new OperationCache <string>("get_context_default_variable_name", delegate() {
return(GetContextId().StyleAsVariableName());
});
get_info_settings = new OperationCache <LookupBackedSet <string, string> >("get_info_settings", delegate() {
return(GetInfo().CreateBackedSet(DEFAULT_INFO_VALUES));
});
}
public DOMEVariableType_Multiple_RuleDefinition_NoParent_LabeledItemSet(DOMEClass p, DOMEVariableTypeConcept t, DOMEVariableTypeConcept l) : base(p, t)
{
label_type_concept = l;
get_type_name = new OperationCache <string>("get_type_name", delegate() {
return(CSLine.Single("LabeledItemSet<?LABEL_TYPE, ?INNER_TYPE>",
"LABEL_TYPE", GetLabelTypeConcept().GetStoreTypeName(),
"INNER_TYPE", GetTypeConcept().GetStoreTypeName()
));
});
}
protected override void LateConstruct()
{
base.LateConstruct();
cache = new OperationCache <List <OctoSubTile>, OctoMask>("cache", delegate(OctoMask mask) {
return(sub_tiles
.Narrow(t => t.GetMask().HasNoOtherBits(mask))
.FindAllHighestRated(t => t.GetMask().GetComplexity())
.ToList());
});
}
public DOMEClass_Generated_GrammarElement_SyntaxException(DOMElement_GrammarDefinition g) : base(g)
{
get_type_name = new OperationCache <string>("get_type_name", delegate() {
return(GetGrammarDefinition().GetGrammarName() + "SyntaxException");
});
get_base_type = new OperationCache <DOMEClass>("get_base_type", delegate() {
return(GetGrammarDefinition()
.GetClassGeneric(
GetGrammarDefinition().GetSettings().GetExceptionBaseTypeName()
));
});
}
public DOMEVariableTypeConcept_Primitive(DOMElement_GrammarDefinition g, string n)
{
name = n;
grammar_definition = g;
get_as_single = new OperationCache <DOMEVariableType>("get_as_single", delegate() {
return(new DOMEVariableType_Single_Primitive(this));
});
get_as_collection = new OperationCache <DOMEVariableType>("get_as_collection", delegate() {
return(new DOMEVariableType_Multiple_Primitive_List(this));
});
}
public FragmentLibrary()
{
fragment_providers = new List <FragmentProvider>();
manual_fragments = Types.GetFilteredTypes(
Filterer_Type.CanBeTreatedAs <CmlFragment_BuiltIn>(),
Filterer_Type.IsConcreteClass()
).CreateInstances <CmlFragment>()
.ToDictionaryValues(f => f.GetName());
fragment_cache = new OperationCache <CmlFragment, string>("fragment_cache", delegate(string name) {
return(manual_fragments.GetValue(name) ??
fragment_providers.Convert(p => p.GetFragment(name)).GetFirstNonNull());
});
}
/// <summary>
/// Update a record in the DB
/// </summary>
/// <param name="id"></param>
/// <param name="data"></param>
/// <returns></returns>
public int Update(TId id, dynamic data)
{
database.InitializeModelData((object)data, OperationType.Update);
List <string> paramNames = OperationCache.GetParamNames((object)data);
var builder = new StringBuilder();
builder.Append("update ").Append(TableName).Append(" set ");
builder.AppendLine(string.Join(",", paramNames.Where(n => n != "Id").Select(p => p + "= @" + p)));
builder.Append("where Id = @Id");
DynamicParameters parameters = new DynamicParameters(data);
parameters.Add("Id", id);
return(database.Execute(builder.ToString(), parameters));
}
public DOMElement_RuleAtom_Variable_Reference()
{
get_default_variable_type_context = new OperationCache <DOMEVariableTypeConcept>("get_default_variable_type_context", delegate() {
DOMEVariableTypeConcept type = GetDefaultVariableTypeInternal();
HasInfo has_info = type as HasInfo;
if (has_info != null)
{
return(has_info.ConvertInfoValue <DOMEVariableTypeConcept>("type",
() => type,
s => GetGrammarDefinition().GetTypeConcept(s)
));
}
return(type);
});
}
/// <summary>
/// Insert a row into the db
/// </summary>
/// <param name="data">Either DynamicParameters or an anonymous type or concrete type</param>
/// <returns></returns>
public virtual int Insert <T>(dynamic data)
{
//this.database.BeginTransaction();
var o = (object)data;
InitializeModelData(o, OperationType.Insert);
List <string> paramNames = OperationCache.GetParamNames(o);
//paramNames.Remove("Id");
string tableName = OperationCache.DetermineTableName <T>();
string cols = string.Join(",", paramNames);
string cols_params = string.Join(",", paramNames.Select(p => "@" + p));
var sql = "insert into" + tableName + " (" + cols + ") values (" + cols_params + ")";
return(this.Execute(sql, o));
}
/// <summary>
/// Insert a row into the db
/// </summary>
/// <param name="data">Either DynamicParameters or an anonymous type or concrete type</param>
/// <returns></returns>
public virtual int Insert(dynamic data)
{
//this.database.BeginTransaction();
var o = (object)data;
database.InitializeModelData(o, OperationType.Insert);
List <string> paramNames = OperationCache.GetParamNames(o);
//paramNames.Remove("Id");
string cols = string.Join(",", paramNames);
string cols_params = string.Join(",", paramNames.Select(p => "@" + p));
//var sql = "set nocount on insert " + TableName + " (" + cols + ") values (" + cols_params + ") select cast(scope_identity() as int)";
var sql = "insert into" + TableName + " (" + cols + ") values (" + cols_params + ")";
return(database.Execute(sql, o));
}
public RepresentationEngine()
{
global_library = new GlobalLibrary();
class_library = new ClassLibrary();
fragment_library = new FragmentLibrary();
instancers = new Dictionary <string, RepresentationInstancer>();
constructors = new Dictionary <string, List <RepresentationConstructor> >();
constructor_cache = new OperationCache <RepresentationConstructor, string, ContentsEnumerable <Type> >("constructor_cache", delegate(string name, ContentsEnumerable <Type> parameter_types) {
return(constructors.GetValues(name)
.FindFirst(c => c.GetParameterTypes().AreElements(parameter_types, (p1, p2) => p1.CanHold(p2))));
});
infos = new Dictionary <string, TypeDictionary <RepresentationInfo> >();
info_sets = new Dictionary <Type, List <RepresentationInfoSet> >();
general_modifiers = new Dictionary <Type, List <RepresentationModifier_General> >();
}
partial void OnConstructor()
{
utilities = new DOMEClass_Generated_GrammarElement_Helper_Utilities(this);
iparse_tree_extensions = new DOMEClass_Generated_GrammarElement_Helper_IParseTreeExtensions(this);
resolver = new DOMEClass_Generated_GrammarElement_Helper_Resolver(this);
syntax_exception = new DOMEClass_Generated_GrammarElement_SyntaxException(this);
syntax_exception_thrower = new DOMEClass_Generated_GrammarElement_Helper_SyntaxExceptionThrower(this);
get_parser_name = new OperationCache <string>("get_parser_name", delegate() {
return(GetGrammarName() + "Parser");
});
get_lexer_name = new OperationCache <string>("get_lexer_name", delegate() {
return(GetGrammarName() + "Lexer");
});
get_visitor_name = new OperationCache <string>("get_visitor_name", delegate() {
return(GetGrammarName() + "BaseVisitor");
});
get_main_filename = new OperationCache <string>("get_main_filename", delegate() {
return(GetGrammarName() + "DOMinator.cs");
});
get_class_generic = new OperationCache <DOMEClass_Generic, string>("get_class_generic", delegate(string name) {
return(new DOMEClass_Generic(this, name));
});
get_type_concept = new OperationCache <DOMEVariableTypeConcept, string>("get_type_concept", delegate(string name) {
return(Types.GetFilteredTypes(
Filterer_Type.CanBeTreatedAs <DOMEVariableTypeConcept>(),
Filterer_Type.HasCustomLabeledAttributeOfType <DOMEVariableTypeConceptAttribute>(name, true)
).GetFirst().IfNotNull(t => t.CreateInstance <DOMEVariableTypeConcept>(this), delegate() {
if (name.TryTrimPrefix("enum_", out name))
{
return new DOMEVariableTypeConcept_Primitive_Enum(this, name);
}
return new DOMEVariableTypeConcept_Primitive_NewConstruct(this, name);
}));
});
}
public DOMElement_RuleAtom_Variable()
{
get_variable_name = new OperationCache <string>("get_variable_name", delegate() {
return(this.ConvertInfoValue <string>("name",
() => GetVariableDefaultName(),
s => s
));
});
get_variable_type_context = new OperationCache <DOMEVariableTypeConcept>("get_variable_type_context", delegate() {
return(this.ConvertInfoValue <DOMEVariableTypeConcept>("type",
() => GetDefaultVariableTypeContext(),
s => GetGrammarDefinition().GetTypeConcept(s)
));
});
get_variable_type_container = new OperationCache <DOMEVariableType>("get_variable_type_container", delegate() {
return(GetVariableTypeConcept().Wrap(IsVariableCollection()));
});
get_variable_default_name = new OperationCache <string>("get_variable_default_name", delegate() {
IndexSituation index_situation = this.GetVariableContextIndexSituation();
string context_default_variable_name = GetVariableContext().GetContextDefaultVariableName();
if (index_situation.IsShared())
{
context_default_variable_name += (index_situation.GetIndex() + 1).ToString();
}
if (IsVariableCollection())
{
return(context_default_variable_name.StyleAsPluralWord());
}
return(context_default_variable_name);
});
get_info_settings = new OperationCache <LookupBackedSet <string, string> >("get_info_settings", delegate() {
return(GetInfo().CreateBackedSet(DEFAULT_SETTING_VALUES));
});
}
public TyonSettings(IEnumerable <TyonTypeHandler> t, IEnumerable <TyonDesignatedVariableProvider> v)
{
type_handlers = t.Prepend(
TyonTypeHandler_Byte.INSTANCE,
TyonTypeHandler_Short.INSTANCE,
TyonTypeHandler_UShort.INSTANCE,
TyonTypeHandler_Int.INSTANCE,
TyonTypeHandler_UInt.INSTANCE,
TyonTypeHandler_Long.INSTANCE,
TyonTypeHandler_Boolean.INSTANCE,
TyonTypeHandler_Float.INSTANCE,
TyonTypeHandler_Double.INSTANCE,
TyonTypeHandler_Decimal.INSTANCE,
TyonTypeHandler_String.INSTANCE,
TyonTypeHandler_Enum.INSTANCE,
TyonTypeHandler_Deconstructable.INSTANCE,
TyonTypeHandler_IEnumerable.INSTANCE,
TyonTypeHandler_Type.INSTANCE
).Append(
TyonTypeHandler_Object.INSTANCE,
TyonTypeHandler_Fallback.INSTANCE
).ToList();
type_handlers.Process(z => z.SetSettings(this));
variable_providers = v.ToList();
variable_providers.Process(z => z.SetSettings(this));
type_handler_cache = new OperationCache <TyonTypeHandler, Type>("type_handler_cache", delegate(Type type) {
return(type_handlers.FindFirst(z => z.IsCompatible(type)));
});
designated_variables_cache = new OperationCache <Dictionary <string, Variable>, Type>("designated_variables_cache", delegate(Type type) {
return(variable_providers.FindFirstNonEmpty(z => z.GetDesignatedVariables(type))
.ToDictionaryValues(z => z.GetVariableName()));
});
}
public DOMEClass_Generated_GrammarElement_Helper_IParseTreeExtensions(DOMElement_GrammarDefinition g) : base(g)
{
get_type_name = new OperationCache <string>("get_type_name", delegate() {
return(GetGrammarDefinition().GetGrammarName() + "IParseTreeExtensions");
});
}
private InputDevice_Keyboard(int di)
{
device_index = di;
buttons = new OperationCache <InputAtom_Button, Key>("buttons", k => new InputAtom_Button_Native_Keyboard(device_index, k));
}
/// <summary>
/// Delete a record for the DB
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public bool Delete <T>(string id)
{
string tableName = OperationCache.DetermineTableName <T>();
return(this.Execute("delete from " + tableName + " where Id = @id", new { id }) > 0);
}
/// <summary>
/// Grab a record with a particular Id from the DB
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public T Get <T>(string id)
{
string tableName = OperationCache.DetermineTableName <T>();
return(this.Query <T>("select * from " + tableName + " where Id = @id", new { id }).FirstOrDefault());
}
/// <summary>
/// 获取数量
/// </summary>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public int Count <T>()
{
string tableName = OperationCache.DetermineTableName <T>();
return(this.ExecuteScalar <int>("select count(*) from " + tableName));
}
/// <summary>
///
/// </summary>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public virtual T First <T>()
{
string tableName = OperationCache.DetermineTableName <T>();
return(this.Query <T>("select top 1 * from " + tableName).FirstOrDefault());
}
public IEnumerable <T> All <T>()
{
string tableName = OperationCache.DetermineTableName <T>();
return(this.Query <T>("select * from " + tableName));
}
