Beispiel #1
0
        private void readDataFeatures(IFMEOReader fmeReader, ref int featureCount)
        {
            // Initialize counters
            int numFeatures = 0;

            // Now, read all the different features
            IFMEOFeature fmeFeature = m_fmeSession.CreateFeature();

            while (fmeReader.Read(fmeFeature))
            {
                // Log the feature to the log file
                m_fmeLogFile.LogFeature(fmeFeature, FMEOMessageLevel.Inform, -1);

                // Increment feature count
                numFeatures++;

                // For every feature, we will put it into m_featureTypeDictionary
                insertIntoFeatureTypeDictionary(fmeFeature);

                // Check if we need to update status bar
                if ((numFeatures % m_kUpdateInterval) == 0)
                {
                    updateStatusBar("Read " + numFeatures.ToString() + " features...");
                }


                // Create a new feature for the next read
                fmeFeature = m_fmeSession.CreateFeature();
            }
            fmeFeature.Dispose();

            featureCount = numFeatures;
        }
Beispiel #2
0
 /// <summary> Returns the value of the specified attribute or expression as String. </summary>
 private static string GetOrResolveAttributeValue(IFMEOFeature feature, string value)
 {
     if (value != null && value.Length > 0)
     {
         if (value.StartsWith("@"))
         {
             value = feature.GetOrResolveAttributeAsString(value);
             if (value != null && value.StartsWith("@"))
             {
                 value = null;
             }
         }
         else
         {
             value = feature.GetAttributeAsString(value);
         }
     }
     return(value);
 }
Beispiel #3
0
        private void insertIntoFeatureTypeDictionary(IFMEOFeature pFeature)
        {
            string currFeatureType = pFeature.FeatureType;

            // First, we check for where to put the feature inside m_featureTypeDictionary
            // Check to see if an entry for currFeatureType already exists
            if (!m_featureTypeDictionary.ContainsKey(currFeatureType))
            {
                // We must create a new entry to the m_featureTypeDictionary
                IFMEOFeatureVectorOnDisk newVectorOnDisk =
                    m_fmeSession.CreateFeatureVectorOnDisk(m_kMaxFeatureInMemory);
                // Add the new entry to the dictionary
                m_featureTypeDictionary.Add(currFeatureType, newVectorOnDisk);
            }
            // Now, we put the feature into the proper IFMEOFeatureVectorOnDisk
            IFMEOFeatureVectorOnDisk currVectorOnDisk = m_featureTypeDictionary[currFeatureType];

            currVectorOnDisk.Append(pFeature);
        }
        /// <summary> Process the specified Feature. </summary>
        public override IEnumerable <KeyValuePair <string, IFMEOFeature> > ProcessFeature(string inputTag, IFMEOFeature feature)
        {
            // Depending on how we have chosen to process features in this factory we could:
            // a) Process and output each feature immediately or
            // b) Process and store features into a list, then when all features have been collected, process and output them.
            //    Under a) the bulk of the work occurs in this function since features are output immediately as soon as they are done processing.
            //    Under b) the bulk of the work occurs in the close() function.
            if (feature != null)
            {
                StringBuilder sb = new StringBuilder();
                sb.Append("## " + GetType().Name + " - Processing Feature, Attributes=[");
                foreach (string attrib in feature.GetAllAttributeNames())
                {
                    sb.Append(attrib).Append("='").Append(feature.GetAttributeAsString(attrib)).Append("', ");
                }
                sb.Length -= 2; sb.Append("]");
                _bridge.LogFile.LogMessageString(sb.ToString(), FMEOMessageLevel.Inform);

                // For this sample we output the feature with a specific OutputTag.
                // For this module the related fmx file defines one unique output tag called "OUTPUT"...
                yield return(new KeyValuePair <string, IFMEOFeature>("OUTPUT", feature));
                // But we can use the '_bridge.OutputTags' member to query the available collection of output tags...
                // foreach (string outputTag in _bridge.OutputTags) yield return new KeyValuePair<string,IFMEOFeature>(outputTag, feature);
            }
            yield break;
        }
Beispiel #5
0
        /// <summary> Process the specified Feature. </summary>
        public override IEnumerable <KeyValuePair <string, IFMEOFeature> > ProcessFeature(string inputTag, IFMEOFeature feature)
        {
            if (feature != null)
            {
                string lvalue = GetOrResolveAttributeValue(feature, _lhandKeyword);
                string rvalue = _rhandKeyword;
                if (_rvalueHash.Count == 0)
                {
                    rvalue = GetOrResolveAttributeValue(feature, _rhandKeyword);
                }
                bool ok = false;

                // First checks and validations.
                if (lvalue == null)
                {
                    ok = _operatorEnum == OperatorEnum.IsMissing;
                    goto gotoReturnFeature;
                }
                lvalue = FixQuotedEmptyString(lvalue);
                rvalue = FixQuotedEmptyString(rvalue);

                // Compare the attribute value.
                switch (_operatorEnum)
                {
                case OperatorEnum.HasAvalidValue:
                    ok = lvalue != null && lvalue.Length > 0;
                    break;

                case OperatorEnum.IsMissing:
                    ok = lvalue == null;
                    break;

                case OperatorEnum.NotEqual:
                    ok = _rvalueHash.Count > 0 ? !_rvalueHash.ContainsKey(lvalue) : !rvalue.Equals(lvalue);
                    break;

                case OperatorEnum.BeginsWith:
                {
                    if (_rvalueHash.Count > 0)
                    {
                        foreach (string rv in _rvalueHash.Keys)
                        {
                            if (lvalue.StartsWith(rv))
                            {
                                ok = true; break;
                            }
                        }
                    }
                    else
                    {
                        ok = lvalue.StartsWith(rvalue);
                    }
                    break;
                }

                case OperatorEnum.EndsWith:
                {
                    if (_rvalueHash.Count > 0)
                    {
                        foreach (string rv in _rvalueHash.Keys)
                        {
                            if (lvalue.EndsWith(rv))
                            {
                                ok = true; break;
                            }
                        }
                    }
                    else
                    {
                        ok = lvalue.EndsWith(rvalue);
                    }
                    break;
                }

                case OperatorEnum.Less:
                {
                    double doubleValue = double.Parse(lvalue, s_englishCultureInfo);

                    if (_rvalueList.Count > 0)
                    {
                        foreach (double rv in _rvalueList)
                        {
                            if (doubleValue < rv)
                            {
                                ok = true; break;
                            }
                        }
                    }
                    else
                    {
                        double rv = double.Parse(rvalue, s_englishCultureInfo);
                        ok = doubleValue < rv;
                    }
                    break;
                }

                case OperatorEnum.LessOrEqual:
                {
                    double doubleValue = double.Parse(lvalue, s_englishCultureInfo);

                    if (_rvalueList.Count > 0)
                    {
                        foreach (double rv in _rvalueList)
                        {
                            if (doubleValue <= rv)
                            {
                                ok = true; break;
                            }
                        }
                    }
                    else
                    {
                        double rv = double.Parse(rvalue, s_englishCultureInfo);
                        ok = doubleValue <= rv;
                    }
                    break;
                }

                case OperatorEnum.Greater:
                {
                    double doubleValue = double.Parse(lvalue, s_englishCultureInfo);

                    if (_rvalueList.Count > 0)
                    {
                        foreach (double rv in _rvalueList)
                        {
                            if (doubleValue > rv)
                            {
                                ok = true; break;
                            }
                        }
                    }
                    else
                    {
                        double rv = double.Parse(rvalue, s_englishCultureInfo);
                        ok = doubleValue > rv;
                    }
                    break;
                }

                case OperatorEnum.GreaterOrEqual:
                {
                    double doubleValue = double.Parse(lvalue, s_englishCultureInfo);

                    if (_rvalueList.Count > 0)
                    {
                        foreach (double rv in _rvalueList)
                        {
                            if (doubleValue >= rv)
                            {
                                ok = true; break;
                            }
                        }
                    }
                    else
                    {
                        double rv = double.Parse(rvalue, s_englishCultureInfo);
                        ok = doubleValue >= rv;
                    }
                    break;
                }

                default:
                    ok = _rvalueHash.Count > 0 ? _rvalueHash.ContainsKey(lvalue) : rvalue.Equals(lvalue);
                    break;
                }
gotoReturnFeature:
                yield return(new KeyValuePair <string, IFMEOFeature>(ok ? "PASSED" : "FAILED", feature));
            }
            yield break;
        }