Download

기본 설정

  • 기본적인 터미널 사용과 동일함
  • 단축키 별도로 확인 필요
  • 설정 파일 위치
    • %USER%\AppData\Local\Packages\Microsoft.WindowsTerminal_~~(임의문자인듯)\LocalState\settings.json

SSH 용 프로필 추가 방법

  • 설정 파일 내의 profiles 항목에 추가
  • 폰트가 깨질 경우 기본 폰트를 변경 (D2Coding 등으로)
    • 윈도우에 설치된 폰트여야 하는듯
  • commandline 으로 ssh 실행 추가
  • 추가한 개별 프로필 탭에 아이콘을 표시하고 싶은 경우 `icon` 옵션 추가
  • 참고 : https://gist.github.com/jmyoon4488/a5dab4a0c460d5824da10540c6f6686b
"profiles":
{
  "defaults":
  {
    // Put settings here that you want to apply to all profiles.
    // zsh 사용중 또는 한글이 깨질경우 폰트 변경
    "fontFace": "D2Coding"
  },
  "list":
  [
    {
      // Make changes here to the powershell.exe profile.
      "guid": "{RANDOM-UNIQUE-GUID}",
      "name": "Windows PowerShell",
      "commandline": "powershell.exe",
      "hidden": false
    },
    {
      // Make changes here to the cmd.exe profile.
      "guid": "{RANDOM-UNIQUE-GUID}",
      "name": "명령 프롬프트",
      "commandline": "cmd.exe",
      "hidden": false
    },
    ......
    {
      "guid": "{RANDOM-UNIQUE-GUID}",
      "hidden": false,
      "name": "for SSH",
      "icon": "{local image path or image url}",
      "commandline": "wsl ssh user@example.com"
    }
  ]
}

 

(지속적으로 추가 예정)

[OPEN SOURCE]

1. Captura

2. HyperLedger Fabric

3. cmder

4. DBeaver Community Edition

  • https://dbeaver.io/
  • 멀티 플랫폼 DB 접속 툴
  • 커뮤니티 버전만 무료
  • Free and Open Source (Apache 2.0)

5. Windows Terminal

 

 

 

 

'Programming > Open Source' 카테고리의 다른 글

Windows Terminal SSH용 프로필 추가  (0) 2020.05.24

Default Method 란

  • Interface 안에서 method 를 구현해놓아 상속받는 클래스에서 해당 method 를 따로 override 하지 않아도 된다.
  • 해당 Interface 를 상속받는 여러 클래스에서는 동일하게 동작하는 method 지만 하나의 클래스에서만 다르게 동작해야 할 경우
    Interface 내에서 default method 로 구현 후 다르게 동작할 클래스에서 override 하여 구현하면 된다.

JDK 내 예시

  • Collection.java (Interface)

      /**
       * Removes all of the elements of this collection that satisfy the given
       * predicate.  Errors or runtime exceptions thrown during iteration or by
       * the predicate are relayed to the caller.
       *
       * @implSpec
       * The default implementation traverses all elements of the collection using
       * its {@link #iterator}.  Each matching element is removed using
       * {@link Iterator#remove()}.  If the collection's iterator does not
       * support removal then an {@code UnsupportedOperationException} will be
       * thrown on the first matching element.
       *
       * @param filter a predicate which returns {@code true} for elements to be
       *        removed
       * @return {@code true} if any elements were removed
       * @throws NullPointerException if the specified filter is null
       * @throws UnsupportedOperationException if elements cannot be removed
       *         from this collection.  Implementations may throw this exception if a
       *         matching element cannot be removed or if, in general, removal is not
       *         supported.
       * @since 1.8
       */
      default boolean removeIf(Predicate<? super E> filter) {
          Objects.requireNonNull(filter);
          boolean removed = false;
          final Iterator<E> each = iterator();
          while (each.hasNext()) {
              if (filter.test(each.next())) {
                  each.remove();
                  removed = true;
              }
          }
          return removed;
      }
    
      /**
       * Creates a {@link Spliterator} over the elements in this collection.
       *
       * Implementations should document characteristic values reported by the
       * spliterator.  Such characteristic values are not required to be reported
       * if the spliterator reports {@link Spliterator#SIZED} and this collection
       * contains no elements.
       *
       * <p>The default implementation should be overridden by subclasses that
       * can return a more efficient spliterator.  In order to
       * preserve expected laziness behavior for the {@link #stream()} and
       * {@link #parallelStream()}} methods, spliterators should either have the
       * characteristic of {@code IMMUTABLE} or {@code CONCURRENT}, or be
       * <em><a href="Spliterator.html#binding">late-binding</a></em>.
       * If none of these is practical, the overriding class should describe the
       * spliterator's documented policy of binding and structural interference,
       * and should override the {@link #stream()} and {@link #parallelStream()}
       * methods to create streams using a {@code Supplier} of the spliterator,
       * as in:
       * <pre>{@code
       *     Stream<E> s = StreamSupport.stream(() -> spliterator(), spliteratorCharacteristics)
       * }</pre>
       * <p>These requirements ensure that streams produced by the
       * {@link #stream()} and {@link #parallelStream()} methods will reflect the
       * contents of the collection as of initiation of the terminal stream
       * operation.
       *
       * @implSpec
       * The default implementation creates a
       * <em><a href="Spliterator.html#binding">late-binding</a></em> spliterator
       * from the collections's {@code Iterator}.  The spliterator inherits the
       * <em>fail-fast</em> properties of the collection's iterator.
       * <p>
       * The created {@code Spliterator} reports {@link Spliterator#SIZED}.
       *
       * @implNote
       * The created {@code Spliterator} additionally reports
       * {@link Spliterator#SUBSIZED}.
       *
       * <p>If a spliterator covers no elements then the reporting of additional
       * characteristic values, beyond that of {@code SIZED} and {@code SUBSIZED},
       * does not aid clients to control, specialize or simplify computation.
       * However, this does enable shared use of an immutable and empty
       * spliterator instance (see {@link Spliterators#emptySpliterator()}) for
       * empty collections, and enables clients to determine if such a spliterator
       * covers no elements.
       *
       * @return a {@code Spliterator} over the elements in this collection
       * @since 1.8
       */
      @Override
      default Spliterator<E> spliterator() {
          return Spliterators.spliterator(this, 0);
      }
      default Stream<E> stream() {
          return StreamSupport.stream(spliterator(), false);
      }
      default Stream<E> parallelStream() {
          return StreamSupport.stream(spliterator(), true);
      }

+ Recent posts