TableNode component
@param container
@param state
@constructor
484537
function( container, state ) {
    this._container = container;
    this._state = state;

    this._options = {
        editable: false,
        enableAddRow: false,
        enableCellNavigation: true
    };
    this._columns = createColumnsFromProperties();

    globalFunc.initTable = () => {
        this._grid = new Slick.Grid(
            this._container.getElement(),
            gAllNodes,
            this._columns,
            this._options
        );
    };

    this._container.on( 'resize', this._resize, this );
    this._container.on( 'destroy', this._destroy, this );
    this._resize();
}
1210237
private void add(State[] stack, State state) {

        if (stackElements != 0) {
            System.arraycopy(stack, 0, stack, 1, stackElements);
        }

        stack[0] = state;
        stackElements++;
    }
1158109
protected void setContainer(final EntityContainer container) {
	if (!Objects.equals(this.container, container)) {
	    this.container = container;
	    if (!isAlive()) {
		return;
	    }
	    // Fix container based tags
	    if (container == null) {
		removeContainerTags();
	    } else {
		addContainerTags();
	    }
	}
    }
1079298
function component(container, data, context) {
    const selection = container.nodeName ? select(container) : container;
    const instances = selection
      .selectAll(mine)
      .data(dataArray(data, context), key);
    instances
      .exit()
      .each(destroyInstance);
    return instances
      .enter().append(tagName)
      .attr('class', className)
      .each(createInstance)
      .merge(instances)
      .each(renderInstance);
  }
1084775
def _parse_node(self, node, state):
        
        # Processing on entry of node
        state = self._parse_section(node, state)

        state = self._parse_figure(node, state)

        if self.tabular:
            state = self._parse_table(node, state)

        state = self._parse_caption(node, state)

        yield from self._parse_paragraph(node, state)
279948
function writeNode(state, level, object, block, compact, iskey) {
  state.tag = null;
  state.dump = object;

  if (!detectType(state, object, false)) {
    detectType(state, object, true);
  }

  var type = _toString.call(state.dump);

  if (block) {
    block = (state.flowLevel < 0 || state.flowLevel > level);
  }

  var objectOrArray = type === '[object Object]' || type === '[object Array]',
      duplicateIndex,
      duplicate;

  if (objectOrArray) {
    duplicateIndex = state.duplicates.indexOf(object);
    duplicate = duplicateIndex !== -1;
  }

  if ((state.tag !== null && state.tag !== '?') || duplicate || (state.indent !== 2 && level > 0)) {
    compact = false;
  }

  if (duplicate && state.usedDuplicates[duplicateIndex]) {
    state.dump = '*ref_' + duplicateIndex;
  } else {
    if (objectOrArray && duplicate && !state.usedDuplicates[duplicateIndex]) {
      state.usedDuplicates[duplicateIndex] = true;
    }
    if (type === '[object Object]') {
      if (block && (Object.keys(state.dump).length !== 0)) {
        writeBlockMapping(state, level, state.dump, compact);
        if (duplicate) {
          state.dump = '&ref_' + duplicateIndex + state.dump;
        }
      } else {
        writeFlowMapping(state, level, state.dump);
        if (duplicate) {
          state.dump = '&ref_' + duplicateIndex + ' ' + state.dump;
        }
      }
    } else if (type === '[object Array]') {
      var arrayLevel = (state.noArrayIndent && (level > 0)) ? level - 1 : level;
      if (block && (state.dump.length !== 0)) {
        writeBlockSequence(state, arrayLevel, state.dump, compact);
        if (duplicate) {
          state.dump = '&ref_' + duplicateIndex + state.dump;
        }
      } else {
        writeFlowSequence(state, arrayLevel, state.dump);
        if (duplicate) {
          state.dump = '&ref_' + duplicateIndex + ' ' + state.dump;
        }
      }
    } else if (type === '[object String]') {
      if (state.tag !== '?') {
        writeScalar(state, state.dump, level, iskey);
      }
    } else {
      if (state.skipInvalid) return false;
      throw new YAMLException('unacceptable kind of an object to dump ' + type);
    }

    if (state.tag !== null && state.tag !== '?') {
      state.dump = '!<' + state.tag + '> ' + state.dump;
    }
  }

  return true;
}
56612
function Table(selector) {
    var _this = this;

    _this.$table = $(selector).eq(0);

    if (!_this.$table.length) {
      return;
    }

    _this.init();
  }
804670
private void processNodeStateEvent(NodeStateEvent event) {
    switch (stateRef.get()) {
      case BEFORE_INIT:
      case DURING_INIT:
        throw new AssertionError("Filter should not be marked ready until LBP init");
      case CLOSING:
        return; // ignore
      case RUNNING:
        for (LoadBalancingPolicy policy : policies) {
          if (event.newState == NodeState.UP) {
            policy.onUp(event.node);
          } else if (event.newState == NodeState.DOWN || event.newState == NodeState.FORCED_DOWN) {
            policy.onDown(event.node);
          } else if (event.newState == NodeState.UNKNOWN) {
            policy.onAdd(event.node);
          } else if (event.newState == null) {
            policy.onRemove(event.node);
          } else {
            LOG.warn("[{}] Unsupported event: {}", logPrefix, event);
          }
        }
        break;
    }
  }
1293727
function(containerBlock) {
    var clauseBlock = containerBlock.nextConnection.targetBlock();
    var i = 1;
    while (clauseBlock) {
      switch (clauseBlock.type) {
        case 'controls_if_elseif':
          var inputIf = this.getInput('IF' + i);
          var inputDo = this.getInput('DO' + i);
          clauseBlock.valueConnection_ =
              inputIf && inputIf.connection.targetConnection;
          clauseBlock.statementConnection_ =
              inputDo && inputDo.connection.targetConnection;
          i++;
          break;
        case 'controls_if_else':
          var inputDo = this.getInput('ELSE');
          clauseBlock.statementConnection_ =
              inputDo && inputDo.connection.targetConnection;
          break;
        default:
          throw 'Unknown block type.';
      }
      clauseBlock = clauseBlock.nextConnection &&
          clauseBlock.nextConnection.targetBlock();
    }
  }
919756
public final void internalSetNodeState (@Nonnull final EHCNodeState eNodeState)
  {
    if (DEBUG_NODE_STATE)
    {
      ValueEnforcer.notNull (eNodeState, "NodeState");
      if (m_eNodeState.isAfter (eNodeState))
        HCConsistencyChecker.consistencyError ("The new node state is invalid. Got " +
                                               eNodeState +
                                               " but having " +
                                               m_eNodeState);
    }
    m_eNodeState = eNodeState;
  }
589489
function updateComponents(selection, state) {
  const nodesToRender = state.nodesToRender();
  const [nodesSelected, nodesNotSelected] = _.partition(
    nodesToRender, d => d.selected);
  const numNodes = nodesToRender.length;
  if (state.enableFocusedView) {
    state.focusedView = numNodes < state.focusedViewThreshold;
  }
  if (state.enableOverlookView) {
    state.overlookView = numNodes > state.overlookViewThreshold;
  }
  const edgesToRender = state.overlookView ? [] : state.edgesToRender();
  const [edgesSelected, edgesNotSelected] = _.partition(
      edgesToRender, d => d.selected);
  selection.select('.node-layer')
      .call(component.updateNodes, nodesNotSelected, state.focusedView)
    .selectAll('.node .node-symbol')
      .attr('stroke-opacity', 0);
  selection.select('.edge-layer')
      .call(component.updateEdges, edgesNotSelected);
  selection.select('.selected-nodes')
      .call(component.updateNodes, nodesSelected, state.focusedView)
    .selectAll('.node .node-symbol')
      .attr('stroke', 'red')
      .attr('stroke-width', 10)
      .attr('stroke-opacity', 0.5);
  selection.select('.selected-edges')
      .call(component.updateEdges, edgesSelected);
  selection.call(component.updateAttrs, state);
}
620553
function PossibleStatesContainer({current, allStates, data}) {
  return {
    caseOf(clauses) {
      const casesCovered = Object.keys(clauses)
      const notCovered = allStates.map(({name}) => name).filter(state => !casesCovered.includes(state))

      if (notCovered.length > 0 && !casesCovered.includes('_')) {
        throw Error('All cases are not covered in a "caseOf" clause')
      }

      const cb = clauses[current.name] || clauses['_']

      return cb instanceof Function ? cb(data) : cb
    },

    current() {
      return current.name
    },

    data() {
      return {...data}
    },

    ...generateTransitionHelpers(current, allStates),
    ...generateWhenAndNotHelpers(current, data, allStates),
  }
}
308758
function createTableLayout(){
    var tableItem = {
        type: 'component',
        componentName: 'Table'
    };

    var stackItem = myLayout.root.getItemsById('stack-topleft')[0];
    stackItem.addChild(tableItem);
    // get focus on the search tab
    stackItem.setActiveContentItem(myLayout.root.getItemsById('node-list')[0]);
    globalFunc.initTable();
}
201328
function(node, state, leaving) {
        for (let i = 0; i < state.currentSegments.length; ++i) {
            const segInternal = state.currentSegments[i].internal;

            if (leaving) {
                segInternal.exitNodes.push(node);
            } else {
                segInternal.nodes.push(node);
            }
        }

        debug([
            `${state.currentSegments.map(getId).join(",")})`,
            `${node.type}${leaving ? ":exit" : ""}`
        ].join(" "));
    }
684482
public final void openTableHead(THeadTag.State state, AbstractRenderAppender appender) {
        if(state == null)
            state = THEAD_STATE;

        if(_theadRenderer == null)
            _theadRenderer = TagRenderingBase.Factory.getRendering(TagRenderingBase.THEAD_TAG, _request);

        appender.append(LINE_BREAK);
        _theadRenderer.doStartTag(appender, state);
    }
88074
private boolean setState(NodeState to)
    {
        try {
            NodeInfo myInfo = new NodeInfo(to.toString(), zk.get().getSessionId());
            byte[] encoded = JsonUtil.asJSONBytes(myInfo);
            ZKUtils.set(zk, "/" + name + "/nodes/" + myNodeID, encoded);
            state.set(to);
            return true;
        } catch (Exception e) { // InterruptedException, IOException
            LOG.warn("Problem trying to setState("+to+"): "+e.getMessage(), e);
            return false;
        }
    }
648516
function buildTables(vueObj) {
  let updatedTemplate = [{h3: "<button class='title'>PROPS, METHODS, EVENTS, SLOTS</button>"}]
  let mdTable
  
  mdTable = tableFromProps(vueObj["props"])
  if(mdTable != null) {
    updatedTemplate.push(mdTable)
  }
  
  mdTable = tableFromMethods(vueObj["methods"])
  if(mdTable != null) {
    updatedTemplate.push(mdTable)
  }

  mdTable = tableFromEvents(vueObj["events"])
  if(mdTable != null) {
    updatedTemplate.push(mdTable)
  }
  
  mdTable = tableFromSlots(vueObj["slots"])
  if(mdTable != null) {
    updatedTemplate.push(mdTable)
  }

  return updatedTemplate.length > 1 ? updatedTemplate : []
}