Implements the abstract method of the ExternalEditor class.
185345
def load_and_set_file_content(self, file_system_path):
        
        semantic_data = load_data_file(os.path.join(file_system_path, storage.SEMANTIC_DATA_FILE))
        self.model.state.semantic_data = semantic_data
1020560
private Set<ExecutableElement> abstractMethods(TypeElement typeElement) {
    Set<ExecutableElement> methods =
        getLocalAndInheritedMethods(
            typeElement, processingEnv.getTypeUtils(), processingEnv.getElementUtils());
    ImmutableSet.Builder<ExecutableElement> abstractMethods = ImmutableSet.builder();
    for (ExecutableElement method : methods) {
      if (method.getModifiers().contains(Modifier.ABSTRACT)) {
        abstractMethods.add(method);
      }
    }
    return abstractMethods.build();
  }
747662
public static void register(Class<?> typeClass, Class<? extends PropertyEditor> editorClass)
    {
        synchronized (editors)
        {
            editors.put(typeClass, editorClass);
        }
    }
1225805
public void writeExternal(java.io.ObjectOutput out) throws java.io.IOException
    {
        out.writeObject(getContextPath());
        out.writeObject(getVirtualHosts());
        HttpHandler[] handlers= getHandlers();
        for (int i= 0; i < handlers.length; i++)
        {
            if (handlers[i] instanceof WebApplicationHandler)
                break;
            out.writeObject(handlers[i]);
        }
        out.writeObject(getAttributes());
        out.writeBoolean(isRedirectNullPath());
        out.writeInt(getMaxCachedFileSize());
        out.writeInt(getMaxCacheSize());
        out.writeBoolean(getStatsOn());
        out.writeObject(getPermissions());
        out.writeBoolean(isClassLoaderJava2Compliant());

        out.writeObject(_defaultsDescriptor);
        out.writeObject(_war);
        out.writeBoolean(_extract);
        out.writeBoolean(_ignorewebjetty);
        out.writeBoolean(_distributable);
        
        out.writeObject(_configurationClassNames);
    }
1353231
def createEditor(self, delegate, parent, option):
        
        return UntypedCtiEditor(self, delegate, parent=parent)
401508
function() {    
    var self = this, vars, j;
    
    // If this editor needs to be rendered by a macro template
    if(this.template) {
      vars = this.getWatchedFieldValues();
      this.setValue(this.template(vars),false,true);
    }
    
    this._super();
  }
1349841
public void writeExternal(PofWriter writer) throws IOException {
        writer.writeObject(0, expression);
        writer.writeMap(1, variables, String.class);
    }
1172306
@Override
  public void writeExternal(ObjectOutput out) throws IOException {
    super.writeExternal(out);
    out.writeDouble(knnDistance);
  }
910886
function() {
    if(this._oCellEditor) {
        if(this._oCellEditor.cancel) {
            this._oCellEditor.cancel();
        }
        // Backward compatibility
        else if(this._oCellEditor.isActive) {
            this.resetCellEditor();
            //TODO: preserve values for the event?
            this.fireEvent("editorCancelEvent", {editor:this._oCellEditor});
        }

    }
}
371335
protected function DefineInterface()
    {
        parent::DefineInterface();
        $externalFunctions = array('generateVariants', 'getPossibleVariantCombinations');
        $this->methodCallAllowed = array_merge($this->methodCallAllowed, $externalFunctions);
    }
812106
@Override
    public void writeExternal(ObjectOutput output) throws IOException {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
            Tr.event(tc, "Serializing: " + this);
        }
        super.writeExternal(output);
        // write out the byte[] to avoid hardcoding impl information (ordinals)
        writeByteArray(output, getMethodValue().getByteArray());
        writeByteArray(output, getSchemeValue().getByteArray());

        writeByteArray(output, getRequestURIAsByteArray());
        writeByteArray(output, getQueryStringAsByteArray());
    }
256973
private final void _writeCallback(Persistable persistable) throws IOException 
    {
        if (_callbackToItem)
        {
            try
            {
                String className = persistable.getItemClassName();
                AbstractItem item = (AbstractItem) (Class.forName(className).newInstance());
                List<DataSlice> dataSlices = _persistentMessageStore.readDataOnly(persistable);
                if (dataSlices != null)
                {
                    item.restore(dataSlices);
                    item.xmlWriteOn(_writer);
                }
            }
            catch (IOException ioexc)
            {
                // No FFDC code needed
                // as this is fault diagnostic code, and the exception 
                // will be dumped to the output anyway
                _writer.write(ioexc);
                throw ioexc;
            }
            catch (Throwable t)
            {
                // No FFDC code needed
                // as this is fault diagnostic code, and the exception 
                // will be dumped to the output anyway
                _writer.write(t);
            }
        }
    }
1134455
def initialize_public_method(method, parent)
      return if !method || !parent

      new_meth = AnyMethod.new("External Alias for module", method.name)
      new_meth.singleton    = method.singleton
      new_meth.params       = method.params.clone
      new_meth.comment      = remove_trailing_alias(method.comment.clone)
      new_meth.comment      << "\n\n#{EXTERNAL_ALIAS_MES} #{parent.strip.chomp}\##{method.name}"

      return new_meth
    end
680272
def createEditor(self, delegate, parent, _option):
        
        return GroupCtiEditor(self, delegate, parent=parent)
1093852
public void generate(Definition def, Writer out) throws IOException
   {
      writeHeader(def, out);
      writeImport(def, out);
      writeClassComment(def, out);
      writeClassBody(def, out);
   }
633512
@Override
  public void writeExternal(ObjectOutput out) throws IOException {
    super.writeExternal(out);
    out.writeObject(approximation);
  }
778549
function (settings) {
        var self = this, editor = getActiveEditor(), editorSettings = editor.settings;
        var actionCallback, fileBrowserCallback, fileBrowserCallbackTypes;
        var fileType = settings.filetype;

        settings.spellcheck = false;

        fileBrowserCallbackTypes = editorSettings.file_picker_types || editorSettings.file_browser_callback_types;
        if (fileBrowserCallbackTypes) {
          fileBrowserCallbackTypes = Tools.makeMap(fileBrowserCallbackTypes, /[, ]/);
        }

        if (!fileBrowserCallbackTypes || fileBrowserCallbackTypes[fileType]) {
          fileBrowserCallback = editorSettings.file_picker_callback;
          if (fileBrowserCallback && (!fileBrowserCallbackTypes || fileBrowserCallbackTypes[fileType])) {
            actionCallback = function () {
              var meta = self.fire('beforecall').meta;

              meta = Tools.extend({ filetype: fileType }, meta);

              // file_picker_callback(callback, currentValue, metaData)
              fileBrowserCallback.call(
                editor,
                function (value, meta) {
                  self.value(value).fire('change', { meta: meta });
                },
                self.value(),
                meta
              );
            };
          } else {
            // Legacy callback: file_picker_callback(id, currentValue, filetype, window)
            fileBrowserCallback = editorSettings.file_browser_callback;
            if (fileBrowserCallback && (!fileBrowserCallbackTypes || fileBrowserCallbackTypes[fileType])) {
              actionCallback = function () {
                fileBrowserCallback(
                  self.getEl('inp').id,
                  self.value(),
                  fileType,
                  window
                );
              };
            }
          }
        }

        if (actionCallback) {
          settings.icon = 'browse';
          settings.onaction = actionCallback;
        }

        self._super(settings);

        setupAutoCompleteHandler(self, editorSettings, editor.getBody(), fileType);
        setupLinkValidatorHandler(self, editorSettings, fileType);
      }