public void Setup()
{
Input = PipeSegment.Input(PipeSegment.End());
Scope = Input.NewSubscriptionScope();
EstablishContext();
}
public void Setup()
{
_addCalled = new Future <bool>();
_removeCalled = new Future <bool>();
_input = PipeSegment.Input(PipeSegment.End());
_subscriberScope = _input.NewSubscriptionScope();
_subscriberScope.Subscribe <SubscriberAdded>(x =>
{
if (x.MessageType == typeof(ClaimModified))
{
_addCalled.Complete(true);
}
});
_subscriberScope.Subscribe <SubscriberRemoved>(x =>
{
if (x.MessageType == typeof(ClaimModified))
{
_removeCalled.Complete(true);
}
});
using (ISubscriptionScope scope = _input.NewSubscriptionScope())
{
scope.Subscribe <ClaimModified>(x => { });
}
}
private void RegisterApplicationServices(IContainer container)
{
var pipe = PipeSegment.Input(PipeSegment.End());
container.RegisterAsSingleton((Pipe)pipe);
container.RegisterAsSingleton <IEventsProvider, EventsProvider>();
}
private void AddSegment(PipeSegment segment)
{
// Segment se instancira kao dete cele cevi (PipeRoot)
var seg = Instantiate(segment, transform);
// Generisu se objekti unutar cevi
seg.SpawnObjects(objectsToSpawn);
/*
* Segment se postavlja na lokalni koordinatni pocetak ukoliko je prvi u nizu,
* inace se postavlja na End poziciju poslednje cevi u nizu
*/
if (segments.Count == 0)
{
seg.transform.position = transform.position;
}
else
{
seg.transform.position = segments[segments.Count - 1].End.position;
}
// Random rotacija cevi oko pravca pruzanja. Postize se utisak skretanja u random smer, ukoliko je kosa cev
seg.transform.Rotate(new Vector3(0f, Random.Range(0, 360), 0f));
// Dodaje se instancirani segment
segments.Add(seg);
}
public void Should_display_an_InputSegment()
{
var end = PipeSegment.End <object>();
Pipe input = PipeSegment.Input(end);
new TracePipeVisitor().Trace(input);
}
private Pipe VisitObjectRecipientList(RecipientListSegment recipientList)
{
var result = base.VisitRecipientList(recipientList) as RecipientListSegment;
if (result == null)
{
return(null);
}
if (_bound)
{
return(result);
}
Pipe list = PipeSegment.RecipientList(_segment.MessageType, new[] { _segment });
Pipe filter = PipeSegment.Filter(list, _segment.MessageType);
IList <Pipe> recipients = new List <Pipe>(result.Recipients);
recipients.Add(filter);
_bound = true;
return(new RecipientListSegment(recipientList.MessageType, recipients));
}
public void Should_display_a_RecipientListSegment_with_one_child_segment()
{
var end = PipeSegment.End <ClaimModified>();
Pipe recipientList = PipeSegment.RecipientList <ClaimModified>(new Pipe[] { end });
new TracePipeVisitor().Trace(recipientList);
}
public void Should_display_a_FilterSegment()
{
var end = PipeSegment.End <ClaimModified>();
Pipe filter = PipeSegment.Filter <object>(end);
new TracePipeVisitor().Trace(filter);
}
private bool CheckSegmentForValidCoverage(RoutingPreferenceManager routingPreferenceManager, double lowerBound, double upperBound, ElementId segmentId, RoutingPreferenceRuleGroupType groupType, List <double> sizesNotCovered)
{
bool retval = true;
if (segmentId == ElementId.InvalidElementId)
{
throw new Exception("Invalid segment ElementId");
}
PipeSegment segment = this.m_document.GetElement(segmentId) as PipeSegment;
foreach (MEPSize size in segment.GetSizes())
{
//skip sizes outside of rp bounds
if (size.NominalDiameter < lowerBound)
{
continue;
}
if (size.NominalDiameter > upperBound)
{
break;
}
RoutingConditions conditions = new RoutingConditions(RoutingPreferenceErrorLevel.None);
conditions.AppendCondition(new RoutingCondition(size.NominalDiameter));
ElementId foundFitting = routingPreferenceManager.GetMEPPartId(groupType, conditions);
if (foundFitting == ElementId.InvalidElementId)
{
sizesNotCovered.Add(size.NominalDiameter);
retval = false;
}
}
return(retval);
}
/// <summary>
/// Creates an instance of the ServiceBus, which implements IServiceBus. This is normally
/// not called and should be created using the ServiceBusConfigurator to ensure proper defaults
/// and operation.
/// </summary>
public ServiceBus(IEndpoint endpointToListenOn,
IObjectBuilder objectBuilder,
IEndpointFactory endpointFactory)
{
ReceiveTimeout = TimeSpan.FromSeconds(3);
endpointToListenOn.MustNotBeNull("endpointToListenOn", "This parameter cannot be null");
objectBuilder.MustNotBeNull("objectBuilder", "This parameter cannot be null");
endpointFactory.MustNotBeNull("endpointFactory", "This parameter cannot be null");
Endpoint = endpointToListenOn;
ObjectBuilder = objectBuilder;
EndpointFactory = endpointFactory;
_eventAggregator = PipeSegment.New();
_eventAggregatorScope = _eventAggregator.NewSubscriptionScope();
_serviceContainer = new ServiceContainer(this);
OutboundPipeline = MessagePipelineConfigurator.CreateDefault(ObjectBuilder, this);
InboundPipeline = MessagePipelineConfigurator.CreateDefault(ObjectBuilder, this);
InboundPipeline.Configure(x => { _unsubscribeEventDispatchers += x.Register(new InboundOutboundSubscriptionBinder(OutboundPipeline, Endpoint)); });
PoisonEndpoint = new PoisonEndpointDecorator(new NullEndpoint());
ControlBus = this;
InitializePerformanceCounters();
}
public override void OnEnter()
{
Debugger.Instance.Log("The player is rolling now");
this.Character.Velocity = new Vector2(this.Character.Velocity.X, -CharacterMoveAbilities.RollFowardSpeed);
this.Character.Scale = 1;
this.Character.HorAcceleraltion = CharacterMoveAbilities.RollHorAcceleration;
_CachedSegment = null;
}
public StraightThroughPipelineRunner()
{
Pipe consumer = PipeSegment.Consumer <ClaimModified>(m => Interlocked.Increment(ref _count));
_input = PipeSegment.Input(consumer);
_message = new ClaimModified();
}
public void Setup()
{
Input = PipeSegment.Input(PipeSegment.End <object>());
BeforeCalled = new ManualResetEvent(false);
AfterCalled = new ManualResetEvent(false);
EstablishContext();
}
public void Setup()
{
_received = new ManualResetEvent(false);
var recipients = new Pipe[] {};
var recipientList = PipeSegment.RecipientList <object>(recipients);
_pipe = PipeSegment.Input(recipientList);
}
public void Second_example()
{
_eventAggregator = PipeSegment.Input(PipeSegment.End());
_scope = _eventAggregator.NewSubscriptionScope();
_scope.Subscribe <CustomerChanged>(message => Trace.WriteLine("Customer changed: " + message.CustomerName));
new TracePipeVisitor().Trace(_eventAggregator);
}
private void CreateRecipientList(InputSegment input, Type messageType)
{
var recipients = input.Output.SegmentType == PipeSegmentType.End ? new Pipe[] {} : new[] { input.Output };
Pipe list = PipeSegment.RecipientList(messageType, recipients);
Pipe result = Visit(list);
input.ReplaceOutput(input.Output, result);
}
private string GetSegmentName(ElementId id)
{
if (id == ElementId.InvalidElementId)
{
throw new Exception("Invalid ElementId");
}
PipeSegment segment = m_document.GetElement(id) as PipeSegment;
return(segment.Name);
}
public void Should_display_a_complex_segment_chain()
{
var consumer = PipeSegment.Consumer <ClaimModified>(x => { });
var end = PipeSegment.End <ClaimModified>();
var recipientList = PipeSegment.RecipientList <ClaimModified>(new Pipe[] { consumer, end });
var filter = PipeSegment.Filter <object>(recipientList);
Pipe input = PipeSegment.Input(filter);
new TracePipeVisitor().Trace(input);
}
public void Setup()
{
_pipe = PipeSegment.Input(PipeSegment.End <object>());
_subscriptionScope = _pipe.NewSubscriptionScope();
_called = new ManualResetEvent(false);
_subscriptionScope.Subscribe <ClaimModified>(x => _called.Set());
EstablishContext();
}
public static void LoadAllData()
{
OpenExcelApp(resourcesPath);
//load data from excel file if it's not already loaded
//loading fixtures flow
if (fixturesFlow == null)
{
LoadFromExcel(1);
}
//loading materials
if (materials == null)
{
materials = LoadMaterialsFromExcel();
}
if (pipeTypes == null)
{
LoadBimitPipeTypes();
}
//initializing vars
calculationsSchedule = PipeScheduleType.Create(doc, string.Concat(calculatedSystem.Name, DateTime.Now.ToString("yyyyMMddHHmmss")));
List <string> matNames = new List <string>(materials.Keys);
segments = new Dictionary <string, PipeSegment>();
//creating this here so it doesn't get created multiple times
FilteredElementCollector materialElementCollector = new FilteredElementCollector(doc).OfCategory(BuiltInCategory.OST_Materials);
foreach (string matName in matNames)
{
ElementId matId;
var existingMat = materialElementCollector.FirstOrDefault(x => string.Compare(x.Name, matName.Remove(0, 5), true) == 0);
if (null == existingMat)
{
matId = Material.Create(doc, matName.Remove(0, 5));
}
else
{
matId = existingMat.Id;
}
/*else
* matId = new FilteredElementCollector(doc).OfCategory(BuiltInCategory.OST_Materials).FirstOrDefault(x => x.Name == matName).Id;*/
/*FamilySymbol newPipeType = CreateNewPipeType(standardPipeType, matName, matId);
* pipeTypes.Add(newPipeType);*/
Values defaultSize = materials[matName][0];
double nd = (defaultSize.intd + defaultSize.extd) / 2;
MEPSize size = new MEPSize(nd / 304.8, defaultSize.intd / 304.8, defaultSize.extd / 304.8, true, true);
List <MEPSize> sizes = new List <MEPSize>();
sizes.Add(size);
PipeSegment seg = PipeSegment.Create(doc, matId, calculationsSchedule.Id, sizes);
segments.Add(matName, seg);
}
CloseExcelApp();
dataIsExtracted = true;
}
public void Subscribe <T>(TimeSpan interval, MessageConsumer <IList <T> > consumer)
where T : class
{
Pipe segment = PipeSegment.IntervalConsumer(interval, consumer);
var binder = new SubscriberBinder(segment);
binder.Bind(_pipe);
_disposables.Add(segment);
}
public void Subscribe <T>(MessageConsumer <T> consumer)
where T : class
{
Pipe segment = PipeSegment.Consumer(consumer);
var binder = new SubscriberBinder(segment);
binder.Bind(_pipe);
_disposables.Add(segment);
}
public void Should_not_pass_unwanted_types_through_the_filter()
{
var received = new Future <bool>();
Pipe consumer = PipeSegment.Consumer <SubClass>(x => received.Complete(true));
Pipe filter = PipeSegment.Filter <object>(consumer);
filter.Send(new BaseClass());
received.WaitUntilCompleted(TimeSpan.Zero).ShouldBeFalse();
}
/// <summary>
/// Create a PipeSegment from XML
/// </summary>
/// <param name="segmentXElement"></param>
private void ParsePipeSegmentFromXML(XElement segmentXElement)
{
XAttribute xaMaterial = segmentXElement.Attribute(XName.Get("materialName"));
XAttribute xaSchedule = segmentXElement.Attribute(XName.Get("pipeScheduleTypeName"));
XAttribute xaRoughness = segmentXElement.Attribute(XName.Get("roughness"));
ElementId materialId = GetMaterialByName(xaMaterial.Value); //There is nothing in the xml schema for creating new materials -- any material specified must already exist in the document.
if (materialId == ElementId.InvalidElementId)
{
throw new RoutingPreferenceDataException("Cannot find Material: " + xaMaterial.Value + " in: " + segmentXElement.ToString());
}
ElementId scheduleId = GetPipeScheduleTypeByName(xaSchedule.Value);
double roughness;
bool r1 = double.TryParse(xaRoughness.Value, out roughness);
if (!r1)
{
throw new RoutingPreferenceDataException("Invalid roughness value: " + xaRoughness.Value + " in: " + segmentXElement.ToString());
}
if (roughness <= 0)
{
throw new RoutingPreferenceDataException("Invalid roughness value: " + xaRoughness.Value + " in: " + segmentXElement.ToString());
}
if (scheduleId == ElementId.InvalidElementId)
{
throw new RoutingPreferenceDataException("Cannot find Schedule: " + xaSchedule.Value + " in: " + segmentXElement.ToString()); //we will not create new schedules.
}
ElementId existingPipeSegmentId = GetSegmentByIds(materialId, scheduleId);
if (existingPipeSegmentId != ElementId.InvalidElementId)
{
return; //Segment found, no need to create.
}
ICollection <MEPSize> sizes = new List <MEPSize>();
foreach (XNode sizeNode in segmentXElement.Nodes())
{
if (sizeNode is XElement)
{
MEPSize newSize = ParseMEPSizeFromXml(sizeNode as XElement, m_document);
sizes.Add(newSize);
}
}
PipeSegment pipeSegment = PipeSegment.Create(m_document, materialId, scheduleId, sizes);
pipeSegment.Roughness = Convert.ConvertValueToFeet(roughness, m_document);
return;
}
// ReSharper disable UnusedMember.Local
private void SubscribeConsumer <TConsumer, TMessage>(TConsumer consumer)
// ReSharper restore UnusedMember.Local
where TConsumer : IConsumer <TMessage>
where TMessage : class
{
Pipe segment = PipeSegment.Consumer <TConsumer, TMessage>(consumer);
var binder = new SubscriberBinder(segment);
binder.Bind(_pipe);
_disposables.Add(segment);
}
// ReSharper disable UnusedMember.Local
private void SubscribeAsyncComponent <TConsumer, TMessage>(Func <TConsumer> getConsumer)
// ReSharper restore UnusedMember.Local
where TConsumer : IAsyncConsumer <TMessage>
where TMessage : class
{
Pipe segment = PipeSegment.AsyncConsumer <TConsumer, TMessage>(getConsumer);
var binder = new SubscriberBinder(segment);
binder.Bind(_pipe);
_disposables.Add(segment);
}
public void Intercept <T>(Action <IInterceptorConfigurator <T> > configureAction)
where T : class
{
var binder = new InterceptionBinder(typeof(T), x =>
{
var interceptor = PipeSegment.Interceptor(x, configureAction);
_disposables.Add(interceptor);
return(interceptor);
});
binder.Bind(_pipe);
}
public void Should_result_in_an_expression_being_called()
{
var called = new ManualResetEvent(false);
var consumer = PipeSegment.Consumer <ClaimModified>(message => called.Set());
var recipients = new[] { consumer };
var recipientList = PipeSegment.RecipientList <ClaimModified>(recipients);
recipientList.Send(new ClaimModified());
Assert.IsTrue(called.WaitOne(TimeSpan.Zero, false));
}
public RecipientListPipelineRunner()
{
Pipe consumer = PipeSegment.Consumer <ClaimModified>(m => Interlocked.Increment(ref _count));
Pipe consumer2 = PipeSegment.Consumer <ClaimModified>(m => Interlocked.Increment(ref _count2));
var recipients = new[] { consumer, consumer2 };
Pipe recipientList = PipeSegment.RecipientList <ClaimModified>(recipients);
Pipe filter = PipeSegment.Filter <object>(recipientList);
Pipe objectRecipientList = PipeSegment.RecipientList <object>(new[] { filter });
_input = PipeSegment.Input(objectRecipientList);
_message = new ClaimModified();
}
public void Should_contain_all_nodes()
{
MessageConsumerSegment consumer = PipeSegment.Consumer <SomethingHappenedEvent>(x => { });
EndSegment end = PipeSegment.End <SomethingHappenedEvent>();
RecipientListSegment recipientList = PipeSegment.RecipientList <SomethingHappenedEvent>(new Pipe[] { consumer, end });
FilterSegment filter = PipeSegment.Filter <object>(recipientList);
Pipe input = PipeSegment.Input(filter);
//var generator = new PipelineGraphGenerator();
//string filename = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "graph.png");
//generator.SaveGraphToFile(input.GetGraphData(), 2560, 1920, filename);
PipelineDebugVisualizer.TestShowVisualizer(input.GetGraphData());
}
