hqmf2js 1.0.1 → 1.1.0

data/app/assets/javascripts/logging_utils.js.coffee

@@ -85,17 +85,6 @@ class @Logger
       return result;
     );
     
-    # hQuery.CodedEntry.prototype.includesCodeFrom = _.wrap(hQuery.CodedEntry.prototype.includesCodeFrom, (func, codeSet) ->
-    #   func = _.bind(func, this, codeSet)
-    #   result = func(codeSet)
-    #   matchText = "--- noMatch"
-    #   matchText = "+++ validMatch" if result
-    #   
-    #   Logger.info("#{matchText}: -> #{Logger.classNameFor(this)}:#{this.freeTextType()}:#{this.date()}:#{Logger.codedValuesAsString(this.type())}")
-    #   
-    #   return result;
-    # );
-    
     @getCodes = _.wrap(@getCodes, (func, oid) -> 
       codes = func(oid)
       Logger.info("accessed codes: #{oid}")

data/app/assets/javascripts/specifics.js.coffee

@@ -1,49 +1,4 @@
-
-wrap = (func, wrapper) ->
-  () ->
-    args = [func].concat(Array::slice.call(arguments, 0));
-    wrapper.apply(this, args);
-
-bind = (func, context) ->
-  
-  return Function::bind.apply(func, Array::slice.call(arguments, 1)) if (func.bind == Function::bind && Function::bind)
-  throw new TypeError if (typeof func != "function") 
-  args = Array::slice.call(arguments, 2)
-  return bound = ->
-    ctor = ->
-    return func.apply(context, args.concat(Array::slice.call(arguments))) if (!(this instanceof bound)) 
-    ctor.prototype = func.prototype
-    self = new ctor
-    result = func.apply(self, args.concat(Array::slice.call(arguments)))
-    return result if (Object(result) == result) 
-    self
-
-Array::unique = ->
-  output = {}
-  output[@[key]] = @[key] for key in [0...@length]
-  value for key, value of output
-
-Array::reduce = (accumulator) ->
-  throw new TypeError("Object is null or undefined") if (this==null or this==undefined) 
-  i = 0
-  l = this.length >> 0
-  curr=undefined
-  
-  throw new TypeError("First argument is not callable") if(typeof accumulator != "function")
-  
-  if(arguments.length < 2) 
-    throw new TypeError("Array length is 0 and no second argument") if (l == 0) 
-    curr = this[0]
-    i = 1
-  else
-    curr = arguments[1]
-
-  while (i < l) 
-    curr = accumulator.call(undefined, curr, this[i], i, this) if(`i in this`) 
-    ++i
-    
-  return curr
-  
+@hqmf ||= {}
 
 ###
   {
@@ -52,43 +7,190 @@ Array::reduce = (accumulator) ->
       [1,7,8],
     ]
   }
+
+A singleton class the represents the table of all specific occurrences
 ###
-class Specifics
+class hqmf.SpecificsManagerSingleton
+  constructor: ->
+    @patient = null
+    @any = '*'
+
+  initialize: (patient, hqmfjs, occurrences...)->
+    @occurrences = occurrences
+    @keyLookup = {}
+    @indexLookup = {}
+    @typeLookup = {}
+    @functionLookup = {}
+    @patient = patient
+    @hqmfjs = hqmfjs
+    for occurrenceKey,i in occurrences
+      @keyLookup[i] = occurrenceKey.id
+      @indexLookup[occurrenceKey.id] = i
+      @functionLookup[i] = occurrenceKey.function
+      @typeLookup[occurrenceKey.type] ||= []
+      @typeLookup[occurrenceKey.type].push(i)
+  
+  _generateCartisian: (allValues) ->
+    _.reduce(allValues, (as, bs) -> 
+      product = []
+      for a in as
+        for b in bs
+          product.push(a.concat(b))
+      product
+    , [[]])
   
-  @OCCURRENCES
-  @KEY_LOOKUP
-  @TYPE_LOOKUP
-  @INITIALIZED: false
-  @PATIENT: null
-  @ANY = '*'
+  identity: ->
+    new hqmf.SpecificOccurrence([new Row(undefined)])
+    
+  getColumnIndex: (occurrenceID) ->
+    columnIndex = @indexLookup[occurrenceID]
+    if typeof columnIndex == "undefined"
+      throw "Unknown occurrence identifier: "+occurrenceID
+    columnIndex
+
+  empty: ->
+    new hqmf.SpecificOccurrence([])
+
+  extractEventsForLeftMost: (rows) ->
+    events = []
+    for row in rows
+      events.push(@extractEvent(row.leftMost, row))
+    events
   
-  @initialize: (patient, hqmfjs, occurrences...)->
-    Specifics.OCCURRENCES = occurrences
-    Specifics.KEY_LOOKUP = {}
-    Specifics.INDEX_LOOKUP = {}
-    Specifics.TYPE_LOOKUP = {}
-    Specifics.FUNCTION_LOOKUP = {}
-    Specifics.PATIENT = patient
-    Specifics.HQMFJS = hqmfjs
-    for occurrenceKey,i in occurrences
-      Specifics.KEY_LOOKUP[i] = occurrenceKey.id
-      Specifics.INDEX_LOOKUP[occurrenceKey.id] = i
-      Specifics.FUNCTION_LOOKUP[i] = occurrenceKey.function
-      Specifics.TYPE_LOOKUP[occurrenceKey.type] ||= []
-      Specifics.TYPE_LOOKUP[occurrenceKey.type].push(i)
+  extractEvents: (key, rows) ->
+    events = []
+    for row in rows
+      events.push(@extractEvent(key, row))
+    events
+    
+  extractEvent: (key, row) ->
+    index = @indexLookup[key]
+    if index?
+      entry = row.values[index]
+    else
+      entry = row.tempValue
+    entry = new hQuery.CodedEntry(entry.json)
+    entry.specificRow = row
+    entry
+    
+  intersectSpecifics: (populations...) ->
+    value = @intersectAll(new Boolean(populations[0].isTrue()), populations)
+    value
+    
+  # Returns a count of the unique events that match the criteria for the supplied
+  # specific occurrence. Call after validating that population criteria are met. Returns
+  # 1 if occurrenceID is null, for use with patient based measures. 
+  countUnique: (occurrenceIDs, intersectedPopulation) ->
+    if occurrenceIDs?
+      columnIndices = (@getColumnIndex(occurrenceID) for occurrenceID in occurrenceIDs)
+      intersectedPopulation.specificContext.uniqueEvents(columnIndices)
+    else if @validate(intersectedPopulation)
+      1
+    else
+      0
+  
+  # remove any rows from initial that have the same event id as a row in exclusions for 
+  # the specified occurence id
+  exclude: (occurrenceIDs, initial, exclusions) ->
+    if occurrenceIDs?
+      resultContext = initial.specificContext
+      for occurrenceID in occurrenceIDs
+        columnIndex = @getColumnIndex(occurrenceID)
+        resultContext = resultContext.removeMatchingRows(columnIndex, exclusions.specificContext)
+      result = new Boolean(resultContext.hasRows())
+      result.specificContext = resultContext
+      return result
+    else if @validate(exclusions)
+      return @maintainSpecifics(new Boolean(false), initial)
+    else
+      return initial
+  
+  # Returns a boolean indication of whether all of the supplied population criteria are
+  # met
+  validate: (intersectedPopulation) ->
+    intersectedPopulation.isTrue() and intersectedPopulation.specificContext.hasRows()
+  
+  intersectAll: (boolVal, values, negate=false) ->
+    result = new hqmf.SpecificOccurrence
+    # add identity row
+    result.addIdentityRow()
+    for value in values
+      if value.specificContext?
+        result = result.intersect(value.specificContext)
+    if negate and (!result.hasRows() or result.hasSpecifics())
+      result = result.negate()
+      result = result.compactReusedEvents()
+      # this is a little odd, but it appears when we have a negation with specifics we can
+      # ignore the logical result of the negation. The reason we do this is because we may
+      # get too many negated values.  Values that may be culled later via other specific 
+      # occurrences.  Thus we do not want to return false out of a negation because the 
+      # values we are evaluating as false may be dropped.
+      # we need to verify that we actually have some occurrences
+      boolVal = new Boolean(true) if @occurrences.length > 0
+    boolVal.specificContext = result.compactReusedEvents()
+    boolVal
+
+  unionAll: (boolVal, values,negate=false) ->
+    result = new hqmf.SpecificOccurrence
+    for value in values
+      if value.specificContext? and (value.isTrue() or negate)
+        result = result.union(value.specificContext) if value.specificContext?
+    
+    if negate and (!result.hasRows() or result.hasSpecifics())
+      result = result.negate() 
+      # this is a little odd, but it appears when we have a negation with specifics we can ignore the logical result of the negation.  See comment in intersectAll.
+      # we need to verify that we actually have some occurrences
+      boolVal = new Boolean(true) if @occurrences.length > 0
+    boolVal.specificContext = result
+    boolVal
   
+  # copy the specifics parameters from an existing element onto the new value element
+  maintainSpecifics: (newElement, existingElement) ->
+    newElement.specificContext = existingElement.specificContext
+    newElement.specific_occurrence = existingElement.specific_occurrence
+    newElement
+    
+@hqmf.SpecificsManager = new hqmf.SpecificsManagerSingleton
+
+class hqmf.SpecificOccurrence
   constructor: (rows=[])->
     @rows = rows
   
   addRows: (rows) ->
     @rows = @rows.concat(rows)
     
+  # Return a new SpecificOccurrence with any matching rows removed  
+  removeMatchingRows: (columnIndex, other) ->
+    removeAll = false
+    idsToRemove = []
+    for row in other.rows
+      if row.values[columnIndex].id?
+        idsToRemove.push(row.values[columnIndex].id)
+      else if row.values[columnIndex] == hqmf.SpecificsManager.any
+        removeAll = true
+    rowsToAdd = []
+    if not removeAll
+      for row in @rows
+        if not (row.values[columnIndex].id in idsToRemove)
+          rowsToAdd.push(row)
+    result = new hqmf.SpecificOccurrence(rowsToAdd)
+    result
+  
   removeDuplicateRows: () ->
-    deduped = new Specifics()
+    deduped = new hqmf.SpecificOccurrence
     for row in @rows
       # this could potentially be hasRow to dump even more rows.
       deduped.addRows([row]) if !deduped.hasExactRow(row)
     deduped
+    
+  # Returns a count of unique events for a supplied column index
+  uniqueEvents: (columnIndices) ->
+    eventIds = []
+    for columnIndex in columnIndices
+      for row in @rows
+        event = row.values[columnIndex]
+        eventIds.push(event.id) if event != hqmf.SpecificsManager.any and not (event.id in eventIds)
+    eventIds.length
   
   hasExactRow: (other) ->
     for row in @rows
@@ -96,12 +198,12 @@ class Specifics
     return false
   
   union: (other) ->
-    value = new Specifics()
+    value = new hqmf.SpecificOccurrence()
     value.rows = @rows.concat(other.rows)
     value.removeDuplicateRows()
   
   intersect: (other) ->
-    value = new Specifics()
+    value = new hqmf.SpecificOccurrence()
     for leftRow in @rows
       for rightRow in other.rows
         result = leftRow.intersect(rightRow)
@@ -120,38 +222,29 @@ class Specifics
     keys = []
     allValues = []
     for index in @specificsWithValues()
-      keys.push(Specifics.KEY_LOOKUP[index])
-      allValues.push(Specifics.HQMFJS[Specifics.FUNCTION_LOOKUP[index]](Specifics.PATIENT))
-    cartesian = Specifics._generateCartisian(allValues)
+      keys.push(hqmf.SpecificsManager.keyLookup[index])
+      allValues.push(hqmf.SpecificsManager.hqmfjs[hqmf.SpecificsManager.functionLookup[index]](hqmf.SpecificsManager.patient))
+    cartesian = hqmf.SpecificsManager._generateCartisian(allValues)
     for values in cartesian
       occurrences = {}
       for key, i in keys
         occurrences[key] = values[i]
       row = new Row(@getLeftMost(), occurrences)
       negatedRows.push(row) if !@hasRow(row)
-    (new Specifics(negatedRows)).compactReusedEvents()
-
-  @_generateCartisian: (allValues) ->
-    Array::reduce.call(allValues, (as, bs) -> 
-      product = []
-      for a in as
-        for b in bs
-          product.push(a.concat(b))
-      product
-    , [[]])
-
-  # removes any rows that have the save value for OccurrenceA and OccurrenceB
+    (new hqmf.SpecificOccurrence(negatedRows)).compactReusedEvents()
+  
+  # removes any rows that have the same value for OccurrenceA and OccurrenceB
   compactReusedEvents: ->
     newRows = []
     for myRow in @rows
       goodRow = true
-      for type,indexes of Specifics.TYPE_LOOKUP
+      for type,indexes of hqmf.SpecificsManager.typeLookup
         ids = []
         for index in indexes
-          ids.push(myRow.values[index].id) if myRow.values[index] != Specifics.ANY
-        goodRow &&= ids.length == ids.unique().length
+          ids.push(myRow.values[index].id) if myRow.values[index] != hqmf.SpecificsManager.any
+        goodRow &&= ids.length == _.unique(ids).length
       newRows.push(myRow) if goodRow
-    new Specifics(newRows)
+    new hqmf.SpecificOccurrence(newRows)
   
   hasRow: (row) ->
     found = false
@@ -167,7 +260,7 @@ class Specifics
     foundSpecificIndexes = []
     for row in @rows
       foundSpecificIndexes = foundSpecificIndexes.concat(row.specificsWithValues())
-    foundSpecificIndexes.unique()
+    _.unique(foundSpecificIndexes)
   
   hasSpecifics: ->
     anyHaveSpecifics = false
@@ -202,9 +295,9 @@ class Specifics
     resultRows = []
     groupedRows = @group()
     for groupKey, group of groupedRows
-      if func(Specifics.extractEventsForLeftMost(group), range).isTrue()
+      if func(hqmf.SpecificsManager.extractEventsForLeftMost(group), range).isTrue()
         resultRows = resultRows.concat(group)
-    new Specifics(resultRows)
+    new hqmf.SpecificOccurrence(resultRows)
 
   FIRST: ->
     @applySubset(FIRST)
@@ -232,108 +325,41 @@ class Specifics
     resultRows = []
     groupedRows = @group()
     for groupKey, group of groupedRows
-      entries = func(Specifics.extractEventsForLeftMost(group))
+      entries = func(hqmf.SpecificsManager.extractEventsForLeftMost(group))
       if entries.length > 0
         resultRows.push(entries[0].specificRow)
-    new Specifics(resultRows)
+    new hqmf.SpecificOccurrence(resultRows)
   
   addIdentityRow: ->
-    @addRows(Specifics.identity().rows)
-  
-  @identity: ->
-    new Specifics([new Row(undefined)])
-  
+    @addRows(hqmf.SpecificsManager.identity().rows)
 
-  @extractEventsForLeftMost: (rows) ->
-    events = []
-    for row in rows
-      events.push(Specifics.extractEvent(row.leftMost, row))
-    events
-  
-  
-  @extractEvents: (key, rows) ->
-    events = []
-    for row in rows
-      events.push(Specifics.extractEvent(key, row))
-    events
-    
-  @extractEvent: (key, row) ->
-    index = Specifics.INDEX_LOOKUP[key]
-    if index?
-      entry = row.values[index]
-    else
-      entry = row.tempValue
-    entry = new hQuery.CodedEntry(entry.json)
-    entry.specificRow = row
-    entry
-  
-  @validate: (populations...) ->
-    value = Specifics.intersectAll(new Boolean(populations[0].isTrue()), populations)
-    value.isTrue() and value.specificContext.hasRows()
-  
-  @intersectAll: (boolVal, values, negate=false) ->
-    result = new Specifics()
-    # add identity row
-    result.addIdentityRow()
-    for value in values
-      if value.specificContext?
-        result = result.intersect(value.specificContext)
-    if negate and (!result.hasRows() or result.hasSpecifics())
-      result = result.negate()
-      result = result.compactReusedEvents()
-      # this is a little odd, but it appears when we have a negation with specifics we can ignore the logical result of the negation.
-      # the reason we do this is because we may get too many negated values.  Values that may be culled later via other specific occurrences.  Thus we do not want to return 
-      # false out of a negation because the values we are evaluating as false may be dropped.
-      boolVal = new Boolean(true)
-    boolVal.specificContext = result.compactReusedEvents()
-    boolVal
 
-  @unionAll: (boolVal, values,negate=false) ->
-    result = new Specifics()
-    for value in values
-      if value.specificContext? and (value.isTrue() or negate)
-        result = result.union(value.specificContext) if value.specificContext?
-    
-    if negate and result.hasSpecifics()
-      result = result.negate() 
-      # this is a little odd, but it appears when we have a negation with specifics we can ignore the logical result of the negation.  See comment in intersectAll.
-      boolVal = new Boolean(true)
-    boolVal.specificContext = result
-    boolVal
-  
-  # copy the specifics parameters from an existing element onto the new value element
-  @maintainSpecifics: (newElement, existingElement) ->
-    newElement.specificContext = existingElement.specificContext
-    newElement.specific_occurrence = existingElement.specific_occurrence
-    newElement
-    
-@Specifics = Specifics
 
 class Row
   # {'OccurrenceAEncounter':1, 'OccurrenceBEncounter'2}
   constructor: (leftMost, occurrences={}) ->
     throw "left most key must be a string or undefined was: #{leftMost}" if typeof(leftMost) != 'string' and typeof(leftMost) != 'undefined'
-    @length = Specifics.OCCURRENCES.length
+    @length = hqmf.SpecificsManager.occurrences.length
     @values = []
     @leftMost = leftMost
     @tempValue = occurrences[undefined]
     for i in [0...@length]
-      key = Specifics.KEY_LOOKUP[i]
-      value = occurrences[key] || Specifics.ANY
+      key = hqmf.SpecificsManager.keyLookup[i]
+      value = occurrences[key] || hqmf.SpecificsManager.any
       @values[i] = value
 
   hasSpecifics: ->
-    @length = Specifics.OCCURRENCES.length
+    @length = hqmf.SpecificsManager.occurrences.length
     foundSpecific = false
     for i in [0...@length]
-      return true if @values[i] != Specifics.ANY
+      return true if @values[i] != hqmf.SpecificsManager.any
     false
 
   specificsWithValues: ->
-    @length = Specifics.OCCURRENCES.length
+    @length = hqmf.SpecificsManager.occurrences.length
     foundSpecificIndexes = []
     for i in [0...@length]
-      foundSpecificIndexes.push(i) if @values[i]? and @values[i] != Specifics.ANY
+      foundSpecificIndexes.push(i) if @values[i]? and @values[i] != hqmf.SpecificsManager.any
     foundSpecificIndexes
 
   equals: (other) ->
@@ -362,9 +388,9 @@ class Row
   groupKey: (key=null) ->
     keyForGroup = ''
     for i in [0...@length]
-      value = Specifics.ANY
-      value = @values[i].id if @values[i] != Specifics.ANY 
-      if Specifics.KEY_LOOKUP[i] == key
+      value = hqmf.SpecificsManager.any
+      value = @values[i].id if @values[i] != hqmf.SpecificsManager.any 
+      if hqmf.SpecificsManager.keyLookup[i] == key
         keyForGroup += "X_"
       else
         keyForGroup += "#{value}_"
@@ -372,8 +398,8 @@ class Row
     
   
   @match: (left, right) ->
-    return right if left == Specifics.ANY
-    return left if right == Specifics.ANY
+    return right if left == hqmf.SpecificsManager.any
+    return left if right == hqmf.SpecificsManager.any
     return left if left.id == right.id
     return undefined
 
@@ -381,7 +407,7 @@ class Row
     return true if !left? and !right?
     return false if !left?
     return false if !right?
-    return true if left == Specifics.ANY and right == Specifics.ANY
+    return true if left == hqmf.SpecificsManager.any and right == hqmf.SpecificsManager.any
     return true if left.id == right.id
     return false
   
@@ -410,50 +436,50 @@ class Row
   Wrap methods to maintain specificContext and specific_occurrence
 ###
 
-hQuery.CodedEntryList::withStatuses = wrap(hQuery.CodedEntryList::withStatuses, (func, statuses, includeUndefined=true) ->
+hQuery.CodedEntryList::withStatuses = _.wrap(hQuery.CodedEntryList::withStatuses, (func, statuses, includeUndefined=true) ->
   context = this.specificContext
   occurrence = this.specific_occurrence
-  func = bind(func, this)
+  func = _.bind(func, this)
   result = func(statuses,includeUndefined)
   result.specificContext = context
   result.specific_occurrence = occurrence
   return result;
 );
 
-hQuery.CodedEntryList::withNegation = wrap(hQuery.CodedEntryList::withNegation, (func, codeSet) ->
+hQuery.CodedEntryList::withNegation = _.wrap(hQuery.CodedEntryList::withNegation, (func, codeSet) ->
   context = this.specificContext
   occurrence = this.specific_occurrence
-  func = bind(func, this)
+  func = _.bind(func, this)
   result = func(codeSet)
   result.specificContext = context
   result.specific_occurrence = occurrence
   return result;
 );
 
-hQuery.CodedEntryList::withoutNegation = wrap(hQuery.CodedEntryList::withoutNegation, (func) ->
+hQuery.CodedEntryList::withoutNegation = _.wrap(hQuery.CodedEntryList::withoutNegation, (func) ->
   context = this.specificContext
   occurrence = this.specific_occurrence
-  func = bind(func, this)
+  func = _.bind(func, this)
   result = func()
   result.specificContext = context
   result.specific_occurrence = occurrence
   return result;
 );
 
-hQuery.CodedEntryList::concat = wrap(hQuery.CodedEntryList::concat, (func, otherEntries) ->
+hQuery.CodedEntryList::concat = _.wrap(hQuery.CodedEntryList::concat, (func, otherEntries) ->
   context = this.specificContext
   occurrence = this.specific_occurrence
-  func = bind(func, this)
+  func = _.bind(func, this)
   result = func(otherEntries)
   result.specificContext = context
   result.specific_occurrence = occurrence
   return result;
 );
 
-hQuery.CodedEntryList::match = wrap(hQuery.CodedEntryList::match, (func, codeSet, start, end, includeNegated=false) ->
+hQuery.CodedEntryList::match = _.wrap(hQuery.CodedEntryList::match, (func, codeSet, start, end, includeNegated=false) ->
   context = this.specificContext
   occurrence = this.specific_occurrence
-  func = bind(func, this)
+  func = _.bind(func, this)
   result = func(codeSet, start, end, includeNegated)
   result.specificContext = context
   result.specific_occurrence = occurrence