public void RegisterAddressBlocks(IAddressManager addressManager)
{
AddressBlock staticRomBank = new AddressBlock(0x0000, 0x03FF, true, true);
AddressBlock romPage0 = new AddressBlock(0x0400, 0x3FFF, true, false);
AddressBlock romPage1 = new AddressBlock(0x4000, 0x7FFF, true, false);
AddressBlock romPage2 = new AddressBlock(0x8000, 0xBFFF, false, false);
AddressBlock pageSelection = new AddressBlock(0xFFFC, 0xFFFF, false, true);
staticRomBank.ReadExpression = StaticRomReadExpression;
staticRomBank.WriteExpression = ReadOnlyExpression;
romPage0.WriteExpression = ReadOnlyExpression;
romPage0.ReadExpression = RomPage0ReadExpression;
romPage1.WriteExpression = ReadOnlyExpression;
romPage1.ReadExpression = RomPage1ReadExpression;
romPage2.WriteExpression = ReadOnlyExpression;
romPage2.ReadExpression = RomPage2ReadExpression;
pageSelection.WriteExpression = PageSelectionWriteExpression;
pageSelection.ReadExpression = WriteOnlyExpression;
addressManager.RegisterAddressBlock(staticRomBank);
addressManager.RegisterAddressBlock(romPage0);
addressManager.RegisterAddressBlock(romPage1);
addressManager.RegisterAddressBlock(romPage2);
addressManager.RegisterAddressBlock(pageSelection);
}
private void InitDependencies(IDataLoaderContextAccessor accessor, IAddressManager addressManager,
IArticleManager articleManager)
{
Accessor = accessor;
AddressManager = addressManager;
ArticleManager = articleManager;
}
public OrderImportor(IOrderManager orderManager,
IStoreManager storeManager,
IProductManager productManager,
IShipmentManager shipmentManager,
IProductAttributeFormatter productAttributeFormatter,
IProductAttributeManager productAttributeManager,
ILogisticsManager logisticsManager,
ILogger logger,
IPriceCalculator priceCalculator,
IStateManager stateManager,
IAddressManager addressManager,
IStateCache stateCache)
{
this._orderManager = orderManager;
this._storeManager = storeManager;
this._productManager = productManager;
this._shipmentManager = shipmentManager;
this._productAttributeFormatter = productAttributeFormatter;
this._productAttributeManager = productAttributeManager;
this._logisticsManager = logisticsManager;
this._logger = logger;
this._stateManager = stateManager;
this._addressManager = addressManager;
this._stateCache = stateCache;
this._priceCalculator = priceCalculator;
}
public AddressesController(IAddressManager addressManager, IDivisionManager divisionManager, IUpazilaManager upazilaManager, IDistrictManager districtManager)
{
this._addressManager = addressManager;
this._divisionManager = divisionManager;
this._upazilaManager = upazilaManager;
this._districtManager = districtManager;
}
public PeerStore(IKeyBook keyBook = null, IMetrics metrics = null)
{
_keybook = keyBook ?? new KeyBook();
_metrics = metrics ?? new Metrics();
_addrManager = new AddressManager();
_ds = new ConcurrentDictionary <string, object>();
}
public void RegisterAddressBlocks(IAddressManager addressManager)
{
AddressBlock addressBlock = new AddressBlock(0x10000, 0x10006, false, false);
addressBlock.ReadExpression = ReadExpression;
addressBlock.WriteExpression = WriteExpression;
addressManager.RegisterAddressBlock(addressBlock);
}
public SystemBus(IInteruptManager interuptManager, IAddressManager addressManager, IPortManager portManager)
{
_interuptManager = interuptManager;
_addressManager = addressManager;
_portManager = portManager;
_watchList = new List<Int32>();
}
public ScheduleController(IScheduleManager adr,IEmployeeManager em,IAddressManager am,IVehicleManager vm)
{
scheduleManager = adr;
empMan = em;
addMan= am;
vehman = vm;
}
public AddressApiController(IAddressManager iAddressManager
, IMapper iMapper
)
{
_iAddressManager = iAddressManager;
_iMapper = iMapper;
_log = LogManager.GetLogger(typeof(AddressController));
}
public static void SetAddrman(NodeConnectionParameters parameters, IAddressManager addrman)
{
if (parameters == null)
{
throw new ArgumentNullException(nameof(parameters));
}
SetAddrman(parameters.TemplateBehaviors, addrman);
}
public static void SetAddrman(Node node, IAddressManager addrman)
{
if (node == null)
{
throw new ArgumentNullException(nameof(node));
}
SetAddrman(node.Behaviors, addrman);
}
public Add(IPatientManager patientManager, IEmergencyContactManager emergencyContactManager, IConsultationManager consultationManager, IAddressManager addressManager)
{
InitializeComponent();
this.patientManager = patientManager;
this.emergencyContactManager = emergencyContactManager;
this.consultationManager = consultationManager;
this.addressManager = addressManager;
}
public RootQuery(IAddressManager addressManager, IArticleManager articleManager,
ICountryManager countryManager, ICityManager cityManager, IPersonManager personManager,
IStateManager stateManager, IUnitManager unitManager)
{
InitDependencies(addressManager, articleManager, cityManager, countryManager,
personManager, stateManager, unitManager);
InitQuery();
}
public AddressManagerBehavior(IAddressManager manager)
{
if (manager == null)
{
throw new ArgumentNullException(nameof(manager));
}
_AddressManager = manager;
Mode = AddressManagerBehaviorMode.AdvertizeDiscover;
}
public static Address GetAddress(this IAddressManager client, MailAddress address, EntityStatus?status)
{
if (address == null)
{
throw new ArgumentNullException("address");
}
return(client.GetAddress(address.Address, status));
}
public void RegisterAddressBlocks(IAddressManager addressManager)
{
var block = new AddressBlock(0xC000, 0xFFFB, false, false);
block.ReadExpression = Read;
block.WriteExpression = Write;
addressManager.RegisterAddressBlock(block);
}
public AccountsController(IAccountManager _accountManager,
IAddressManager _addressManager,
ICommunicationInfoManager _commInfoManager,
IMapper _mapper)
{
accountManager = _accountManager;
addressManager = _addressManager;
mapper = _mapper;
commInfoManager = _commInfoManager;
}
internal Address[] GetAddresses(long[] addressIDs)
{
Debug.Assert(m_settings.HasAddressManager);
IAddressManager client = CreateAddressManagerClient();
using (client as IDisposable)
{
return(client.GetAddressesByID(addressIDs, EntityStatus.Enabled));
}
}
public ComponentManager(
IInteruptManager interuptManager,
IAddressManager addressManager,
IPortManager portManager
)
{
_runDelegates = new Dictionary<IRunnableSystemComponent, RunDelegate>();
_interuptManager = interuptManager;
_addressManager = addressManager;
_portManager = portManager;
_components = new List<ISystemComponent>();
}
private void InitDependencies(IAddressManager addressManager, IArticleManager articleManager,
ICityManager cityManager, ICountryManager countryManager, IPersonManager personManager,
IStateManager stateManager, IUnitManager unitManager)
{
AddressManager = addressManager;
ArticleManager = articleManager;
CityManager = cityManager;
CountryManager = countryManager;
PersonManager = personManager;
StateManager = stateManager;
UnitManager = unitManager;
}
public Read(Patient patient, IPatientManager patientManager,
IAddressManager addressManager,
IEmergencyContactManager emergencyContactManager,
ITestResultManager testResultManager
)
{
InitializeComponent();
this.patient = patient;
this.patientManager = patientManager;
this.addressManager = addressManager;
this.emergencyContactManager = emergencyContactManager;
this.testResultManager = testResultManager;
}
public CheckoutController
(
UserManager <ApplicationUser> userManager,
IShoppingCartService shoppingCartService,
IAddressManager addressManager,
IOrderService orderService
)
{
_userManager = userManager;
_shoppingCartService = shoppingCartService;
_addressManager = addressManager;
_orderService = orderService;
}
public PatientController(IPatientManager patientManager,
IAddressManager addressManager,
IEmergencyContactManager emergencyContactManager,
IConsultationManager consultationManager,
IAppointmentManager appointmentManager,
IPatientFactory patientFactory)
{
_patientManager = patientManager;
_addressManager = addressManager;
_emergencyContactManager = emergencyContactManager;
_consultationManager = consultationManager;
_appointmentManager = appointmentManager;
_patientFactory = patientFactory;
}
internal Address GetAddress(DirectAddress address)
{
Debug.Assert(m_settings.HasAddressManager);
IAddressManager client = CreateAddressManagerClient();
using (client as IDisposable)
{
if (AddressDomainSearchEnabled(m_settings.AddressManager))
{
return(client.GetAddressesOrDomain(address, EntityStatus.Enabled));
}
return(client.GetAddress(address, EntityStatus.Enabled));
}
}
public static Address GetAddressesOrDomain(this IAddressManager client, string emailAddress, EntityStatus?status)
{
if (string.IsNullOrEmpty(emailAddress))
{
throw new ArgumentException("value was null or empty", "emailAddress");
}
Address[] addresses = client.GetAddressesOrDomain(new string[] { emailAddress }, status);
if (addresses.IsNullOrEmpty())
{
return(null);
}
return(addresses[0]);
}
public ManageController(
UserManager <ApplicationUser> userManager,
SignInManager <ApplicationUser> signInManager,
IEmailSender emailSender,
IAddressManager addressManager,
ILogger <ManageController> logger,
UrlEncoder urlEncoder)
{
_userManager = userManager;
_signInManager = signInManager;
_addressManager = addressManager;
_emailSender = emailSender;
_logger = logger;
_urlEncoder = urlEncoder;
}
public static void SetAddrman(NodeBehaviorsCollection behaviors, IAddressManager addrman)
{
if (behaviors == null)
{
throw new ArgumentNullException(nameof(behaviors));
}
var behavior = behaviors.Find <AddressManagerBehavior>();
if (behavior == null)
{
// FIXME: Please take a look at this
behavior = new AddressManagerBehavior(addrman);
behaviors.Add(behavior);
}
behavior.AddressManager = addrman;
}
public MainForm(IAddressManager addressManager, IClientManager clientManager, IDriverLicenseManager driverLicenseManager, IFuelManager fuelManager,
IInspectionManager inspectionManager, ITransportCategoryManager transportCategoryManager, ITransportMakeManager transportMakeManager,
ITransportManager transportManager, ITransportModelManager transportModelManager, AboutForm aboutForm)
{
InitializeComponent();
this.addressManager = addressManager;
this.clientManager = clientManager;
this.driverLicenseManager = driverLicenseManager;
this.fuelManager = fuelManager;
this.inspectionManager = inspectionManager;
this.transportCategoryManager = transportCategoryManager;
this.transportMakeManager = transportMakeManager;
this.transportManager = transportManager;
this.transportModelManager = transportModelManager;
this.aboutForm = aboutForm;
dataGridManager = new DataGridManager(dataGrid);
}
internal Address[] GetAddresses(DirectAddressCollection addresses)
{
Debug.Assert(_settings.HasAddressManager);
List <Address> managedAddresses;
string[] emailAddresses = addresses
.Select(address => address.Address)
.ToArray();
if (_addressCache != null)
{
managedAddresses = _addressCache.Get(emailAddresses);
if (managedAddresses != null && managedAddresses.Count(d => d != null) == addresses.Count())
{
managedAddresses.RemoveAll(d => d == null);
return(managedAddresses.ToArray());
}
}
IAddressManager client = CreateAddressManagerClient();
using (client as IDisposable)
{
Address[] addressesFound;
if (_enabledDomainSearch)
{
addressesFound = client.GetAddressesOrDomain(emailAddresses, EntityStatus.Enabled);
}
else
{
addressesFound = client.GetAddresses(emailAddresses, EntityStatus.Enabled);
}
managedAddresses = addressesFound.ToList();
}
if (_addressCache != null)
{
_addressCache.Put(managedAddresses);
}
return(managedAddresses.ToArray());
}
public AuthenticationController(IUserManager dbContextUser
, IRepository <UserAddress> dbContextUserAddress
, UserManager <ApplicationUser> userManager
, IAgentManager agentManager
, IJobManager jobManager
, IAddressManager addressManager
, ISkillManager skillManager
, IAgentSkillManager agentSkillManager)
{
this.userManager = userManager;
this.dbContextUser = dbContextUser;
this.dbContextUserAddress = dbContextUserAddress;
this.agentManager = agentManager;
this.jobManager = jobManager;
this.addressManager = addressManager;
this.skillManager = skillManager;
this.agentSkillManager = agentSkillManager;
}
internal Address[] GetAddresses(DirectAddressCollection addresses)
{
Debug.Assert(m_settings.HasAddressManager);
string[] emailAddresses = (
from address in addresses
select address.Address
).ToArray();
IAddressManager client = CreateAddressManagerClient();
using (client as IDisposable)
{
if (AddressDomainSearchEnabled(m_settings.AddressManager))
{
return(client.GetAddressesOrDomain(emailAddresses, EntityStatus.Enabled));
}
return(client.GetAddresses(emailAddresses, EntityStatus.Enabled));
}
}
internal Address GetAddress(DirectAddress address)
{
Debug.Assert(_settings.HasAddressManager);
Address managedAddress;
if (_addressCache != null)
{
managedAddress = _addressCache.Get(address.Address);
if (managedAddress != null)
{
return(managedAddress);
}
}
IAddressManager client = CreateAddressManagerClient();
using (client as IDisposable)
{
if (_enabledDomainSearch)
{
managedAddress = client.GetAddressesOrDomain(address, EntityStatus.Enabled);
}
else
{
managedAddress = client.GetAddress(address, EntityStatus.Enabled);
}
}
if (_addressCache != null)
{
_addressCache.Put(managedAddress);
}
return(managedAddress);
}
public MeasurementManager(IMeasurementDao measurementDao, IStationDao stationDao, IAddressManager addressManager)
{
this.measurementDao = measurementDao;
this.stationDao = stationDao;
this.addressManager = addressManager;
SetupTwitter();
/* Twitter Testing
*
* Measurement m = new Measurement()
* {
* StationId = 45,
* MeasurementTypeId = 1,
* Value = -23,
* TimesStamp = DateTime.Now,
* UnitId=1
*
* };
*
* bool res = AddMeasurement(m).Result;
*
*/
}
public OrderManager(IRepository <Order, long> OrderRepository,
IRepository <OrderItem, long> OrderItemRepository,
IStoreManager storeManager,
IProductManager productManager,
IProductAttributeFormatter productAttributeFormatter,
IProductAttributeManager productAttributeManager,
ILogisticsManager logisticsManager,
ILogger logger,
IStateManager stateManager,
IAddressManager addressManager,
IStateCache stateCache)
{
this.OrderRepository = OrderRepository;
this.OrderItemRepository = OrderItemRepository;
this._storeManager = storeManager;
this._productManager = productManager;
this._productAttributeFormatter = productAttributeFormatter;
this._productAttributeManager = productAttributeManager;
this._logisticsManager = logisticsManager;
this._logger = logger;
this._stateManager = stateManager;
this._addressManager = addressManager;
this._stateCache = stateCache;
}
public AddressRepository(IAddressManager client)
{
m_client = client;
}
public AddressController()
{
_aManager = new AddressManager();
}
public CountryOutputType(IDataLoaderContextAccessor accessor, IAddressManager addressManager)
{
InitDependencies(accessor, addressManager);
InitType();
}
