text:
// code dedicated to windows

// +build windows

package endless

import (
	"crypto/tls"
	"fmt"
	"log"
	"net"
	"net/http"
	"os"
	"sync"
	"time"
	// "github.com/fvbock/uds-go/introspect"
)

const (
	PRE_SIGNAL = iota
	POST_SIGNAL

	STATE_INIT
	STATE_RUNNING
	STATE_SHUTTING_DOWN
	STATE_TERMINATE
)

var (
	DefaultReadTimeOut    time.Duration
	DefaultWriteTimeOut   time.Duration
	DefaultMaxHeaderBytes int
	DefaultHammerTime     time.Duration
)

func init() {

	DefaultMaxHeaderBytes = 0 // use http.DefaultMaxHeaderBytes - which currently is 1 << 20 (1MB)

	DefaultHammerTime = 60 * time.Second

}

type endlessServer struct {
	http.Server
	EndlessListener  net.Listener
	SignalHooks      map[int]map[os.Signal][]func()
	tlsInnerListener *endlessListener
	wg               sync.WaitGroup
	sigChan          chan os.Signal
	isChild          bool
	state            uint8
	lock             *sync.RWMutex
	BeforeBegin      func(add string)
}

/*
NewServer returns an intialized endlessServer Object. Calling Serve on it will
actually "start" the server.
*/
func NewServer(addr string, handler http.Handler) (srv *endlessServer) {

	srv = &endlessServer{}

	srv.Server.Addr = addr
	srv.Server.ReadTimeout = DefaultReadTimeOut
	srv.Server.WriteTimeout = DefaultWriteTimeOut
	srv.Server.MaxHeaderBytes = DefaultMaxHeaderBytes
	srv.Server.Handler = handler

	return
}

/*
ListenAndServe listens on the TCP network address addr and then calls Serve
with handler to handle requests on incoming connections. Handler is typically
nil, in which case the DefaultServeMux is used.
*/
func ListenAndServe(addr string, handler http.Handler) error {
	server := NewServer(addr, handler)
	return server.ListenAndServe()
}

/*
ListenAndServeTLS acts identically to ListenAndServe, except that it expects
HTTPS connections. Additionally, files containing a certificate and matching
private key for the server must be provided. If the certificate is signed by a
certificate authority, the certFile should be the concatenation of the server's
certificate followed by the CA's certificate.
*/
func ListenAndServeTLS(addr string, certFile string, keyFile string, handler http.Handler) error {
	server := NewServer(addr, handler)
	return server.ListenAndServeTLS(certFile, keyFile)
}

// PJS
// func (srv *endlessServer) ListenAndServeTLSWithSNI(tlsConfigs []TLSConfig) (err error) {
// func ListenAndServeTLSWithSNI(srv *http.Server, tlsConfigs []TLSConfig) (err error) {
func ListenAndServeTLSWithSNI(addr string, handler http.Handler, tlsConfigs []TLSConfig) (err error) {
	server := NewServer(addr, handler)
	return server.ListenAndServeTLSWithSNI(tlsConfigs)
}

/*
Serve accepts incoming HTTP connections on the listener l, creating a new
service goroutine for each. The service goroutines read requests and then call
handler to reply to them. Handler is typically nil, in which case the
DefaultServeMux is used.

In addition to the stl Serve behaviour each connection is added to a
sync.Waitgroup so that all outstanding connections can be served before shutting
down the server.
*/
func (srv *endlessServer) Serve() (err error) {
	err = srv.Server.Serve(srv.EndlessListener)
	return
}

/*
ListenAndServe listens on the TCP network address srv.Addr and then calls Serve
to handle requests on incoming connections. If srv.Addr is blank, ":http" is
used.
*/
func (srv *endlessServer) ListenAndServe() (err error) {
	addr := srv.Addr
	if addr == "" {
		addr = ":http"
	}

	l, err := srv.getListener(addr)
	if err != nil {
		log.Println(err)
		return
	}

	srv.EndlessListener = newEndlessListener(l, srv)

	srv.BeforeBegin(srv.Addr)

	return srv.Serve()
}

/*
ListenAndServeTLS listens on the TCP network address srv.Addr and then calls
Serve to handle requests on incoming TLS connections.

Filenames containing a certificate and matching private key for the server must
be provided. If the certificate is signed by a certificate authority, the
certFile should be the concatenation of the server's certificate followed by the
CA's certificate.

If srv.Addr is blank, ":https" is used.
*/
func (srv *endlessServer) ListenAndServeTLS(certFile, keyFile string) (err error) {
	addr := srv.Addr
	if addr == "" {
		addr = ":https"
	}

	config := &tls.Config{}
	if srv.TLSConfig != nil {
		*config = *srv.TLSConfig
	}
	if config.NextProtos == nil {
		config.NextProtos = []string{"http/1.1"}
	}

	config.NextProtos = append(config.NextProtos, "h2") // Enable HTTP2.0 progocall

	config.Certificates = make([]tls.Certificate, 1)
	config.Certificates[0], err = tls.LoadX509KeyPair(certFile, keyFile)
	if err != nil {
		return
	}

	l, err := srv.getListener(addr)
	if err != nil {
		log.Println(err)
		return
	}

	srv.tlsInnerListener = newEndlessListener(l, srv)
	srv.EndlessListener = tls.NewListener(srv.tlsInnerListener, config)

	return srv.Serve()
}

type TLSConfig struct {
	Certificate              string   // file name of Cert Key
	Key                      string   // file name of Cert Key
	ProtocolMinVersion       uint16   // ?? - defaults? I think to 1.2 the highest level - so why set
	ProtocolMaxVersion       uint16   // ?? - defaults?
	Ciphers                  []uint16 // Flags of Ciphers - need special processing to read in
	PreferServerCipherSuites bool     // Flags of Ciphers - need special processing to read in
}

// PJS mod 1
// func ListenAndServeTLSWithSNI(srv *http.Server, tlsConfigs []TLSConfig) (err error) {
func (srv *endlessServer) ListenAndServeTLSWithSNI(tlsConfigs []TLSConfig) (err error) {
	addr := srv.Addr
	if addr == "" {
		addr = ":https"
	}

	//config := &tls.Config{}
	//if srv.TLSConfig != nil {
	//	*config = *srv.TLSConfig
	//}
	//if config.NextProtos == nil {
	//	config.NextProtos = []string{"http/1.1"}
	//}

	var config *tls.Config
	if srv.TLSConfig != nil {
		config = srv.TLSConfig
	} else {
		config = new(tls.Config)
	}

	// return strSliceContains(srv.TLSConfig.NextProtos, http2NextProtoTLS)
	config.NextProtos = append(config.NextProtos, "h2") // Enable HTTP2.0 progocall

	config.MinVersion = tls.VersionTLS11
	config.CipherSuites = tlsConfigs[0].Ciphers

	//config.Certificates = make([]tls.Certificate, 1)
	//config.Certificates[0], err = tls.LoadX509KeyPair(certFile, keyFile)
	//if err != nil {
	//	return
	//}
	// PJS - Load set of certificate paris instead of single certificate.
	config.Certificates = make([]tls.Certificate, len(tlsConfigs))
	for i, tlsConfig := range tlsConfigs {
		// PJS params are file names, can be relative
		config.Certificates[i], err = tls.LoadX509KeyPair(tlsConfig.Certificate, tlsConfig.Key) // PJS - reads and parses certs
		if err != nil {
			return
		}
	}
	config.BuildNameToCertificate()

	l, err := srv.getListener(addr)
	if err != nil {
		log.Println(err)
		return
	}

	srv.tlsInnerListener = newEndlessListener(l, srv)
	srv.EndlessListener = tls.NewListener(srv.tlsInnerListener, config)

	return srv.Serve()
}

/*
getListener either opens a new socket to listen on, or takes the acceptor socket
it got passed when restarted.
*/
func (srv *endlessServer) getListener(laddr string) (l net.Listener, err error) {
	l, err = net.Listen("tcp", laddr)
	if err != nil {
		err = fmt.Errorf("net.Listen error: %v", err)
		return
	}
	return
}

type endlessListener struct {
	net.Listener
	stopped bool
	server  *endlessServer
}

func (el *endlessListener) Accept() (c net.Conn, err error) {
	tc, err := el.Listener.(*net.TCPListener).AcceptTCP()
	if err != nil {
		return
	}

	tc.SetKeepAlive(true)                  // see http.tcpKeepAliveListener
	tc.SetKeepAlivePeriod(3 * time.Minute) // see http.tcpKeepAliveListener

	c = endlessConn{
		Conn:   tc,
		server: el.server,
	}

	el.server.wg.Add(1)
	return
}

func newEndlessListener(l net.Listener, srv *endlessServer) (el *endlessListener) {
	el = &endlessListener{
		Listener: l,
		server:   srv,
	}

	return
}

func (el *endlessListener) Close() error {

	el.stopped = true
	return el.Listener.Close()
}

func (el *endlessListener) File() *os.File {
	// returns a dup(2) - FD_CLOEXEC flag *not* set
	tl := el.Listener.(*net.TCPListener)
	fl, _ := tl.File()
	return fl
}

type endlessConn struct {
	net.Conn
	server *endlessServer
}

func (w endlessConn) Close() error {
	err := w.Conn.Close()
	if err == nil {
		w.server.wg.Done()
	}
	return err
}

/*
RegisterSignalHook registers a function to be run PRE_SIGNAL or POST_SIGNAL for
a given signal. PRE or POST in this case means before or after the signal
related code endless itself runs
*/
func (srv *endlessServer) RegisterSignalHook(prePost int, sig os.Signal, f func()) (err error) {
	return
}

repository: pschlump/endless

repo_name: pschlump/endless


text:
SUMMARY     = "FSI debug tool"
DESCRIPTION = "fsidbg is a tool to access remote FSI engines and perform client driver operations"
LICENSE     = "GPLv3"
LIC_FILES_CHKSUM = "file://${S}/LICENSE;md5=84dcc94da3adb52b53ae4fa38fe49e5d"

SRC_URI = "git://github.com/eddiejames/fsidbg.git;branch=master;protocol=https"

SRCREV = "dfe278065c877724242dfae15a4c627fd2e3611c"
PV = "git${SRCREV}"

S = "${WORKDIR}/git"

do_install() {
    install -d ${D}${bindir}
    install -m 0755 fsidbg ${D}${bindir}
}

TARGET_CC_ARCH += "${LDFLAGS}"

repository: openbmc/openbmc

license_type: permissive

repo_name: openbmc/openbmc

branch_name: refs/heads/master

gha_license_id: NOASSERTION

gha_language: Python

extension: bb


text:
# Find the ECW library - Enhanced Compression Wavelets for JPEG2000.
#
# Sets
#   ECW_FOUND.  If false, don't try to use ecw
#   ECW_INCLUDE_DIR
#   ECW_LIBRARIES

# The original sponsorring website of this library appears to have vanished,
# but there are still traces at http://www.gdal.org/frmt_ecw.html and a
# distribution at https://svn.zib.de/lenne3d/lib/libecw/current - IMS  7-Dec-2009.
IF( VXL_FORCE_V3P_J2K )
ELSE( VXL_FORCE_V3P_J2K )
SET( ECW_FOUND "NO" )

FIND_PATH( ECW_INCLUDE_DIR NCSEcw.h
  /usr/include
  /usr/local/include
)

IF( ECW_INCLUDE_DIR )

  FIND_LIBRARY( ECW_ncsutil_LIBRARY NCSUtild
    /usr/lib
    /usr/local/lib
    /usr/lib64
    /usr/local/lib64
  )

  FIND_LIBRARY( ECW_ncsecw_LIBRARY NCSEcwd
    /usr/lib
    /usr/local/lib
    /usr/lib64
    /usr/local/lib64
  )

  IF( ECW_ncsutil_LIBRARY )
  IF( ECW_ncsecw_LIBRARY )

    SET( ECW_FOUND "YES" )
    SET( ECW_LIBRARIES ${ECW_ncsutil_LIBRARY} ${ECW_ncsecw_LIBRARY} )

  ENDIF( ECW_ncsecw_LIBRARY )
  ENDIF( ECW_ncsutil_LIBRARY )

ENDIF( ECW_INCLUDE_DIR )
ENDIF( VXL_FORCE_V3P_J2K )

IF( ECW_FOUND )
    SET(VXL_USING_NATIVE_J2K "YES")
ELSE( ECW_FOUND )
#~ INCLUDE(${MODULE_PATH}/NewCMake/FindWin32SDK.cmake)
#~ INCLUDE(${CMAKE_ROOT}/Modules/FindMFC.cmake)

SET(J2K_SOURCES_FOUND "NO")
IF (EXISTS ${vxl_SOURCE_DIR}/v3p/j2k/Source/include/NCSEcw.h )
IF (EXISTS ${vxl_SOURCE_DIR}/v3p/j2k/Source/include/NCSUtil.h)
IF (EXISTS${vxl_SOURCE_DIR}/v3p/j2k/Source/include/NCSCnet.h)
SET(J2K_SOURCES_FOUND "YES")
ENDIF (EXISTS${vxl_SOURCE_DIR}/v3p/j2k/Source/include/NCSCnet.h)
ENDIF (EXISTS ${vxl_SOURCE_DIR}/v3p/j2k/Source/include/NCSUtil.h)
ENDIF (EXISTS ${vxl_SOURCE_DIR}/v3p/j2k/Source/include/NCSEcw.h )

 IF( WIN32 AND J2K_SOURCES_FOUND AND WIN32SDK_FOUND AND MFC_FOUND)

    SET( ECW_FOUND "YES" )
    SET( ECW_INCLUDE_DIR ${vxl_SOURCE_DIR}/v3p/j2k/Source/include)
    SET( ECW_INSTALL_INCLUDE_DIR ${CMAKE_INSTALL_DIR}/include/vxl/v3p/j2k)
    SET( ECW_LIBRARIES NCSEcw NCSUtil )

  ENDIF( WIN32 AND J2K_SOURCES_FOUND AND WIN32SDK_FOUND AND MFC_FOUND )
 ENDIF( ECW_FOUND )

license: MIT

repository: LuaDist/im

repo_name: LuaDist/im

extension: cmake


text:
import { TagsState } from './../../store/ducks/tags/contracts/state';
import axios from 'axios'

export const TagsApi = {
    fetchTags(): Promise<TagsState['items']>{
        return axios.get('/tags').then(({ data }) => data)
    },
};

branch_name: refs/heads/main

extension: ts


text:
package network

import (
	"fmt"
	"net"
	"sync/atomic"
	"time"

	"github.com/okpub/rhino/errors"
)

//可以看作统一类型的连接管理器
func NewManager(addr string) Manager {
	return &myManager{addr: addr, ch: make(chan net.Conn)}
}

//class manager
type myManager struct {
	addr string
	code int32
	ch   chan net.Conn
}

func (this *myManager) Dial(addr string) error {
	if atomic.LoadInt32(&this.code) == 1 {
		return fmt.Errorf("close of dial addr=%s", this.addr)
	}
	conn, err := net.DialTimeout("tcp", addr, time.Second*5)
	if err == nil {
		if err = this.joinAndConn(conn); err != nil {
			conn.Close()
		}
	}
	return err
}

//join
func (this *myManager) joinAndConn(conn net.Conn) (err error) {
	defer func() { err = errors.Catch(recover()) }()
	this.ch <- conn
	return
}

//Listener
func (this *myManager) Accept() (net.Conn, error) {
	if conn, ok := <-this.ch; ok {
		return conn, nil
	}
	return nil, fmt.Errorf("accept closed addr=%s", this.addr)
}

func (this *myManager) Close() (err error) {
	if atomic.CompareAndSwapInt32(&this.code, 0, 1) {
		close(this.ch)
	} else {
		err = fmt.Errorf("close nothing addr=%s", this.addr)
	}
	return
}

func (this *myManager) Addr() net.Addr  { return this }
func (this *myManager) Network() string { return "tcp" }
func (this *myManager) String() string  { return this.addr }

repository: mikestrange/rhino

repo_name: mikestrange/rhino

extension: go


text:
// --------------------------------------------------------------------------------------------------------------------
// <copyright file="CompositeExpirationPolicy.cs" company="Catel development team">
//   Copyright (c) 2008 - 2015 Catel development team. All rights reserved.
// </copyright>
// --------------------------------------------------------------------------------------------------------------------

namespace Catel.Caching.Policies
{
    using System.Collections.Generic;
    using System.Linq;
    using Catel.Threading;

    ///
    /// The composite expiration policy.
    ///
    public sealed class CompositeExpirationPolicy : ExpirationPolicy
    {
        #region Fields

        ///
        /// The expiration policies.
        ///
        private readonly List<ExpirationPolicy> _expirationPolicies = new List<ExpirationPolicy>();

        ///
        /// The synchronization context.
        ///
        private readonly SynchronizationContext _synchronizationContext = new SynchronizationContext();

        /// If <c>true</c> indicates that the cache will expires only if All policies of the composition expires,
        /// otherwise the cache will expires if Any policy does.
        private readonly bool _expiresOnlyIfAllPoliciesExpires;

        #endregion

        #region Constructors

        ///
        /// Initializes a new instance of the <see cref="CompositeExpirationPolicy"/> class.
        ///
        /// <param name="expiresOnlyIfAllPoliciesExpires">
        /// If <c>true</c> indicates that the cache will expires only if All policies of the composition expires,
        /// otherwise the cache will expires if Any policy does.
        /// </param>
        public CompositeExpirationPolicy(bool expiresOnlyIfAllPoliciesExpires = false)
        {
            _expiresOnlyIfAllPoliciesExpires = expiresOnlyIfAllPoliciesExpires;
        }

        #endregion

        #region Properties

        ///
        /// Gets a value indicating whether can reset.
        ///
        public override bool CanReset
        {
            get
            {
                _synchronizationContext.Acquire();

                bool canReset = _expirationPolicies.Any(policy => policy.CanReset);

                if (!IsResting || !canReset)
                {
                    _synchronizationContext.Release();
                }

                return canReset;
            }
        }

        ///
        /// Gets a value indicating whether is expired.
        ///
        public override bool IsExpired
        {
            get
            {
                return _expiresOnlyIfAllPoliciesExpires ? _synchronizationContext.Execute(() => _expirationPolicies.All(policy => policy.IsExpired)) : _synchronizationContext.Execute(() => _expirationPolicies.Any(policy => policy.IsExpired));
            }
        }
        #endregion

        #region Methods

        ///
        /// Called when the policy is resetting.
        ///
        protected override void OnReset()
        {
            try
            {
                foreach (var expirationPolicy in _expirationPolicies.Where(expirationPolicy => expirationPolicy.CanReset))
                {
                    expirationPolicy.Reset();
                }
            }
            finally
            {
                if (IsResting)
                {
                    _synchronizationContext.Release();
                }
            }
        }

        ///
        /// Adds an expiration policy to the composition.
        ///
        /// <param name="expirationPolicy">
        /// The expiration policy.
        /// </param>
        /// <returns>
        /// The <see cref="CompositeExpirationPolicy"/>.
        /// </returns>
        public CompositeExpirationPolicy Add(ExpirationPolicy expirationPolicy)
        {
            _synchronizationContext.Execute(() => _expirationPolicies.Add(expirationPolicy));

            return this;
        }

        #endregion
    }
}

repository: lyonc/Catel

repo_name: lyonc/Catel

extension: cs


text:
namespace OrchardCore.Queries.ViewModels
{
    public class QueriesEditViewModel : QueriesCreateViewModel
    {
        public string Name { get; set; }
        public string Schema { get; set; }
    }
}

repository: OrchardCMS/OrchardCore

repo_name: OrchardCMS/OrchardCore

gha_language: C#


text:
package curve

import (
	"fmt"

	GF "github.com/armfazh/hash-to-curve-ref/go-h2c/field"
)

type mt2wec struct {
	E0   *MTCurve
	E1   *WCCurve
	invB GF.Elt
}

func (e *MTCurve) ToWeierstrassC() RationalMap {
	F := e.Field()
	invB := F.Inv(e.params.B)
	a := F.Mul(invB, e.params.A)
	b := F.Sqr(invB)
	return &mt2wec{E0: e, E1: NewWeierstrassC(Custom, F, a, b, e.params.R, e.params.H), invB: invB}
}

func (r *mt2wec) Domain() EllCurve   { return r.E0 }
func (r *mt2wec) Codomain() EllCurve { return r.E1 }
func (r *mt2wec) Push(p Point) Point {
	if p.IsIdentity() {
		return r.E1.Identity()
	}
	F := r.E0.Field()

	P := p.(*ptMt)
	x := F.Mul(P.x, r.invB) // s = x/B
	y := F.Mul(P.y, r.invB) // t = y/B
	return r.E1.NewPoint(x, y)
}
func (r *mt2wec) Pull(p Point) Point {
	if p.IsIdentity() {
		return r.E0.Identity()
	}
	F := r.E0.Field()
	P := p.(*ptWc)
	x := F.Mul(P.x, r.E0.B) // x = s*B
	y := F.Mul(P.y, r.E0.B) // y = t*B
	return r.E0.NewPoint(x, y)
}

type te2wec struct {
	E0       *TECurve
	E1       *WCCurve
	invSqrtD GF.Elt // 4/(a-d)
}

func (e *TECurve) ToWeierstrassC() RationalMap {
	F := e.Field()
	half := F.Inv(F.Elt(2))             // 1/2
	t0 := F.Add(e.params.A, e.params.D) // a+d
	a := F.Mul(t0, half)                // A = (a+d)/2

	t0 = F.Sub(e.params.A, e.params.D) // a-d
	t0 = F.Mul(t0, half)               // (a-d)/2
	t0 = F.Mul(t0, half)               // (a-d)/4
	invSqrtD := F.Inv(t0)              // 4/(a-d)
	b := F.Sqr(t0)                     // B = (a-d)^2/16
	return &te2wec{E0: e, E1: NewWeierstrassC(Custom, F, a, b, e.params.R, e.params.H), invSqrtD: invSqrtD}
}

func (r *te2wec) Domain() EllCurve   { return r.E0 }
func (r *te2wec) Codomain() EllCurve { return r.E1 }
func (r *te2wec) Push(p Point) Point {
	if p.IsIdentity() {
		return r.E1.Identity()
	}
	F := r.E0.Field()
	P := p.(*ptTe)
	t0 := F.Add(F.One(), P.y)  // 1+y
	t1 := F.Sub(F.One(), P.y)  // 1-y
	t1 = F.Mul(t1, r.invSqrtD) // invSqrtD*(1-y)
	t1 = F.Inv(t1)             // 1/(invSqrtD*(1-y))
	x := F.Mul(t0, t1)         // x = (1+y)/(invSqrtD*(1-y))
	t0 = F.Inv(P.y)            // 1/y
	y := F.Mul(x, t0)          // y = x/y
	return r.E1.NewPoint(x, y)
}
func (r *te2wec) Pull(p Point) Point {
	if p.IsIdentity() {
		return r.E0.Identity()
	}
	P := p.(*ptWc)
	F := r.E0.Field()
	if P.IsTwoTorsion() {
		return r.E0.NewPoint(F.Zero(), F.Elt(-1))
	}
	t0 := F.Inv(P.y)            // 1/y
	x := F.Mul(P.x, t0)         // X = x/y
	t0 = F.Mul(r.invSqrtD, P.x) // invSqrtD*x
	t1 := F.Add(t0, F.One())    // invSqrtD*x+1
	t2 := F.Sub(t0, F.One())    // invSqrtD*x-1
	t1 = F.Inv(t1)              // 1/(invSqrtD*x+1)
	y := F.Mul(t1, t2)          // Y = (invSqrtD*x-1)/(invSqrtD*x+1)
	return r.E0.NewPoint(x, y)
}

type wc2we struct {
	E0    *WCCurve
	E1    *WECurve
	Adiv3 GF.Elt
}

func (e *WCCurve) ToWeierstrass() RationalMap {
	F := e.Field()
	var t0, t1 GF.Elt
	t0 = F.Inv(F.Elt(3))    // 1/3
	Adiv3 := F.Mul(t0, e.A) // A/3
	t0 = F.Neg(Adiv3)       // -A/3
	t0 = F.Mul(t0, e.A)     // -A^2/3
	A := F.Add(t0, e.B)     // -A^2/3 + B

	t0 = F.Mul(F.Elt(9), e.B) // 9B
	t1 = F.Sqr(e.A)           // A^2
	t1 = F.Add(t1, t1)        // 2A^2
	t1 = F.Sub(t1, t0)        // 2A^2 - 9B
	t1 = F.Mul(t1, e.A)       // A(2A^2 - 9B)
	t0 = F.Inv(F.Elt(27))     // 1/27
	B := F.Mul(t0, t1)        // A(2A^2 - 9B)/27
	return &wc2we{E0: e, E1: NewWeierstrass(Custom, F, A, B, e.params.R, e.params.H), Adiv3: Adiv3}
}
func (r *wc2we) Domain() EllCurve   { return r.E0 }
func (r *wc2we) Codomain() EllCurve { return r.E1 }
func (r *wc2we) Push(p Point) Point {
	if p.IsIdentity() {
		return r.E1.Identity()
	}
	P := p.(*ptWc)
	F := r.E0.Field()
	xx := F.Add(P.x, r.Adiv3)
	return r.E1.NewPoint(xx, P.y)
}
func (r *wc2we) Pull(p Point) Point {
	if p.IsIdentity() {
		return r.E0.Identity()
	}
	P := p.(*ptWe)
	F := r.E0.Field()
	xx := F.Sub(P.x, r.Adiv3)
	return r.E0.NewPoint(xx, P.y)
}

type te2mt25519 struct {
	E0       T
	E1       M
	invSqrtD GF.Elt // sqrt(-486664) such that sgn0(sqrt_neg_486664) == 1
}

// FromTe2Mt25519 returns the birational map between Edwards25519 and Curve25519 curves.
func FromTe2Mt25519() RationalMap {
	e0 := Edwards25519.Get()
	e1 := Curve25519.Get()
	F := e0.Field()
	return te2mt25519{
		E0:       e0.(T),
		E1:       e1.(M),
		invSqrtD: F.Elt("6853475219497561581579357271197624642482790079785650197046958215289687604742"),
	}
}
func (m te2mt25519) String() string     { return fmt.Sprintf("Rational Map from %v to\n%v", m.E0, m.E1) }
func (m te2mt25519) Domain() EllCurve   { return m.E0 }
func (m te2mt25519) Codomain() EllCurve { return m.E1 }
func (m te2mt25519) Push(p Point) Point {
	if p.IsIdentity() {
		return m.E1.Identity()
	}
	F := m.E0.Field()
	x0, y0, one := p.X(), p.Y(), F.One()
	t0 := F.Add(one, y0)       // 1+y
	t1 := F.Sub(one, y0)       // 1-y
	t1 = F.Inv(t1)             // 1/(1-y)
	xx := F.Mul(t0, t1)        // xx = (1+y)/(1-y)
	t0 = F.Inv(x0)             // 1/x
	t0 = F.Mul(t0, m.invSqrtD) // invSqrtD/x
	yy := F.Mul(t0, xx)        // yy = invSqrtD*xx/x
	return m.E1.NewPoint(xx, yy)
}
func (m te2mt25519) Pull(p Point) Point {
	if p.IsIdentity() {
		return m.E0.Identity()
	}
	F := m.E0.Field()
	if p.IsTwoTorsion() {
		return m.E0.NewPoint(F.Zero(), F.Elt(-1))
	}
	x0, y0, one := p.X(), p.Y(), F.One()
	t0 := F.Inv(y0)             // 1/y
	t0 = F.Mul(t0, x0)          // x/y
	xx := F.Mul(m.invSqrtD, t0) // xx = invSqrtD*x/y
	t0 = F.Add(x0, one)         // x+1
	t1 := F.Sub(x0, one)        // x-1
	t0 = F.Inv(t0)              // 1/(x+1)
	yy := F.Mul(t0, t1)         // yy = (x-1)/(x+1)
	return m.E0.NewPoint(xx, yy)
}

type te2mt4iso448 struct {
	E0 T
	E1 M
}

// FromTe2Mt4ISO448 returns the four-degree isogeny between Edwards448 and Curve448 curves.
func FromTe2Mt4ISO448() RationalMap       { return te2mt4iso448{Edwards448.Get().(T), Curve448.Get().(M)} }
func (m te2mt4iso448) String() string     { return fmt.Sprintf("4-Isogeny from %v to\n%v", m.E0, m.E1) }
func (m te2mt4iso448) Domain() EllCurve   { return m.E0 }
func (m te2mt4iso448) Codomain() EllCurve { return m.E1 }
func (m te2mt4iso448) Push(p Point) Point {
	if p.IsIdentity() {
		return m.E1.Identity()
	}
	F := m.E0.Field()
	x, y := p.X(), p.Y()
	t0 := F.Inv(x)           // 1/x
	t1 := F.Sqr(t0)          // 1/x^2
	t2 := F.Mul(t0, t1)      // 1/x^3
	t0 = F.Sqr(y)            // y^2
	xx := F.Mul(t0, t1)      // xx = y^2/x^2
	t0 = F.Sub(F.Elt(2), t0) // 2-y^2
	t1 = F.Sqr(x)            // x^2
	t0 = F.Sub(t0, t1)       // 2-y^2-x^2
	t0 = F.Mul(t0, y)        // (2-y^2-x^2)*y
	yy := F.Mul(t0, t2)      // (2-y^2-x^2)*y/x^3
	return m.E1.NewPoint(xx, yy)
}
func (m te2mt4iso448) Pull(p Point) Point {
	if p.IsIdentity() {
		return m.E0.Identity()
	}
	F := m.E0.Field()
	x, y, one := p.X(), p.Y(), F.One()

	t0 := F.Sqr(x)       // x^2
	t1 := F.Add(t0, one) // x^2+1
	t0 = F.Sub(t0, one)  // x^2-1
	t2 := F.Sqr(y)       // y^2
	t2 = F.Add(t2, t2)   // 2y^2
	t3 := F.Add(x, x)    // 2x

	t4 := F.Mul(t0, y)    // y(x^2-1)
	t4 = F.Add(t4, t4)    // 2y(x^2-1)
	xNum := F.Add(t4, t4) // xNum = 4y(x^2-1)

	t5 := F.Sqr(t0)       // x^4-2x^2+1
	t4 = F.Add(t5, t2)    // x^4-2x^2+1+2y^2
	xDen := F.Add(t4, t2) // xDen = x^4-2x^2+1+4y^2

	t5 = F.Mul(t5, x)     // x^5-2x^3+x
	t4 = F.Mul(t2, t3)    // 4xy^2
	yNum := F.Sub(t4, t5) // yNum = -(x^5-2x^3+x-4xy^2)

	t4 = F.Mul(t1, t2)    // 2x^2y^2+2y^2
	yDen := F.Sub(t5, t4) // yDen = x^5-2x^3+x-2x^2y^2-2y^2

	xx := F.Mul(xNum, F.Inv(xDen))
	yy := F.Mul(yNum, F.Inv(yDen))
	return m.E0.NewPoint(xx, yy)
}

type isosecp256k1 struct {
	E0, E1                 W
	xNum, xDen, yNum, yDen []GF.Elt
}

// GetSECP256K1Isogeny returns a 3-degree isogeny from SECP256K1_3ISO to the SECP256K1 elliptic curve.
func GetSECP256K1Isogeny() Isogeny {
	e0 := SECP256K1_3ISO.Get()
	e1 := SECP256K1.Get()
	F := e0.Field()
	return isosecp256k1{
		E0: e0.(W),
		E1: e1.(W),
		xNum: []GF.Elt{
			F.Elt("0x8e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38daaaaa8c7"),
			F.Elt("0x07d3d4c80bc321d5b9f315cea7fd44c5d595d2fc0bf63b92dfff1044f17c6581"),
			F.Elt("0x534c328d23f234e6e2a413deca25caece4506144037c40314ecbd0b53d9dd262"),
			F.Elt("0x8e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38daaaaa88c")},
		xDen: []GF.Elt{
			F.Elt("0xd35771193d94918a9ca34ccbb7b640dd86cd409542f8487d9fe6b745781eb49b"),
			F.Elt("0xedadc6f64383dc1df7c4b2d51b54225406d36b641f5e41bbc52a56612a8c6d14"),
			F.One(),
			F.Zero()},
		yNum: []GF.Elt{
			F.Elt("0x4bda12f684bda12f684bda12f684bda12f684bda12f684bda12f684b8e38e23c"),
			F.Elt("0xc75e0c32d5cb7c0fa9d0a54b12a0a6d5647ab046d686da6fdffc90fc201d71a3"),
			F.Elt("0x29a6194691f91a73715209ef6512e576722830a201be2018a765e85a9ecee931"),
			F.Elt("0x2f684bda12f684bda12f684bda12f684bda12f684bda12f684bda12f38e38d84")},
		yDen: []GF.Elt{
			F.Elt("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffff93b"),
			F.Elt("0x7a06534bb8bdb49fd5e9e6632722c2989467c1bfc8e8d978dfb425d2685c2573"),
			F.Elt("0x6484aa716545ca2cf3a70c3fa8fe337e0a3d21162f0d6299a7bf8192bfd2a76f"),
			F.One()},
	}
}
func (m isosecp256k1) String() string     { return fmt.Sprintf("3-Isogeny from %v to\n%v", m.E0, m.E1) }
func (m isosecp256k1) Domain() EllCurve   { return m.E0 }
func (m isosecp256k1) Codomain() EllCurve { return m.E1 }
func (m isosecp256k1) Push(p Point) Point {
	F := m.E0.F
	x, y := p.X(), p.Y()
	xNum, xDen, yNum, yDen := F.Zero(), F.Zero(), F.Zero(), F.Zero()
	for i := 3; i >= 0; i-- {
		xNum = F.Add(F.Mul(xNum, x), m.xNum[i])
		xDen = F.Add(F.Mul(xDen, x), m.xDen[i])
		yNum = F.Add(F.Mul(yNum, x), m.yNum[i])
		yDen = F.Add(F.Mul(yDen, x), m.yDen[i])
	}
	xx := F.Mul(xNum, F.Inv(xDen))
	yy := F.Mul(yNum, F.Inv(yDen))
	yy = F.Mul(yy, y)
	return m.E1.NewPoint(xx, yy)
}

type isobls12381G1 struct {
	E0, E1                 W
	xNum, xDen, yNum, yDen []GF.Elt
}

// GetSECP256K1Isogeny returns an 11-degree isogeny from BLS12381G1_11ISO to the BLS12381G1 elliptic curve.
func GetBLS12381G1Isogeny() Isogeny {
	e0 := BLS12381G1_11ISO.Get()
	e1 := BLS12381G1.Get()
	F := e0.Field()
	return isobls12381G1{
		E0: e0.(W),
		E1: e1.(W),
		xNum: []GF.Elt{
			F.Elt("0x11a05f2b1e833340b809101dd99815856b303e88a2d7005ff2627b56cdb4e2c85610c2d5f2e62d6eaeac1662734649b7"),
			F.Elt("0x17294ed3e943ab2f0588bab22147a81c7c17e75b2f6a8417f565e33c70d1e86b4838f2a6f318c356e834eef1b3cb83bb"),
			F.Elt("0xd54005db97678ec1d1048c5d10a9a1bce032473295983e56878e501ec68e25c958c3e3d2a09729fe0179f9dac9edcb0"),
			F.Elt("0x1778e7166fcc6db74e0609d307e55412d7f5e4656a8dbf25f1b33289f1b330835336e25ce3107193c5b388641d9b6861"),
			F.Elt("0xe99726a3199f4436642b4b3e4118e5499db995a1257fb3f086eeb65982fac18985a286f301e77c451154ce9ac8895d9"),
			F.Elt("0x1630c3250d7313ff01d1201bf7a74ab5db3cb17dd952799b9ed3ab9097e68f90a0870d2dcae73d19cd13c1c66f652983"),
			F.Elt("0xd6ed6553fe44d296a3726c38ae652bfb11586264f0f8ce19008e218f9c86b2a8da25128c1052ecaddd7f225a139ed84"),
			F.Elt("0x17b81e7701abdbe2e8743884d1117e53356de5ab275b4db1a682c62ef0f2753339b7c8f8c8f475af9ccb5618e3f0c88e"),
			F.Elt("0x80d3cf1f9a78fc47b90b33563be990dc43b756ce79f5574a2c596c928c5d1de4fa295f296b74e956d71986a8497e317"),
			F.Elt("0x169b1f8e1bcfa7c42e0c37515d138f22dd2ecb803a0c5c99676314baf4bb1b7fa3190b2edc0327797f241067be390c9e"),
			F.Elt("0x10321da079ce07e272d8ec09d2565b0dfa7dccdde6787f96d50af36003b14866f69b771f8c285decca67df3f1605fb7b"),
			F.Elt("0x6e08c248e260e70bd1e962381edee3d31d79d7e22c837bc23c0bf1bc24c6b68c24b1b80b64d391fa9c8ba2e8ba2d229")},
		xDen: []GF.Elt{
			F.Elt("0x8ca8d548cff19ae18b2e62f4bd3fa6f01d5ef4ba35b48ba9c9588617fc8ac62b558d681be343df8993cf9fa40d21b1c"),
			F.Elt("0x12561a5deb559c4348b4711298e536367041e8ca0cf0800c0126c2588c48bf5713daa8846cb026e9e5c8276ec82b3bff"),
			F.Elt("0xb2962fe57a3225e8137e629bff2991f6f89416f5a718cd1fca64e00b11aceacd6a3d0967c94fedcfcc239ba5cb83e19"),
			F.Elt("0x3425581a58ae2fec83aafef7c40eb545b08243f16b1655154cca8abc28d6fd04976d5243eecf5c4130de8938dc62cd8"),
			F.Elt("0x13a8e162022914a80a6f1d5f43e7a07dffdfc759a12062bb8d6b44e833b306da9bd29ba81f35781d539d395b3532a21e"),
			F.Elt("0xe7355f8e4e667b955390f7f0506c6e9395735e9ce9cad4d0a43bcef24b8982f7400d24bc4228f11c02df9a29f6304a5"),
			F.Elt("0x772caacf16936190f3e0c63e0596721570f5799af53a1894e2e073062aede9cea73b3538f0de06cec2574496ee84a3a"),
			F.Elt("0x14a7ac2a9d64a8b230b3f5b074cf01996e7f63c21bca68a81996e1cdf9822c580fa5b9489d11e2d311f7d99bbdcc5a5e"),
			F.Elt("0xa10ecf6ada54f825e920b3dafc7a3cce07f8d1d7161366b74100da67f39883503826692abba43704776ec3a79a1d641"),
			F.Elt("0x95fc13ab9e92ad4476d6e3eb3a56680f682b4ee96f7d03776df533978f31c1593174e4b4b7865002d6384d168ecdd0a"),
			F.One(),
			F.Zero()},
		yNum: []GF.Elt{
			F.Elt("0x90d97c81ba24ee0259d1f094980dcfa11ad138e48a869522b52af6c956543d3cd0c7aee9b3ba3c2be9845719707bb33"),
			F.Elt("0x134996a104ee5811d51036d776fb46831223e96c254f383d0f906343eb67ad34d6c56711962fa8bfe097e75a2e41c696"),
			F.Elt("0xcc786baa966e66f4a384c86a3b49942552e2d658a31ce2c344be4b91400da7d26d521628b00523b8dfe240c72de1f6"),
			F.Elt("0x1f86376e8981c217898751ad8746757d42aa7b90eeb791c09e4a3ec03251cf9de405aba9ec61deca6355c77b0e5f4cb"),
			F.Elt("0x8cc03fdefe0ff135caf4fe2a21529c4195536fbe3ce50b879833fd221351adc2ee7f8dc099040a841b6daecf2e8fedb"),
			F.Elt("0x16603fca40634b6a2211e11db8f0a6a074a7d0d4afadb7bd76505c3d3ad5544e203f6326c95a807299b23ab13633a5f0"),
			F.Elt("0x4ab0b9bcfac1bbcb2c977d027796b3ce75bb8ca2be184cb5231413c4d634f3747a87ac2460f415ec961f8855fe9d6f2"),
			F.Elt("0x987c8d5333ab86fde9926bd2ca6c674170a05bfe3bdd81ffd038da6c26c842642f64550fedfe935a15e4ca31870fb29"),
			F.Elt("0x9fc4018bd96684be88c9e221e4da1bb8f3abd16679dc26c1e8b6e6a1f20cabe69d65201c78607a360370e577bdba587"),
			F.Elt("0xe1bba7a1186bdb5223abde7ada14a23c42a0ca7915af6fe06985e7ed1e4d43b9b3f7055dd4eba6f2bafaaebca731c30"),
			F.Elt("0x19713e47937cd1be0dfd0b8f1d43fb93cd2fcbcb6caf493fd1183e416389e61031bf3a5cce3fbafce813711ad011c132"),
			F.Elt("0x18b46a908f36f6deb918c143fed2edcc523559b8aaf0c2462e6bfe7f911f643249d9cdf41b44d606ce07c8a4d0074d8e"),
			F.Elt("0xb182cac101b9399d155096004f53f447aa7b12a3426b08ec02710e807b4633f06c851c1919211f20d4c04f00b971ef8"),
			F.Elt("0x245a394ad1eca9b72fc00ae7be315dc757b3b080d4c158013e6632d3c40659cc6cf90ad1c232a6442d9d3f5db980133"),
			F.Elt("0x5c129645e44cf1102a159f748c4a3fc5e673d81d7e86568d9ab0f5d396a7ce46ba1049b6579afb7866b1e715475224b"),
			F.Elt("0x15e6be4e990f03ce4ea50b3b42df2eb5cb181d8f84965a3957add4fa95af01b2b665027efec01c7704b456be69c8b604")},
		yDen: []GF.Elt{
			F.Elt("0x16112c4c3a9c98b252181140fad0eae9601a6de578980be6eec3232b5be72e7a07f3688ef60c206d01479253b03663c1"),
			F.Elt("0x1962d75c2381201e1a0cbd6c43c348b885c84ff731c4d59ca4a10356f453e01f78a4260763529e3532f6102c2e49a03d"),
			F.Elt("0x58df3306640da276faaae7d6e8eb15778c4855551ae7f310c35a5dd279cd2eca6757cd636f96f891e2538b53dbf67f2"),
			F.Elt("0x16b7d288798e5395f20d23bf89edb4d1d115c5dbddbcd30e123da489e726af41727364f2c28297ada8d26d98445f5416"),
			F.Elt("0xbe0e079545f43e4b00cc912f8228ddcc6d19c9f0f69bbb0542eda0fc9dec916a20b15dc0fd2ededda39142311a5001d"),
			F.Elt("0x8d9e5297186db2d9fb266eaac783182b70152c65550d881c5ecd87b6f0f5a6449f38db9dfa9cce202c6477faaf9b7ac"),
			F.Elt("0x166007c08a99db2fc3ba8734ace9824b5eecfdfa8d0cf8ef5dd365bc400a0051d5fa9c01a58b1fb93d1a1399126a775c"),
			F.Elt("0x16a3ef08be3ea7ea03bcddfabba6ff6ee5a4375efa1f4fd7feb34fd206357132b920f5b00801dee460ee415a15812ed9"),
			F.Elt("0x1866c8ed336c61231a1be54fd1d74cc4f9fb0ce4c6af5920abc5750c4bf39b4852cfe2f7bb9248836b233d9d55535d4a"),
			F.Elt("0x167a55cda70a6e1cea820597d94a84903216f763e13d87bb5308592e7ea7d4fbc7385ea3d529b35e346ef48bb8913f55"),
			F.Elt("0x4d2f259eea405bd48f010a01ad2911d9c6dd039bb61a6290e591b36e636a5c871a5c29f4f83060400f8b49cba8f6aa8"),
			F.Elt("0xaccbb67481d033ff5852c1e48c50c477f94ff8aefce42d28c0f9a88cea7913516f968986f7ebbea9684b529e2561092"),
			F.Elt("0xad6b9514c767fe3c3613144b45f1496543346d98adf02267d5ceef9a00d9b8693000763e3b90ac11e99b138573345cc"),
			F.Elt("0x2660400eb2e4f3b628bdd0d53cd76f2bf565b94e72927c1cb748df27942480e420517bd8714cc80d1fadc1326ed06f7"),
			F.Elt("0xe0fa1d816ddc03e6b24255e0d7819c171c40f65e273b853324efcd6356caa205ca2f570f13497804415473a1d634b8f"),
			F.One()},
	}
}
func (m isobls12381G1) String() string     { return fmt.Sprintf("11-Isogeny from %v to\n%v", m.E0, m.E1) }
func (m isobls12381G1) Domain() EllCurve   { return m.E0 }
func (m isobls12381G1) Codomain() EllCurve { return m.E1 }
func (m isobls12381G1) Push(p Point) Point {
	F := m.E0.F
	x, y := p.X(), p.Y()
	xNum, xDen := F.Zero(), F.Zero()
	for i := len(m.xNum) - 1; i >= 0; i-- {
		xNum = F.Add(F.Mul(xNum, x), m.xNum[i])
		xDen = F.Add(F.Mul(xDen, x), m.xDen[i])
	}
	yNum, yDen := F.Zero(), F.Zero()
	for i := len(m.yNum) - 1; i >= 0; i-- {
		yNum = F.Add(F.Mul(yNum, x), m.yNum[i])
		yDen = F.Add(F.Mul(yDen, x), m.yDen[i])
	}
	xx := F.Mul(xNum, F.Inv(xDen))
	yy := F.Mul(yNum, F.Inv(yDen))
	yy = F.Mul(yy, y)
	return m.E1.NewPoint(xx, yy)
}

repository: armfazh/hash-to-curve-ref

repo_name: armfazh/hash-to-curve-ref


text:
// Copyright 2021 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "chromeos/services/libassistant/grpc/grpc_libassistant_client.h"

#include <memory>

#include "base/check.h"
#include "base/memory/scoped_refptr.h"
#include "base/notreached.h"
#include "base/threading/sequenced_task_runner_handle.h"
#include "chromeos/assistant/internal/libassistant_util.h"

namespace chromeos {
namespace libassistant {

namespace {

// Implements one async client method. ResponseCallback will be invoked from
// caller's sequence. The raw pointer will be handled by |RPCState| internally
// and gets deleted upon completion of the RPC call.
#define LIBAS_GRPC_CLIENT_METHOD(service, method)                             \
  void GrpcLibassistantClient::method(                                        \
      const ::assistant::api::method##Request& request,                       \
      chromeos::libassistant::ResponseCallback<                               \
          grpc::Status, ::assistant::api::method##Response> done,             \
      chromeos::libassistant::StateConfig state_config) {                     \
    new chromeos::libassistant::RPCState<::assistant::api::method##Response>( \
        channel_, client_thread_.completion_queue(),                          \
        chromeos::assistant::GetLibassistGrpcMethodName(service, #method),    \
        request, std::move(done),                                             \
        /*callback_task_runner=*/base::SequencedTaskRunnerHandle::Get(),      \
        state_config);                                                        \
  }

}  // namespace

GrpcLibassistantClient::GrpcLibassistantClient(
    std::shared_ptr<grpc::Channel> channel)
    : channel_(std::move(channel)), client_thread_("gRPCLibassistantClient") {
  DCHECK(channel_);
}

GrpcLibassistantClient::~GrpcLibassistantClient() = default;

LIBAS_GRPC_CLIENT_METHOD("CustomerRegistrationService", RegisterCustomer)

}  // namespace libassistant
}  // namespace chromeos

extension: cc


text:
% Encoding: UTF-8

@Book{banerjee2014hierarchical,
  title={Hierarchical modeling and analysis for spatial data},
  author={{Banerjee}, S and Carlin, Bradley P and Gelfand, Alan E},
  year={2014},
  publisher={Crc Press}
}

@InBook{broy:2002,
  title =     {Software engineering -- From auxiliary to key technologies},
  publisher = {Springer},
  author =    {Broy, M},
  editor =    {Broy, M. and E. Denert},
  booktitle = {Software Pioneers},
  date =      {2002},
  location =  {New York},
  url =       {http://oceancolor.gsfc.nasa.gov}
}

@Article{carr2006comparison,
  title={A comparison of global estimates of marine primary production from ocean color},
  author={Carr, Mary-Elena and Friedrichs, Marjorie AM and Schmeltz, Marjorie and Aita, Maki Noguchi and Antoine, David and Arrigo, Kevin R and Asanuma, Ichio and Aumont, Olivier and Barber, Richard and Behrenfeld, Michael and others},
  journal={Deep Sea Research Part II: Topical Studies in Oceanography},
  volume={53},
  number={5},
  pages={741--770},
  year={2006},
  publisher={Elsevier}
}

@Article{Caverhill:2015:modis,
  author =      {Caverhill, C. and H Maass and C. Porter and G White III and C. Fuentes-Yaco},
  title =       {MODIS/Aqua Ocean Colour Dataset, Remote Sensing Unit},
  journaltitle = {Bedford Institute of Oceanography RSU-BIO Technical Document},
  volume =      {5},
  date =        {2015}
}

@Article{Caverhill:2015:pp,
  author =      {Caverhill, C. and H Maass and C. Porter and G White III and C. Fuentes-Yaco},
  title =       {Primary Production Datasets, Remote Sensing Unit},
  journaltitle = {Bedford Institute of Oceanography RSU-BIO Technical Document},
  volume =      {2},
  date =        {2015}
}

@Article{Caverhill:2015:sst,
  author =      {Caverhill, C. and H Maass and C. Porter and G White III and C. Fuentes-Yaco},
  title =       {AVHRR Sea Surface Temperature (SST) Dataset, Remote Sensing Unit},
  journaltitle = {Bedford Institute of Oceanography RSU-BIO Technical Document},
  volume =      {1},
  date =        {2015}
}

@InBook{choi:2010,
  pages =     {361--376},
  title =     {Habitat Preferences of the Snow Crab, Chionoecetes opilio: Where Stock Assessment and Ecology Intersect},
  publisher = {Alaska Sea Grant, University of Alaska Fairbanks},
  author =    {{Choi}, Jae Seok},
  editor =    {Kruse, G.H. and G.L. Eckert and R.J. Foy and R.N. Lipcius and B. Sainte-Marie and D.L. Stram and D. Woodby },
  booktitle = {Biology and Management of Exploited Crab Populations under Climate Change},
  date =      {2010}
}

@Article{choi:2012:resdoc,
  author =      {{Choi}, Jae Seok and Zisserson, Ben and Cameron, Brent},
  title =       {Assessment of Scotian Shelf Snow Crab in 2011},
  journaltitle = {DFO Canadian Science Advisory Secretariat Research Document},
  volume =      {2012/024},
  date =        {2012}
}

@Article{ref:snowcrabAssessment2016,
  author =      {{Hubley}, Brad and Zisserson, Ben and Cameron, Brent and {Choi}, Jae Seok },
  title =       {Assessment of Scotian Shelf Snow Crab in 2016},
  journaltitle = {DFO Canadian Science Advisory Secretariat Research Document},
  volume =      {2017/XXX},
  date =        {2017}
}

@Article{coll:2012:mediterranean,
  author =       {Coll, Marta and Chiara Piroddi and Chemamille Albouy and Frida Ben Rais Lasram and William W L Cheung and Villy Christensen and Vasiliki S Karpouzi and Fran{\c{c}}ois Guilhaumon and David Mouillot and Michelle Paleczny and others},
  title =        {The Mediterranean Sea under siege: spatial overlap between marine biodiversity, cumulative threats and marine reserves},
  volume =       {21},
  number =       {4},
  pages =        {465--480},
  date =         {2012},
  journaltitle = {Global Ecology and Biogeography},
  publisher =    {Wiley Online Library}
}

@Article{constantine:1994,
  author =       {Constantine, A.G. and P. Hall},
  title =        {Characterizing surface smoothness via estimation of effective fractal dimension},
  volume =       {56},
  pages =        {97--113},
  date =         {1994},
  journaltitle = {Journal of the Royal Statistical Society, Series B (Statistical Methodology)},
}

@Article{cook2010food,
  author =       {{Cook}, A. M. and A. Bundy},
  title =        {The food habits database: an update, determination of sampling adequacy and estimation of diet for key species},
  volume =       {2884},
  pages =        {1--140},
  date =         {2010},
  journaltitle = {Canadian Technical Report of Fisheries and Aquatic Sciences}
}

@Article{cook2012use,
  author =       {{Cook}, A. M. and A. Bundy},
  title =        {Use of fishes as sampling tools for understanding biodiversity and ecosystem functioning in the ocean},
  volume =       {454},
  pages =        {1--18},
  date =         {2012},
  journaltitle = {Marine Ecology Progress Series},
  publisher =    {Inter-Research, Nordbuente 23 Oldendorf/Luhe 21385 Germany}
}

@article{darecki2004evaluation,
  title={An evaluation of MODIS and SeaWiFS bio-optical algorithms in the Baltic Sea},
  author={Darecki, Miroslaw and Stramski, Dariusz},
  journal={Remote sensing of Environment},
  volume={89},
  number={3},
  pages={326--350},
  year={2004},
  publisher={Elsevier}
}

@Article{DFO:2012:conservation,
  author =      {DFO},
  title =       {Conservation Priorities, Objectives, and Ecosystem Assessment Approach for the St. Anns Bank Area of Interest (AOI)},
  journaltitle = {DFO Canadian Science Advise Secretariat Science Advisory Report},
  volume =      {2012/034},
  date =        {2012}
}

@Article{DFO:2013:musquash,
  author =      {DFO},
  title =       {Review and Assessment of the Baseline Data for the Musquash Estuary Marine Protected Area Monitoring Indicators},
  journaltitle = {DFO Canadian Science Advise Secretariat Science Advisory Report},
  volume =      {2013/073},
  date =        {2013}
}

@Article{DFO:2014:biochem,
  author =      {Devine, L. and M.K. Kennedy and I. St-Pierre and C. Lafleur and M. Ouellet, and S. Bond},
  title =       {BioChem: the Fisheries and Oceans {Canada} database for biological and chemical data},
  journaltitle = {Canadian Technical Report of Fisheries and Aquatic Sciences},
  volume =      {3073},
  date =        {2014},
  pages =       {iv + 40 pp.}
}

@InBook{diggle:2007,
  booktitle =     {Model Based Geostatistics},
  publisher = {Springer},
  author =    {Diggle, P. J. and P. J. Jr. Ribeiro},
  date =      {2007},
  location =  {New York}
}

@Article{feldman:2015,
  title =     {Ocean Color Web},
  author =    {Feldman, G. C. and C. R. McClain},
  journaltitle = {MODIS Aqua Reprocessing},
  date =      {2015},
  editor =    {Kuring, N. and Bailey, S. W.},
  publisher = {NASA Goddard Space Flight Center},
  url =       {http://oceancolor.gsfc.nasa.gov},
  volume =    {2013.1}
}

@Article{finley:2007,
  title = {spBayes: An R package for univariate and multivariate hierarchical point-referenced spatial models},
  author = {Finley, A. O. and  S. Banerjee and  B. P. Carlin },
  year = {2007},
  journaltitle = {Journal of Statistical Software},
  volume = {19},
  number = {4},
  pages = {1-24}
}

@Article{Ford:2013:sab,
  author =      {Ford, Jennifer and Anna Serdynska},
  title =       {Ecological Overview of St Anns Bank},
  journaltitle = {Canadian Technical Report of Fisheries and Aquatic Sciences},
  volume =      {3023},
  date =        {2013}
}

@Article{gerritsen2013much,
  author =       {Gerritsen, Hans D and C{\'o}il{\'\i}n Minto and Colm Lordan},
  title =        {How much of the seabed is impacted by mobile fishing gear? Absolute estimates from Vessel Monitoring System (VMS) point data},
  pages =        {fst017, 1--9},
  date =         {2013},
  journaltitle = {ICES Journal of Marine Science: Journal du Conseil},
  publisher =    {Oxford University Press}
}

@Book{green:1979,
  title =     {Sampling design and statistical methods for environmental biologists},
  publisher = {Wiley Interscience, Chichester, England},
  author =    {Green, R.H.},
  date =      {1979}
}

@Article{guzman2013potential,
  author =       {Guzman, Hector M and Catalina G Gomez and Carlos A Guevara and Lars Kleivane},
  title =        {Potential vessel collisions with Southern Hemisphere humpback whales wintering off Pacific {Panama}},
  volume =       {29},
  number =       {4},
  pages =        {629--642},
  date =         {2013},
  journaltitle = {Marine Mammal Science}
}

@Article{hart1968formal,
  author =       {Hart, Peter E and Nils J Nilsson and Bertram Raphael},
  title =        {A formal basis for the heuristic determination of minimum cost paths},
  volume =       {4},
  number =       {2},
  pages =        {100--107},
  date =         {1968},
  journaltitle = {Systems Science and Cybernetics, IEEE Transactions},
  publisher =    {IEEE}
}

@Article{hatch2008characterizing,
  author =       {{Hatch}, {Leila T.} and Christopher Clark and Richard Merrick and Sofie Van Parijs and Dimitri Ponirakis and Kurt Schwehr and Michael Thompson and David Wiley},
  title =        {Characterizing the relative contributions of large vessels to total ocean noise fields: a case study using the Gerry E. Studds Stellwagen Bank National Marine Sanctuary},
  volume =       {42},
  number =       {5},
  pages =        {735--752},
  date =         {2008},
  journaltitle = {Environmental management}
}

@Article{hatch2012quantifying,
  author =       {{Hatch}, {Leila T.} and Christopher W Clark and Sofie M Van Parijs and Adam S Frankel and Dimitri W Ponirakis},
  title =        {Quantifying loss of acoustic communication space for right whales in and around a US National Marine Sanctuary},
  volume =       {26},
  number =       {6},
  pages =        {983--994},
  date =         {2012},
  journaltitle = {Conservation Biology}
}

@Article{hung2004decadal,
  title={Decadal oscillation of spring rain in northern Taiwan},
  author={Hung, Chih-wen and Hsu, Huang-Hsiung and Lu, Mong-Ming},
  journal={Geophysical Research Letters},
  volume={31},
  number={22},
  year={2004},
  publisher={Wiley Online Library}
}

@Article{hurlbert1984pseudoreplication,
  title={Pseudoreplication and the design of ecological field experiments},
  author={Hurlbert, Stuart H},
  journal={Ecological monographs},
  volume={54},
  number={2},
  pages={187--211},
  year={1984},
  publisher={Wiley Online Library}
}

@Article{Kenchington:2013:sab,
  author =      {Kenchington, Trevor J.},
  title =       {A Monitoring Framework for the St. Anns Bank Area of Interest},
  journaltitle = {Canadian Science Advisory Secretariat Research Document},
  volume =      {2013/117},
  date =        {2013},
}

@Article{lee2010developing,
  author =       {Lee, Janette and Andy B South and Simon Jennings},
  title =        {Developing reliable, repeatable, and accessible methods to provide high-resolution estimates of fishing-effort distributions from vessel monitoring system (VMS) data},
  pages =        {fsq010},
  date =         {2010},
  journaltitle = {ICES Journal of Marine Science: Journal du Conseil},
  publisher =    {Oxford University Press}
}

@Article{Lindgren:2011:spde,
  author =       {Lindgren, Finn and H{{\aa}}vard Rue and Johan Lindstr{\"{o}}m },
  title =        {An explicit link between {Gauss}ian fields and {Gauss}ian {Markov} random fields: the stochastic partial differential equation approach},
  volume =       {73},
  number =       {4},
  pages =        {423--498},
  date =         {2011},
  doi =          {10.1111/j.1467-9868.2011.00777.x},
  issn =         {1467-9868},
  journaltitle = {Journal of the Royal Statistical Society: Series B (Statistical Methodology)},
  keywords =     {Approximate Bayesian inference, Covariance functions, Gaussian fields, Gaussian Markov random fields, Latent Gaussian models, Sparse matrices, Stochastic partial differential equations},
  publisher =    {Blackwell Publishing Ltd}
}

@Book{lotka1925,
  title =     {Elements of Physical Biology},
  publisher = {Williams and Wilkins},
  author =    {Lotka, A.J.},
  date =      {1925},
  location =  {Baltimore},
  pages =     {495}
}

@Article{mckenna2012underwater,
  author =       {McKenna, Megan F. and Donald Ross and Sean M. Wiggins and John A. Hildebrand },
  title =        {Underwater radiated noise from modern commercial ships},
  volume =       {131},
  number =       {1},
  pages =        {92--103},
  date =         {2012},
  journaltitle = {The Journal of the Acoustical Society of America}
}

@Article{merchant2014monitoring,
  author = { {Merchant}, {Nathan D.} and Enrico Pirotta and Tim R. Barton and Paul M. Thompson},
  title =        {Monitoring ship noise to assess the impact of coastal developments on marine mammals},
  volume =       {78},
  number =       {1},
  pages =        {85--95},
  date =         {2014},
  journaltitle = {Marine pollution bulletin}
}

@Incollection{Mitchell:2002:azmp,
  author =      {Mitchell, M. R. and G. Harrison and K. Pauley and A. Gagn\'{e} and G. Maillet and P. Strain},
  title =       {Atlantic Zone Monitoring Program Sampling Protocol},
  series = {Canadian Technical Report of Hydrography and Ocean Sciences},
  number =      {223},
  date =        {2002}
}

@Article{moore2008impacts,
  title={Impacts of climate variability and future climate change on harmful algal blooms and human health},
  author={Moore, Stephanie K and Trainer, Vera L and Mantua, Nathan J and Parker, Micaela S and Laws, Edward A and Backer, Lorraine C and Fleming, Lora E},
  journal={Environmental Health},
  volume={7},
  number={2},
  pages={S4},
  year={2008},
  publisher={BioMed Central}
}

@Article{Munden:2017nets,
  author =      {{Munden}, J. and J. S. Choi},
  title =       {Calculating swept area for the Maritimes region trawl survey},
  journaltitle = {Canadian Technical Report of Fisheries and Aquatic Sciences},
  volume =      {nnnn},
  year =        {nnnn},
  note =        {in prep. }
}

@Article{ODMS,
  author = {ODMS, Oceanographic Data management System},
  year ={2016},
  title = {Quality control of bottle data, IML},
  journaltitle = {Canadian Technical Report of Hydrography and Ocean Sciences},
  volume = {2016-03-24},
  url = {http://slgo.ca/app-sgdo/en/docs_reference/botl_odf_quality.html}
}

@Article{platt1988,
  author =       {Platt, T. and S. Sathyendranath},
  title =        {Oceanic primary production: estimation by remote sensing at local and regional scales},
  volume =       {241},
  pages =        {1613--1620},
  date =         {1988},
  journaltitle = {Science}
}

@Article{platt2008,
  author =       {Platt, T. and S. Sathyendranath and M.-H. Forget and G.N. White III and C. Caverhill and H. Bouman and E. Devred and S. Son},
  title =        {Operational estimation of primary production at large geographical scales},
  volume =       {112},
  pages =        {3437--3448},
  date =         {2008},
  journaltitle = {Remote Sensing of Environment}
}

@Article{Plummer03jags,
  author = {Plummer, Martyn},
  title = {JAGS: A program for analysis of Bayesian graphical models using Gibbs sampling},
  year = {2003}
}
@Manual{rCran,
  title =        {R: A Language and Environment for Statistical Computing},
  author =       {{R~Core~Team}},
  organization = {R Foundation for Statistical Computing},
  date =         {2015},
  location =     {Vienna, Austria},
  url =          {https://www.R-project.org}
}

@Article{redfern2013assessing,
  author =       {Redfern, J V and M F McKenna and T J Moore and J Calambokidis and M L Deangelis and E A Becker and J Barlow and K A Forney and P C Fiedler and S J Chivers},
  title =        {Assessing the risk of ships striking large whales in marine spatial planning},
  volume =       {27},
  number =       {2},
  pages =        {292--302},
  date =         {2013},
  journaltitle = {Conservation Biology}
}

@Article{ribeiro:2001,
  author =       {Ribeiro, P. J. Jr. and P. J. Diggle},
  title =        {{geoR: }a package for geostatistical analysis},
  volume =       {1},
  number =       {2},
  pages =        {15--18},
  date =         {2001},
  journaltitle = {R-NEWS: June}
}

@Article{rinla:2015,
  author =       {Lindgren, Finn and H\aa{}vard Rue},
  title =        {{Bayes}ian Spatial Modelling with R-{INL}A},
  volume =       {63},
  number =       {1},
  pages =        {1--25},
  date =         {2015},
  doi =          {10.18637/jss.v063.i19},
  issn =         {1548-7660},
  journaltitle = {Journal of Statistical Software},
  url =          {https://www.jstatsoft.org/index.php/jss/Article/view/v063i19}
}

@Manual{rRaster,
  title =  {raster: Geographic analysis and modeling with raster data},
  author = {Robert J. Hijmans \& Jacob van Etten},
  note =   {R package version 2.0-12},
  date =   {2012},
  url =    {http://CRAN.R-project.org/package=raster}
}

@Article{Schepers:2002:fractals,
  author =       {Schepers, Hans E. and Johannes H.G.M. van Beek and James B. Bassingthwaighte},
  title =        {Four Methods to Estimate the Fractal Dimension from Self-Affine Signals},
  volume =       {11},
  pages =        {57--64},
  date =         {2002},
  journaltitle = {IEEE Eng Med Biol Mag.}
}

@Article{sigrist2015stochastic,
  title={Stochastic partial differential equation based modelling of large space--time data sets},
  author={Sigrist, Fabio and K{\"u}nsch, Hans R and Stahel, Werner A},
  journal={Journal of the Royal Statistical Society: Series B (Statistical Methodology)},
  volume={77},
  number={1},
  pages={3--33},
  year={2015},
  publisher={Wiley Online Library}
}
@Article{Simard2014shipping,
  author =       {Simard, Y and N. Roy and S. Giard and M Yayla},
  title =        {Canadian year-round shipping traffic atlas for 2013: Volume 1, East Coast marine waters},
  volume =       {3091},
  pages =        { 1-- 327 },
  date =         {2014},
  journaltitle = { Canadian Technical Report of Fisheries and Aquatic Sciences }
}

@Article{solna1996time,
  title={Time trend estimation for a geographic region},
  author={S{\o}lna, Knut and Switzer, Paul},
  journal={Journal of the American Statistical Association},
  volume={91},
  number={434},
  pages={577--589},
  year={1996},
  publisher={Taylor \& Francis}
}
@Article{tremblay2007distribution,
  author =       {Tremblay, Michael John and G A P Black and R M Branton },
  title =        {The distribution of common decapod crustaceans and other invertebrates recorded in annual ecosystem surveys of the Scotian Shelf 1999-2006},
  volume =       {2762},
  pages =        {1--74},
  date =         {2007},
  journaltitle = { Canadian Technical Report of Fisheries and Aquatic Sciences }
}

@Article{underwood1992,
  author =       {Underwood, A. J.},
  title =        {Beyond BACI: the detection of environmental impacts on populations in the real, but variable world},
  volume =       {161},
  pages =        {145--178},
  date =         {1992},
  journaltitle = {Journal of Experimental Marine Biology and Ecology}
}

@Article{Unesco:1990qaqc,
  author =      {Unesco},
  title =       {GTSPP real-time quality control manual},
  journaltitle = {Intergovernmental Oceanographic Commission, Manuals and Guides},
  volume =      {22},
  date =        {1990}
}

@Article{vanderlaan:2009:efficacy,
  author =       {Vanderlaan, Angelia SM and Christopher T Taggart },
  title =        {Efficacy of a voluntary area to be avoided to reduce risk of lethal vessel strikes to endangered whales},
  volume =       {23},
  number =       {6},
  pages =        {1467--1474},
  date =         {2009},
  journaltitle = {Conservation Biology}
}

@Article{wiley:2011:modeling,
  author =       {Wiley, David N and Michael Thompson and Richard M Pace and Jake Levenson},
  title =        {Modeling speed restrictions to mitigate lethal collisions between ships and whales in the Stellwagen Bank National Marine Sanctuary, {USA}},
  volume =       {144},
  number =       {9},
  pages =        {2377--2381},
  date =         {2011},
  journaltitle = {Biological Conservation}
}

@Article{wikle1999dimension,
  title={A dimension-reduced approach to space-time Kalman filtering},
  author={Wikle, Christopher K and Cressie, Noel},
  journal={Biometrika},
  pages={815--829},
  year={1999},
  publisher={JSTOR}
}

@Article{xu2005kernel,
  title={A kernel-based spatio-temporal dynamical model for nowcasting weather radar reflectivities},
  author={Xu, Ke and Wikle, Christopher K and Fox, Neil I},
  journal={Journal of the American Statistical Association},
  volume={100},
  number={472},
  pages={1133--1144},
  year={2005},
  publisher={Taylor \& Francis}
}

extension: bib


text:
SUMMARY = "asyncio-compatible timeout context manager"
HOMEPAGE = "https://github.com/aio-libs/multidict/"
SECTION = "devel/python"
LICENSE = "Apache-2.0"
LIC_FILES_CHKSUM = "file://LICENSE;md5=e3fc50a88d0a364313df4b21ef20c29e"

SRCNAME = "async_timeout"
S = "${WORKDIR}/${SRCNAME}-${PV}"

SRC_URI = "https://pypi.python.org/packages/c3/5b/d00e06296f5fe2c1db230f5f3f39538a4ae23c153adb1672e87e94137f89/${SRCNAME}-${PV}.tar.gz"
SRC_URI[md5sum] = "f8baef770792f04fa3d74e7d083c43e9"
SRC_URI[sha256sum] = "c7afd7355b93fca0aecc15811aa53eea57f6fd7307b5bff2336b01419ebeda36"

inherit setuptools3

repository: urnenfeld/meta-widde

repo_name: urnenfeld/meta-widde

gha_language: BitBake


text:
DESCRIPTION = "Gstreamer 1.0 pluggins good components"
LICENSE = "LGPLv2+"
LIC_FILES_CHKSUM = "file://${COREBASE}/meta/files/common-licenses/LGPL-2.0;md5=9427b8ccf5cf3df47c29110424c9641a"

PR = "r0"

PACKAGE_ARCH = "${TUNE_PKGARCH}"

inherit packagegroup

PACKAGES = "\
    packagegroup-gstreamer1-0-plugins-good \
    "

#---------------------------------------------------
# Information
# Possible configuration for version 1.4.5
#   x11: X libraries and plugins and extensions
#   pulseaudio: pulseaudio plug-in: pulseaudio
#   cairo: Cairo graphics rendering and gobject bindings: cairo
#   flac: FLAC lossless audio: flac
#   gdk-pixbuf: GDK pixbuf: gdkpixbuf
#   gudev:
#   jack: Jack: jack
#   jpeg: jpeg library
#   libpng: Portable Network Graphics library
#   soup: soup http client plugin (2.4): souphttpsrc
#   speex: speex speech codec: speex
#   taglib: taglib tagging library
#   vpx: VPX decoder
#   wavpack: wavpack plug-in
#   orc:

# Default configuration used:
# PACKAGECONFIG_pn-gstreamer1.0-plugins-good = " \
#    ${@bb.utils.contains('DISTRO_FEATURES', 'x11', 'x11', '', d)} \
#    ${@bb.utils.contains('DISTRO_FEATURES', 'pulseaudio', 'pulseaudio', '', d)} \
#    orc cairo flac gdk-pixbuf gudev jpeg libpng soup speex taglib \
#    "

# List of package generated (not complete):
#    1394: Source for video data via IEEE1394 interface
#    aasink: ASCII Art video sink
#    alaw: ALaw audio conversion routines
#    alpha: adds an alpha channel to video - constant or via chroma-keying
#    alphacolor: RGBA from/to AYUV colorspace conversion preserving the alpha channel
#    apetag: APEv1/2 tag reader
#    audiofx: Audio effects plugin
#    auparse: parses au streams
#    autodetect: Plugin contains auto-detection plugins for video/audio in- and outputs
#    avi: AVI stream handling
#    cacasink: Colored ASCII Art video sink
#    cairo: Cairo-based elements
#    cutter: Audio Cutter to split audio into non-silent bits
#    debug: elements for testing and debugging
#    deinterlace: Deinterlacer
#    directsound: DirectSound plugin
#    dtmf: DTMF plugins
#    dv: DV demuxer and decoder based on libdv (libdv.sf.net)
#    equalizer: GStreamer audio equalizers
#    effectv: effect plugins from the effectv project
#    flac: The FLAC Lossless compressor Codec
#    flv: FLV muxing and demuxing plugin
#    flxdec: FLC/FLI/FLX video decoder
#    gdkpixbuf: GdkPixbuf-based image decoder, overlay and sink
#    goom: GOOM visualization filter
#    goom2k1: GOOM 2k1 visualization filter
#    icydemux: Demux ICY tags from a stream
#    id3demux: Demux ID3v1 and ID3v2 tags from a file
#    imagefreeze: Still frame stream generator
#    interleave: Audio interleaver/deinterleaver
#    isomp4: ISO base media file format support (mp4, 3gpp, qt, mj2)
#    jack: JACK audio elements
#    jpeg: JPeg plugin library
#    level: Audio level plugin
#    matroska: Matroska and WebM stream handling
#    monoscope: Monoscope visualization
#    mulaw: MuLaw audio conversion routines
#    multifile: Reads/Writes buffers from/to sequentially named files
#    multipart: multipart stream manipulation
#    navigationtest: Template for a video filter
#    oss4: Open Sound System (OSS) version 4 support for GStreamer
#    ossaudio: OSS (Open Sound System) support for GStreamer
#    osxaudio: OSX (Mac OS X) audio support for GStreamer
#    osxvideo: OSX native video output plugin
#    png: PNG plugin library
#    pulseaudio: PulseAudio plugin library
#    replaygain: ReplayGain volume normalization
#    rtp: Real-time protocol plugins
#    rtpmanager: RTP session management plugin library
#    rtsp: transfer data via RTSP
#    shapewipe: Shape Wipe transition filter
#    shout2send: Sends data to an icecast server using libshout2
#    smpte: Apply the standard SMPTE transitions on video images
#    soup: libsoup HTTP client src/sink
#    spectrum: Run an FFT on the audio signal, output spectrum data
#    speex: Speex plugin library
#    taglib: Tag writing plug-in based on taglib
#    udp: transfer data via UDP
#    video4linux2: elements for Video 4 Linux
#    videobox: resizes a video by adding borders or cropping
#    videocrop: Crops video into a user-defined region
#    videofilter: Video filters plugin
#    videomixer: Video mixer
#    vpx: VP8 plugin
#    waveform: WaveForm API based plugin
#    wavenc: Encode raw audio into WAV
#    wavpack: Wavpack lossless/lossy audio format handling
#    wavparse: Parse a .wav file into raw audio
#    ximagesrc: X11 video input plugin using standard Xlib calls
#    y4menc: Encodes a YUV frame into the yuv4mpeg format (mjpegtools)

PROVIDES = "${PACKAGES}"

#The following list of package are sorted by:
# mandatory
# \
# selected by PACKAGECONFIG
# \
# others
RDEPENDS_packagegroup-gstreamer1-0-plugins-good = "\
    gstreamer1.0-plugins-good-meta \
    \
    gstreamer1.0-plugins-good-cairo \
    gstreamer1.0-plugins-good-flac \
    gstreamer1.0-plugins-good-jpeg \
    gstreamer1.0-plugins-good-png \
    gstreamer1.0-plugins-good-souphttpsrc \
    gstreamer1.0-plugins-good-taglib \
    \
    gstreamer1.0-plugins-good-audioparsers \
    gstreamer1.0-plugins-good-auparse \
    gstreamer1.0-plugins-good-autodetect \
    gstreamer1.0-plugins-good-avi \
    gstreamer1.0-plugins-good-deinterlace \
    gstreamer1.0-plugins-good-flv \
    gstreamer1.0-plugins-good-flxdec \
    gstreamer1.0-plugins-good-id3demux \
    gstreamer1.0-plugins-good-interleave \
    gstreamer1.0-plugins-good-isomp4 \
    gstreamer1.0-plugins-good-level \
    gstreamer1.0-plugins-good-matroska \
    gstreamer1.0-plugins-good-multifile \
    gstreamer1.0-plugins-good-multipart \
    gstreamer1.0-plugins-good-rtp \
    gstreamer1.0-plugins-good-rtpmanager \
    gstreamer1.0-plugins-good-rtsp \
    gstreamer1.0-plugins-good-udp \
    gstreamer1.0-plugins-good-video4linux2 \
    gstreamer1.0-plugins-good-videocrop \
    gstreamer1.0-plugins-good-videofilter \
    gstreamer1.0-plugins-good-videomixer \
    gstreamer1.0-plugins-good-wavenc \
    gstreamer1.0-plugins-good-wavparse \
"

repository: psivasubramanian/meta-lhg

repo_name: psivasubramanian/meta-lhg

gha_license_id: MIT


text:
DESCRIPTION = "Tiny XML Library"
LICENSE = "Apache-2.0"
LIC_FILES_CHKSUM = "file://LICENSE;md5=86d3f3a95c324c9479bd8986968f4327"
HOMEPAGE = "https://www.msweet.org/mxml/"
BUGTRACKER = "https://github.com/michaelrsweet/mxml/issues"

SRC_URI = "git://github.com/michaelrsweet/mxml.git"
SRCREV = "c7755b6992a2afdd34dde47fc9be97f1237cfded"
S = "${WORKDIR}/git"
# v3.0
PV = "3.0"

CONFIGUREOPTS = " --prefix=${prefix} \
                  --bindir=${bindir} \
                  --sbindir=${sbindir} \
                  --libexecdir=${libexecdir} \
                  --datadir=${datadir} \
                  --sysconfdir=${sysconfdir} \
                  --sharedstatedir=${sharedstatedir} \
                  --localstatedir=${localstatedir} \
                  --libdir=${libdir} \
                  --includedir=${includedir} \
                  --oldincludedir=${oldincludedir} \
                  --infodir=${infodir} \
                  --mandir=${mandir} \
                  --host=${TARGET_SYS} \
                  --build=${BUILD_SYS} \
                  ${PACKAGECONFIG_CONFARGS} \
                "

do_configure() {
    install -m 0755 ${STAGING_DATADIR_NATIVE}/gnu-config/config.guess ${S}
    install -m 0755 ${STAGING_DATADIR_NATIVE}/gnu-config/config.sub ${S}
    ./configure ${CONFIGUREOPTS} --enable-shared
}

do_install () {
    export DSTROOT=${D}
    oe_runmake install
}

PACKAGES += " ${PN}-bin "
FILES_${PN} = "${libdir}/*"
FILES_${PN}-bin = "${bindir}/*"

repository: eigendude/meta-openembedded

repo_name: eigendude/meta-openembedded

branch_name: refs/heads/warrior