Exemplo n.º 1
0
        public static DocEntityUnits Get(Guid hash)
        {
            var query = DocQuery.ActiveQuery;
            var ret   = DocEntityThreadCache <DocEntityUnits> .GetFromCache(hash, UNITS_CACHE);

            if (null == ret)
            {
                ret = query.SelectAll <DocEntityUnits>().Where(e => e.Hash == hash).FirstOrDefault();
                if (null != ret)
                {
                    DocEntityThreadCache <DocEntityUnits> .UpdateCache(ret.Id, ret, UNITS_CACHE);

                    DocEntityThreadCache <DocEntityUnits> .UpdateCache(ret.Hash, ret, UNITS_CACHE);
                }
            }
            return(ret);
        }
Exemplo n.º 2
0
        public static DocEntityComparator GetComparator(Guid hash)
        {
            var query = DocQuery.ActiveQuery;
            var ret   = DocEntityThreadCache <DocEntityComparator> .GetFromCache(hash, COMPARATOR_CACHE);

            if (null == ret)
            {
                ret = query.SelectAll <DocEntityComparator>().Where(e => e.Hash == hash).FirstOrDefault();
                if (null != ret)
                {
                    DocEntityThreadCache <DocEntityComparator> .UpdateCache(ret.Id, ret, COMPARATOR_CACHE);

                    DocEntityThreadCache <DocEntityComparator> .UpdateCache(ret.Hash, ret, COMPARATOR_CACHE);
                }
            }
            return(ret);
        }
Exemplo n.º 3
0
        public static DocEntityMeanRangeValue Get(Guid hash)
        {
            var query = DocQuery.ActiveQuery;
            var ret   = DocEntityThreadCache <DocEntityMeanRangeValue> .GetFromCache(hash, MEANRANGEVALUE_CACHE);

            if (null == ret)
            {
                ret = query.SelectAll <DocEntityMeanRangeValue>().Where(e => e.Hash == hash).FirstOrDefault();
                if (null != ret)
                {
                    DocEntityThreadCache <DocEntityMeanRangeValue> .UpdateCache(ret.Id, ret, MEANRANGEVALUE_CACHE);

                    DocEntityThreadCache <DocEntityMeanRangeValue> .UpdateCache(ret.Hash, ret, MEANRANGEVALUE_CACHE);
                }
            }
            return(ret);
        }
Exemplo n.º 4
0
        public static DocEntityCharacteristic GetCharacteristic(Guid hash)
        {
            var query = DocQuery.ActiveQuery;
            var ret   = DocEntityThreadCache <DocEntityCharacteristic> .GetFromCache(hash, CHARACTERISTIC_CACHE);

            if (null == ret)
            {
                ret = query.SelectAll <DocEntityCharacteristic>().Where(e => e.Hash == hash).FirstOrDefault();
                if (null != ret)
                {
                    DocEntityThreadCache <DocEntityCharacteristic> .UpdateCache(ret.Id, ret, CHARACTERISTIC_CACHE);

                    DocEntityThreadCache <DocEntityCharacteristic> .UpdateCache(ret.Hash, ret, CHARACTERISTIC_CACHE);
                }
            }
            return(ret);
        }
Exemplo n.º 5
0
        public static DocEntityDocumentSetHistory Get(Guid hash)
        {
            var query = DocQuery.ActiveQuery;
            var ret   = DocEntityThreadCache <DocEntityDocumentSetHistory> .GetFromCache(hash, DOCUMENTSETHISTORY_CACHE);

            if (null == ret)
            {
                ret = query.SelectAll <DocEntityDocumentSetHistory>().Where(e => e.Hash == hash).FirstOrDefault();
                if (null != ret)
                {
                    DocEntityThreadCache <DocEntityDocumentSetHistory> .UpdateCache(ret.Id, ret, DOCUMENTSETHISTORY_CACHE);

                    DocEntityThreadCache <DocEntityDocumentSetHistory> .UpdateCache(ret.Hash, ret, DOCUMENTSETHISTORY_CACHE);
                }
            }
            return(ret);
        }
Exemplo n.º 6
0
        public static DocEntityDataProperty Get(Guid hash)
        {
            var query = DocQuery.ActiveQuery;
            var ret   = DocEntityThreadCache <DocEntityDataProperty> .GetFromCache(hash, DATAPROPERTY_CACHE);

            if (null == ret)
            {
                ret = query.SelectAll <DocEntityDataProperty>().Where(e => e.Hash == hash).FirstOrDefault();
                if (null != ret)
                {
                    DocEntityThreadCache <DocEntityDataProperty> .UpdateCache(ret.Id, ret, DATAPROPERTY_CACHE);

                    DocEntityThreadCache <DocEntityDataProperty> .UpdateCache(ret.Hash, ret, DATAPROPERTY_CACHE);
                }
            }
            return(ret);
        }
        public new static DocEntityServePortalSet Get(Guid hash)
        {
            var query = DocQuery.ActiveQuery;
            var ret   = DocEntityThreadCache <DocEntityServePortalSet> .GetFromCache(hash, SERVEPORTALSET_CACHE);

            if (null == ret)
            {
                ret = query.SelectAll <DocEntityServePortalSet>().Where(e => e.Hash == hash).FirstOrDefault();
                if (null != ret)
                {
                    DocEntityThreadCache <DocEntityServePortalSet> .UpdateCache(ret.Id, ret, SERVEPORTALSET_CACHE);

                    DocEntityThreadCache <DocEntityServePortalSet> .UpdateCache(ret.Hash, ret, SERVEPORTALSET_CACHE);
                }
            }
            return(ret);
        }
        public static DocEntityBackgroundTaskHistory Get(Guid hash)
        {
            var query = DocQuery.ActiveQuery;
            var ret   = DocEntityThreadCache <DocEntityBackgroundTaskHistory> .GetFromCache(hash, BACKGROUNDTASKHISTORY_CACHE);

            if (null == ret)
            {
                ret = query.SelectAll <DocEntityBackgroundTaskHistory>().Where(e => e.Hash == hash).FirstOrDefault();
                if (null != ret)
                {
                    DocEntityThreadCache <DocEntityBackgroundTaskHistory> .UpdateCache(ret.Id, ret, BACKGROUNDTASKHISTORY_CACHE);

                    DocEntityThreadCache <DocEntityBackgroundTaskHistory> .UpdateCache(ret.Hash, ret, BACKGROUNDTASKHISTORY_CACHE);
                }
            }
            return(ret);
        }
Exemplo n.º 9
0
        public static DocEntityAttributeInterval Get(Guid hash)
        {
            var query = DocQuery.ActiveQuery;
            var ret   = DocEntityThreadCache <DocEntityAttributeInterval> .GetFromCache(hash, ATTRIBUTEINTERVAL_CACHE);

            if (null == ret)
            {
                ret = query.SelectAll <DocEntityAttributeInterval>().Where(e => e.Hash == hash).FirstOrDefault();
                if (null != ret)
                {
                    DocEntityThreadCache <DocEntityAttributeInterval> .UpdateCache(ret.Id, ret, ATTRIBUTEINTERVAL_CACHE);

                    DocEntityThreadCache <DocEntityAttributeInterval> .UpdateCache(ret.Hash, ret, ATTRIBUTEINTERVAL_CACHE);
                }
            }
            return(ret);
        }
        public static DocEntityVariableInstance Get(Guid hash)
        {
            var query = DocQuery.ActiveQuery;
            var ret   = DocEntityThreadCache <DocEntityVariableInstance> .GetFromCache(hash, VARIABLEINSTANCE_CACHE);

            if (null == ret)
            {
                ret = query.SelectAll <DocEntityVariableInstance>().Where(e => e.Hash == hash).FirstOrDefault();
                if (null != ret)
                {
                    DocEntityThreadCache <DocEntityVariableInstance> .UpdateCache(ret.Id, ret, VARIABLEINSTANCE_CACHE);

                    DocEntityThreadCache <DocEntityVariableInstance> .UpdateCache(ret.Hash, ret, VARIABLEINSTANCE_CACHE);
                }
            }
            return(ret);
        }
Exemplo n.º 11
0
        public static DocEntityLocaleLookup Get(Guid hash)
        {
            var query = DocQuery.ActiveQuery;
            var ret   = DocEntityThreadCache <DocEntityLocaleLookup> .GetFromCache(hash, LOCALELOOKUP_CACHE);

            if (null == ret)
            {
                ret = query.SelectAll <DocEntityLocaleLookup>().Where(e => e.Hash == hash).FirstOrDefault();
                if (null != ret)
                {
                    DocEntityThreadCache <DocEntityLocaleLookup> .UpdateCache(ret.Id, ret, LOCALELOOKUP_CACHE);

                    DocEntityThreadCache <DocEntityLocaleLookup> .UpdateCache(ret.Hash, ret, LOCALELOOKUP_CACHE);
                }
            }
            return(ret);
        }
Exemplo n.º 12
0
        public static DocEntityDatabaseVersion Get(Guid hash)
        {
            var query = DocQuery.ActiveQuery;
            var ret   = DocEntityThreadCache <DocEntityDatabaseVersion> .GetFromCache(hash, DATABASEVERSION_CACHE);

            if (null == ret)
            {
                ret = query.SelectAll <DocEntityDatabaseVersion>().Where(e => e.Hash == hash).FirstOrDefault();
                if (null != ret)
                {
                    DocEntityThreadCache <DocEntityDatabaseVersion> .UpdateCache(ret.Id, ret, DATABASEVERSION_CACHE);

                    DocEntityThreadCache <DocEntityDatabaseVersion> .UpdateCache(ret.Hash, ret, DATABASEVERSION_CACHE);
                }
            }
            return(ret);
        }
Exemplo n.º 13
0
        public new static DocEntityDiseaseStateSet Get(Guid hash)
        {
            var query = DocQuery.ActiveQuery;
            var ret   = DocEntityThreadCache <DocEntityDiseaseStateSet> .GetFromCache(hash, DISEASESTATESET_CACHE);

            if (null == ret)
            {
                ret = query.SelectAll <DocEntityDiseaseStateSet>().Where(e => e.Hash == hash).FirstOrDefault();
                if (null != ret)
                {
                    DocEntityThreadCache <DocEntityDiseaseStateSet> .UpdateCache(ret.Id, ret, DISEASESTATESET_CACHE);

                    DocEntityThreadCache <DocEntityDiseaseStateSet> .UpdateCache(ret.Hash, ret, DISEASESTATESET_CACHE);
                }
            }
            return(ret);
        }
Exemplo n.º 14
0
        public static DocEntityIntervention GetIntervention(Guid hash)
        {
            var query = DocQuery.ActiveQuery;
            var ret   = DocEntityThreadCache <DocEntityIntervention> .GetFromCache(hash, INTERVENTION_CACHE);

            if (null == ret)
            {
                ret = query.SelectAll <DocEntityIntervention>().Where(e => e.Hash == hash).FirstOrDefault();
                if (null != ret)
                {
                    DocEntityThreadCache <DocEntityIntervention> .UpdateCache(ret.Id, ret, INTERVENTION_CACHE);

                    DocEntityThreadCache <DocEntityIntervention> .UpdateCache(ret.Hash, ret, INTERVENTION_CACHE);
                }
            }
            return(ret);
        }
Exemplo n.º 15
0
        public static DocEntityWorkflowComment GetWorkflowComment(Guid hash)
        {
            var query = DocQuery.ActiveQuery;
            var ret   = DocEntityThreadCache <DocEntityWorkflowComment> .GetFromCache(hash, WORKFLOWCOMMENT_CACHE);

            if (null == ret)
            {
                ret = query.SelectAll <DocEntityWorkflowComment>().Where(e => e.Hash == hash).FirstOrDefault();
                if (null != ret)
                {
                    DocEntityThreadCache <DocEntityWorkflowComment> .UpdateCache(ret.Id, ret, WORKFLOWCOMMENT_CACHE);

                    DocEntityThreadCache <DocEntityWorkflowComment> .UpdateCache(ret.Hash, ret, WORKFLOWCOMMENT_CACHE);
                }
            }
            return(ret);
        }
        public new static DocEntityAdjudicatedRating Get(Guid hash)
        {
            var query = DocQuery.ActiveQuery;
            var ret   = DocEntityThreadCache <DocEntityAdjudicatedRating> .GetFromCache(hash, ADJUDICATEDRATING_CACHE);

            if (null == ret)
            {
                ret = query.SelectAll <DocEntityAdjudicatedRating>().Where(e => e.Hash == hash).FirstOrDefault();
                if (null != ret)
                {
                    DocEntityThreadCache <DocEntityAdjudicatedRating> .UpdateCache(ret.Id, ret, ADJUDICATEDRATING_CACHE);

                    DocEntityThreadCache <DocEntityAdjudicatedRating> .UpdateCache(ret.Hash, ret, ADJUDICATEDRATING_CACHE);
                }
            }
            return(ret);
        }
        public new static DocEntityReconcileDocument Get(Guid hash)
        {
            var query = DocQuery.ActiveQuery;
            var ret   = DocEntityThreadCache <DocEntityReconcileDocument> .GetFromCache(hash, RECONCILEDOCUMENT_CACHE);

            if (null == ret)
            {
                ret = query.SelectAll <DocEntityReconcileDocument>().Where(e => e.Hash == hash).FirstOrDefault();
                if (null != ret)
                {
                    DocEntityThreadCache <DocEntityReconcileDocument> .UpdateCache(ret.Id, ret, RECONCILEDOCUMENT_CACHE);

                    DocEntityThreadCache <DocEntityReconcileDocument> .UpdateCache(ret.Hash, ret, RECONCILEDOCUMENT_CACHE);
                }
            }
            return(ret);
        }
Exemplo n.º 18
0
        public new static DocEntityUnits Get(int?primaryKey)
        {
            var query = DocQuery.ActiveQuery;

            if (null == primaryKey)
            {
                return(null);
            }
            var ret = DocEntityThreadCache <DocEntityUnits> .GetFromCache(primaryKey, UNITS_CACHE);

            if (null == ret)
            {
                ret = query.SelectAll <DocEntityUnits>().Where(e => e.Id == primaryKey.Value).FirstOrDefault();
                if (null != ret)
                {
                    DocEntityThreadCache <DocEntityUnits> .UpdateCache(ret.Id, ret, UNITS_CACHE);

                    DocEntityThreadCache <DocEntityUnits> .UpdateCache(ret.Hash, ret, UNITS_CACHE);
                }
            }
            return(ret);
        }
Exemplo n.º 19
0
        public new static DocEntityAttributeInterval Get(int?primaryKey)
        {
            var query = DocQuery.ActiveQuery;

            if (null == primaryKey)
            {
                return(null);
            }
            var ret = DocEntityThreadCache <DocEntityAttributeInterval> .GetFromCache(primaryKey, ATTRIBUTEINTERVAL_CACHE);

            if (null == ret)
            {
                ret = query.SelectAll <DocEntityAttributeInterval>().Where(e => e.Id == primaryKey.Value).FirstOrDefault();
                if (null != ret)
                {
                    DocEntityThreadCache <DocEntityAttributeInterval> .UpdateCache(ret.Id, ret, ATTRIBUTEINTERVAL_CACHE);

                    DocEntityThreadCache <DocEntityAttributeInterval> .UpdateCache(ret.Hash, ret, ATTRIBUTEINTERVAL_CACHE);
                }
            }
            return(ret);
        }
        public new static DocEntityVariableInstance Get(int?primaryKey)
        {
            var query = DocQuery.ActiveQuery;

            if (null == primaryKey)
            {
                return(null);
            }
            var ret = DocEntityThreadCache <DocEntityVariableInstance> .GetFromCache(primaryKey, VARIABLEINSTANCE_CACHE);

            if (null == ret)
            {
                ret = query.SelectAll <DocEntityVariableInstance>().Where(e => e.Id == primaryKey.Value).FirstOrDefault();
                if (null != ret)
                {
                    DocEntityThreadCache <DocEntityVariableInstance> .UpdateCache(ret.Id, ret, VARIABLEINSTANCE_CACHE);

                    DocEntityThreadCache <DocEntityVariableInstance> .UpdateCache(ret.Hash, ret, VARIABLEINSTANCE_CACHE);
                }
            }
            return(ret);
        }
Exemplo n.º 21
0
        public static DocEntityReleaseStatus GetReleaseStatus(int?primaryKey)
        {
            var query = DocQuery.ActiveQuery;

            if (null == primaryKey)
            {
                return(null);
            }
            var ret = DocEntityThreadCache <DocEntityReleaseStatus> .GetFromCache(primaryKey, RELEASESTATUS_CACHE);

            if (null == ret)
            {
                ret = query.SelectAll <DocEntityReleaseStatus>().Where(e => e.Id == primaryKey.Value).FirstOrDefault();
                if (null != ret)
                {
                    DocEntityThreadCache <DocEntityReleaseStatus> .UpdateCache(ret.Id, ret, RELEASESTATUS_CACHE);

                    DocEntityThreadCache <DocEntityReleaseStatus> .UpdateCache(ret.Hash, ret, RELEASESTATUS_CACHE);
                }
            }
            return(ret);
        }
        public new static DocEntityBackgroundTaskHistory Get(int?primaryKey)
        {
            var query = DocQuery.ActiveQuery;

            if (null == primaryKey)
            {
                return(null);
            }
            var ret = DocEntityThreadCache <DocEntityBackgroundTaskHistory> .GetFromCache(primaryKey, BACKGROUNDTASKHISTORY_CACHE);

            if (null == ret)
            {
                ret = query.SelectAll <DocEntityBackgroundTaskHistory>().Where(e => e.Id == primaryKey.Value).FirstOrDefault();
                if (null != ret)
                {
                    DocEntityThreadCache <DocEntityBackgroundTaskHistory> .UpdateCache(ret.Id, ret, BACKGROUNDTASKHISTORY_CACHE);

                    DocEntityThreadCache <DocEntityBackgroundTaskHistory> .UpdateCache(ret.Hash, ret, BACKGROUNDTASKHISTORY_CACHE);
                }
            }
            return(ret);
        }
        public new static DocEntityAdjudicatedRating Get(int?primaryKey)
        {
            var query = DocQuery.ActiveQuery;

            if (null == primaryKey)
            {
                return(null);
            }
            var ret = DocEntityThreadCache <DocEntityAdjudicatedRating> .GetFromCache(primaryKey, ADJUDICATEDRATING_CACHE);

            if (null == ret)
            {
                ret = query.SelectAll <DocEntityAdjudicatedRating>().Where(e => e.Id == primaryKey.Value).FirstOrDefault();
                if (null != ret)
                {
                    DocEntityThreadCache <DocEntityAdjudicatedRating> .UpdateCache(ret.Id, ret, ADJUDICATEDRATING_CACHE);

                    DocEntityThreadCache <DocEntityAdjudicatedRating> .UpdateCache(ret.Hash, ret, ADJUDICATEDRATING_CACHE);
                }
            }
            return(ret);
        }
        public new static DocEntityReconcileDocument Get(int?primaryKey)
        {
            var query = DocQuery.ActiveQuery;

            if (null == primaryKey)
            {
                return(null);
            }
            var ret = DocEntityThreadCache <DocEntityReconcileDocument> .GetFromCache(primaryKey, RECONCILEDOCUMENT_CACHE);

            if (null == ret)
            {
                ret = query.SelectAll <DocEntityReconcileDocument>().Where(e => e.Id == primaryKey.Value).FirstOrDefault();
                if (null != ret)
                {
                    DocEntityThreadCache <DocEntityReconcileDocument> .UpdateCache(ret.Id, ret, RECONCILEDOCUMENT_CACHE);

                    DocEntityThreadCache <DocEntityReconcileDocument> .UpdateCache(ret.Hash, ret, RECONCILEDOCUMENT_CACHE);
                }
            }
            return(ret);
        }
Exemplo n.º 25
0
        public static DocEntityIntervention GetIntervention(int?primaryKey)
        {
            var query = DocQuery.ActiveQuery;

            if (null == primaryKey)
            {
                return(null);
            }
            var ret = DocEntityThreadCache <DocEntityIntervention> .GetFromCache(primaryKey, INTERVENTION_CACHE);

            if (null == ret)
            {
                ret = query.SelectAll <DocEntityIntervention>().Where(e => e.Id == primaryKey.Value).FirstOrDefault();
                if (null != ret)
                {
                    DocEntityThreadCache <DocEntityIntervention> .UpdateCache(ret.Id, ret, INTERVENTION_CACHE);

                    DocEntityThreadCache <DocEntityIntervention> .UpdateCache(ret.Hash, ret, INTERVENTION_CACHE);
                }
            }
            return(ret);
        }
Exemplo n.º 26
0
        public new static DocEntityLookupTableEnum Get(int?primaryKey)
        {
            var query = DocQuery.ActiveQuery;

            if (null == primaryKey)
            {
                return(null);
            }
            var ret = DocEntityThreadCache <DocEntityLookupTableEnum> .GetFromCache(primaryKey, LOOKUPTABLEENUM_CACHE);

            if (null == ret)
            {
                ret = query.SelectAll <DocEntityLookupTableEnum>().Where(e => e.Id == primaryKey.Value).FirstOrDefault();
                if (null != ret)
                {
                    DocEntityThreadCache <DocEntityLookupTableEnum> .UpdateCache(ret.Id, ret, LOOKUPTABLEENUM_CACHE);

                    DocEntityThreadCache <DocEntityLookupTableEnum> .UpdateCache(ret.Hash, ret, LOOKUPTABLEENUM_CACHE);
                }
            }
            return(ret);
        }
Exemplo n.º 27
0
        public static DocEntityWorkflowComment GetWorkflowComment(int?primaryKey)
        {
            var query = DocQuery.ActiveQuery;

            if (null == primaryKey)
            {
                return(null);
            }
            var ret = DocEntityThreadCache <DocEntityWorkflowComment> .GetFromCache(primaryKey, WORKFLOWCOMMENT_CACHE);

            if (null == ret)
            {
                ret = query.SelectAll <DocEntityWorkflowComment>().Where(e => e.Id == primaryKey.Value).FirstOrDefault();
                if (null != ret)
                {
                    DocEntityThreadCache <DocEntityWorkflowComment> .UpdateCache(ret.Id, ret, WORKFLOWCOMMENT_CACHE);

                    DocEntityThreadCache <DocEntityWorkflowComment> .UpdateCache(ret.Hash, ret, WORKFLOWCOMMENT_CACHE);
                }
            }
            return(ret);
        }
Exemplo n.º 28
0
        public new static DocEntityDatabaseVersion Get(int?primaryKey)
        {
            var query = DocQuery.ActiveQuery;

            if (null == primaryKey)
            {
                return(null);
            }
            var ret = DocEntityThreadCache <DocEntityDatabaseVersion> .GetFromCache(primaryKey, DATABASEVERSION_CACHE);

            if (null == ret)
            {
                ret = query.SelectAll <DocEntityDatabaseVersion>().Where(e => e.Id == primaryKey.Value).FirstOrDefault();
                if (null != ret)
                {
                    DocEntityThreadCache <DocEntityDatabaseVersion> .UpdateCache(ret.Id, ret, DATABASEVERSION_CACHE);

                    DocEntityThreadCache <DocEntityDatabaseVersion> .UpdateCache(ret.Hash, ret, DATABASEVERSION_CACHE);
                }
            }
            return(ret);
        }
Exemplo n.º 29
0
        public new static DocEntityDocumentSetHistory Get(int?primaryKey)
        {
            var query = DocQuery.ActiveQuery;

            if (null == primaryKey)
            {
                return(null);
            }
            var ret = DocEntityThreadCache <DocEntityDocumentSetHistory> .GetFromCache(primaryKey, DOCUMENTSETHISTORY_CACHE);

            if (null == ret)
            {
                ret = query.SelectAll <DocEntityDocumentSetHistory>().Where(e => e.Id == primaryKey.Value).FirstOrDefault();
                if (null != ret)
                {
                    DocEntityThreadCache <DocEntityDocumentSetHistory> .UpdateCache(ret.Id, ret, DOCUMENTSETHISTORY_CACHE);

                    DocEntityThreadCache <DocEntityDocumentSetHistory> .UpdateCache(ret.Hash, ret, DOCUMENTSETHISTORY_CACHE);
                }
            }
            return(ret);
        }
Exemplo n.º 30
0
        public static DocEntityOutcome GetOutcome(int?primaryKey)
        {
            var query = DocQuery.ActiveQuery;

            if (null == primaryKey)
            {
                return(null);
            }
            var ret = DocEntityThreadCache <DocEntityOutcome> .GetFromCache(primaryKey, OUTCOME_CACHE);

            if (null == ret)
            {
                ret = query.SelectAll <DocEntityOutcome>().Where(e => e.Id == primaryKey.Value).FirstOrDefault();
                if (null != ret)
                {
                    DocEntityThreadCache <DocEntityOutcome> .UpdateCache(ret.Id, ret, OUTCOME_CACHE);

                    DocEntityThreadCache <DocEntityOutcome> .UpdateCache(ret.Hash, ret, OUTCOME_CACHE);
                }
            }
            return(ret);
        }