public async Task BuildAsync(IEntityBuilder builder)
{
var descriptor = this._endpointDescriptorProvider.GetEndpointDescriptor(this._captureExpression, this._claimsPrincipal);
if (descriptor == null)
{
await Task.CompletedTask;
return;
}
if (descriptor.Body != null)
{
throw new InvalidOperationException("Cannot add link, body is not null!");
}
if (descriptor.Method != "GET")
{
throw new InvalidOperationException("Cannot add link, method is not GET!");
}
var href = this._hrefFactory.MakeHref(descriptor);
builder.WithLink(new Link(this._name, href, this._rel));
}
/// <summary>
/// Implemented by the derived class to provide a sprite set used
/// to draw a preview of this structure on MapView.
/// </summary>
protected AlphaBlendSpriteSet createAlphaSprites()
{
IEntityBuilder contrib = current.current;
if (contrib is LandBuilderContribution)
{
return(null);
}
Sprite[,,] temp;
if (contrib is VarHeightBuildingContribution)
{
VarHeightBuildingContribution vhcontrib = (VarHeightBuildingContribution)contrib;
Size sz = vhcontrib.size;
int pHeight = 3;
temp = new Sprite[sz.Width, sz.Height, pHeight];
for (int z = 0; z < pHeight; z++)
{
for (int y = 0; y < sz.Height; y++)
{
for (int x = 0; x < sz.Width; x++)
{
temp[x, y, z] = vhcontrib.getSprites(x, y, z, pHeight)[0];
}
}
}
}
else
{
temp = ((CommercialStructureContribution)contrib).sprites;
}
return(new AlphaBlendSpriteSet(temp));
}
public static void FillEntityView <T>(this IEntityBuilder entityBuilder
, ref T entityView
, FasterList <KeyValuePair <Type, ActionCast <T> > >
entityViewBlazingFastReflection
, object[] implementors,
#if DEBUG && !PROFILER
Dictionary <Type, ECSTuple <object, int> > implementorsByType
public object ModifyTargetValue(IEntityBuilder caller, Type SourcePropertyType, object NewValue)
{
if (!(NewValue is string))
{
throw new ArgumentException(String.Format("Expected NewValue ({0}) to be string", NewValue), "NewValue");
}
string strValue = (string)NewValue;
string tokenPattern = "(?<TokenMatch>" + Token.GetRegexPattern(null) + "){1}";
string nontokenPattern = "(?<NontokenMatch>.*)";
string pattern = (this.Direction == AppendDirection.Postfix) ? (nontokenPattern + tokenPattern) : (tokenPattern + nontokenPattern);
pattern = "^" + pattern + "$";
var regex = new Regex(pattern, RegexOptions.Singleline);
var match = regex.Match(strValue);
if (!match.Success)
{
throw new InvalidOperationException(String.Format("Could not match value {0} with regex {1}", strValue, pattern));
}
var grp = match.Groups["NontokenMatch"];
var grpValue = grp.Value;
return(grpValue);
}
public Task BuildAsync(IEntityBuilder builder)
{
var endpointDescriptor = this._endpointDescriptorProvider.GetEndpointDescriptor(this._captureExpression, this._claimsPrincipal);
if (endpointDescriptor == null)
{
return(Task.CompletedTask);
}
var method = endpointDescriptor.Method;
var href = this._hrefFactory.MakeHref(endpointDescriptor);
var fields = this._fieldsFactory.MakeFields(new ActionArgument(endpointDescriptor.BodyArgument.Descriptor, endpointDescriptor.BodyArgument.Value));
var action = new Actions.Action(this._name, href, method, fields);
if (this._configureActionBuilder != null)
{
var actionBuilder = new ActionBuilder <TBody>(action);
this._configureActionBuilder(actionBuilder);
}
builder.WithAction(action);
return(Task.CompletedTask);
}
public override void ModifyAbnfSyntaxRepresentationFor(IEntityBuilder caller, ref object value, StringBuilder representation)
{
if (value == null)
{
representation.Clear();
}
}
static int SetupSpecialEntityStruct(IEntityBuilder[] defaultEntities, out IEntityBuilder[] entitiesToBuild,
int extraLenght)
{
int length = defaultEntities.Length;
int index = -1;
for (var i = 0; i < length; i++)
{
//the special entity already exists
if (defaultEntities[i].GetEntityType() == EntityBuilderUtilities.ENTITY_STRUCT_INFO_VIEW)
{
index = i;
break;
}
}
if (index == -1)
{
index = length + extraLenght;
entitiesToBuild = new IEntityBuilder[index + 1];
}
else
{
entitiesToBuild = new IEntityBuilder[length + extraLenght];
}
Array.Copy(defaultEntities, 0, entitiesToBuild, 0, length);
return(index);
}
public static T BuildAndPersist <T>(this IEntityBuilder <T> builder, ISession session) where T : SystemEntity
{
var entity = builder.Build();
session.Transact(s => s.Save(entity));
return(entity);
}
public override void ModifyAbnfSyntaxRepresentationFor(IEntityBuilder caller, ref object value, StringBuilder representation)
{
if (value == null)
{
return;
}
string strValue;
if (value is string)
{
strValue = (string)value;
}
else
{
Type TargetType = value.GetType();
var converter = GetConverterFor(TargetType);
if (converter == null)
{
converter = caller.DefaultConverter;
}
if (converter == null)
{
throw new NullReferenceException(String.Format("Could not find/create an approrpiate converter for type {0}", TargetType.Name));
}
strValue = converter.ConvertToString(value);
}
representation.Append(strValue);
}
/// <summary>
/// Sets the partition key, row key, and creates a composite entity key
/// </summary>
/// <typeparam name="TEntity"></typeparam>
/// <typeparam name="TEntityBuilder"></typeparam>
/// <param name="builder"></param>
/// <param name="partitionKeyExpression"></param>
/// <param name="rowKeyExpression"></param>
/// <returns></returns>
public static TEntityBuilder PartitionAndRowKey <TEntity, TEntityBuilder>(
[NotNull] this IEntityBuilder <TEntity, TEntityBuilder> builder,
[NotNull] Expression <Func <TEntity, object> > partitionKeyExpression,
[NotNull] Expression <Func <TEntity, object> > rowKeyExpression)
where TEntityBuilder : IEntityBuilder <TEntity, TEntityBuilder>
{
Check.NotNull(builder, "builder");
Check.NotNull(partitionKeyExpression, "partitionKeyExpression");
Check.NotNull(rowKeyExpression, "rowKeyExpression");
var entityType = builder.Metadata;
var partitionKeyInfo = partitionKeyExpression.GetPropertyAccess();
var rowKeyInfo = rowKeyExpression.GetPropertyAccess();
var partitionKey = entityType.GetOrAddProperty(partitionKeyInfo);
var rowKey = entityType.GetOrAddProperty(rowKeyInfo);
partitionKey.SetColumnName("PartitionKey");
rowKey.SetColumnName("RowKey");
entityType.GetOrSetPrimaryKey(new[] { partitionKey, rowKey });
return((TEntityBuilder)builder);
}
public override void ModifyAbnfSyntaxRepresentationFor(IEntityBuilder caller, ref object memberValue, StringBuilder representation)
{
if (memberValue == null)
{
return;
}
Type objType = memberValue.GetType();
if (!this.Types.Contains(objType))
{
throw new InvalidOperationException(String.Format("Encountered unknown object type {0}", objType.Name));
}
var builder = caller.OwningSyntax.Entity(objType);
if (builder == null)
{
throw new InvalidOperationException(String.Format("No AbnfSyntaxBuilder-type registered for {0}", objType.Name));
}
string abnfSyntax = builder.ToAbnfSyntax(memberValue);
representation.Append(abnfSyntax);
}
static (int indexSerial, int indexDynamic) SetupSpecialEntityStruct(IEntityBuilder[] defaultEntities,
out IEntityBuilder[] entitiesToBuild)
{
int length = defaultEntities.Length;
int newLenght = length + 1;
int indexSerial = -1;
int indexDynamic = -1;
for (var i = 0; i < length; ++i)
{
if (defaultEntities[i].GetEntityType() == _serializableStructType)
{
indexSerial = i;
--newLenght;
}
if (defaultEntities[i].GetEntityType() == EntityBuilderUtilities.ENTITY_STRUCT_INFO_VIEW)
{
indexDynamic = i;
}
}
entitiesToBuild = new IEntityBuilder[newLenght];
Array.Copy(defaultEntities, 0, entitiesToBuild, 0, length);
return(indexSerial, indexDynamic);
}
public static SqlServerEntityBuilder ForSqlServer <TEntity, TEntityBuilder>(
[NotNull] this IEntityBuilder <TEntity, TEntityBuilder> entityBuilder)
where TEntityBuilder : IEntityBuilder <TEntity, TEntityBuilder>
{
Check.NotNull(entityBuilder, "entityBuilder");
return(new SqlServerEntityBuilder(entityBuilder.Metadata));
}
public EntityFacade(IEntityDataService entityDataSrv, IEntityBuilder <Entity, Category> entityBuilder, IEntitySchemeDataService schemesDataSrvcade, IUnitOfWork unitOfWork, ICategoryDataService categoryDataService)
{
_entityDataSrv = entityDataSrv;
_entityBuilder = entityBuilder;
_schemesDataSrv = schemesDataSrvcade;
_unitOfWork = unitOfWork;
_categoryDataService = categoryDataService;
}
public ActionBuilderStub(IEntityBuilder source, IEntityBuilder target, string stringRepresentation,
Resolver <IActionBuilder> resolver)
: base(stringRepresentation)
{
Source = source;
Target = target;
_resolver = resolver;
}
public static AtsEntityBuilder <TEntity> ForAzureTableStorage <TEntity, TEntityBuilder>(
[NotNull] this IEntityBuilder <TEntity, TEntityBuilder> entityBuilder)
where TEntityBuilder : IEntityBuilder <TEntity, TEntityBuilder>
{
Check.NotNull(entityBuilder, "entityBuilder");
return(new AtsEntityBuilder <TEntity>(entityBuilder.Metadata));
}
public IEnumerable <TIEntity> ExecuteReader <TIEntity>(IDbCommand command, IEntityBuilder <TIEntity> builder)
where TIEntity : class
{
builder.EntityCache = Cache ?? new EntitiesCache();
// Need for VS2008 compilation
// ReSharper disable once RedundantTypeArgumentsOfMethod
return(ExecuteCommandReader <TIEntity>(command, builder.Deserialize, builder.Offset));
}
public IBuffBuilderCollection Buffs(IEntityBuilder source = null, params IEntityBuilder[] targets)
{
var allEntitiesBuilder = EntityBuilder.AllEntities;
var sourceEntity = source ?? allEntitiesBuilder;
var targetEntity = targets.Any() ? new CompositeEntityBuilder(targets) : allEntitiesBuilder;
return(new BuffBuilderCollection(_statFactory, _allBuffs, sourceEntity, targetEntity));
}
public IStatBuilder EffectOn(IEntityBuilder target)
{
return(new StatBuilder(StatFactory, FromStatFactory(BuildStats)));
IEnumerable <IStat> BuildStats(BuildParameters parameters, Entity source, string identity)
=> target.Build(parameters.ModifierSourceEntity)
.Select(t => BuildEffectStat(source, t, identity));
}
public static RelationalEntityBuilder ForRelational <TEntity, TEntityBuilder>(
[NotNull] this IEntityBuilder <TEntity, TEntityBuilder> entityBuilder)
where TEntityBuilder : IEntityBuilder <TEntity, TEntityBuilder>
{
Check.NotNull(entityBuilder, "entityBuilder");
return(new RelationalEntityBuilder(entityBuilder.Metadata));
}
public CoreStatBuilderFromCoreBuilder(
ICoreBuilder <T> coreBuilder,
StatFactory statFactory,
IEntityBuilder entityBuilder = null)
{
_coreBuilder = coreBuilder;
_statFactory = statFactory;
_entityBuilder = entityBuilder ?? new ModifierSourceEntityBuilder();
}
public PatchEntityFromModelCommandHandler(
ILogger <PatchEntityFromModelCommandHandler <TModel, TEntity, TKey, TContext> > logger,
IEntityRepository <TContext> repository,
IEntityBuilder <TEntity, TKey> entityBuilder)
{
this.logger = logger;
this.repository = repository;
this.entityBuilder = entityBuilder;
}
public IStatBuilder AddStatForSource(IStatBuilder stat, IEntityBuilder source)
{
var baseCoreBuilder = new StatBuilderAdapter(base.AddStat(stat));
var coreBuilder = new StatBuilderWithValueConverter(baseCoreBuilder,
target => CreateAddStatMultiplier(source, target),
(l, r) => l.Multiply(r));
return(new StatBuilder(StatFactory, coreBuilder));
}
private IStatBuilder MultiplyValueByEffectModifier(
IStatBuilder gainedStat, string buffIdentity, IEntityBuilder targetEntities)
{
var coreStatBuilder = new StatBuilderWithValueConverter(new StatBuilderAdapter(gainedStat),
(ps, target) => new StatValue(_statFactory.BuffEffect(ps.ModifierSourceEntity, target, buffIdentity)),
(l, r) => l.Multiply(r));
return(new StatBuilder(_statFactory, coreStatBuilder).For(targetEntities));
}
public IStatBuilder ApplyToEntity(IEntityBuilder target)
{
var coreStats = _buffs
.Select(b => ApplyToEntity(b.Buff, target))
.Select(b => new StatBuilderAdapter(b))
.ToList();
return(new StatBuilder(_statFactory, new ConcatCompositeCoreStatBuilder(coreStats)));
}
public override string DecorateRegexPattern(IEntityBuilder caller, MemberInfo Source, string InitialPattern)
{
if (String.IsNullOrEmpty(InitialPattern))
{
throw new ArgumentException("Expected InitialPattern not to be null or empty", "InitialPattern");
}
return("(" + InitialPattern + ")?");
}
private StatBuilderWithValueConverter(
ICoreStatBuilder inner, IEntityBuilder entity, Func <BuildParameters, Entity, IValue> buildValue,
Func <IValueBuilder, IValueBuilder, IValueBuilder> combineValues)
{
_inner = inner;
_entity = entity;
_buildValue = buildValue;
_combineValues = combineValues;
}
public static TBuilder SharedNameExtension <TEntity, TBuilder>(this IEntityBuilder <TEntity, TBuilder> builder, string value)
where TBuilder : IEntityBuilder <TEntity, TBuilder>
{
builder.Annotation("Annotation", value + ".Annotation");
builder.Metadata["Metadata"] = value + ".Metadata";
builder.Model["Model"] = value + ".Model";
return((TBuilder)builder);
}
private StatBuilderWithValueConverter(
ICoreStatBuilder inner, IEntityBuilder entity, Func <Entity, IValueBuilder> createValue,
Func <IValueBuilder, IValueBuilder, IValueBuilder> combineValues)
{
_inner = inner;
_entity = entity;
_createValue = createValue;
_combineValues = combineValues;
}
public IStatBuilder AddStatForSource(IStatBuilder stat, IEntityBuilder source)
{
var baseCoreBuilder = new StatBuilderAdapter(base.AddStat(stat));
var coreBuilder = new StatBuilderWithValueConverter(baseCoreBuilder,
(ps, target) => BuildAddStatMultiplier(source.Build(ps.ModifierSourceEntity), target),
(l, r) => l.Multiply(r));
return(new StatBuilder(StatFactory, coreBuilder));
}
public MainViewModel(IViewModelServices services, IEntityBuilder entityBuilder)
: base(services)
{
if (entityBuilder == null) throw new ArgumentNullException("entityBuilder");
_entityBuilder = entityBuilder;
}
