public new void StartRecord(IRecord r)
 {
     //RegisterStartRecord(r);
     _max = 0;
     _best = null;
     _current = r;
 }

 private static string GetResultPath(IRecord record)
 {
     var candidate = record.Path;
     if (candidate.Contains(" "))
         return string.Format("\"{0}\"", candidate);
     return candidate;
 }

        public void Serialize(IRecord record)
        {
            var tr = record as ITypedRecord;
            if (tr == null) throw new NotSupportedException();
            var info = tr.GetInfo();
            var value = record.Value;
            var count = value.Count;

            //_s.WriteLine(count);

            for (int i = 0; i < count; i++)
            {
                _s.Write(info.GetKey(i));

                var x = value[i];
                if(x != null)
                {
                    var xr = x as IRecord;
                    if(xr == null)
                    {
                        _s.Write('\t');
                        _s.Write(x.ToString());
                        _s.WriteLine();
                    }
                    else
                    {
                        _s.WriteLine('\\');
                        Serialize(xr);
                    }
                }
            }
        }

 public new void Matches(IRecord r1, IRecord r2, double confidence)
 {
     if (confidence > _max)
     {
         _max = confidence;
         _best = r2;
     }
 }

        private bool FilterByType(IRecord record)
        {
            if (_types.Count == 0) // there is no filtering
                return true;

            bool found = false;
            return record.GetValues(RDF_TYPE).Any(value => _types.Contains(value));
        }

 /// <summary>
 /// Updates the specified record.
 /// </summary>
 /// <param name="record">The record.</param>
 public void Update(IRecord record)
 {
     TraceInfo("{0} - {1}", record, this);
     if (record.IsNew)
     {
         OnUpdateNewRecord(record);
     }
     OnUpdateRecord(record);
 }

        /// <summary>
        /// Called when the record is to be updated
        /// </summary>
        /// <param name="record">The record.</param>
        protected override void OnUpdateRecord(IRecord record)
        {
            int iOne = record.GetFieldValue<int>("One", 0);
            int iTwo = record.GetFieldValue<int>("Two", 0);
            int iThree = record.GetFieldValue<int>("Three", 0);

            record.SetFieldValue<int>("One + Two", iOne + iTwo);
            record.SetFieldValue<int>("One + Three", iOne + iThree);
        }

        protected IContent CreateContent(IRecord record)
        {
            var contentFactory = Diffusion.Content;

            // Create Content wrapping the Record
            var recordContentBuilder = contentFactory.NewBuilder<IRecordContentBuilder>();
            recordContentBuilder.PutRecords(record); // because PutRecord doesn't work
            return recordContentBuilder.Build();
        }

 /// <summary>
 /// Called when the record is to be updated
 /// </summary>
 /// <param name="record">The record.</param>
 protected override void OnUpdateRecord(IRecord record)
 {
     bool refresh = record.GetFieldValue<bool>("Refresh Material", false);
     if (refresh)
     {
         UpdateMaterialFields(record);
         record.SetFieldValue("Refresh Material", false);
     }
 }

 public LocalRecordStore GetStoreForRecord(IRecord record)
 {
     if (record == null)
     {
         throw new ArgumentException(null);
     }
     
     return this.EnsureRecordStoreObject(record);
 }

 /// <summary>
 /// Updates the lookup.
 /// </summary>
 /// <param name="record">The record.</param>
 protected void UpdateMaterialFields(IRecord record)
 {
     string materialCode = record.GetFieldValue<string>("Material Code", null);
     if (!string.IsNullOrEmpty(materialCode))
     {
         string vendor = materialService.GetVendor(materialCode);
         record.SetFieldValue("Material Vendor", vendor);
     }
 }

        public IAsyncAction DownloadAsync(IRecord record, IOutputStream destination)
        {
            if (record == null)
            {
                throw new ArgumentNullException("record");
            }

            return record.DownloadBlob(this, destination);
        }

 protected override void OnUpdateRecord(IRecord record)
 {
     UpdateWeightAndPercentage(record, coarseMeasurements, "Coarse Coke Weight ({0})", "Coarse Coke Percentage ({0})");
     UpdateWeightAndPercentage(record, mediumMeasurements, "Medium Coke Weight ({0})", "Medium Coke Percentage ({0})");
     UpdateWeightAndPercentage(record, fineMeasurements, "Fine Coke Weight ({0})", "Fine Coke Percentage ({0})");
     UpdateWeightAndPercentage(record, ballmillMeasurements, "Ball Mill Product Weight ({0})", "Ball Mill Product Percentage ({0})");
     UpdateWeightAndPercentage(record, coarseButtMeasurements, "Coarse Butt Weight ({0})", "Coarse Butt Percentage ({0})");
     UpdateWeightAndPercentage(record, fineButtMeasurements, "Fine Butt Weight ({0})", "Fine Butt Percentage ({0})");
 }

 public string Evaluate(IRecord record)
 {
     IOwner parent = EntityFactory.GetById<IOwner>(_ownerId);
     if(parent == null)
         throw new Exception("Owner id " + _ownerId + " not found");
     StringBuilder buf = new StringBuilder();
     GetAllTeamMemberEmails(parent, buf);
     return buf.ToString();
 }

 internal static void MapList(IRecord record, List<SpamKeyword> list)
 {
     SpamKeyword m = new SpamKeyword();
     m.Id = record.GetInt32OrDefault(0, 0);
     m.Keyword = record.GetStringOrEmpty(1);
     m.Status = record.GetInt32OrDefault(2, 0);
     m.AddUserID = record.GetInt32OrDefault(3, 0);
     m.AddDate = record.GetDateTime(4);
     list.Add(m);
 }

        public LocalRecordStore(IRecord record, StorageFolder folder, string encryptionKey)
        {
            IObjectStore store = new FolderObjectStore(folder);
            if (!String.IsNullOrEmpty(encryptionKey))
            {
                store = new EncryptedObjectStore(store, new Cryptographer(), encryptionKey);
            }

            Initialize(record, store, null);
        }

 public SynchronizedViewSynchronizer(IRecord record, int maxAgeInSeconds)
 {
     if (record == null)
     {
         throw new ArgumentNullException("record");
     }
     m_record = record;
     this.MaxAgeInSeconds = maxAgeInSeconds;
     m_syncQueries = new List<ItemQuery>();
     m_queriesToRun = new List<ItemQuery>();
 }

        internal static void MapBandInfoList(IRecord record, List<BandInfo> list)
        {
            BandInfo m = new BandInfo();
            m.BandId = record.GetInt32OrDefault(0, 0);
            m.BandName = record.GetStringOrEmpty(1);
            m.Info1 = record.GetStringOrEmpty(2);
            m.Info2 = record.GetStringOrEmpty(3);
            m.Info3 = record.GetStringOrEmpty(4);
            m.Remark = record.GetStringOrEmpty(5);

            list.Add(m);
        }

        /// <summary>
        /// Adds the record to the component's queue.
        /// </summary>
        /// <param name="record">The record.</param>
        public void AddRecord(IRecord record)
        {
            if (record == null)
            {
                return;
            }

            if (RecordCount++ < 1)
            {
                Offset = AddTrace("Starting Pledge Run...", DateTime.MinValue, ClientId);
            }

            var recordHasErrors = false;
            Rules.CurrentRecord = record;

            foreach (var rule in Rules)
            {
                var result = EvaluateRule(record, rule);
                if (result.Type != ResultType.Passed)
                {
                    DocumentHasErrors = true;
                    recordHasErrors = true;

                    //we're only reporting errors from the first 500 records to the UI (or caller) 
                    //as this is more than enough to indicate a really messed up file
                    if (ErrorCount < 500)
                    {
                        foreach (var message in result.Dispositions)
                        {
                            EventsManager.ReportRuleFailure(record.RowNumber, message.Annotation, ClientId);
                        }
                    }
                }
            }

            if (!recordHasErrors)
            {
                record.IsValid = true;
                DocumentHasValidRecords = true;
                PassCount++;
            }
            else
            {
                ErrorCount++;
            }

            Successor.AddRecord(record);

            if (RecordCount % EventCounter == 0)
            {
                UpdateProgress(RecordCount, ClientId);
            }
        }

 /// <summary>
 /// Called when the record is to be updated
 /// </summary>
 /// <param name="record">The record.</param>
 protected override void OnUpdateRecord(IRecord record)
 {
     double source = record.GetFieldValue<double>(sourceField, 0);
     if (source > 0)
     {
         double log = System.Math.Log10(source);
         record.SetFieldValue<double>(logResultField, log);
     }
     else
     {
         TraceError("{0} - Unable to calculate ['{1}'] = Math.Log10({2})  ({2} = {3})", this, logResultField, sourceField, source);
     }
 }