text:
#ifndef IP_TYPES_INCLUDED
#define IP_TYPES_INCLUDED

#include <winapifamily.h>
#if WINAPI_FAMILY_PARTITION (WINAPI_PARTITION_DESKTOP) || _WIN32_WINNT >= 0x0A00

#ifdef __cplusplus
extern "C" {
#endif

#include <time.h>
#include <ifdef.h>
#include <nldef.h>

#define MAX_ADAPTER_DESCRIPTION_LENGTH 128
#define MAX_ADAPTER_NAME_LENGTH 256
#define MAX_ADAPTER_ADDRESS_LENGTH 8
#define DEFAULT_MINIMUM_ENTITIES 32
#define MAX_HOSTNAME_LEN 128
#define MAX_DOMAIN_NAME_LEN 128
#define MAX_SCOPE_ID_LEN 256
#define MAX_DHCPV6_DUID_LENGTH 130
#define MAX_DNS_SUFFIX_STRING_LENGTH 256

#define BROADCAST_NODETYPE 1
#define PEER_TO_PEER_NODETYPE 2
#define MIXED_NODETYPE 4
#define HYBRID_NODETYPE 8

  typedef struct {
    char String[4*4];
  } IP_ADDRESS_STRING,*PIP_ADDRESS_STRING,IP_MASK_STRING,*PIP_MASK_STRING;

  typedef struct _IP_ADDR_STRING {
    struct _IP_ADDR_STRING *Next;
    IP_ADDRESS_STRING IpAddress;
    IP_MASK_STRING IpMask;
    DWORD Context;
  } IP_ADDR_STRING,*PIP_ADDR_STRING;

  typedef struct _IP_ADAPTER_INFO {
    struct _IP_ADAPTER_INFO *Next;
    DWORD ComboIndex;
    char AdapterName[MAX_ADAPTER_NAME_LENGTH + 4];
    char Description[MAX_ADAPTER_DESCRIPTION_LENGTH + 4];
    UINT AddressLength;
    BYTE Address[MAX_ADAPTER_ADDRESS_LENGTH];
    DWORD Index;
    UINT Type;
    UINT DhcpEnabled;
    PIP_ADDR_STRING CurrentIpAddress;
    IP_ADDR_STRING IpAddressList;
    IP_ADDR_STRING GatewayList;
    IP_ADDR_STRING DhcpServer;
    WINBOOL HaveWins;
    IP_ADDR_STRING PrimaryWinsServer;
    IP_ADDR_STRING SecondaryWinsServer;
    time_t LeaseObtained;
    time_t LeaseExpires;
  } IP_ADAPTER_INFO,*PIP_ADAPTER_INFO;

#ifdef _WINSOCK2API_

  typedef NL_PREFIX_ORIGIN IP_PREFIX_ORIGIN;
  typedef NL_SUFFIX_ORIGIN IP_SUFFIX_ORIGIN;
  typedef NL_DAD_STATE IP_DAD_STATE;

  typedef struct _IP_ADAPTER_UNICAST_ADDRESS_XP {
    __C89_NAMELESS union {
      ULONGLONG Alignment;
      __C89_NAMELESS struct {
	ULONG Length;
	DWORD Flags;
      };
    };
    struct _IP_ADAPTER_UNICAST_ADDRESS_XP *Next;
    SOCKET_ADDRESS Address;
    IP_PREFIX_ORIGIN PrefixOrigin;
    IP_SUFFIX_ORIGIN SuffixOrigin;
    IP_DAD_STATE DadState;
    ULONG ValidLifetime;
    ULONG PreferredLifetime;
    ULONG LeaseLifetime;
  } IP_ADAPTER_UNICAST_ADDRESS_XP,*PIP_ADAPTER_UNICAST_ADDRESS_XP;

  typedef struct _IP_ADAPTER_UNICAST_ADDRESS_LH {
    __C89_NAMELESS union {
      ULONGLONG Alignment;
      __C89_NAMELESS struct {
	ULONG Length;
	DWORD Flags;
      };
    };
    struct _IP_ADAPTER_UNICAST_ADDRESS_LH *Next;
    SOCKET_ADDRESS Address;
    IP_PREFIX_ORIGIN PrefixOrigin;
    IP_SUFFIX_ORIGIN SuffixOrigin;
    IP_DAD_STATE DadState;
    ULONG ValidLifetime;
    ULONG PreferredLifetime;
    ULONG LeaseLifetime;
    UINT8 OnLinkPrefixLength;
  } IP_ADAPTER_UNICAST_ADDRESS_LH,*PIP_ADAPTER_UNICAST_ADDRESS_LH;

#if (_WIN32_WINNT >= 0x0600)
  typedef IP_ADAPTER_UNICAST_ADDRESS_LH   IP_ADAPTER_UNICAST_ADDRESS;
  typedef IP_ADAPTER_UNICAST_ADDRESS_LH *PIP_ADAPTER_UNICAST_ADDRESS;
#else /* _WIN32_WINNT >= 0x0501 */
  typedef IP_ADAPTER_UNICAST_ADDRESS_XP   IP_ADAPTER_UNICAST_ADDRESS;
  typedef IP_ADAPTER_UNICAST_ADDRESS_XP *PIP_ADAPTER_UNICAST_ADDRESS;
#endif

  typedef struct _IP_ADAPTER_ANYCAST_ADDRESS_XP {
    __C89_NAMELESS union {
      ULONGLONG Alignment;
      __C89_NAMELESS struct {
	ULONG Length;
	DWORD Flags;
      };
    };
    struct _IP_ADAPTER_ANYCAST_ADDRESS_XP *Next;
    SOCKET_ADDRESS Address;
  } IP_ADAPTER_ANYCAST_ADDRESS_XP,*PIP_ADAPTER_ANYCAST_ADDRESS_XP;
  typedef IP_ADAPTER_ANYCAST_ADDRESS_XP   IP_ADAPTER_ANYCAST_ADDRESS;
  typedef IP_ADAPTER_ANYCAST_ADDRESS_XP *PIP_ADAPTER_ANYCAST_ADDRESS;

  typedef struct _IP_ADAPTER_MULTICAST_ADDRESS_XP {
    __C89_NAMELESS union {
      ULONGLONG Alignment;
      __C89_NAMELESS struct {
	ULONG Length;
	DWORD Flags;
      };
    };
    struct _IP_ADAPTER_MULTICAST_ADDRESS_XP *Next;
    SOCKET_ADDRESS Address;
  } IP_ADAPTER_MULTICAST_ADDRESS_XP,*PIP_ADAPTER_MULTICAST_ADDRESS_XP;
  typedef IP_ADAPTER_MULTICAST_ADDRESS_XP   IP_ADAPTER_MULTICAST_ADDRESS;
  typedef IP_ADAPTER_MULTICAST_ADDRESS_XP *PIP_ADAPTER_MULTICAST_ADDRESS;

#define IP_ADAPTER_ADDRESS_DNS_ELIGIBLE 0x01
#define IP_ADAPTER_ADDRESS_TRANSIENT 0x02
#define IP_ADAPTER_ADDRESS_PRIMARY 0x04

  typedef struct _IP_ADAPTER_DNS_SERVER_ADDRESS_XP {
    __C89_NAMELESS union {
      ULONGLONG Alignment;
      __C89_NAMELESS struct {
	ULONG Length;
	DWORD Reserved;
      };
    };
    struct _IP_ADAPTER_DNS_SERVER_ADDRESS_XP *Next;
    SOCKET_ADDRESS Address;
  } IP_ADAPTER_DNS_SERVER_ADDRESS_XP,*PIP_ADAPTER_DNS_SERVER_ADDRESS_XP;
  typedef IP_ADAPTER_DNS_SERVER_ADDRESS_XP   IP_ADAPTER_DNS_SERVER_ADDRESS;
  typedef IP_ADAPTER_DNS_SERVER_ADDRESS_XP *PIP_ADAPTER_DNS_SERVER_ADDRESS;

  typedef struct _IP_ADAPTER_PREFIX_XP {
    __C89_NAMELESS union {
      ULONGLONG Alignment;
      __C89_NAMELESS struct {
	ULONG Length;
	DWORD Flags;
      };
    };
    struct _IP_ADAPTER_PREFIX_XP *Next;
    SOCKET_ADDRESS Address;
    ULONG PrefixLength;
  } IP_ADAPTER_PREFIX_XP,*PIP_ADAPTER_PREFIX_XP;
  typedef IP_ADAPTER_PREFIX_XP   IP_ADAPTER_PREFIX;
  typedef IP_ADAPTER_PREFIX_XP *PIP_ADAPTER_PREFIX;

  typedef struct _IP_ADAPTER_WINS_SERVER_ADDRESS_LH {
    __C89_NAMELESS union {
      ULONGLONG Alignment;
      __C89_NAMELESS struct {
	ULONG Length;
	DWORD Reserved;
      };
    };
    struct _IP_ADAPTER_WINS_SERVER_ADDRESS_LH *Next;
    SOCKET_ADDRESS Address;
  } IP_ADAPTER_WINS_SERVER_ADDRESS_LH,*PIP_ADAPTER_WINS_SERVER_ADDRESS_LH;
#if (_WIN32_WINNT >= 0x0600)
  typedef IP_ADAPTER_WINS_SERVER_ADDRESS_LH   IP_ADAPTER_WINS_SERVER_ADDRESS;
  typedef IP_ADAPTER_WINS_SERVER_ADDRESS_LH *PIP_ADAPTER_WINS_SERVER_ADDRESS;
#endif

  typedef struct _IP_ADAPTER_GATEWAY_ADDRESS_LH {
    __C89_NAMELESS union {
      ULONGLONG Alignment;
      __C89_NAMELESS struct {
	ULONG Length;
	DWORD Reserved;
      };
    };
    struct _IP_ADAPTER_GATEWAY_ADDRESS_LH *Next;
    SOCKET_ADDRESS Address;
  } IP_ADAPTER_GATEWAY_ADDRESS_LH,*PIP_ADAPTER_GATEWAY_ADDRESS_LH;
#if (_WIN32_WINNT >= 0x0600)
  typedef IP_ADAPTER_GATEWAY_ADDRESS_LH   IP_ADAPTER_GATEWAY_ADDRESS;
  typedef IP_ADAPTER_GATEWAY_ADDRESS_LH *PIP_ADAPTER_GATEWAY_ADDRESS;
#endif

  typedef struct _IP_ADAPTER_DNS_SUFFIX {
    struct _IP_ADAPTER_DNS_SUFFIX *Next;
    WCHAR String[MAX_DNS_SUFFIX_STRING_LENGTH];
  } IP_ADAPTER_DNS_SUFFIX, *PIP_ADAPTER_DNS_SUFFIX;

#define IP_ADAPTER_DDNS_ENABLED 0x01
#define IP_ADAPTER_REGISTER_ADAPTER_SUFFIX 0x02
#define IP_ADAPTER_DHCP_ENABLED 0x04
#define IP_ADAPTER_RECEIVE_ONLY 0x08
#define IP_ADAPTER_NO_MULTICAST 0x10
#define IP_ADAPTER_IPV6_OTHER_STATEFUL_CONFIG 0x20
#define IP_ADAPTER_NETBIOS_OVER_TCPIP_ENABLED 0x40
#define IP_ADAPTER_IPV4_ENABLED 0x80
#define IP_ADAPTER_IPV6_ENABLED 0x100
#define IP_ADAPTER_IPV6_MANAGE_ADDRESS_CONFIG 0x200

  typedef struct _IP_ADAPTER_ADDRESSES_LH {
    __C89_NAMELESS union {
      ULONGLONG   Alignment;
      __C89_NAMELESS struct {
	ULONG Length;
	IF_INDEX IfIndex;
      };
    };
    struct _IP_ADAPTER_ADDRESSES_LH *Next;
    PCHAR AdapterName;
    PIP_ADAPTER_UNICAST_ADDRESS_LH    FirstUnicastAddress;
    PIP_ADAPTER_ANYCAST_ADDRESS_XP    FirstAnycastAddress;
    PIP_ADAPTER_MULTICAST_ADDRESS_XP  FirstMulticastAddress;
    PIP_ADAPTER_DNS_SERVER_ADDRESS_XP FirstDnsServerAddress;
    PWCHAR DnsSuffix;
    PWCHAR Description;
    PWCHAR FriendlyName;
    BYTE PhysicalAddress[MAX_ADAPTER_ADDRESS_LENGTH];
    ULONG PhysicalAddressLength;
    __C89_NAMELESS union {
      ULONG Flags;
      __C89_NAMELESS struct {
	ULONG DdnsEnabled : 1;
	ULONG RegisterAdapterSuffix : 1;
	ULONG Dhcpv4Enabled : 1;
	ULONG ReceiveOnly : 1;
	ULONG NoMulticast : 1;
	ULONG Ipv6OtherStatefulConfig : 1;
	ULONG NetbiosOverTcpipEnabled : 1;
	ULONG Ipv4Enabled : 1;
	ULONG Ipv6Enabled : 1;
	ULONG Ipv6ManagedAddressConfigurationSupported : 1;
      };
    };
    ULONG Mtu;
    IFTYPE IfType;
    IF_OPER_STATUS OperStatus;
    IF_INDEX Ipv6IfIndex;
    ULONG ZoneIndices[16];
    PIP_ADAPTER_PREFIX_XP FirstPrefix;

    ULONG64 TransmitLinkSpeed;
    ULONG64 ReceiveLinkSpeed;
    PIP_ADAPTER_WINS_SERVER_ADDRESS_LH FirstWinsServerAddress;
    PIP_ADAPTER_GATEWAY_ADDRESS_LH     FirstGatewayAddress;
    ULONG Ipv4Metric;
    ULONG Ipv6Metric;
    IF_LUID Luid;
    SOCKET_ADDRESS Dhcpv4Server;
    NET_IF_COMPARTMENT_ID CompartmentId;
    NET_IF_NETWORK_GUID NetworkGuid;
    NET_IF_CONNECTION_TYPE ConnectionType;
    TUNNEL_TYPE TunnelType;

    SOCKET_ADDRESS Dhcpv6Server;
    BYTE Dhcpv6ClientDuid[MAX_DHCPV6_DUID_LENGTH];
    ULONG Dhcpv6ClientDuidLength;
    ULONG Dhcpv6Iaid;
#if (NTDDI_VERSION >= 0x06000100) /* NTDDI_VISTASP1 */
    PIP_ADAPTER_DNS_SUFFIX FirstDnsSuffix;
#endif
  } IP_ADAPTER_ADDRESSES_LH, *PIP_ADAPTER_ADDRESSES_LH;

  typedef struct _IP_ADAPTER_ADDRESSES_XP {
    __C89_NAMELESS union {
      ULONGLONG Alignment;
      __C89_NAMELESS struct {
	ULONG Length;
	DWORD IfIndex;
      };
    };
    struct _IP_ADAPTER_ADDRESSES_XP *Next;
    PCHAR AdapterName;
    PIP_ADAPTER_UNICAST_ADDRESS_XP    FirstUnicastAddress;
    PIP_ADAPTER_ANYCAST_ADDRESS_XP    FirstAnycastAddress;
    PIP_ADAPTER_MULTICAST_ADDRESS_XP  FirstMulticastAddress;
    PIP_ADAPTER_DNS_SERVER_ADDRESS_XP FirstDnsServerAddress;
    PWCHAR DnsSuffix;
    PWCHAR Description;
    PWCHAR FriendlyName;
    BYTE PhysicalAddress[MAX_ADAPTER_ADDRESS_LENGTH];
    DWORD PhysicalAddressLength;
    DWORD Flags;
    DWORD Mtu;
    DWORD IfType;
    IF_OPER_STATUS OperStatus;
    DWORD Ipv6IfIndex;
    DWORD ZoneIndices[16];
    PIP_ADAPTER_PREFIX_XP FirstPrefix;
  } IP_ADAPTER_ADDRESSES_XP,*PIP_ADAPTER_ADDRESSES_XP;

#if (_WIN32_WINNT >= 0x0600)
  typedef IP_ADAPTER_ADDRESSES_LH   IP_ADAPTER_ADDRESSES;
  typedef IP_ADAPTER_ADDRESSES_LH *PIP_ADAPTER_ADDRESSES;
#else /* _WIN32_WINNT >= 0x0501 */
  typedef IP_ADAPTER_ADDRESSES_XP   IP_ADAPTER_ADDRESSES;
  typedef IP_ADAPTER_ADDRESSES_XP *PIP_ADAPTER_ADDRESSES;
#endif

#define GAA_FLAG_SKIP_UNICAST 0x0001
#define GAA_FLAG_SKIP_ANYCAST 0x0002
#define GAA_FLAG_SKIP_MULTICAST 0x0004
#define GAA_FLAG_SKIP_DNS_SERVER 0x0008
#define GAA_FLAG_INCLUDE_PREFIX 0x0010
#define GAA_FLAG_SKIP_FRIENDLY_NAME 0x0020
#define GAA_FLAG_INCLUDE_WINS_INFO 0x0040
#define GAA_FLAG_INCLUDE_GATEWAYS 0x0080
#define GAA_FLAG_INCLUDE_ALL_INTERFACES 0x0100
#define GAA_FLAG_INCLUDE_ALL_COMPARTMENTS 0x0200
#define GAA_FLAG_INCLUDE_TUNNEL_BINDINGORDER 0x0400
#endif /* _WINSOCK2API_ */

  typedef struct _IP_PER_ADAPTER_INFO {
    UINT AutoconfigEnabled;
    UINT AutoconfigActive;
    PIP_ADDR_STRING CurrentDnsServer;
    IP_ADDR_STRING DnsServerList;
  } IP_PER_ADAPTER_INFO,*PIP_PER_ADAPTER_INFO;

  typedef struct {
    char HostName[MAX_HOSTNAME_LEN + 4];
    char DomainName[MAX_DOMAIN_NAME_LEN + 4];
    PIP_ADDR_STRING CurrentDnsServer;
    IP_ADDR_STRING DnsServerList;
    UINT NodeType;
    char ScopeId[MAX_SCOPE_ID_LEN + 4];
    UINT EnableRouting;
    UINT EnableProxy;
    UINT EnableDns;
  } FIXED_INFO,*PFIXED_INFO;

#ifndef IP_INTERFACE_NAME_INFO_DEFINED
#define IP_INTERFACE_NAME_INFO_DEFINED

  typedef struct ip_interface_name_info {
    ULONG Index;
    ULONG MediaType;
    UCHAR ConnectionType;
    UCHAR AccessType;
    GUID DeviceGuid;
    GUID InterfaceGuid;
  } IP_INTERFACE_NAME_INFO,*PIP_INTERFACE_NAME_INFO;
#endif

#ifdef __cplusplus
}
#endif

#endif /* #if WINAPI_FAMILY_PARTITION (WINAPI_PARTITION_DESKTOP) || _WIN32_WINNT >= 0x0A00 */

#endif /* IP_TYPES_INCLUDED */


text:
<resources>

    <style name="mi_AppTheme"
        parent="Theme.AppCompat.Light.NoActionBar">
        <item name="colorPrimary">@color/mi_primary</item>
        <item name="colorPrimaryDark">@color/mi_primary_dark</item>
        <item name="colorAccent">@color/mi_accent</item>
    </style>

    <style name="mi_BlueAppTheme"
        parent="Theme.AppCompat.Light.NoActionBar">
        <item name="colorPrimary">@color/mi_bat_primary</item>
        <item name="colorPrimaryDark">@color/mi_bat_primary_dark</item>
        <item name="colorAccent">@color/mi_bat_accent</item>
    </style>

</resources>

redpajama_set_name: RedPajamaGithub


text:
<?php

namespace WellCommerce\Component\Form\Elements\Optioned;

use WellCommerce\Component\Form\Elements\ElementInterface;

/**
 * Interface OptionedFieldInterface
 *
 * @author  Adam Piotrowski <adam@wellcommerce.org>
 */
interface OptionedFieldInterface extends ElementInterface
{
    /**
     * Adds new option to select
     *
     * @param $value
     * @param $label
     */
    public function addOptionToSelect($value, $label);
}


text:
var publicApi = require('./publicApi/public.js')

var routes = [].concat(publicApi);

//pubblica un unico array di routes, per darlo in pasto a index.js
module.exports = routes;


text:
@import settings.Helpers._
@import helper._
@import play.api.Play.current

@(loginForm: Form[LoginData])(implicit message: RequestHeader, messages: Messages, lang: Lang)

@form(action = routes.Api.login, args = 'class -> "form-horizontal", 'role -> "form", 'id -> "loginForm") {
@CSRF.formField

        @inputText(loginForm("email"),
        args = 'class -> "form-control",
        'id -> "emailLogin",
        'placeholder -> messages("form.email"),
        'type -> "email")

        @inputPassword(loginForm("password"),
        args = 'class -> "form-control",
        'id -> "passwordLogin",
        'placeholder -> messages("form.password"))

            @messages("form.forgetPassword")

        <button type="button" id="loginButton" class="btn btn-black">@messages("button.login")</button>

}


text:
namespace blink {

const char* V8AnyCallbackFunctionVariadicAnyArgs::NameInHeapSnapshot() const {
  return "V8AnyCallbackFunctionVariadicAnyArgs";
}

v8::Maybe<ScriptValue> V8AnyCallbackFunctionVariadicAnyArgs::Invoke(bindings::V8ValueOrScriptWrappableAdapter callback_this_value, const HeapVector<ScriptValue>& arguments) {
  ScriptState* callback_relevant_script_state =
      CallbackRelevantScriptStateOrThrowException(
          "AnyCallbackFunctionVariadicAnyArgs",
          "invoke");
  if (!callback_relevant_script_state) {
    return v8::Nothing<ScriptValue>();
  }

  if (!IsCallbackFunctionRunnable(callback_relevant_script_state,
                                  IncumbentScriptState())) {
    // Wrapper-tracing for the callback function makes the function object and
    // its creation context alive. Thus it's safe to use the creation context
    // of the callback function here.
    v8::HandleScope handle_scope(GetIsolate());
    v8::Local<v8::Object> callback_object = CallbackObject();
    CHECK(!callback_object.IsEmpty());
    v8::Context::Scope context_scope(callback_object->CreationContext());
    V8ThrowException::ThrowError(
        GetIsolate(),
        ExceptionMessages::FailedToExecute(
            "invoke",
            "AnyCallbackFunctionVariadicAnyArgs",
            "The provided callback is no longer runnable."));
    return v8::Nothing<ScriptValue>();
  }

  // step: Prepare to run script with relevant settings.
  ScriptState::Scope callback_relevant_context_scope(
      callback_relevant_script_state);
  // step: Prepare to run a callback with stored settings.
  v8::Context::BackupIncumbentScope backup_incumbent_scope(
      IncumbentScriptState()->GetContext());

  if (UNLIKELY(ScriptForbiddenScope::IsScriptForbidden())) {
    ScriptForbiddenScope::ThrowScriptForbiddenException(GetIsolate());
    return v8::Nothing<ScriptValue>();
  }

  v8::Local<v8::Function> function;
  // callback function's invoke:
  // step 4. If ! IsCallable(F) is false:
  //
  // No [TreatNonObjectAsNull] presents.  Must be always callable.
  DCHECK(CallbackObject()->IsFunction());
  function = CallbackFunction();

  v8::Local<v8::Value> this_arg;
  if (callback_this_value.IsEmpty()) {
    // step 2. If thisArg was not given, let thisArg be undefined.
    this_arg = v8::Undefined(GetIsolate());
  } else {
    this_arg = callback_this_value.V8Value(callback_relevant_script_state);
  }

  // step: Let esArgs be the result of converting args to an ECMAScript
  //   arguments list. If this throws an exception, set completion to the
  //   completion value representing the thrown exception and jump to the step
  //   labeled return.
  v8::Local<v8::Object> argument_creation_context =
      callback_relevant_script_state->GetContext()->Global();
  ALLOW_UNUSED_LOCAL(argument_creation_context);
  // Secure one element at least in |argv| to avoid the following restriction.
  //
  // C++14 8.3.4 Arrays
  // If the constant-expression (5.19) is present, it shall be a converted
  // constant expression of type std::size_t and its value shall be greater than
  // zero.
  const int argc = 0 + arguments.size();
  v8::Local<v8::Value> argv[std::max(1, argc)];
  for (wtf_size_t i = 0; i < arguments.size(); ++i) {
    argv[0 + i] = ToV8(arguments[i], argument_creation_context, GetIsolate());
  }

  v8::Local<v8::Value> call_result;
  // step: Let callResult be Call(X, thisArg, esArgs).
  if (!V8ScriptRunner::CallFunction(
          function,
          ExecutionContext::From(callback_relevant_script_state),
          this_arg,
          argc,
          argv,
          GetIsolate()).ToLocal(&call_result)) {
    // step: If callResult is an abrupt completion, set completion to callResult
    //   and jump to the step labeled return.
    return v8::Nothing<ScriptValue>();
  }

  // step: Set completion to the result of converting callResult.[[Value]] to
  //   an IDL value of the same type as the operation's return type.
  {
    ExceptionState exception_state(GetIsolate(),
                                   ExceptionState::kExecutionContext,
                                   "AnyCallbackFunctionVariadicAnyArgs",
                                   "invoke");
    auto native_result =
        NativeValueTraits<ScriptValue>::NativeValue(
            GetIsolate(), call_result, exception_state);
    if (exception_state.HadException())
      return v8::Nothing<ScriptValue>();
    else
      return v8::Just<ScriptValue>(native_result);
  }
}

v8::Maybe<ScriptValue> V8AnyCallbackFunctionVariadicAnyArgs::Construct(const HeapVector<ScriptValue>& arguments) {
  ScriptState* callback_relevant_script_state =
      CallbackRelevantScriptStateOrThrowException(
          "AnyCallbackFunctionVariadicAnyArgs",
          "construct");
  if (!callback_relevant_script_state) {
    return v8::Nothing<ScriptValue>();
  }

  if (!IsCallbackFunctionRunnable(callback_relevant_script_state,
                                  IncumbentScriptState())) {
    // Wrapper-tracing for the callback function makes the function object and
    // its creation context alive. Thus it's safe to use the creation context
    // of the callback function here.
    v8::HandleScope handle_scope(GetIsolate());
    v8::Local<v8::Object> callback_object = CallbackObject();
    CHECK(!callback_object.IsEmpty());
    v8::Context::Scope context_scope(callback_object->CreationContext());
    V8ThrowException::ThrowError(
        GetIsolate(),
        ExceptionMessages::FailedToExecute(
            "construct",
            "AnyCallbackFunctionVariadicAnyArgs",
            "The provided callback is no longer runnable."));
    return v8::Nothing<ScriptValue>();
  }

  // step: Prepare to run script with relevant settings.
  ScriptState::Scope callback_relevant_context_scope(
      callback_relevant_script_state);
  // step: Prepare to run a callback with stored settings.
  v8::Context::BackupIncumbentScope backup_incumbent_scope(
      IncumbentScriptState()->GetContext());

  if (UNLIKELY(ScriptForbiddenScope::IsScriptForbidden())) {
    ScriptForbiddenScope::ThrowScriptForbiddenException(GetIsolate());
    return v8::Nothing<ScriptValue>();
  }

  // step 3. If ! IsConstructor(F) is false, throw a TypeError exception.
  //
  // Note that step 7. and 8. are side effect free (except for a very rare
  // exception due to no incumbent realm), so it's okay to put step 3. after
  // step 7. and 8.
  if (!IsConstructor()) {
    V8ThrowException::ThrowTypeError(
        GetIsolate(),
        ExceptionMessages::FailedToExecute(
            "construct",
            "AnyCallbackFunctionVariadicAnyArgs",
            "The provided callback is not a constructor."));
    return v8::Nothing<ScriptValue>();
  }

  v8::Local<v8::Function> function;
  // callback function's invoke:
  // step 4. If ! IsCallable(F) is false:
  //
  // No [TreatNonObjectAsNull] presents.  Must be always callable.
  DCHECK(CallbackObject()->IsFunction());
  function = CallbackFunction();

  // step: Let esArgs be the result of converting args to an ECMAScript
  //   arguments list. If this throws an exception, set completion to the
  //   completion value representing the thrown exception and jump to the step
  //   labeled return.
  v8::Local<v8::Object> argument_creation_context =
      callback_relevant_script_state->GetContext()->Global();
  ALLOW_UNUSED_LOCAL(argument_creation_context);
  // Secure one element at least in |argv| to avoid the following restriction.
  //
  // C++14 8.3.4 Arrays
  // If the constant-expression (5.19) is present, it shall be a converted
  // constant expression of type std::size_t and its value shall be greater than
  // zero.
  const int argc = 0 + arguments.size();
  v8::Local<v8::Value> argv[std::max(1, argc)];
  for (wtf_size_t i = 0; i < arguments.size(); ++i) {
    argv[0 + i] = ToV8(arguments[i], argument_creation_context, GetIsolate());
  }

  v8::Local<v8::Value> call_result;
  if (!V8ScriptRunner::CallAsConstructor(
          GetIsolate(),
          function,
          ExecutionContext::From(callback_relevant_script_state),
          argc,
          argv).ToLocal(&call_result)) {
    // step 11. If callResult is an abrupt completion, set completion to
    //   callResult and jump to the step labeled return.
    return v8::Nothing<ScriptValue>();
  }

  // step: Set completion to the result of converting callResult.[[Value]] to
  //   an IDL value of the same type as the operation's return type.
  {
    ExceptionState exception_state(GetIsolate(),
                                   ExceptionState::kExecutionContext,
                                   "AnyCallbackFunctionVariadicAnyArgs",
                                   "construct");
    auto native_result =
        NativeValueTraits<ScriptValue>::NativeValue(
            GetIsolate(), call_result, exception_state);
    if (exception_state.HadException())
      return v8::Nothing<ScriptValue>();
    else
      return v8::Just<ScriptValue>(native_result);
  }
}

}  // namespace blink


text:
package ru.yandexmusiccasher.presentation.view.activity;

import android.content.DialogInterface;
import android.content.Intent;
import android.net.Uri;
import android.os.Bundle;
import android.support.v7.app.AlertDialog;
import android.support.v7.app.AppCompatActivity;
import android.view.View;

import ru.yandexmusiccasher.R;
import ru.yandexmusiccasher.presentation.model.AMSOperations;
import ru.yandexmusiccasher.presentation.model.AMusicStorage;
import ru.yandexmusiccasher.presentation.presenter.HelloPresenter;
import ru.yandexmusiccasher.presentation.view.HelloView;

public class MainActivity extends AppCompatActivity implements HelloView {

    private final int PICK_PATH = 1;

    private HelloPresenter presenter;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        presenter = new HelloPresenter(new AMSOperations(this));
        presenter.setView(this);
        presenter.start();
    }

    public void onInfoButton(View v){
        new AlertDialog.Builder(this)
                .setTitle(R.string.guide)
                .setView(R.layout.guide_layout)
                .setPositiveButton(R.string.OK, new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialog, int which) {
                        dialog.cancel();
                    }
                })
                .create()
                .show();
    }

    @Override
    public void onActivityResult(int requestCode, int resultCode, Intent resultData) {
        if (requestCode == PICK_PATH)
            if (resultCode == RESULT_OK) {
                Uri treeUri = resultData.getData();
                getContentResolver().takePersistableUriPermission(treeUri,
                        Intent.FLAG_GRANT_READ_URI_PERMISSION | Intent.FLAG_GRANT_WRITE_URI_PERMISSION);
                presenter.onPathReceived(new AMusicStorage(treeUri, this));
            } else presenter.onPathFailToReceive();
    }

    @Override
    public void pickPath() {
        new AlertDialog.Builder(this)
                .setMessage(R.string.choose_path)
                .setPositiveButton(R.string.ok, new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialogInterface, int i) {
                        dialogInterface.cancel();
                        startActivityForResult(new Intent(Intent.ACTION_OPEN_DOCUMENT_TREE), PICK_PATH);
                    }
                })
                .setNeutralButton(R.string.Cancel, new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialogInterface, int i) {
                        dialogInterface.cancel();
                        finish();
                    }
                })
                .setCancelable(false)
                .create()
                .show();
    }

}


text:
'use strict';

// Use local.env.js for environment variables that grunt will set when the server starts locally.
// Use for your api keys, secrets, etc. This file should not be tracked by git.
//
// You will need to set these on the server you deploy to.

module.exports = {
  DOMAIN:           'http://localhost:9000',
  SESSION_SECRET:   'ideabuilder-secret',

  FACEBOOK_ID:      'app-id',
  FACEBOOK_SECRET:  'secret',

  TWITTER_ID:       'app-id',
  TWITTER_SECRET:   'secret',

  GOOGLE_ID:        'app-id',
  GOOGLE_SECRET:    'secret',

  // Control debug level for modules using visionmedia/debug
  DEBUG: ''
};


text:
// Copyright (c) 2016-2020 The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.

#include <deploymentinfo.h>

#include <consensus/params.h>

const struct VBDeploymentInfo VersionBitsDeploymentInfo[Consensus::MAX_VERSION_BITS_DEPLOYMENTS] = {
    {
        /*.name =*/ "testdummy",
        /*.gbt_force =*/ true,
    },
    {
        /*.name =*/ "taproot",
        /*.gbt_force =*/ true,
    },
};

std::string DeploymentName(Consensus::BuriedDeployment dep)
{
    assert(ValidDeployment(dep));
    switch (dep) {
    case Consensus::DEPLOYMENT_HEIGHTINCB:
        return "bip34";
    case Consensus::DEPLOYMENT_CLTV:
        return "bip65";
    case Consensus::DEPLOYMENT_DERSIG:
        return "bip66";
    case Consensus::DEPLOYMENT_CSV:
        return "csv";
    case Consensus::DEPLOYMENT_SEGWIT:
        return "segwit";
    } // no default case, so the compiler can warn about missing cases
    return "";
}


text:
var convert = require('./convert');
module.exports = convert('cloneDeepWith', require('../cloneDeepWith'));


text:
process.env.SUPPRESS_NO_CONFIG_WARNING = true;

var fs      = require('fs');
var path    = require('path');
var through = require('through2');
var gutil   = require('gulp-util');
var glob    = require('glob');
var stream  = require('stream');
var series  = require('stream-series');
var config  = require('config');
var _       = require('lodash');

var AVAILABLE_FORMATS = ['json', 'json5', 'hjson', 'toml', 'iced', 'yaml', 'yml', 'cson', 'properties'];

function Config() {}

Config.prototype.load = function compile(publicPath, localPath, params) {
    if (typeof localPath === 'object') {
        params    = localPath;
        localPath = undefined;
    }

    if (typeof publicPath === 'object') {
        params     = publicPath;
        publicPath = undefined;
    }

    params         = params || {};
    publicPath     = publicPath || 'config';
    params.env     = params.env || process.env.NODE_ENV;
    params.project = params.project || process.env.PROJECT;

    var setDefaultConfig = typeof params.defaults === 'function' ? params.defaults : function(env, projectName) {
        return params.defaults || {env: env, project: projectName};
    };

    var def     = params.defaultFileName || 'default',
        env     = params.env || def,
        project = params.project === '*' ? undefined : params.project;

    var publicDirPaths = publicPath ? glob.sync(publicPath, params) : [];
    var localDirPaths  = localPath  ? glob.sync(localPath, params)  : [];

    var publicConfigs = findConfigs(publicDirPaths);
    var localConfigs  = findConfigs(localDirPaths, {ignoreErrors: true});

    var configs = _.merge(this, publicConfigs, localConfigs);

    //Stay config for one project
    if (project) {
        _.forEach(configs, function(config, projectName) {
            if (projectName !== project) {
                delete configs[projectName];
            }
        })
    }

    function findConfigs(directoriesPaths, params) {
        var configs = {};

        directoriesPaths.forEach(function(dirPath) {
            loadConfigs(dirPath, path.basename(path.dirname(dirPath)), configs);
        });

        return combineConfigs(configs, params);
    }

    function loadConfigs(dirPath, project, configs) {
        var dirFilesPaths = fs.readdirSync(dirPath, 'utf8');

        dirFilesPaths.forEach(function(fileName) {
            var filePath = path.join(dirPath, fileName);

            if (fs.lstatSync(filePath).isDirectory()) {
                loadConfigs(filePath, path.basename(filePath), configs);

            } else {
                var env = path.basename(fileName, path.extname(fileName));

                configs[project] = configs[project] || {};
                configs[project][env] = readConfig(filePath);
            }
        });
    }

    function readConfig(filePath) {
        var ext = path.extname(filePath).substring(1);

        if (AVAILABLE_FORMATS.indexOf(ext) === -1) return;

        var file = fs.readFileSync(filePath, 'utf8');

        return config.util.parseString(file, ext);
    }

    function combineConfigs(configs, params) {
        params = params || {};

        var inheritedConfigs = {};

        _.forEach(configs, function(config, projectName) {
            var defaultConfig = config[def];
            var enviromentConfig = config[env];

            if (defaultConfig && defaultConfig.inherit) {
                inheritedConfigs[projectName] = defaultConfig.inherit;
            }

            if (!params.ignoreErrors && !enviromentConfig && (!defaultConfig || !defaultConfig.inherit)) {
                if (!defaultConfig.useIfNoEnv) {
                    throw new Error('Can not read "' + env + '" config for project "' + projectName +'"');
                }
            }

            var projectConfig = _.merge({}, defaultConfig, enviromentConfig);
            var defaultProjectConfig = setDefaultConfig.call(projectConfig, env, projectName);

            configs[projectName] = _.merge(defaultProjectConfig, projectConfig);
        });

        _.forEach(inheritedConfigs, function(parentProjectName, projectName) {
            if (!configs[parentProjectName]) {
                throw new Error('Can not load ' + parentProjectName + ' config');
            }
            configs[projectName] = _.merge({}, configs[parentProjectName], configs[projectName]);
        });

        return configs;
    }

    return this;
};

Config.prototype.stream = function compile(params) {
    params = params || {};
    var stream = through.obj(),
        config = this,
        projectConfigs = {};

    function save(projectConfig, projectName) {
        var file = new gutil.File({
            path: path.join(projectName || '', params.name || 'config.js'),
            contents: new Buffer(JSON.stringify(projectConfig, null, params.stringifySpace || 4))
        });

        stream.write(file);
    }

    _.forEach(config, function(projectConfig, project) {
        projectConfigs[project] = _.get(projectConfig, params.section);
    });

    save(projectConfigs);

    process.nextTick(function() {
        return stream.end();
    });

    return stream;
};

Config.prototype.forEach = function(section, callback) {
    var streams = [];

    if (!callback) {
        callback = section;
        section = undefined;
    }

    _.forEach(this, function(configs, projectName) {
        if (section) {
            configs = _.get(configs, section);
        } else {
            configs = configs || {};
        }

        if (!configs) return;

        configs = configs instanceof Array ? configs : [configs];

        configs.forEach(function(config) {
            var configStream = callback(config, projectName);

            if (configStream instanceof stream.Stream) {
                streams.push(configStream);
            }
        });
    });

    return streams.length ? series.apply(this, streams) : null;
};

Config.prototype.reduce = function(callback, initial, thisArg, right) {
    return right ? _.reduceRight(this, callback, initial) : _.reduce(this, callback, initial);
};

Config.prototype.reduceRight = function(callback, initial, thisArg) {
    return this.reduce(callback, initial, thisArg, true);
};

module.exports = new Config();


text:
__author__ = 'Nikolay Arefyev'

from math import ceil

import numpy as np

from .parallel import parallel_map

def argmaxk_rows_basic(arr, k=10, sort=False):
    """
    Reference non-optimized implementation.
    """
    if sort:
        return np.argsort(arr, axis=1)[:, :-k - 1:-1]
    else:
        return np.argpartition(arr, kth=-k, axis=1)[:, -k:]

def argmaxk_rows_opt1(arr, k=10, sort=False):
    """
    Optimized implementation. When sort=False it is equal to argmaxk_rows_basic. When sort=True and k << arr.shape[1],
    it is should be faster, because we argsort only subarray of k max elements from each row of arr (arr.shape[0] x k) instead of
    the whole array arr (arr.shape[0] x arr.shape[1]).
    """
    best_inds = np.argpartition(arr, kth=-k, axis=1)[:, -k:]  # column indices of k max elements in each row (m x k)
    if not sort:
        return best_inds
    # generate row indices corresponding to best_ids (just current row id in each row) (m x k)
    rows = np.arange(best_inds.shape[0], dtype=np.intp)[:, np.newaxis].repeat(best_inds.shape[1], axis=1)
    best_elems = arr[rows, best_inds]  # select k max elements from each row using advanced indexing (m x k)
    # indices which sort each row of best_elems in descending order (m x k)
    best_elems_inds = np.argsort(best_elems, axis=1)[:, ::-1]
    # reorder best_indices so that arr[i, sorted_best_inds[i,:]] will be sorted in descending order
    sorted_best_inds = best_inds[rows, best_elems_inds]
    return sorted_best_inds

def argmaxk_rows(arr, k=10, sort=False, impl='opt1', nthreads=8):
    """
    Returns column indices of k max elements in each row of input ndarray.
    :param arr: input ndarray (m x n)
    :param k: number of maximum values to find in each row of input matrix
    :param sort: for each row of input matrix returned column indices should sort k max elements of this row in
    descending order (particularly, res[:,0] equals to argmax(arr, axis=1) )
    :param impl: single thread implementation to use (look at implementations docs)
    :param nthreads: split input array into this many parts and process in parallel; takes advantage of the fact that
    numpy.argpartition is not parallelized
    :return: output ndarray (m x k) of column indices of k max elements in each row of input matrix
    """
    IMPLS = {'basic': argmaxk_rows_basic, 'opt1': argmaxk_rows_opt1}
    if impl not in IMPLS:
        raise ValueError('Unknown value of parameter: impl=%s; possible values: %r' % (impl, IMPLS.keys()))
    fimpl = IMPLS[impl]

    if nthreads == 1:
        res = fimpl(arr, k, sort)
    else:
        m = arr.shape[0]
        batchsize = int(ceil(1. * m / nthreads))

        def ppp(i):
            return fimpl(arr[i:i + batchsize, :], k, sort)

        lres = parallel_map(ppp, range(0, m, batchsize), threads=nthreads)
        res = np.vstack(lres)

    return res


text:
package org.apache.ambari.server.controller.metrics.timeline.cache;

import org.apache.ambari.server.configuration.Configuration;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.google.inject.Inject;
import com.google.inject.Singleton;

import net.sf.ehcache.Cache;
import net.sf.ehcache.CacheManager;
import net.sf.ehcache.config.CacheConfiguration;
import net.sf.ehcache.config.PersistenceConfiguration;
import net.sf.ehcache.config.PersistenceConfiguration.Strategy;
import net.sf.ehcache.config.SizeOfPolicyConfiguration;
import net.sf.ehcache.config.SizeOfPolicyConfiguration.MaxDepthExceededBehavior;
import net.sf.ehcache.store.MemoryStoreEvictionPolicy;

/**
 * Cache implementation that provides ability to perform incremental reads
 * from Metrics backend and reduce the amount of calls between Ambari and the
 * Metrics backend.
 */
@Singleton
public class TimelineMetricCacheProvider {
  private TimelineMetricCache timelineMetricsCache;
  private volatile boolean isCacheInitialized = false;
  public static final String TIMELINE_METRIC_CACHE_MANAGER_NAME = "timelineMetricCacheManager";
  public static final String TIMELINE_METRIC_CACHE_INSTANCE_NAME = "timelineMetricCache";

  Configuration configuration;
  TimelineMetricCacheEntryFactory cacheEntryFactory;

  private final static Logger LOG = LoggerFactory.getLogger(TimelineMetricCacheProvider.class);

  @Inject
  public TimelineMetricCacheProvider(Configuration configuration,
                                     TimelineMetricCacheEntryFactory cacheEntryFactory) {
    this.configuration = configuration;
    this.cacheEntryFactory = cacheEntryFactory;
  }

  private synchronized void initializeCache() {
    // Check in case of contention to avoid ObjectExistsException
    if (isCacheInitialized) {
      return;
    }

    System.setProperty("net.sf.ehcache.skipUpdateCheck", "true");
    if (configuration.useMetricsCacheCustomSizingEngine()) {
      // Use custom sizing engine to speed cache sizing calculations
      System.setProperty("net.sf.ehcache.sizeofengine." + TIMELINE_METRIC_CACHE_MANAGER_NAME,
        "org.apache.ambari.server.controller.metrics.timeline.cache.TimelineMetricsCacheSizeOfEngine");
    }

    net.sf.ehcache.config.Configuration managerConfig =
      new net.sf.ehcache.config.Configuration();
    managerConfig.setName(TIMELINE_METRIC_CACHE_MANAGER_NAME);

    // Set max heap available to the cache manager
    managerConfig.setMaxBytesLocalHeap(configuration.getMetricsCacheManagerHeapPercent());

    //Create a singleton CacheManager using defaults
    CacheManager manager = CacheManager.create(managerConfig);

    LOG.info("Creating Metrics Cache with timeouts => ttl = " +
      configuration.getMetricCacheTTLSeconds() + ", idle = " +
      configuration.getMetricCacheIdleSeconds());

    // Create a Cache specifying its configuration.
    CacheConfiguration cacheConfiguration = createCacheConfiguration();
    Cache cache = new Cache(cacheConfiguration);

    // Decorate with UpdatingSelfPopulatingCache
    timelineMetricsCache = new TimelineMetricCache(cache, cacheEntryFactory);

    LOG.info("Registering metrics cache with provider: name = " +
      cache.getName() + ", guid: " + cache.getGuid());

    manager.addCache(timelineMetricsCache);

    isCacheInitialized = true;
  }

  // Having this as a separate public method for testing/mocking purposes
  public CacheConfiguration createCacheConfiguration() {

    CacheConfiguration cacheConfiguration = new CacheConfiguration()
      .name(TIMELINE_METRIC_CACHE_INSTANCE_NAME)
      .timeToLiveSeconds(configuration.getMetricCacheTTLSeconds()) // 1 hour
      .timeToIdleSeconds(configuration.getMetricCacheIdleSeconds()) // 5 minutes
      .memoryStoreEvictionPolicy(MemoryStoreEvictionPolicy.LRU)
      .sizeOfPolicy(new SizeOfPolicyConfiguration() // Set sizeOf policy to continue on max depth reached - avoid OOM
        .maxDepth(10000)
        .maxDepthExceededBehavior(MaxDepthExceededBehavior.CONTINUE))
      .eternal(false)
      .persistence(new PersistenceConfiguration()
        .strategy(Strategy.NONE.name()));

    return cacheConfiguration;
  }

  /**
   * Return an instance of a Ehcache
   * @return @TimelineMetricCache or null if caching is disabled through config.
   */
  public TimelineMetricCache getTimelineMetricsCache() {
    if (configuration.isMetricsCacheDisabled()) {
      return null;
    }

    if (!isCacheInitialized) {
      initializeCache();
    }
    return timelineMetricsCache;
  }

}


text:
<!DOCTYPE html>

    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width initial-scale=1" />
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <title>Una guía sobre Jekyll - YAML</title>
    <meta name="description" content="Un blog sobre SVG · CSS3 · HTML5">
    <meta name="generator" content="Jekyll v3.8.5">
    <link rel="stylesheet" href="/blog/css/styles.css">
    <link rel="canonical" href="http://jorgeatgu.com/blog/una-guia-sobre-jekyll-configuracion-yaml/">
    <link href="https://fonts.googleapis.com/css?family=IBM+Plex+Serif:400,500|Rubik:400,500" rel="stylesheet">

            WEB
            BLOG
            CATEGORIAS
            RSS

            GitHub
            Twitter
            Carto
            CodePen

Una guía sobre Jekyll - YAML

            <time datetime="2014-10-13 00:00:00 +0200">
                El
                13 de

                octubre

                de
                2014
            </time>

        Archivado en:

            Diseño Web

            Jekyll

El archivo de configuración de Jekyll se llama _config.yml esta en YAML. YAML es el acrónimo de Ain't Markup Language, un lenguaje de marcado con una sintaxis bastante sencilla.

Aqui le podéis echar un vistazo a la especificación de YAML

También vamos a ver cosas de LIQUID, un lenguaje creado por Shopify. A continuación un par de enlaces en castellano que son de obligada lectura Liquid para diseñadores y Liquid para programadores

Como ya he dicho anteriormente la sintaxis es bastante sencilla. Lo primero es definir una variable seguida de : y después de dejar un espacio le vamos a asignar un valor.

Un apunte antes de empezar, con YAML no podemos usar tabulaciones. Así que hay que utilizar los espacios normales.

title: Una guía sobre Jekyll

Como bien supondréis title es la variable y Una guía sobre Jekyll es el valor.

Si vamos a pasar más de un valor a la variable lo podemos hacer de la siguiente manera

exclude: ["config.codekit", ".sass-cache", ".gitignore" ]

Esta variable le dice a Jekyll que a la hora de compilar excluya los archivos y carpetas que le hemos indicado.

También lo podemos hacer en forma de lista por ejemplo a la hora de indicar las categorías en las que ira por ejemplo este post.

tags:
  - Diseño Web
  - Jekyll

Esto último es parte del código que incluyo al principio de cada post.

Ahora vamos a crear un array

estructura:
  post: diez
  categorias: cinco

_config.yml

Ya conocemos algo más sobre YAML así que ahora vamos a ver mi archivo de configuración y voy a ir explicando para que utilizo cada variable en mi tema.

# Inicio
name: Scalable
description: Un blog sobre SVG · CSS3 · HTML5
themeJekyll: Amanixer
version: 0.1.0
timezone: Europe/Madrid

# Configuracion
url: http://jorgeatgu.com/blog
baseurl: /blog
paginate: 5
paginate_path: "page:num"
highlighter: pygments
markdown: kramdown

# Redes Sociales
author: Jorge Aznar Tobajas
twitter: https://twitter.com/jorgeatgu
CodePen: https://codepen.io/jorgeatgu
GooglePlus: https://plus.google.com/+JorgeATGU/
GitHub: https://github.io/jorgeatgu/
Behance: https://www.behance.net/jorgeatgu
Facebook: https://facebok.com/jorgeatgu
Vimeo: https://vimeo.com/jorgeatgu
dribbble: http://www.dribbble.com/jorgeATGU

exclude: [ config.codekit ]

Para utilizar las variables que hemos almacenado en config.yml siempre las vamos a invocar en nuestros archivos a través de site. y seguido el nombre de la variable. Para utilizar la variable url: lo haremos de la siguiente manera

{{ site.url }}

En este caso dará este resultado

http://jorgeatgu.com/blog

Sin duda alguna esta es la variable que más vamos a ir utilizando a la hora de construir nuestro tema de Jekyll. Así cada vez que necesitemos escribir la dirección simplemente tenemos que llamarla con site.url y así nos ahorraremos el tener que escribir la dirección de nuestra web donde se aloja Jekyll.

Inicio

Vamos a ir viendo por bloques las parte de mi archivo config.yml. Las secciones las podéis llamar como más os apetezca. Esta sección que vamos a ver tiene partes prescindibles como themeJekyll y version

name: el nombre de vuestro blog

description: la descripción de vuestro blog

themeJekyll: el nombre de vuestro tema

version: la versión de vuestro tema

timezone: la zona horaria en la que os encontréis. Más información

Configuración

Vamos a ver la sección configuración. Aquí vamos a adjuntar la dirección de nuestro blog, y algo bastante importante como el número de post que irá en cada página.

url: la dirección de vuestro blog

baseurl: nos vendrá bien cuando no tengamos que utilizar la dirección completa de nuestro blog

paginate: el número de post por páginas

paginate_path: la nomenclatura que tendrá la paginación. Por ejemplo "page:num" da como resultado: /page1/

highlighter: para incluir snippets de código. Más información

markdown: interprete de Markdown. Imprescindible si vas a alojar tu blog en GitHub Pages

Redes Sociales

Aquí vamos a ir incluyendo todos los enlaces a nuestros perfiles en redes sociales. Otra buena manera de no andar repitiendo toda la dirección cuando queremos incluir un enlace a nuestro perfil.

En mi header y footer utilizo las variables con cada nombre de red social de la siguiente manera

<a target="_blank" href="{{ site.twitter }}" title="Twitter">
  <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32" class="iconos-footer">
    <use xlink:href="{{ site.urliconos }}#twitter"/>
  </svg>
</a>
<a target="_blank" href="{{ site.CodePen }}" title="codepen">
  <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32" class="iconos-footer">
    <use xlink:href="{{ site.urliconos }}#codepen"/>
  </svg>
</a>
<a target="_blank" href="{{ site.GitHub }}" title="GitHub">
  <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32" class="iconos-footer">
    <use xlink:href="{{ site.urliconos }}#github"/>
  </svg>
</a>
<a target="_blank" href="{{ site.Behance }}" title="behance">
  <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32" class="iconos-footer">
    <use xlink:href="{{ site.urliconos }}#behance"/>
  </svg>
</a>

Cada vez que hagamos una modificación en config.yml tenemos que ejecutar un build para volver a compilar todo y que los cambios se hagan efectivos sobre nuestro sitio. Recordad que se ejecutaba con el siguiente comando desde el Terminal

sudo jekyll build

Si tenéis el server en funcionamiento no hace falta cerrarlo, simplemente abrid otra ventana del Terminal y ejecutad el comando desde esa ventana.

En la documentación oficial de Jekyll tenemos más variables para incluir en nuestro archivo de configuración.

Si queréis echarle un ojo a archivos de configuraciones curradisimos y de paso sacar alguna idea daros una vuelta por Jekyll Themes, basta con mirar en los repositorios de los temas para ver los archivos sin necesidad de tener que descargar todo el tema.

<button class="boton-centrar">
   PRIMERA PARTE DE LA GUÍA
</button>
<button class="boton-centrar">
   TERCERA PARTE DE LA GUÍA
</button>
<button class="boton-centrar">
   CUARTA PARTE DE LA GUÍA
</button>
<button class="boton-centrar">
   QUINTA PARTE DE LA GUÍA
</button>

        SCALABLE, un libro sobre SVGA lo largo de 15 capítulos, 120 páginas y más de 70 ejemplos vamos a ver todo lo que podemos hacer con SVG.
            Tu pones el precio, disponible desde 0$ para descargar desde LeanPub(PDF, ePUB y MOBI).

    Artículo posterior

    Artículo anterior

Boira por Jorge Aznar

GitHub · Carto · Twitter · CodePen


text:
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Globalization;
using System.Linq;
using System.Reflection;

namespace SharpDomain.DDD
{
    public abstract class DomainConcept : IDomainConcept
    {
        private readonly Type _type;
        private readonly string _name;
        private readonly Func<CultureInfo, string> _description;

        protected DomainConcept()
        {
            _type = this.GetType();
            _name = GetBoundedContextName(_type);
            _description = GetBoundedContextDescription(_type);
        }

        public virtual string Name { get { return _name; } }
        public string Description { get { return GetDescription(null); } }
        public virtual string GetDescription(CultureInfo culture)
        {
            return _description(culture);
        }

        private string GetBoundedContextName(Type type)
        {
            // cache result and use attribute convention [BoundedContextName("...")]
            return type.Name;
        }

        private Func<CultureInfo, string> GetBoundedContextDescription(Type type)
        {
            // cache result and use attribute convention [Description("...")]
            return (_) => "";
        }
    }

    public abstract class BoundedContext : DomainConcept, IBoundedContext
    {
        private readonly IReadOnlyDictionary<string, IDomainObject> _domainObjects;
        private readonly IDictionary<string, IDomainObject> _domainObjectsInternal;
        private static readonly Type TypeOfIDomainObject = typeof(IDomainObject);

        protected BoundedContext()
        {
            _domainObjects = new ReadOnlyDictionary<string, IDomainObject>(_domainObjectsInternal);
        }

        public IReadOnlyDictionary<string, IDomainObject> DomainObjects { get { return _domainObjects; } }

        protected void HasDomainObjectsInThisAssembly()
        {
            var thisAssembly = Assembly.GetExecutingAssembly();
            var domainObjectTypes = thisAssembly.GetExportedTypes()
                .Where(TypeOfIDomainObject.IsAssignableFrom)
                .ToList();
            foreach (var obj in domainObjectTypes)
            {
                HasDomainObjectInternal(obj);
            }
        }

        protected void HasDomainObject(Type domainObject)
        {
            if (domainObject == null)
                throw new ArgumentNullException("domainObject");
            if (!TypeOfIDomainObject.IsAssignableFrom(domainObject))
                throw new ArgumentException(string.Format("Cannot setup type {0} on domain {1}.", domainObject.FullName, Name), "domainObject");

            var instance = CreateDomainObjectInstance(domainObject);
        }

        protected void HasDomainObject<TDomainObject>() where TDomainObject : class, IDomainObject
        {

        }

        private void HasDomainObjectInternal(Type domainObject)
        {
            var instance = CreateDomainObjectInstance(domainObject);
        }

        private IDomainObject CreateDomainObjectInstance(Type domainObject)
        {
            return (IDomainObject) Activator.CreateInstance(domainObject);
        }
    }

    public abstract class DomainObject : DomainConcept, IDomainObject
    {
        protected DomainObject()
        {
        }
    }
}


text:
package errors

import (
	"strings"

	. "code.cloudfoundry.org/cli/cf/i18n"
)

type AmbiguousModelError struct {
	ModelType string
	ModelName string
}

func NewAmbiguousModelError(modelType, name string) error {
	return &AmbiguousModelError{
		ModelType: modelType,
		ModelName: name,
	}
}

func (err *AmbiguousModelError) Error() string {
	return T("Multiple ") + strings.ToLower(err.ModelType) + "s named " + err.ModelName + T(" found.")
}


text:
<?xml version="1.0" encoding="iso-8859-1"?>
<!DOCTYPE html PUBLIC "-//Tigris//DTD XHTML 1.0 Transitional//EN"
"http://style.tigris.org/tigris_transitional.dtd">

<link rel="stylesheet" type="text/css" href="css/print.css" media="print" />
 <title>Review Meeting Notes</title>

QA Plan > Review Meeting Notes

Review Meeting Information

   Product:
   PRODUCTNAME

   Release Number:

     X.Y.Z

   Location of Meeting:

     LOCATION, BUILDING, ROOM

   Date and Time of Meeting:

     YEAR/MONTH/DAY  HH:MM

   Attendees:

PERSONNAME

PERSONNAME

PERSONNAME

PERSONNAME

   Related documents:

Review Meeting Checklists

Documents and Code Reviewed at this Meeting

Feature list section of requirements

Multi-user section of requirements

Hello.java

HelloStream.java

HelloPanel.java

Meeting Minutes

  TODO: Fill in the information above and write a brief summary of what happened at the meeting.
  The text below is just a sample.

We started on time with 3 members and the other team members
 arrived shortly thereafter.

In the first hour of the review meeting, we went over issues that
 the team had entered individually.  Most of the issues raised
 questions about the error handling capability of Hello.java, but
 there were also issues about multi-user robustness requirements and
 UI.

In the second hour, we read through all of the methods of
 HelloStream.java.  All team members agreed that they understood each
 method and thought is was correct before we moved on to the next
 method. We raised issues of consistency between the constructors in
 that class and other classes.  The checklist was helpful in
 identifying the fact that we needed to implement hash() and equals().
 All raised issues were entered into the issue tracker and marked with
 the word "review".

Although, some issues were found, we do not feel that Hello.java
 and HelloStream.java need to be inspected again.  HelloPanel was not
 inspected, it still needs review.

Action Items

All defects and tasks identified in this review are being tracked
 in the issue tracker.

  TODO:  Check for words
  of wisdom and discuss ways to improve this template.
  Or, evaluate the ReadySET Pro professional review report template.

Company Proprietary

 Copyright © 2003-2004 Jason Robbins.  All rights reserved. License terms.
 Retain this copyright statement whenever this file is used as a
 template.


text:
@implementation YXTBanner

@end


text:
namespace caf::io {

class middleman;

/// @defgroup Broker Actor-based Network Abstraction
///
/// Brokers provide an actor-based abstraction for low-level network IO.
/// The central component in the network abstraction of CAF is the
/// `middleman`. It connects any number of brokers to a `multiplexer`,
/// which implements a low-level IO event loop.
///
/// ![Relation between middleman, multiplexer, and broker](broker.png)
///
/// Brokers do *not* operate on sockets or other platform-dependent
/// communication primitives. Instead, brokers use a `connection_handle`
/// to identify a reliable, end-to-end byte stream (e.g. a TCP connection)
/// and `accept_handle` to identify a communication endpoint others can
/// connect to via its port.
///
/// Each `connection_handle` is associated with a `scribe` that provides
/// access to an output buffer as well as a `flush` operation to request
/// sending its content via the network. Instead of actively receiving data,
/// brokers configure a scribe to asynchronously receive data, e.g.,
/// `self->configure_read(hdl, receive_policy::exactly(1024))` would
/// configure the scribe associated with `hdl` to receive *exactly* 1024 bytes
/// and generate a `new_data_msg` message for the broker once the
/// data is available. The buffer in this message will be re-used by the
/// scribe to minimize memory usage and heap allocations.
///
/// Each `accept_handle` is associated with a `doorman` that will create
/// a `new_connection_msg` whenever a new connection was established.
///
/// All `scribe` and `doorman` instances are managed by the `multiplexer`

/// A broker mediates between actor systems and other components in the network.
/// @ingroup Broker
class CAF_IO_EXPORT abstract_broker : public scheduled_actor,
                                      public prohibit_top_level_spawn_marker {
public:
  abstract_broker(abstract_broker&&) = delete;

  abstract_broker(const abstract_broker&&) = delete;

  abstract_broker& operator=(abstract_broker&&) = delete;

  abstract_broker& operator=(const abstract_broker&&) = delete;

  ~abstract_broker() override;

  // even brokers need friends
  friend class scribe;
  friend class doorman;
  friend class datagram_servant;

  // -- overridden modifiers of abstract_actor ---------------------------------

  bool enqueue(mailbox_element_ptr, execution_unit*) override;

  bool enqueue(strong_actor_ptr, message_id, message, execution_unit*) override;

  // -- overridden modifiers of local_actor ------------------------------------

  void launch(execution_unit* eu, bool lazy, bool hide) override;

  // -- overridden modifiers of abstract_broker --------------------------------

  bool cleanup(error&& reason, execution_unit* host) override;

  // -- overridden modifiers of resumable --------------------------------------

  resume_result resume(execution_unit*, size_t) override;

  // -- modifiers --------------------------------------------------------------

  /// Suspends activities on `hdl` unconditionally.
  template <class Handle>
  void halt(Handle hdl) {
    auto ref = by_id(hdl);
    if (ref)
      ref->halt();
  }

  /// Allows activities on `hdl` unconditionally (default).
  template <class Handle>
  void trigger(Handle hdl) {
    auto ref = by_id(hdl);
    if (ref)
      ref->trigger();
  }

  /// Allows `num_events` activities on `hdl`.
  template <class Handle>
  void trigger(Handle hdl, size_t num_events) {
    auto ref = by_id(hdl);
    if (!ref)
      return;
    if (num_events > 0) {
      ref->trigger(num_events);
    } else {
      // if we have any number of activity tokens, ignore this call
      // otherwise (currently in unconditional receive state) halt
      auto x = ref->activity_tokens();
      if (!x)
        ref->halt();
    }
  }

  /// Modifies the receive policy for a given connection.
  /// @param hdl Identifies the affected connection.
  /// @param cfg Contains the new receive policy.
  void configure_read(connection_handle hdl, receive_policy::config cfg);

  /// Enables or disables write notifications for a given connection.
  void ack_writes(connection_handle hdl, bool enable);

  /// Returns the write buffer for a given connection.
  byte_buffer& wr_buf(connection_handle hdl);

  /// Writes `data` into the buffer for a given connection.
  void write(connection_handle hdl, size_t bs, const void* buf);

  /// Writes `buf` into the buffer for a given connection.
  void write(connection_handle hdl, span<const std::byte> buf);

  /// Sends the content of the buffer for a given connection.
  void flush(connection_handle hdl);

  /// Enables or disables write notifications for a given datagram socket.
  void ack_writes(datagram_handle hdl, bool enable);

  /// Returns the write buffer for a given sink.
  byte_buffer& wr_buf(datagram_handle hdl);

  /// Enqueue a buffer to be sent as a datagram via a given endpoint.
  void enqueue_datagram(datagram_handle, byte_buffer);

  /// Writes `data` into the buffer of a given sink.
  void write(datagram_handle hdl, size_t data_size, const void* data);

  /// Sends the content of the buffer to a UDP endpoint.
  void flush(datagram_handle hdl);

  /// Returns the middleman instance this broker belongs to.
  middleman& parent() {
    return system().middleman();
  }

  /// Adds the uninitialized `scribe` instance `ptr` to this broker.
  void add_scribe(scribe_ptr ptr);

  /// Creates and assigns a new `scribe` from given native socked `fd`.
  connection_handle add_scribe(network::native_socket fd);

  /// Tries to connect to `host` on given `port` and creates
  /// a new scribe describing the connection afterwards.
  /// @returns The handle of the new `scribe` on success.
  expected<connection_handle> add_tcp_scribe(const std::string& host,
                                             uint16_t port);

  /// Moves the initialized `scribe` instance `ptr` from another broker to this
  /// broker.
  void move_scribe(scribe_ptr ptr);

  /// Adds a `doorman` instance to this broker.
  void add_doorman(doorman_ptr ptr);

  /// Creates and assigns a new `doorman` from given native socked `fd`.
  accept_handle add_doorman(network::native_socket fd);

  /// Adds a `doorman` instance to this broker.
  void move_doorman(doorman_ptr ptr);

  /// Tries to open a local port and creates a `doorman` managing
  /// it on success. If `port == 0`, then the broker will ask
  /// the operating system to pick a random port.
  /// @returns The handle of the new `doorman` and the assigned port.
  expected<std::pair<accept_handle, uint16_t>>
  add_tcp_doorman(uint16_t port = 0, const char* in = nullptr,
                  bool reuse_addr = false);

  /// Adds a `datagram_servant` to this broker.
  void add_datagram_servant(datagram_servant_ptr ptr);

  /// Adds the `datagram_servant` under an additional `hdl`.
  void add_hdl_for_datagram_servant(datagram_servant_ptr ptr,
                                    datagram_handle hdl);

  /// Creates and assigns a new `datagram_servant` from a given socket `fd`.
  datagram_handle add_datagram_servant(network::native_socket fd);

  /// Creates and assigns a new `datagram_servant` from a given socket `fd`
  /// for the remote endpoint `ep`.
  datagram_handle
  add_datagram_servant_for_endpoint(network::native_socket fd,
                                    const network::ip_endpoint& ep);

  /// Creates a new `datagram_servant` for the remote endpoint `host` and
  /// `port`.
  /// @returns The handle to the new `datagram_servant`.
  expected<datagram_handle> add_udp_datagram_servant(const std::string& host,
                                                     uint16_t port);

  /// Tries to open a local port and creates a `datagram_servant` managing it on
  /// success. If `port == 0`, then the broker will ask the operating system to
  /// pick a random port.
  /// @returns The handle of the new `datagram_servant` and the assigned port.
  expected<std::pair<datagram_handle, uint16_t>>
  add_udp_datagram_servant(uint16_t port = 0, const char* in = nullptr,
                           bool reuse_addr = false);

  /// Moves an initialized `datagram_servant` instance `ptr` from another broker
  /// to this one.
  void move_datagram_servant(datagram_servant_ptr ptr);

  /// Returns the remote address associated with `hdl`
  /// or empty string if `hdl` is invalid.
  std::string remote_addr(connection_handle hdl);

  /// Returns the remote port associated with `hdl`
  /// or `0` if `hdl` is invalid.
  uint16_t remote_port(connection_handle hdl);

  /// Returns the local address associated with `hdl`
  /// or empty string if `hdl` is invalid.
  std::string local_addr(accept_handle hdl);

  /// Returns the local port associated with `hdl` or `0` if `hdl` is invalid.
  uint16_t local_port(accept_handle hdl);

  /// Returns the handle associated with given local `port` or `none`.
  accept_handle hdl_by_port(uint16_t port);

  /// Returns the dgram handle associated with given local `port` or `none`.
  datagram_handle datagram_hdl_by_port(uint16_t port);

  /// Returns the remote address associated with `hdl`
  /// or an empty string if `hdl` is invalid.
  std::string remote_addr(datagram_handle hdl);

  /// Returns the remote port associated with `hdl`
  /// or `0` if `hdl` is invalid.
  uint16_t remote_port(datagram_handle hdl);

  /// Returns the remote port associated with `hdl`
  /// or `0` if `hdl` is invalid.
  uint16_t local_port(datagram_handle hdl);

  /// Remove the endpoint `hdl` from the broker.
  bool remove_endpoint(datagram_handle hdl);

  /// Closes all connections and acceptors.
  void close_all();

  /// Closes the connection or acceptor identified by `handle`.
  /// Unwritten data will still be send.
  template <class Handle>
  bool close(Handle hdl) {
    auto x = by_id(hdl);
    if (!x)
      return false;
    x->graceful_shutdown();
    return true;
  }

  /// Checks whether `hdl` is assigned to broker.
  template <class Handle>
  bool valid(Handle hdl) {
    return get_map(hdl).count(hdl) > 0;
  }

  /// @cond PRIVATE
  template <class Handle>
  void erase(Handle hdl) {
    auto& elements = get_map(hdl);
    auto i = elements.find(hdl);
    if (i != elements.end())
      elements.erase(i);
  }

  // meta programming utility (not implemented)
  static intrusive_ptr<doorman> ptr_of(accept_handle);

  // meta programming utility (not implemented)
  static intrusive_ptr<scribe> ptr_of(connection_handle);

  // meta programming utility (not implemented)
  static intrusive_ptr<datagram_servant> ptr_of(datagram_handle);

  /// Returns an intrusive pointer to a `scribe` or `doorman`
  /// identified by `hdl` and remove it from this broker.
  template <class Handle>
  auto take(Handle hdl) -> decltype(ptr_of(hdl)) {
    using std::swap;
    auto& elements = get_map(hdl);
    decltype(ptr_of(hdl)) result;
    auto i = elements.find(hdl);
    if (i == elements.end())
      return nullptr;
    swap(result, i->second);
    elements.erase(i);
    return result;
  }
  /// @endcond

  // -- overridden observers of abstract_actor ---------------------------------

  const char* name() const override;

  // -- overridden observers of resumable --------------------------------------

  subtype_t subtype() const override;

  // -- observers --------------------------------------------------------------

  /// Returns the number of open connections.
  size_t num_connections() const noexcept {
    return scribes_.size();
  }

  /// Returns the number of attached doorman for accepting incoming connections.
  size_t num_doormen() const noexcept {
    return doormen_.size();
  }

  /// Returns all handles of all `scribe` instances attached to this broker.
  std::vector<connection_handle> connections() const;

  /// Returns the `multiplexer` running this broker.
  network::multiplexer& backend() {
    return *backend_;
  }

protected:
  void init_broker();

  explicit abstract_broker(actor_config& cfg);

  using doorman_map = std::unordered_map<accept_handle, intrusive_ptr<doorman>>;

  using scribe_map
    = std::unordered_map<connection_handle, intrusive_ptr<scribe>>;

  using datagram_servant_map
    = std::unordered_map<datagram_handle, intrusive_ptr<datagram_servant>>;
  /// @cond PRIVATE

  // meta programming utility
  doorman_map& get_map(accept_handle) {
    return doormen_;
  }

  // meta programming utility
  scribe_map& get_map(connection_handle) {
    return scribes_;
  }

  datagram_servant_map& get_map(datagram_handle) {
    return datagram_servants_;
  }
  /// @endcond

  /// Returns a `scribe` or `doorman` identified by `hdl`.
  template <class Handle>
  auto by_id(Handle hdl) -> decltype(ptr_of(hdl)) {
    auto& elements = get_map(hdl);
    auto i = elements.find(hdl);
    if (i == elements.end())
      return nullptr;
    return std::addressof(*(i->second));
  }

private:
  void launch_servant(scribe_ptr&) {
    // nop
  }

  void launch_servant(doorman_ptr& ptr);

  void launch_servant(datagram_servant_ptr& ptr);

  template <class T>
  typename T::handle_type add_servant(intrusive_ptr<T>&& ptr) {
    CAF_ASSERT(ptr != nullptr);
    CAF_ASSERT(ptr->parent() == nullptr);
    ptr->set_parent(this);
    auto hdl = ptr->hdl();
    launch_servant(ptr);
    get_map(hdl).emplace(hdl, std::move(ptr));
    return hdl;
  }

  template <class T>
  void move_servant(intrusive_ptr<T>&& ptr) {
    CAF_ASSERT(ptr != nullptr);
    CAF_ASSERT(ptr->parent() != nullptr && ptr->parent() != this);
    ptr->set_parent(this);
    CAF_ASSERT(ptr->parent() == this);
    auto hdl = ptr->hdl();
    get_map(hdl).emplace(hdl, std::move(ptr));
  }

  network::multiplexer* backend_ = nullptr;
  scribe_map scribes_;
  doorman_map doormen_;
  datagram_servant_map datagram_servants_;
  byte_buffer dummy_wr_buf_;
};

} // namespace caf::io


text:
ACCEPTED

#### According to
Index Fungorum

#### Published in
null

#### Original name
Paranectria meliolicola var. meliolicola F. Stevens

### Remarks
null


text:
import warnings

# these fixtures will be available for whole tests package
from .fixtures import *  # noqa

# supress all future warnings for better log output
warnings.simplefilter("ignore", FutureWarning)


text:
<?xml version="1.0" encoding="UTF-8"?>
<ti:module xmlns:ti="http://ti.appcelerator.org" xmlns:android="http://schemas.android.com/apk/res/android">
	<!--
		Similar to tiapp.xml, but contains module/platform specific
		configuration in <iphone>, <android>, and <mobileweb> sections
	-->
	<iphone>
	</iphone>
	<android xmlns:android="http://schemas.android.com/apk/res/android">
		<manifest>
			<!-- START COUNT.LY PERMISSIONS SECTION-->
	        <permission android:name="${tiapp.properties['id']}.permission.C2D_MESSAGE" android:protectionLevel="signature" />
			<uses-permission android:name="${tiapp.properties['id']}.permission.C2D_MESSAGE" />
			<uses-permission android:name="android.permission.INTERNET"/>
    		<uses-permission android:name="com.google.android.c2dm.permission.RECEIVE"/>
   			<uses-permission android:name="android.permission.GET_ACCOUNTS"/>
   			<uses-permission android:name="android.permission.WAKE_LOCK"/>

	        <!-- END COUNT.LY PERMISSIONS SECTION-->
	        <!-- START - Application SECTION -->
	        <application>
	        	<meta-data android:name="com.google.android.gms.version" android:value="@integer/google_play_services_version" />
		        <receiver
		            android:name="count.ly.messaging.CountlyMessaging"
		            android:permission="com.google.android.c2dm.permission.SEND" >
		            <intent-filter>
		                <action android:name="com.google.android.c2dm.intent.RECEIVE" />
		                <category android:name="ly.count.android.api" />
		            </intent-filter>
		        </receiver>
		        <service android:name="count.ly.messaging.CountlyMessagingService" >
		            <meta-data android:name="broadcast_action" android:value="ly.count.android.api.broadcast" />
		        </service>
		        <service android:name="count.ly.messaging.TitaniumProxyService" >
		        </service>
				<service android:name="org.openudid.OpenUDID_service">
					<intent-filter>
						<action android:name="org.openudid.GETUDID" />
					</intent-filter>
				</service>
			</application>
	        <!-- END - Application SECTION -->
		</manifest>
	</android>
	<mobileweb>
	</mobileweb>
</ti:module>


text:
<?php

namespace App\Http\Controllers\API;

use App\Http\Requests\API\Createlogify_provisionAPIRequest;
use App\Http\Requests\API\Updatelogify_provisionAPIRequest;
use App\Models\logify_provision;
use App\Repositories\logify_provisionRepository;
use Illuminate\Http\Request;
use App\Http\Controllers\AppBaseController as InfyOmBaseController;
use InfyOm\Generator\Criteria\LimitOffsetCriteria;
use InfyOm\Generator\Utils\ResponseUtil;
use Prettus\Repository\Criteria\RequestCriteria;
use Response;

/**
 * Class logify_provisionController
 * @package App\Http\Controllers\API
 */

class logify_provisionAPIController extends InfyOmBaseController
{
    /** @var  logify_provisionRepository */
    private $logifyProvisionRepository;

    public function __construct(logify_provisionRepository $logifyProvisionRepo)
    {
        $this->logifyProvisionRepository = $logifyProvisionRepo;
    }

    /**
     * @param Request $request
     * @return Response
     *
     * @SWG\Get(
     *      path="/logifyProvisions",
     *      summary="Get a listing of the logify_provisions.",
     *      tags={"logify_provision"},
     *      description="Get all logify_provisions",
     *      produces={"application/json"},
     *      @SWG\Response(
     *          response=200,
     *          description="successful operation",
     *          @SWG\Schema(
     *              type="object",
     *              @SWG\Property(
     *                  property="success",
     *                  type="boolean"
     *              ),
     *              @SWG\Property(
     *                  property="data",
     *                  type="array",
     *                  @SWG\Items(ref="#/definitions/logify_provision")
     *              ),
     *              @SWG\Property(
     *                  property="message",
     *                  type="string"
     *              )
     *          )
     *      )
     * )
     */
    public function index(Request $request)
    {
        $this->logifyProvisionRepository->pushCriteria(new RequestCriteria($request));
        $this->logifyProvisionRepository->pushCriteria(new LimitOffsetCriteria($request));
        $logifyProvisions = $this->logifyProvisionRepository->all();

        return $this->sendResponse($logifyProvisions->toArray(), 'logify_provisions retrieved successfully');
    }

    /**
     * @param Createlogify_provisionAPIRequest $request
     * @return Response
     *
     * @SWG\Post(
     *      path="/logifyProvisions",
     *      summary="Store a newly created logify_provision in storage",
     *      tags={"logify_provision"},
     *      description="Store logify_provision",
     *      produces={"application/json"},
     *      @SWG\Parameter(
     *          name="body",
     *          in="body",
     *          description="logify_provision that should be stored",
     *          required=false,
     *          @SWG\Schema(ref="#/definitions/logify_provision")
     *      ),
     *      @SWG\Response(
     *          response=200,
     *          description="successful operation",
     *          @SWG\Schema(
     *              type="object",
     *              @SWG\Property(
     *                  property="success",
     *                  type="boolean"
     *              ),
     *              @SWG\Property(
     *                  property="data",
     *                  ref="#/definitions/logify_provision"
     *              ),
     *              @SWG\Property(
     *                  property="message",
     *                  type="string"
     *              )
     *          )
     *      )
     * )
     */
    public function store(Createlogify_provisionAPIRequest $request)
    {
        $input = $request->all();

        $logifyProvisions = $this->logifyProvisionRepository->create($input);

        return $this->sendResponse($logifyProvisions->toArray(), 'logify_provision saved successfully');
    }

    /**
     * @param int $id
     * @return Response
     *
     * @SWG\Get(
     *      path="/logifyProvisions/{id}",
     *      summary="Display the specified logify_provision",
     *      tags={"logify_provision"},
     *      description="Get logify_provision",
     *      produces={"application/json"},
     *      @SWG\Parameter(
     *          name="id",
     *          description="id of logify_provision",
     *          type="integer",
     *          required=true,
     *          in="path"
     *      ),
     *      @SWG\Response(
     *          response=200,
     *          description="successful operation",
     *          @SWG\Schema(
     *              type="object",
     *              @SWG\Property(
     *                  property="success",
     *                  type="boolean"
     *              ),
     *              @SWG\Property(
     *                  property="data",
     *                  ref="#/definitions/logify_provision"
     *              ),
     *              @SWG\Property(
     *                  property="message",
     *                  type="string"
     *              )
     *          )
     *      )
     * )
     */
    public function show($id)
    {
        /** @var logify_provision $logifyProvision */
        $logifyProvision = $this->logifyProvisionRepository->find($id);

        if (empty($logifyProvision)) {
            return Response::json(ResponseUtil::makeError('logify_provision not found'), 404);
        }

        return $this->sendResponse($logifyProvision->toArray(), 'logify_provision retrieved successfully');
    }

    /**
     * @param int $id
     * @param Updatelogify_provisionAPIRequest $request
     * @return Response
     *
     * @SWG\Put(
     *      path="/logifyProvisions/{id}",
     *      summary="Update the specified logify_provision in storage",
     *      tags={"logify_provision"},
     *      description="Update logify_provision",
     *      produces={"application/json"},
     *      @SWG\Parameter(
     *          name="id",
     *          description="id of logify_provision",
     *          type="integer",
     *          required=true,
     *          in="path"
     *      ),
     *      @SWG\Parameter(
     *          name="body",
     *          in="body",
     *          description="logify_provision that should be updated",
     *          required=false,
     *          @SWG\Schema(ref="#/definitions/logify_provision")
     *      ),
     *      @SWG\Response(
     *          response=200,
     *          description="successful operation",
     *          @SWG\Schema(
     *              type="object",
     *              @SWG\Property(
     *                  property="success",
     *                  type="boolean"
     *              ),
     *              @SWG\Property(
     *                  property="data",
     *                  ref="#/definitions/logify_provision"
     *              ),
     *              @SWG\Property(
     *                  property="message",
     *                  type="string"
     *              )
     *          )
     *      )
     * )
     */
    public function update($id, Updatelogify_provisionAPIRequest $request)
    {
        $input = $request->all();

        /** @var logify_provision $logifyProvision */
        $logifyProvision = $this->logifyProvisionRepository->find($id);

        if (empty($logifyProvision)) {
            return Response::json(ResponseUtil::makeError('logify_provision not found'), 404);
        }

        $logifyProvision = $this->logifyProvisionRepository->update($input, $id);

        return $this->sendResponse($logifyProvision->toArray(), 'logify_provision updated successfully');
    }

    /**
     * @param int $id
     * @return Response
     *
     * @SWG\Delete(
     *      path="/logifyProvisions/{id}",
     *      summary="Remove the specified logify_provision from storage",
     *      tags={"logify_provision"},
     *      description="Delete logify_provision",
     *      produces={"application/json"},
     *      @SWG\Parameter(
     *          name="id",
     *          description="id of logify_provision",
     *          type="integer",
     *          required=true,
     *          in="path"
     *      ),
     *      @SWG\Response(
     *          response=200,
     *          description="successful operation",
     *          @SWG\Schema(
     *              type="object",
     *              @SWG\Property(
     *                  property="success",
     *                  type="boolean"
     *              ),
     *              @SWG\Property(
     *                  property="data",
     *                  type="string"
     *              ),
     *              @SWG\Property(
     *                  property="message",
     *                  type="string"
     *              )
     *          )
     *      )
     * )
     */
    public function destroy($id)
    {
        /** @var logify_provision $logifyProvision */
        $logifyProvision = $this->logifyProvisionRepository->find($id);

        if (empty($logifyProvision)) {
            return Response::json(ResponseUtil::makeError('logify_provision not found'), 404);
        }

        $logifyProvision->delete();

        return $this->sendResponse($id, 'logify_provision deleted successfully');
    }
}


text:
<?php

/**
 * `RENAME` statement.
 */

namespace SqlParser\Statements;

use SqlParser\Parser;
use SqlParser\Statement;
use SqlParser\Token;
use SqlParser\TokensList;
use SqlParser\Components\RenameOperation;

/**
 * `RENAME` statement.
 *
 * RENAME TABLE tbl_name TO new_tbl_name
 *  [, tbl_name2 TO new_tbl_name2] ...
 *
 * @category   Statements
 *
 * @license    https://www.gnu.org/licenses/gpl-2.0.txt GPL-2.0+
 */
class RenameStatement extends Statement
{
    /**
     * The old and new names of the tables.
     *
     * @var RenameOperation[]
     */
    public $renames;

    /**
     * Function called before the token is processed.
     *
     * Skips the `TABLE` keyword after `RENAME`.
     *
     * @param Parser     $parser the instance that requests parsing
     * @param TokensList $list   the list of tokens to be parsed
     * @param Token      $token  the token that is being parsed
     */
    public function before(Parser $parser, TokensList $list, Token $token)
    {
        if (($token->type === Token::TYPE_KEYWORD) && ($token->value === 'RENAME')) {
            // Checking if it is the beginning of the query.
            $list->getNextOfTypeAndValue(Token::TYPE_KEYWORD, 'TABLE');
        }
    }
}


text:
[TOC]
# Delete Save Key # {#DeleteSaveKey}
Deletes a saved value from permanent storage.

Defined in Fungus.DeleteSaveKey

Property | Type | Description
 --- | --- | ---
Key | System.String | Name of the saved value. Supports variable substition e.g. "player_{$PlayerNumber}

# From String # {#FromString}
Attempts to parse a string into a given fungus variable type, such as integer or float

Defined in Fungus.FromString

Property | Type | Description
 --- | --- | ---
Source String | Fungus.StringVariable | Source of string data to parse into another variables value
Out Value | Fungus.Variable | The variable type to be parsed and value stored within

# Load Variable # {#LoadVariable}
Loads a saved value and stores it in a Boolean, Integer, Float or String variable. If the key is not found then the variable is not modified.

Defined in Fungus.LoadVariable

Property | Type | Description
 --- | --- | ---
Key | System.String | Name of the saved value. Supports variable substition e.g. "player_{$PlayerNumber}"
Variable | Fungus.Variable | Variable to store the value in.

# Random Float # {#RandomFloat}
Sets an float variable to a random value in the defined range.

Defined in Fungus.RandomFloat

Property | Type | Description
 --- | --- | ---
Variable | Fungus.FloatVariable | The variable whos value will be set
Min Value | Fungus.FloatData | Minimum value for random range
Max Value | Fungus.FloatData | Maximum value for random range

# Random Integer # {#RandomInteger}
Sets an integer variable to a random value in the defined range.

Defined in Fungus.RandomInteger

Property | Type | Description
 --- | --- | ---
Variable | Fungus.IntegerVariable | The variable whos value will be set
Min Value | Fungus.IntegerData | Minimum value for random range
Max Value | Fungus.IntegerData | Maximum value for random range

# Read Text File # {#ReadTextFile}
Reads in a text file and stores the contents in a string variable

Defined in Fungus.ReadTextFile

Property | Type | Description
 --- | --- | ---
Text File | UnityEngine.TextAsset | Text file to read into the string variable
String Variable | Fungus.StringVariable | String variable to store the tex file contents in

# Reset # {#Reset}
Resets the state of all commands and variables in the Flowchart.

Defined in Fungus.Reset

Property | Type | Description
 --- | --- | ---
Reset Commands | System.Boolean | Reset state of all commands in the script
Reset Variables | System.Boolean | Reset variables back to their default values

# Save Variable # {#SaveVariable}
Save an Boolean, Integer, Float or String variable to persistent storage using a string key. The value can be loaded again later using the Load Variable command. You can also use the Set Save Profile command to manage separate save profiles for multiple players.

Defined in Fungus.SaveVariable

Property | Type | Description
 --- | --- | ---
Key | System.String | Name of the saved value. Supports variable substition e.g. "player_{$PlayerNumber}
Variable | Fungus.Variable | Variable to read the value from. Only Boolean, Integer, Float and String are supported.

# Set Save Profile # {#SetSaveProfile}
Sets the active profile that the Save Variable and Load Variable commands will use. This is useful to crete multiple player save games. Once set, the profile applies across all Flowcharts and will also persist across scene loads.

Defined in Fungus.SetSaveProfile

Property | Type | Description
 --- | --- | ---
Save Profile Name | System.String | Name of save profile to make active.

# Set Variable # {#SetVariable}
Sets a Boolean, Integer, Float or String variable to a new value using a simple arithmetic operation. The value can be a constant or reference another variable of the same type.

Defined in Fungus.SetVariable

Property | Type | Description
 --- | --- | ---
Variable | Fungus.Variable | The variable whos value will be set
Set Operator | Fungus.SetOperator | The type of math operation to be performed
Boolean Data | Fungus.BooleanData | Boolean value to set with
Integer Data | Fungus.IntegerData | Integer value to set with
Float Data | Fungus.FloatData | Float value to set with
String Data | Fungus.StringDataMulti | String value to set with
Animator Data | Fungus.AnimatorData | Animator value to set with
Audio Source Data | Fungus.AudioSourceData | AudioSource value to set with
Color Data | Fungus.ColorData | Color value to set with
Game Object Data | Fungus.GameObjectData | GameObject value to set with
Material Data | Fungus.MaterialData | Material value to set with
Object Data | Fungus.ObjectData | Object value to set with
Rigidbody2 D Data | Fungus.Rigidbody2DData | Rigidbody2D value to set with
Sprite Data | Fungus.SpriteData | Sprite value to set with
Texture Data | Fungus.TextureData | Texture value to set with
Transform Data | Fungus.TransformData | Transform value to set with
Vector2 Data | Fungus.Vector2Data | Vector2 value to set with
Vector3 Data | Fungus.Vector3Data | Vector3 value to set with

# To String # {#ToString}
Stores the result of a ToString on given variable in a string.

Defined in Fungus.ToString

Property | Type | Description
 --- | --- | ---
Variable | Fungus.Variable | Target variable to get String of.
Out Value | Fungus.StringVariable | Variable to store the result of ToString


text:
import { stringify } from 'query-string';

export default class FetchHttpClient {

  constructor(baseUrl) {
    this.baseUrl = baseUrl || '';
    this.middlewareId = 1;
    this.middlewares = [];
  }

  addMiddleware(middleware) {
    if (!middleware.middlewareId) {
      middleware.middlewareId = this.middlewareId++;
    }
    this.middlewares.push(middleware);

    return this;
  }

  removeMiddleware(middleware) {
    if (!middleware.middlewareId) {
      return this;
    }

    if (this.middlewares[middleware.middlewareId]) {
      delete this.middlewares[middleware.middlewareId];
    }

    return this;
  }

  fetch(path, options = {}) {
    if (typeof fetch !== 'function') {
      throw new TypeError('fetch() function not available');
    }

    options = { headers: {}, ...options };

    const url = this.resolveUrl(path, options.uriParams || {});
    const responseMiddlewares = [];
    const requestPromise = this.middlewares.reduce(
      (promise, middleware) => promise.then(request => {
        const result = middleware(request);
        if (typeof result === 'function') {
          responseMiddlewares.push(result);
        }
        return (result && typeof result !== 'function') ? result : request;
      }),
      Promise.resolve({ url, path, options, fetch })
    ).then(request => request.fetch(request.url, request.options));

    return requestPromise.then(response => responseMiddlewares.reduce(
      (promise, middleware) => promise.then(response => middleware(response) || response),
      Promise.resolve(response)
    ));
  }

  request(path, method, options = {}) {
    return this.fetch(path, { ...options, method });
  }

  get(path, options = {}) {
    return this.request(path, 'GET', options);
  }

  post(path, options = {}) {
    return this.request(path, 'POST', options);
  }

  put(path, options = {}) {
    return this.request(path, 'PUT', options);
  }

  delete(path, options = {}) {
    return this.request(path, 'DELETE', options);
  }

  patch(path, options = {}) {
    return this.request(path, 'PATCH', options);
  }

  resolveUrl(path, variables = {}) {
    if (path.toLowerCase().startsWith('http://')
      || path.toLowerCase().startsWith('https://')
      || path.startsWith('//')) {
      return path;
    }

    const baseUrl = this.baseUrl.replace(/\/+$/g, '');
    let fullUrl = '';

    if (path.startsWith('/')) {
      const rootPos = baseUrl.indexOf('/', baseUrl.indexOf('//') + 2);
      fullUrl = baseUrl.substr(0, rootPos === -1 ? undefined : rootPos) + path;
    } else {
      fullUrl = `${baseUrl}/${path}`;
    }

    fullUrl = fullUrl.replace(/\{(\w+)\}/ig, (match, group) => {
      if (!variables[group]) throw new Error(`Unknown path variable '${group}'.`);
      return encodeURIComponent(variables[group]);
    });

    return fullUrl;
  }
}

export const query = () => request => {
  if (request.options.query) {
    const queryString = stringify(request.options.query);
    if (request.url.indexOf('?') === -1) {
      request.url = request.url.concat('?');
    }
    if (request.url.endsWith('&') || request.url.endsWith('?')) {
      request.url = request.url.concat(queryString);
    } else {
      request.url = request.url.concat('&', queryString);
    }
  }
};

export const form = () => request => {
  if (request.options.form) {
    request.options.body = stringify(request.options.form);
    request.options.headers['Content-Type'] = 'application/x-www-form-urlencoded;charset=UTF-8';
  }
};

export const json = () => request => {
  if (request.options.json) {
    request.options.body = JSON.stringify(request.options.json);
    request.options.headers['Content-Type'] = 'application/json';
  }
  request.options.headers.Accept = 'application/json';

  return response => {
    const contentType = response.headers.get('Content-Type') || '';
    if (contentType.indexOf('json') === -1) return response;
    return response.json().then(json => (response.jsonData = json, response));
  };
};

export const header = headers => request => {
  request.options.headers = { ...request.options.headers, ...headers };
};

export const userAgent = ua => request => {
  const uaSegments = [];
  Object.keys(ua).forEach(key => uaSegments.push(`${key}/${ua[key]}`));
  request.options.headers['User-Agent'] = uaSegments.join(' ');
};

export const credentials = credentials => request => {
  request.options.credentials = credentials;
};

export const timeout = globalTimeout => request => {
  const ms = parseInt(request.options.timeout || globalTimeout, 10);

  if (ms) {
    const fetchRequest = request.fetch;
    const abort = new Promise((resolve, reject) => setTimeout(reject, ms, 'request timeout!'));

    request.fetch = (url, options) => Promise.race([fetchRequest(url, options), abort]);
  }
};


text:
// Copyright 2017 Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
////////////////////////////////////////////////////////////////////////////////

package com.google.crypto.tink.aead;

import static com.google.common.truth.Truth.assertThat;
import static org.junit.Assert.assertThrows;

import com.google.crypto.tink.Aead;
import com.google.crypto.tink.Registry;
import com.google.crypto.tink.config.TinkFips;
import com.google.crypto.tink.config.internal.TinkFipsUtil;
import java.security.GeneralSecurityException;
import org.junit.Assume;
import org.junit.FixMethodOrder;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
import org.junit.runners.MethodSorters;

/**
 * Tests for AeadConfig. Using FixedMethodOrder to ensure that aaaTestInitialization runs first, as
 * it tests execution of a static block within AeadConfig-class.
 */
@RunWith(JUnit4.class)
@FixMethodOrder(MethodSorters.NAME_ASCENDING)
public class AeadConfigTest {

  // This test must run first.
  @Test
  public void aaaTestInitialization() throws Exception {
    Assume.assumeFalse(TinkFips.useOnlyFips());

    GeneralSecurityException e =
        assertThrows(GeneralSecurityException.class, () -> Registry.getCatalogue("tinkmac"));
    assertThat(e.toString()).contains("no catalogue found");
    assertThat(e.toString()).contains("MacConfig.register()");
    e = assertThrows(GeneralSecurityException.class, () -> Registry.getCatalogue("tinkaead"));
    assertThat(e.toString()).contains("no catalogue found");
    assertThat(e.toString()).contains("AeadConfig.register()");
    // Before registration, key manager should be absent.
    String typeUrl = "type.googleapis.com/google.crypto.tink.AesCtrHmacAeadKey";
    e = assertThrows(GeneralSecurityException.class, () -> Registry.getUntypedKeyManager(typeUrl));
    assertThat(e.toString()).contains("No key manager found");

    // Initialize the config.
    AeadConfig.register();

    // After registration the key manager should be present.
    Registry.getKeyManager(typeUrl, Aead.class);

    // Running init() manually again should succeed.
    AeadConfig.register();
  }

  @Test
  public void testNoFipsRegister() throws Exception {
    Assume.assumeFalse(TinkFips.useOnlyFips());

    // Register AEAD key manager
    AeadConfig.register();

    // Check if all key types are registered when not using FIPS mode.
    String[] keyTypeUrls = {
      "type.googleapis.com/google.crypto.tink.AesCtrHmacAeadKey",
      "type.googleapis.com/google.crypto.tink.AesGcmKey",
      "type.googleapis.com/google.crypto.tink.AesEaxKey",
      // AES-GCM-SIV is not included here, as it's not available with the default JCE provider.
      // "type.googleapis.com/google.crypto.tink.AesGcmSivKey",
      "type.googleapis.com/google.crypto.tink.ChaCha20Poly1305Key",
      "type.googleapis.com/google.crypto.tink.XChaCha20Poly1305Key",
    };

    for (String typeUrl : keyTypeUrls) {
      Registry.getKeyManager(typeUrl, Aead.class);
    }
  }

  @Test
  public void testFipsRegisterFipsKeys() throws Exception {
    Assume.assumeTrue(TinkFips.useOnlyFips());
    Assume.assumeTrue(TinkFipsUtil.fipsModuleAvailable());

    // Register AEAD key manager
    AeadConfig.register();

    String[] keyTypeUrls = {
      "type.googleapis.com/google.crypto.tink.AesCtrHmacAeadKey",
      "type.googleapis.com/google.crypto.tink.AesGcmKey",
    };

    for (String typeUrl : keyTypeUrls) {
      Registry.getKeyManager(typeUrl, Aead.class);
    }
  }

  @Test
  public void testFipsRegisterNonFipsKeys() throws Exception {
    Assume.assumeTrue(TinkFips.useOnlyFips());
    Assume.assumeTrue(TinkFipsUtil.fipsModuleAvailable());

    // Register AEAD key manager
    AeadConfig.register();

    // List of algorithms which are not part of FIPS and should not be registered.
    String[] keyTypeUrls = {
      "type.googleapis.com/google.crypto.tink.AesEaxKey",
      "type.googleapis.com/google.crypto.tink.AesGcmSivKey",
      "type.googleapis.com/google.crypto.tink.ChaCha20Poly1305Key",
      "type.googleapis.com/google.crypto.tink.XChaCha20Poly1305Key",
    };

    for (String typeUrl : keyTypeUrls) {
      GeneralSecurityException e =
          assertThrows(
              GeneralSecurityException.class, () -> Registry.getUntypedKeyManager(typeUrl));
      assertThat(e.toString()).contains("No key manager found");
    }
  }
}