public ParserContext(bool objectsAllowed, LineTypes.Property[] properties, LineTypes.Component[] components, ContextType type)
 {
     this.ObjectsAllowed = objectsAllowed;
     this.Properties = properties;
     this.Components = components;
     this.Type = type;
 }

 /// <summary>
 /// Get Configuration data for selected context.
 /// </summary>
 /// <param name="context">Context for using.</param>
 /// <returns></returns>
 public ISolutionEvents getConfig(ContextType context)
 {
     if(configs.ContainsKey(context)) {
         return configs[context];
     }
     return new SolutionEvents();
 }

 public void WriteContextInitialization(ContextType contextType)
 {
     _transport.SendOperation(OperationCode.SetupContext, new Dictionary<byte, object>
     {
         [(byte) OperationParameterCode.ContextType] = contextType
     });
 }

        public IFiber GetContext(ContextType contextType)
        {
            IFiber fiber = null;
            switch (contextType)
            {
                case ContextType.New:
                    fiber = new PoolFiber();
                    fiber.Start();
                    //poolfibers.Add(fiber);
                    break;
                case ContextType.Gui:
                    //if(formFiber == null)
                    //{
                    //    if (marshaler == null) marshaler = new MarshalingControl();
                    //    formFiber = new FormFiber(marshaler, new BatchAndSingleExecutor());
                    //    formFiber.Start();
                    //}

                    //fiber = formFiber;

                    fiber = GetStartedGuiFiber();
                    break;
            }

            return fiber;
        }

 internal JsonReaderContext(
     JsonReaderContext parentContext,
     ContextType contextType
 ) {
     this.parentContext = parentContext;
     this.contextType = contextType;
 }

 /// <summary>
 /// Get User-Configuration data for selected context.
 /// </summary>
 /// <param name="context">Context for using.</param>
 /// <returns></returns>
 public IUserData getUserConfig(ContextType context)
 {
     if(userConfigs.ContainsKey(context)) {
         return userConfigs[context];
     }
     return new UserData();
 }

 // constructors
 internal BsonBinaryReaderContext(BsonBinaryReaderContext parentContext, ContextType contextType, int startPosition, int size)
 {
     this.parentContext = parentContext;
     this.contextType = contextType;
     this.startPosition = startPosition;
     this.size = size;
 }

 /// <summary>
 /// This method accepts a day of the week and returns the corresponding date depending on what the preposition is.
 /// </summary>
 /// <param name="preposition">The prefix specifying how many weeks to add to the next found day.</param>
 /// <param name="desiredDay">The required day.</param>
 /// <returns>Date on which the <var>preposition</var> <var>desiredDay</var> is found.</returns>
 private static DateTime GetDateFromDay(ContextType preposition, DayOfWeek desiredDay)
 {
     DateTime startDate;
     DateTime todayDate = DateTime.Today;
     int daysToAdd = GetDaysToAdd(todayDate.DayOfWeek, desiredDay);
     switch (preposition)
     {
         case ContextType.CURRENT:
             break;
         case ContextType.NEXT:
             Logger.Info("preposition is NEXT", "GetDateFromDay::TokenDay");
             daysToAdd += 7;
             break;
         case ContextType.FOLLOWING:
             Logger.Info("preposition is FOLLOWING", "GetDateFromDay::TokenDay");
             daysToAdd += 14;
             break;
         default:
             Logger.Error("Fell through preposition switch statement.", "GetDateFromDay::TokenDay");
             Debug.Assert(false, "Fell through switch statement in GetDateFromDay!");
             break;
     }
     startDate = todayDate.AddDays(daysToAdd);
     Logger.Info("Updated startDate", "GetDateFromDay::TokenDay");
     return startDate;
 }

 // used by Clone
 private BsonDocumentReaderContext(BsonDocumentReaderContext parentContext, ContextType contextType, BsonDocument document, BsonArray array, int index)
 {
     this.parentContext = parentContext;
     this.contextType = contextType;
     this.document = document;
     this.array = array;
     this.index = index;
 }

 public NotifierRule(HotItem item, RuleType type, int value, ContextType contextType, INotificationHost host)
 {
     this.Host = host;
     this.Money = new Money(0, 0, value) { Name = "Rule" };
     this.Item = item;
     this.SelectedRuleType = type;
     this.ContextType = contextType;
 }

 public ChangePasswordController()
 {
     _domainDisplayName = ConfigurationManager.AppSettings["domainDisplayName"];
     _contextType = (ContextType)Enum.Parse(typeof(ContextType), ConfigurationManager.AppSettings["contextType"], true);
     _domain = ConfigurationManager.AppSettings["domain"];
     _container = ConfigurationManager.AppSettings["container"];
     _identityType = (IdentityType)Enum.Parse(typeof(IdentityType), ConfigurationManager.AppSettings["identityType"], true);
 }

 // used by Clone
 private BsonDocumentReaderContext(BsonDocumentReaderContext parentContext, ContextType contextType, BsonDocument document, BsonArray array, int index)
 {
     _parentContext = parentContext;
     _contextType = contextType;
     _document = document;
     _array = array;
     _index = index;
 }

 public DurableInstanceContextReplyChannel(ChannelManagerBase channelManager,
     ContextType contextType,
     IReplyChannel innerChannel)
     : base(channelManager, innerChannel)
 {
     this.contextType = contextType;
     this.innerReplyChannel = innerChannel;
 }

 public ContextSpan(int start, int end, Context context, Context parentContext, ContextType type)
 {
     Start = start;
     End = end;
     Context = context;
     ParentContext = parentContext;
     Type = type;
 }

 // constructors
 internal BsonDocumentWriterContext(
     BsonDocumentWriterContext parentContext,
     ContextType contextType,
     BsonDocument document)
 {
     _parentContext = parentContext;
     _contextType = contextType;
     _document = document;
 }

 internal BsonDocumentWriterContext(
     BsonDocumentWriterContext parentContext,
     ContextType contextType,
     BsonArray array
 ) {
     this.parentContext = parentContext;
     this.contextType = contextType;
     this.array = array;
 }

 // constructors
 internal BsonBinaryWriterContext(
     BsonBinaryWriterContext parentContext,
     ContextType contextType,
     int startPosition)
 {
     _parentContext = parentContext;
     _contextType = contextType;
     _startPosition = startPosition;
 }

 public DurableInstanceContextReplySessionChannel(ChannelManagerBase channelManager,
     ContextType contextType,
     IReplySessionChannel innerChannel)
     : base(channelManager, innerChannel)
 {
     this.contextType = contextType;
     this.innerReplySessionChannel = innerChannel;
     this.isFirstMessage = true;
     this.stateLock = new object();
 }

 public static DbContext GetContext(ContextType type)
 {
     switch (type)
     {
         case ContextType.AdventureWorks2012Context:
             return new AdventureWorks2012Entities();
         default:
             return null;
     }
 }

        public override void ApplyConfiguration(BindingElement bindingElement)
        {
            base.ApplyConfiguration(bindingElement);

            DurableInstanceContextBindingElement typedBindingElement =
                (DurableInstanceContextBindingElement)bindingElement;

            this.contextStoreLocation = typedBindingElement.ContextStoreLocation;
            this.contextType = typedBindingElement.ContextType;
        }