public RuntimeServer( IReader reader
, IBaseMarshaller marshaller
, IReferenceManager referenceManager
, IReflector reflector
)
{
this.reader = reader;
this.marshaller = marshaller;
this.referenceManager = referenceManager;
this.reflector = reflector;
}
internal DictCase2(IStateManager stateManager, IReferenceManager referenceManager)
{
_stateManager = stateManager;
_referencesManager = referenceManager;
}
void IObservableDictionaryEntries.Initialize(IStateManager stateManager, IReferenceManager referenceManager, ISurrogateManager surrogateManager)
{
throw new NotImplementedException();
}
internal DictCase6(IStateManager stateManager, ISurrogateManager surrogateManager, IReferenceManager referencesManager)
{
_stateManager = stateManager;
this.surrogateManager = surrogateManager;
this.referencesManager = referencesManager;
}
/// <summary>
/// Initializes a new instance of the <see cref="CollectionTypeSerializer"/> class.
/// </summary>
/// <param name="settings"></param>
/// <param name="factory"></param>
/// <param name="inspector"></param>
/// <param name="refManager"></param>
protected CollectionTypeSerializer(Settings settings, ITypeSerializerFactory factory, ITypeInspector inspector, IReferenceManager refManager)
: base(settings, factory, inspector, refManager)
{
}
public City(uint id,
IPlayer owner,
string name,
Position position,
ILazyResource resource,
byte radius,
decimal ap,
string defaultTheme,
string roadTheme,
string troopTheme,
string wallTheme,
IActionWorker worker,
CityNotificationManager notifications,
IReferenceManager references,
ITechnologyManager technologies,
ITroopManager troops,
IUnitTemplate template,
ITroopStubFactory troopStubFactory,
IDbManager dbManager,
IGameObjectFactory gameObjectFactory,
IActionFactory actionFactory,
BattleProcedure battleProcedure)
{
Id = id;
Owner = owner;
this.name = name;
this.radius = radius;
this.troopStubFactory = troopStubFactory;
this.dbManager = dbManager;
this.gameObjectFactory = gameObjectFactory;
this.actionFactory = actionFactory;
this.battleProcedure = battleProcedure;
PrimaryPosition = position;
AlignmentPoint = ap;
DefaultTheme = defaultTheme;
RoadTheme = roadTheme;
WallTheme = wallTheme;
TroopTheme = troopTheme;
Resource = resource;
Worker = worker;
Notifications = notifications;
References = references;
Technologies = technologies;
Troops = troops;
Template = template;
#region Event Proxies
Template.UnitUpdated += evtTemplate =>
{
if (Global.Current.FireEvents && DbPersisted)
{
dbManager.Save(evtTemplate);
}
UnitTemplateUpdated(this, new EventArgs());
};
Troops.TroopAdded += stub => TroopAdded(this, new TroopStubEventArgs {
Stub = stub
});
Troops.TroopRemoved += stub => TroopRemoved(this, new TroopStubEventArgs {
Stub = stub
});
Troops.TroopUpdated += stub => TroopUpdated(this, new TroopStubEventArgs {
Stub = stub
});
Troops.TroopUnitUpdated += stub => TroopUnitUpdated(this, new TroopStubEventArgs {
Stub = stub
});
Worker.ActionRemoved += (stub, state) => ActionRemoved(this, new ActionWorkerEventArgs {
State = state, Stub = stub
});
Worker.ActionStarted += (stub, state) => ActionStarted(this, new ActionWorkerEventArgs {
State = state, Stub = stub
});
Worker.ActionRescheduled += (stub, state) => ActionRescheduled(this, new ActionWorkerEventArgs {
State = state, Stub = stub
});
Resource.ResourcesUpdate += () =>
{
CheckUpdateMode();
ResourcesUpdated(this, new EventArgs());
};
Technologies.TechnologyCleared += OnTechnologyCleared;
Technologies.TechnologyAdded += OnTechnologyAdded;
Technologies.TechnologyRemoved += OnTechnologyRemoved;
Technologies.TechnologyUpgraded += OnTechnologyUpgraded;
References.ReferenceAdded += (sender, args) => ReferenceAdded(this, args);
References.ReferenceRemoved += (sender, args) => ReferenceRemoved(this, args);
#endregion
}
public BaseMarshaller(IReferenceManager referenceManager)
{
this.referenceManager = referenceManager;
this.marshallerMap = new Hashtable();
this.marshallerCache = new Hashtable();
}
public BaseMarshaller(IReferenceManager referenceManager)
{
this.referenceManager = referenceManager;
this.marshallerMap = new Hashtable();
this.marshallerCache = new Hashtable();
}
protected void SubscribeToReferenceManager(IReferenceManager _referenceManager, Page page, object item)
{
//Subscribe the item into the page's reference table
_referenceManager.Subscribe(page, item);
}
public TagsManagerMainViewModel(ITagsManager tagsManager, IBlockManager blockManager,
EventAggregator eventAggregator, IReferenceManager referenceManager, IRelationManager relationManager,
IIdeaManager ideaManager, ISharedService shared, IMaterialManager materialManager, IParticlesManager particlesManager)
{
_eventAggregator = eventAggregator;
_shared = shared;
_db = new AllDb()
{
TagsManager = tagsManager,
RelationManager = relationManager,
IdeaManager = ideaManager,
BlockManager = blockManager,
MaterialManager = materialManager,
ParticlesManager = particlesManager
};
_eventAggregator.GetEvent<BlockAddedEvent>().Subscribe(guid =>
{
var block = _db.BlockManager.GetBlockById(guid);
if (block is Idea)
{
var ideaDto = IdeaDto.FromBase(block as Idea, _db);
OnNodeAdded(ideaDto);
}
if (block is Relation)
{
var relDto = RelationDto.FromBase(block as Relation, _db);
OnNodeAdded(relDto);
}
if (block is Comment)
{
var commDto = CommentDto.FromBase(block as Comment, _db);
OnNodeAdded(commDto);
}
});
_eventAggregator.GetEvent<DatabaseImportedEvent>().Subscribe(s => OnRefresh());
_eventAggregator.GetEvent<MaterialUpdatedEvent>().Subscribe(guid =>
{
var mat = _db.MaterialManager.GetMaterialById(guid);
var matDto = MaterialDto.FromBase(mat, _db);
OnMaterialUpdate(matDto as MaterialDto);
});
NewTagCommand = new DelegateCommand<TreeItemDto>((dto) =>
{
if (dto == null || dto is TagDto)
{
var added = _db.TagsManager.AddTag(dto == null ? null : (Guid?) dto.Id, "New tag");
var addedDto = TagDto.FromBase(added, _db);
OnNodeAdded(addedDto);
OnRenameTag(addedDto);
}
});
NewIdeaCommand = new DelegateCommand<TreeItemDto>(dto =>
{
/*var added = _ideaManager.CreateIdea("New idea");
var addedDto = _map.Map<IdeaDto>(added);
OnNodeAdded(addedDto);
OnRenameTag(addedDto);*/
});
AddReferenceCommand = new DelegateCommand<TreeItemDto>(dto =>
{
if (dto is IdeaDto || dto is RelationDto)
{
var dlgVm = new CreateReferenceDlgViewModel(_db.BlockManager, dto);
if (shared.SelectedParticle != Guid.Empty)
{
var pis = _db.ParticlesManager.GetParticleInplacesForParticle(shared.SelectedParticle);
if (pis != null && pis.Any())
{
var block = _db.BlockManager.GetBlockById(pis.First().BlockId) as Idea;
if (block != null)
dlgVm.Block2 = new NamedGuid() {Caption = block.Caption, Uid = block.Id};
}
}
var dlg = new CreateReferenceDlg(dlgVm);
var res = dlg.ShowDialog();
if (res.HasValue && res.Value)
{
if (dlgVm.IsTo || dlgVm.IsBoth)
{
var refer = referenceManager.CreateReference(dlgVm.Block1.Uid, dlgVm.Block2.Uid);
OnNodeAdded(ReferenceDto.FromBase(refer, _db));
}
if (dlgVm.IsFrom || dlgVm.IsBoth)
{
var refer = referenceManager.CreateReference(dlgVm.Block2.Uid, dlgVm.Block1.Uid);
OnNodeAdded(ReferenceDto.FromBase(refer, _db));
}
}
}
});
ClearCommand = new DelegateCommand(() =>
{
tagsManager.DeleteAllTAgs();
OnRefresh();
});
OpenIdeaCommand = new DelegateCommand<TreeItemDto>(dto =>
{
if (dto is IdeaDto)
Interfaces.CompositeCommands.OpenBlockCommand.Execute(dto.Id);
if (dto is MaterialDto)
Interfaces.CompositeCommands.OpenSourceCommand.Execute(dto.Id);
});
RenameCommand = new DelegateCommand<TreeItemDto>(OnRenameTag);
AddCurrentMaterialCommand = new DelegateCommand<TagDto>(dto =>
{
if (_shared.CurrentMaterial.HasValue)
{
_db.TagsManager.ApplyTagToMaterial(_shared.CurrentMaterial.Value, dto.Id);
var m = _db.MaterialManager.GetMaterialById(_shared.CurrentMaterial.Value);
var addedDto = MaterialDto.FromBase(m, _db);
OnNodeAdded(addedDto);
}
});
DeleteCommand = new DelegateCommand<TreeItemDto>(dto =>
{
if (dto is IdeaDto)
{
_db.IdeaManager.DeleteIdea((dto as IdeaDto).Id);
NodeAnnihilated(dto);
}
});
}
public MessageReader(IReferenceManager referenceManager,IReflector reflector)
{
this.referenceManager = referenceManager;
this.reflector = reflector;
}
/// <summary>
/// Initializes a new instance of the <see cref="TypeSerializerBase{T}" /> class.
/// </summary>
/// <param name="settings"></param>
/// <param name="factory"></param>
/// <param name="inspector"></param>
/// <param name="refManager"></param>
/// <param name="title"></param>
public DogSerializer(Settings settings, ITypeSerializerFactory factory, ITypeInspector inspector, IReferenceManager refManager, string title = "")
: base(settings, factory, inspector, refManager)
{
Title = title;
}
public MessageReader(IReferenceManager referenceManager, IReflector reflector)
{
this.referenceManager = referenceManager;
this.reflector = reflector;
}
public void GetMembers(object provider, Type type, ResourceOperationContext context)
{
_members = new Dictionary <string, object>();
IReferenceManager referenceManager = context.ReferenceManager;
if (referenceManager == null)
{
Debug.Assert(referenceManager != null, "Reference Manager in the context must not be null");
}
foreach (var prop in type.GetProperties())
{
if (!prop.CanRead)
{
continue;
}
var attr = prop.GetCustomAttribute <AssetMemberAttribute>(true);
if (attr == null)
{
continue;
}
var converter = attr.Converter;
if (converter != null)
{
var value = prop.GetValue(provider);
if (value != null)
{
_members.Add(prop.Name, converter.GetStorage(provider, prop.GetValue(provider), prop, context));
}
}
else if (prop.CanWrite)
{
var value = prop.GetValue(provider);
switch (attr.StoreAs)
{
case StoreType.None:
{
if (prop.PropertyType.IsSerializable)
{
_members.Add(prop.Name, value);
}
else
{
var resource = value as IResource;
if (resource != null)
{
var refe = referenceManager.GetReference(resource, context);
_members.Add(prop.Name, refe);
}
}
break;
}
case StoreType.Asset:
{
var persistable = value as IPersistable;
if (persistable != null)
{
var asset = persistable.CreateAsset(context);
_members.Add(prop.Name, asset);
}
break;
}
case StoreType.Reference:
{
var resource = value as IResource;
if (resource != null)
{
var refe = referenceManager.GetReference(resource, context);
_members.Add(prop.Name, refe);
}
break;
}
}
}
}
if (_members.Count == 0)
{
_members = null;
}
}
public void InitializeTheList(IStateManager stateManager, IPageManager pageManager, IReferenceManager refManager, ISurrogateManager surManager, IUniqueIDGenerator uniqueIdGenerator, IServerEventAggregator serverEventAggregator)
{
_stateManager = stateManager;
_pageManager = pageManager;
_referenceManager = refManager;
_surrogateManager = surManager;
_uniqueIdGenerator = uniqueIdGenerator;
_serverEventAggregator = serverEventAggregator;
InitializeOperationHelper();
}
