public Convert(LIRMethod parent, ISource source, LIRType sourceType, IDestination dest, LIRType destType) : base(parent, LIROpCode.Convert)
		{
			Source = source;
			SourceType = sourceType;
			Destination = dest;
			DestinationType = destType;
		}

		public CallIndirect(LIRMethod parent, ISource targetMethod, IEnumerable<ISource> sources = null, IDestination returnValueDest = null) : base(parent, LIROpCode.CallIndirect)
		{
			this.TargetMethod = targetMethod;
			if (sources != null)
				Sources.AddRange(sources);
			this.ReturnValueDestination = returnValueDest;
		}

 /// <summary>
 /// Generates a list of commands used to modify the source. If it does not exist prior, the
 /// commands will create the source from scratch. Otherwise the commands will only add new
 /// fields, tables, etc. It does not delete old fields.
 /// </summary>
 /// <param name="DesiredStructure">Desired source structure</param>
 /// <param name="Source">Source to use</param>
 /// <returns>List of commands generated</returns>
 public IEnumerable<string> GenerateSchema(ISource DesiredStructure, ISourceInfo Source)
 {
     Contract.Requires<ArgumentNullException>(Source != null, "Source");
     return SchemaGenerators.ContainsKey(Source.SourceType) ?
         SchemaGenerators[Source.SourceType].GenerateSchema(DesiredStructure, Source) :
         new List<string>();
 }

 public static void AddToSourceLocations(Object obj,ISource location)
 {
     var source = GetOrSet(obj);
     if (source != null) {
         source.Add(location);
     }
 }

 public SourceLocations Add(ISource source)
 {
     if (!m_sourcesByName.ContainsKey(source.SourceName)) {
         m_sourcesByName.Add(source.SourceName,source);
     }
     return this;
 }

        public IEnumerable<ISection> GetSections(ISource source)
        {
            var context = new Context
            {
                CurrentSource = source,
                CurrentState = State.WhiteSpace,
                CurrentPosition = SourcePosition.InitialPosition(),
                CurrentText = string.Empty
            };

            char? prev = null;
            ISection section = null;
            foreach (var c in source.GetChars())
            {
                if (!prev.HasValue)
                {
                    prev = c;
                    continue;
                }
                
                section = Analyze(prev, c, context);
                if (section != null)
                    yield return section;
                prev = c;
            }
            section = Analyze(prev, null, context);
            if (section != null)
                yield return section;
            section = EndOfFileActions(context);
            if (section != null)
                yield return section;
        }

		public bool HasAuthorization(ISource aDoc)
		{
			//Check if user isn't set, or if he isn't creator or collaborator.
			if (Context.Current.User == null || (!IsCreator(aDoc) && !IsCollaborator(aDoc)))
				return false;
			return true;
		}

 /// <summary>
 /// Loads a waves.bin file
 /// </summary>
 public override object Load( ISource source, LoadParameters parameters )
 {
     using ( Stream stream = ( ( IStreamSource )source ).Open( ) )
     {
         return WaveAnimation.Load( stream );
     }
 }

 /// <summary>
 /// Initializing constructor
 /// </summary>
 /// <param name="contained">Tracker source object whose calls are to be logged</param>
 /// <param name="logWriter">TextWriter which will receive log output</param>
 /// <param name="config">Configuration object for the LoggingSourceDecorator</param>
 public LoggingSourceDecorator( ISource              contained,
                                TextWriter           logWriter,
                                LoggingSourceConfig  config     ) : base( contained )
 {
     _logWriter = logWriter;
     _config = new LoggingSourceConfig( config );
 }

        public FeedPropertiesDialog(ISource f)
            : base(WindowType.Toplevel)
        {
            feed = f;

            Title = "\""+feed.Name+"\" Properties";
            Icon = feed.Favicon;
            BorderWidth = 5;
            DeleteEvent += OnClose;

            vbox = new VBox();
            vbox.Spacing = 6;
            Add(vbox);

            notebook = new Notebook();
            vbox.PackStart(notebook, false, false, 0);

            bbox = new HButtonBox();
            bbox.Layout = ButtonBoxStyle.End;
            vbox.PackStart(bbox, false, false, 0);

            AddGeneralTab();
            AddTagsTab();
            AddCloseButton();
        }

		public Unary(LIRMethod parent, ISource src, IDestination dest, UnaryOperation op, LIRType argType) : base(parent, LIROpCode.Unary)
		{
			Source = src;
			Destination = dest;
			Operation = op;
			ArgumentType = argType;
		}

 public bool Equals(ISource other)
 {
     if (other == null) return false;
     if (other == this) return true;
     var ot = other as TextSource;
     if (ot != null) { return ot.Content == this.Content; }
     return false;
 }

 protected ModifierBase(string type, PhaseCode startPhase, ISource source, ICardInPlay target, TimeScope duration, int value)
     : base("Modifier", GetText(target, type, value), source)
 {
     this.StartPhase = startPhase;
     this.Target = target;
     this.Duration = duration;
     this.Value = value;
 }

 /// <summary>
 /// Returns true if the specified source can be loaded
 /// </summary>
 public override bool CanLoad( ISource source )
 {
     if ( source is IFolder )
     {
         return ( ( IFolder )source ).Contains( "*.md3" );
     }
     return source.HasExtension( "md3" );
 }

        public TupleValue(DataReference reference, int index)
        {
            var list = reference.Dereference();

            Source = list as ISource;

            Index = index;
        }

		public Math(LIRMethod parent, ISource srcA, ISource srcB, IDestination dest, MathOperation op, LIRType argType) : base(parent, LIROpCode.Math)
		{
			SourceA = srcA;
			SourceB = srcB;
			Destination = dest;
			Operation = op;
			ArgumentType = argType;
		}

 internal LexicalAnalyzer(ISource source)
 {
     _source = source;
     _tokens = new List<Token>();
     _buffer = new List<char>();
     _tokenLineStart = 1;
     _tokenColumnStart = 1;
 }

		public Compare(LIRMethod parent, ISource sourceA, ISource sourceB, IDestination destination, LIRType type, CompareCondition condition) : base(parent, LIROpCode.Compare)
		{
			this.SourceA = sourceA;
			this.SourceB = sourceB;
			this.Destination = destination;
			this.Type = type;
			this.Condition = condition;
		}

		public Result<ISource> Update(string aSourceId, string rev, ISource aDoc, Result<ISource> aResult)
		{
			ArgCheck.NotNullNorEmpty("aSourceId", aSourceId);
			ArgCheck.NotNull("aSource", aDoc);

			Coroutine.Invoke(UpdateHelper, aSourceId, rev, aDoc, aResult);
			return aResult;
		}

 public LocationTreeNode( LocationTreeFolder parent, ISource source, string name, int image, int selectedImage )
 {
     m_Parent = parent;
     m_Source = source;
     m_Name = name;
     m_Image = image;
     m_SelectedImage = selectedImage;
 }