/// <summary>
/// Contents which are cached.
/// XNodes are cached fully parsed.
/// </summary>
/// <param name="origin"></param>
/// <param name="byteCache"></param>
/// <param name="xmlCache"></param>
public CachedXmlContents(IContents origin) : this(
origin,
new ConcurrentDictionary <string, XNode>(),
new ManyOf()
)
{
}
public INode <_, TTo> Get <TTo>(IContents <TOut, TTo> parameter)
{
var container = new LinkedContents <TIn, TOut, TTo>(_container.Get(Leases <TOut> .Default), parameter);
var result = new ContentNode <_, TIn, TTo>(_origin, container);
return(result);
}
public DefaultElementMemberContents(ICollectionItemTypeLocator locator, ISerializer runtime,
IContents contents)
{
_locator = locator;
_runtime = runtime;
_contents = contents;
}
/// <summary>
/// Contents which are cached.
/// XNodes are cached fully parsed.
/// </summary>
/// <param name="origin"></param>
public CachedContents(IContents origin) : this(
origin,
new BytesCache(),
new XmlCache()
)
{
}
public DeferredReferenceContents(ISpecification <TypeInfo> specification, IRootReferences references,
IContents contents)
{
_specification = specification;
_references = references;
_contents = contents;
}
// ReSharper disable once TooManyDependencies
public VariableTypeMemberContents(IVariableTypeMemberSpecifications specifications, IProperty <TypeInfo> type,
ISerializer runtime, IContents contents)
{
_specifications = specifications;
_type = type;
_runtime = runtime;
_contents = contents;
}
// ReSharper disable once TooManyDependencies
public Contents(IFormatReaders factory, IClassification classification,
ITypedTable <IEnumerable <Action <XElement> > > migrations, IContents contents)
{
_factory = factory;
_classification = classification;
_migrations = migrations;
_contents = contents;
}
/// <summary>
/// Contents which are cached.
/// XNodes are cached fully parsed.
/// </summary>
/// <param name="origin"></param>
/// <param name="byteCache"></param>
/// <param name="xmlCache"></param>
public CachedByteContents(IContents origin, int maxCachedSize) : this(
origin,
new ConcurrentDictionary <string, byte[]>(),
maxCachedSize,
new ManyOf()
)
{
}
// ReSharper disable once TooManyDependencies
public EnumerableAwareSerializers(IsEnumerableElement specification, IContents contents,
IAlteration <TypeInfo> element, ISerializers previous)
{
_specification = specification;
_contents = contents;
_element = element;
_previous = previous;
}
public DemoController(IContents contents, IOrderService orderService, IAccountPayService accountPayService, IWorkFlowService workFlowService, IMsgProvider msgProvider, IPermissionProvider permissionProvider)
{
_contents = contents;
_orderService = orderService;
_accountPayService = accountPayService;
_workFlowService = workFlowService;
_msgProvider = msgProvider;
_permissionProvider = permissionProvider;
}
//----------------------------------------------------------------------------
// Attack
//----------------------------------------------------------------------------
#region Attack
public void Attack(IHasTurn attacker, IContents victim)
{
MyAttackerTurn = attacker;
MyVictimContents = victim;
MyHasAttack = MyAttackerTurn.MyHasAttack;
MyIsVictim = MyVictimContents.MyHasTurn.MyIsVictim;
StartCoroutine(AttackCoroutine());
}
public DemoController(IContents contents, IOrderService orderService, IAccountPayService accountPayService, IWorkFlowService workFlowService, IMsgProvider msgProvider, IPermissionProvider permissionProvider, IRepository <demo_dayoff> dayoff)
{
_contents = contents;
_orderService = orderService;
_accountPayService = accountPayService;
_workFlowService = workFlowService;
_msgProvider = msgProvider;
_permissionProvider = permissionProvider;
_dayoff = dayoff;
}
public ContentsController()
{
_contentHandler = new ContentRepository();
_categoriesHandler = new CategoriesRepository();
_sitesHandler = new SitesRepository();
// Настройка AutoMapper
Mapper.Initialize(cfg => cfg.CreateMap <Contents, ContentViewModel>()
.ForMember("introtext", opt => opt.MapFrom(c => new HtmlString(c.introtext))));
}
/// <summary>
/// Contents which are cached.
/// XNodes are cached fully parsed.
/// </summary>
/// <param name="origin"></param>
public CachedContents(IContents origin, IEnumerable <string> ignored, long maxSize) : this(
origin,
new IgnoringCache <byte[]>(
new BytesCache(maxSize),
ignored
),
new IgnoringCache <XNode>(
new XmlCache(),
ignored
)
)
{
}
public ReferenceContents(ISpecification <TypeInfo> specification, ISpecification <TypeInfo> convertible,
IReferenceEncounters identifiers, IReferenceMaps maps, IEntities entities,
IContents option, IClassification classification)
{
_identifiers = identifiers;
_maps = maps;
_entities = entities;
_option = option;
_classification = classification;
_specification = specification;
_convertible = convertible;
}
/// <summary>
/// Contents which are cached.
/// XNodes are cached fully parsed.
/// </summary>
/// <param name="origin"></param>
/// <param name="byteCache"></param>
/// <param name="xmlCache"></param>
public CachedXmlContents(IContents origin, ConcurrentDictionary <string, XNode> xmlCache, IEnumerable <string> blacklist)
{
this.origin = origin;
this.xmlMem = xmlCache;
this.blacklist =
new ListOf <string>(
new ManyOf(() =>
{
var blacks = new List <string>(blacklist);
var compiled = new string[blacks.Count];
for (int i = 0; i < blacks.Count; i++)
{
compiled[i] = Regex.Escape(blacks[i].ToLower()).Replace("\\*", ".*").Replace("\\?", ".") + "$";
}
return(compiled);
})
);
}
//----------------------------------------------------------------------------
// ConnectContentsToHex
//----------------------------------------------------------------------------
#region ConnectContentsToHex
/// <summary>
/// Initialise the IHexContents subsystem <para />
/// This allows objects/map to interact
/// </summary>
public void ConnectContentsToHex()
{
IContentMarker[] hexContentMarkers = GameObject.FindObjectsOfType <IContentMarker>();
foreach (IContentMarker hexContentMarker in hexContentMarkers)
{
GameObject go = hexContentMarker.gameObject;
IContents contents = go.GetComponent <IContents>();
//object told about hex
contents.Location = HexDict[HexMath.CalculateHexCoords(contents.ContentTransform.position)];
//hex told about object
contents.Location.Contents = contents;
//Move the object to the centre of the hex
contents.ContentTransform.position = HexMath.HexCoordsToWorldSpace(contents.Location.MyHexMap.CoOrds);
contents.Initialise();
}
}
public Serializers(IElement element, IContents contents)
{
_element = element;
_contents = contents;
}
public RuntimeSerializer(IRuntimeSerialization serialization, IClassification classification)
{
_serialization = serialization;
_classification = classification;
}
public Serializers(IElements <T> elements, IContents <T> contents)
{
_elements = elements;
_contents = contents;
}
public ContentsController(IContents contents)
{
_contents = contents;
}
public NullableStructureAwareContents(IContents previous) => _previous = previous;
public AccountController(IContents contents, IPermissionProvider permissionProvider)
{
_contents = contents;
_permissionProvider = permissionProvider;
// _employeeOrg = employeeOrg;
}
public DefaultElementMemberContents(ISerializer runtime, IContents contents)
: this(CollectionItemTypeLocator.Default, runtime, contents)
{
}
public ContentContainer(IPartition <TIn> partition, IContents <TIn, TOut> contents)
{
_contents = contents;
_partition = partition;
}
public CachedContents(IContents content) : base(content.Get)
{
}
/// <summary>
/// A cell which is cached in memory.
/// </summary>
internal CachedCell(ICell origin, IContents cache)
{
this.origin = origin;
this.mem = cache;
}
public MappedArrayContents(IContents source)
: base(ArraySpecification.Default.And(MappedArraySpecification.Default),
new MappedArraySerializers(source), source)
{
}
public Contents(IContents contents, ISpecification <TypeInfo> specification)
{
_contents = contents;
_specification = specification;
}
public Contents(IContents contents) : this(contents, IsAssignableSpecification <RandomType> .Default)
{
}
