精华内容
下载资源
问答
  • dsl模式 java DSL:数字用户线 (DSL: Digital Subscriber Line) DSL is an abbreviation of Digital Subscriber Line. DSL is a channel of communication used over the line of standard telecommunication of ...

    dsl模式 java

    DSL:数字用户线 (DSL: Digital Subscriber Line)

    DSL is an abbreviation of Digital Subscriber Line. DSL is a channel of communication used over the line of standard telecommunication of copper wire to conduct high-speed internet. Over different types of internet access like broadband, DSL provides the perfect price, internet connectivity, and services.

    DSL是Digital Subscriber Line的缩写DSL是用于铜线标准电信线上进行高速互联网通信的信道。 通过宽带等不同类型的Internet访问,DSL可提供完美的价格,Internet连接和服务。

    Over a DSL, the transaction of data and conversation on the telephone can be done at the same time. Voice signal is transferring signals using low frequencies range (0Hz to 4 kHz), over the 'voice band' frequency range, while digital signals are transferring signals through high frequencies (25 kHz to 1.5MHz). DSL filters or splitters are used, to make clear and confirm that no phone call get intervened by high frequencies.

    通过DSL,电话上的数据和对话可以同时进行。 语音信号正在“语音频带”频率范围内使用低频范围(0Hz至4 kHz)传输信号,而数字信号正在通过高频(25 kHz至1.5MHz)传输信号。 使用DSL过滤器或分离器来明确并确认没有电话被高频干扰。

    DSL full form


    Image source: http://pokesoku.co/fax-line-wiring-diagram.html

    图片来源:http://pokesoku.co/fax-line-wiring-diagram.html

    DSL类型 (Types of DSL)

    1. SDSL:

      SDSL

      SDSL is called Symmetric DSL which makes available for use uniform bandwidth for uploading and downloading both and is almost tend to choose by all small corporations.

      SDSL称为对称DSL,它可以使用统一的带宽上载和下载两者,几乎所有小型公司都倾向于选择。

    2. ADSL:

      ADSL

      ADSL is called Asymmetric DSL. In ADSL, downstream speed is higher than upstream. ADSL is used by those users who download more data than uploading. Uploading potential may not that much better as downloading potential. Those users who do not upload too much as compared to downloading can use ADSL. It may provide while uploading 1.5 Mbps, on the other hand, it provides as high as 20 Mbps speed in case of downloading.

      ADSL被称为非对称DSL。 在ADSL中,下行速度高于上行速度。 下载数据多于上载的那些用户使用ADSL。 上传潜力可能不如下载潜力那么好。 与下载相比上传不太多的用户可以使用ADSL。 它可以在上载1.5 Mbps时提供,另一方面,在下载的情况下可以提供高达20 Mbps的速度。

    3. HDSL:

      HDSL

      HDSL is called a high bit-rate Digital Subscriber Line. It is a broadband digital communication that is used between the telephone company and its clients and also inside a corporate area. It is a regular consistent line, provides uniform bandwidth in both directions.

      HDSL被称为高比特率数字用户线。 它是在电话公司及其客户之间以及公司内部使用的宽带数字通信。 这是一条规则的一致线,可在两个方向上提供均匀的带宽。

    4. RADSL:

      RADSL

      RADSL is called rate-adaptive DSL. The modem can alter bandwidth and controlling the functioning of speed to increase the transfer of data in this RADSL technology. The applications it supports are both symmetrical and asymmetrical with non-uniform speeds.

      RADSL称为速率自适应DSL。 在此RADSL技术中,调制解调器可以更改带宽并控制速度功能以增加数据传输。 它支持的应用程序具有不均匀的速度,既对称又不对称。

    5. VDSL:

      VDSL

      VDSL is called a very high data rate DSL. It provides a more genuine experience of the internet than fundamental broadband because it is a developing DSL technology. Over short distances, it provides a huge rate of data transfer than other related services e.g. 50 to 55 Mbps over lines up to 300 meters in length.

      VDSL被称为超高数据速率DSL。 比起基本的宽带,它提供了更真实的互联网体验,因为它是一种正在发展的DSL技术。 在短距离内,与其他相关服务相比,它可提供巨大的数据传输速率,例如,最长300米的线路上的速度为50至55 Mbps。

    特征 (Features)

    • It is worldwide accessible.

      它是全球可访问的。

    • It provides more security and cost less.

      它提供了更高的安全性并降低了成本。

    • It provides a more genuine internet experience than other broadband services.

      它提供比其他宽带服务更真实的互联网体验。

    • It provides less speed in comparison to broadband services.

      与宽带服务相比,它提供的速度较慢。

    • It provides a restricted range due to the larger distance between the main hub DSL provider and receiver which also affects the standard of the internet.

      由于主集线器DSL提供者和接收者之间的距离较大,因此它提供了有限的范围,这也影响了Internet的标准。

    翻译自: https://www.includehelp.com/dictionary/dsl-full-form.aspx

    dsl模式 java

    展开全文
  • DSL淘 用于基于模式DSL构建的工具
  • 它使用定义数据库模式,并根据DSL更新数据库模式。 (例如厨师/木偶) 变更日志 >= 0.4.8 activerecord-mysql-unsigned现在是可选的。 如果要使用,请在安装 --enable-mysql-unsigned之后传递--enable-mysql-...
  • Avro::Builder提供了一个Ruby DSL来创建模式。 创建此DSL的原因是: Ruby不支持 。 Avro IDL仅可用于定义协议。 可以从IDL协议中将模式提取为JSON,但是对导入的支持仍然有限。 提供有关我们为何开发avro-...
  • 7.6、LSM6DSL_SENSOR_HUB模式 文章目录7.6、LSM6DSL_SENSOR_HUB模式7.6.1、简介7.6.2、LSM6DSL_SENSOR_HUB模式7.6.3、sensor_hub直连模式7.6.4 测试结果 7.6.1、简介 硬件概述里面讲了有两种接线模式,其中第二种...

    7.6、LSM6DSL_SENSOR_HUB模式

    7.6.1、简介

    硬件概述里面讲了有两种接线模式,其中第二种模式允许外部传感器连接到LSM6DSL.

    7.6.2、LSM6DSL_SENSOR_HUB模式

    该模式下的接线图如下所示.

    20210128235446

    在模式2(SENSOR HUB mode)下,最多有四个传感器连接到LSM6DSL器件的I2C主接口.有两种触发方式.

    • 和加速度计数据就绪信号(MAX 104HZ)同步(内部触发)

    • 将传感器的触发信号连接到INT2,最大ODR取决于两个连续触发信号之间可以执行的读/写操作数量.

    关于这个模式我也仔细过了一遍,重点说一下可以配置的项,如果要使用的话可以参考AN5040文档.

    • sensor_hub模式有一个总开关(MASTER_CONFIG寄存器)

    • LSM6DSL内部有一个关于从设备的IIC上拉开关
      (MASTER_CONFIG寄存器)

    • 从设备数据有两种触发方式可选(MASTER_CONFIG寄存器)

    • SLVX_ADD存放从设备的IIC地址和读写操作的选择位(X = 0,1,2,3)

    • SLVX_SUBADD存放从设备的(写/读)操作的寄存器地址(X = 0,1,2,3)

    • SLVEX_CONFIG有点复杂,需要阅读原文档.且每一个都有一点细微的差别.

    • 20210129002438

    7.6.3、sensor_hub直连模式

    简单说一下,直连模式个sensor_hub模式是两个模式.直连的等效电路如下所示.

    20210128233709

    我用的就是直连模式,sensor_hub模式并未使用,所以配置方法相对而言比较简单,共有如下两步.

    1. 关闭sensor_hub模式(默认关闭).

    2. 打开直连模式.

    具体代码如下(添加到lsm6dsl.c).

    int32_t LSM6DSL_Enable_Func(LSM6DSL_Object_t *pObj)
    {
      int32_t ret = LSM6DSL_OK;
        /*  设定master_config的 MASTER_ON位 */
      if (lsm6dsl_sh_master_set(&(pObj->Ctx), PROPERTY_DISABLE) != LSM6DSL_OK)
      {
        return LSM6DSL_ERROR;
      }
      /*  设定master_config的 PASS_THROUGH_MODE */
      if(lsm6dsl_sh_pass_through_set(&(pObj->Ctx), PROPERTY_ENABLE) != LSM6DSL_OK)
      {
        return LSM6DSL_ERROR;
      }
      return ret;
    }
    

    如果想要sensor_hub模式和直连模式同时使用,那么配置可能就比较麻烦,可能有如下三种情形.

    1. sensor_hub模式为内部触发,且不使用直连功能时,INT2引脚无限制.

    2. sensor_hub模式为内部触发,但使用直连功能时,INT2引脚必须接地.不能使用外部触发信号,不能使用INT2引脚.

    3. sensor_hub模式为外部触发,且直连功能不使用,INT2引脚必须连接到外部传感器的数据准备就绪引脚.并且必须执行如下操作避免与INT2的> 冲突.如下所示.

    20210129000649

    比较复杂,我只挂载了一个传感器使用的直连模式.所以没有尝试.关于两种模式同时初始化的方法如下所示.

    20210129001114

    关于更具体的可以参考官方AN5040文档.里面有较为详细的介绍,只是在阅读的时候需要多读几遍,翻译的不是很好,有点难理解.

    7.6.4 测试结果

    在只使用直连模式的情况下,测试结果如下所示.

    20210129001411

    展开全文
  • Kotlin中用DSL代替建造者模式

    千次阅读 2018-07-12 13:34:51
    原文:Kotlin-ifying a Builder Pattern 原文地址:... 原文作者:Doug Sigelbaum 翻译:却把清梅嗅 在Java语言中,当一个对象的实例化需要多个参数时,建造者模式(Bui...

    原文:Kotlin-ifying a Builder Pattern
    原文地址:https://medium.com/google-developers/kotlin-ifying-a-builder-pattern-e5540c91bdbe
    原文作者:Doug Sigelbaum
    翻译:却把清梅嗅

    译者说

    Doug Sigelbaum是Google的Android工程师,在这篇文章中,作者讲述了如何用Kotlin中Builder模式的实现方式,并且针对会出现的问题提出了对应的解决方案。

    我最近在网上翻看了很多Kotlin对Builder模式实现方式的文章,说实话,个人感觉都不是很好,当我阅读到这篇文章时,我认为这是目前我 比较满意 的实现方式(可能Google有加分),因此翻译下来以供大家参考。


    在Java语言中,当一个对象的实例化需要多个参数时,建造者模式(Builder)已被认可为非常好的实现方式之一。 正如《Effective Java》指出的,当一个构造器拥有太多的参数时,对于构造器中所需参数的修改很容易影响到实际的代码。

    当然,Kotlin语言中的命名参数在许多情况下解决了这个问题,因为在调用Kotlin的函数时,开发者可以指定每个参数的名称,从而减少错误的发生。 但是,由于Java并没有这样的特性,因此Builder模式仍然是有必要的。 此外,对于可选参数的动态设置,这种情况下也需要借助于Builder模式。

    让我们思考一下通过Java实现的一个简单的Builder模式案例。 我们首先有一个POJO Company类,它包含几个属性,也许这种情况足以使用Builder模式:

    public final class Company {
        public final String name;
        public final double marketCap;
        public final double annualCosts;
        public final double annualRevenue;
        public final List<Employee> employees;
        public final List<Office> offices;
    
        private Company(Builder builder) {
            List<Employee> builtEmployees = new ArrayList<>();
            for (Employee.Builder employee : builder.employees) {
                builtEmployees.add(employee.build());
            }
            List<Office> builtOffices = new ArrayList<>();
            for (Office.Builder office : builder.offices) {
                builtOffices.add(office.build());
            }
            employees = Collections.unmodifiableList(builtEmployees);
            offices = Collections.unmodifiableList(builtOffices);
            name = builder.name;
            marketCap = builder.marketCap;
            annualCosts = builder.annualCosts;
            annualRevenue = builder.annualRevenue;
        }
    
        public static class Builder {
            private String name;
            private double marketCap;
            private double annualCosts;
            private double annualRevenue;
            private List<Employee.Builder> employees = new ArrayList<>();
            private List<Office.Builder> offices = new ArrayList<>();
    
            public Company build() {
                return new Company(this);
            }
    
            public Builder addEmployee(Employee.Builder employee) {
                employees.add(employee);
                return this;
            }
    
            public Builder addOffice(Office.Builder office) {
                offices.add(office);
                return this;
            }
    
            public Builder setName(String name) {
                this.name = name;
                return this;
            }
    
            public Builder setMarketCap(double marketCap) {
                this.marketCap = marketCap;
                return this;
            }
    
            public Builder setAnnualCosts(double annualCosts) {
                this.annualCosts = annualCosts;
                return this;
            }
    
            public Builder setAnnualRevenue(double annualRevenue) {
                this.annualRevenue = annualRevenue;
                return this;
            }
        }
    }

    此外,公司有List和List。 这些类也使用构建器模式:

    public final class Employee {
        public final String firstName;
        public final String lastName;
        public final String id;
        public final boolean isManager;
        public final String managerId;
    
        private Employee(Builder builder) {
            this.firstName = builder.firstName;
            this.lastName = builder.lastName;
            this.id = builder.id;
            this.isManager = builder.isManager;
            this.managerId = builder.managerId;
        }
    
        public static class Builder {
            private String firstName;
            private String lastName;
            private String id;
            private boolean isManager;
            private String managerId;
    
            Employee build() {
                return new Employee(this);
            }
    
            public Builder setFirstName(String firstName) {
                this.firstName = firstName;
                return this;
            }
    
            public Builder setLastName(String lastName) {
                this.lastName = lastName;
                return this;
            }
    
            public Builder setId(String id) {
                this.id = id;
                return this;
            }
    
            public Builder setIsManager(boolean manager) {
                isManager = manager;
                return this;
            }
    
            public Builder setManagerId(String managerId) {
                this.managerId = managerId;
                return this;
            }
        }
    }

    来看看Office.java:

    public final class Office {
        public final String address;
        public final int capacity;
        public final int occupancy;
        public final int sqft;
    
        private Office(Builder builder) {
            address = builder.address;
            capacity = builder.capacity;
            occupancy = builder.occupancy;
            sqft = builder.sqft;
        }
    
        public static class Builder {
            private String address;
            private int capacity;
            private int occupancy;
            private int sqft;
    
            Office build() {
                return new Office(this);
            }
    
            public Builder setAddress(String address) {
                this.address = address;
                return this;
            }
    
            public Builder setCapacity(int capacity) {
                this.capacity = capacity;
                return this;
            }
    
            public Builder setOccupancy(int occupancy) {
                this.occupancy = occupancy;
                return this;
            }
    
            public Builder setSqft(int sqft) {
                this.sqft = sqft;
                return this;
            }
        }
    }

    现在,如果我们想构建一个包含Employee和Office的Company,我们可以这样:

    public class JavaClient {
        public Company buildCompany() {
            Company.Builder company = new Company.Builder();
            Employee.Builder employee = new Employee.Builder()
                    .setFirstName("Doug")
                    .setLastName("Sigelbaum")
                    .setIsManager(false)
                    .setManagerId("XXX");
            Office.Builder office = new Office.Builder()
                    .setAddress("San Francisco")
                    .setCapacity(2500)
                    .setOccupancy(2400);
            company.setAnnualCosts(0)
                    .setAnnualRevenue(0)
                    .addEmployee(employee)
                    .addOffice(office);
            return company.build();
        }
    }

    在Kotlin中,我们会这样去实现:

    class KotlinClient {
        fun buildCompany(): Company {
            val company = Company.Builder()
            val employee = Employee.Builder()
                .setFirstName("Doug")
                .setLastName("Sigelbaum")
                .setIsManager(false)
                .setManagerId("XXX")
            val office = Office.Builder()
                .setAddress("San Francisco")
                .setCapacity(2500)
                .setOccupancy(2400)
            company.setAnnualCosts(0.0)
                .setAnnualRevenue(0.0)
                .addEmployee(employee)
                .addOffice(office)
            return company.build()
        }
    }

    Kotlin中实现Lambda参数的方法封装

    在Dokka(译者注:这应该是作者之前所在的一个公司),我们使用kotlinx.html,它可以通过一个漂亮的DSL来实例化HTML的对象。 在Android中,它和通过Anko Layouts构建布局类似。 正如我在上一篇文章中所讨论的,slice-builders-ktx还在Builder模式之外提供了DSL包装器。 所有这些库都使用lambda参数提供了DSL的实现方式。 Lambda参数在Kotlin和Java 8+中可用,它们的使用方式略有不同。 有很多同行朋友,特别是Android开发者,都在使用Java 7,我们只会在这篇文章中简单使用一下Kotlin lambda参数。 现在让我们尝试为Company类提供DSL的支持!

    顶层的封装(Top Level Wrapper)

    这里是Kotlin中的一个顶层函数,这个函数将会为Company对象提供DSL的唯一支持:

    inline fun company(buildCompany: Company.Builder.() -> Unit): Company {
        val builder = Company.Builder()
        // Since `buildCompany` is an extension function for Company.Builder,
        // buildCompany() is called on the Company.Builder object.
        builder.buildCompany()
        return builder.build()
    }

    注意:这里我们使用了 内联函数(inline) 以避免lambda的额外开销。

    因为方法中的lambda参数类型为 Company.Builder.() -> Unit ,因此,该lambda中所有语句都处于Company.Builder的内部。现在,通过Kotlin的语法,我们可以通过调用build()以获得Company.Builder的实例,而不是直接实例化Builder:

    class KtxClient1 {
        fun buildCompany(): Company {
            return company {
                // `this` scope is the Company.Builder being built.
                addEmployee(
                    Employee.Builder()
                        .setFirstName("Doug")
                        .setLastName("Sigelbaum")
                        .setIsManager(false)
                        .setManagerId("XXX")
                )
                addOffice(
                    Office.Builder()
                        .setAddress("San Francisco")
                        .setCapacity(2500)
                        .setOccupancy(2400)
                )
            }
        }
    }

    封装嵌套的Builder

    我们现在可以为Company.Builder添加更多扩展函数,以避免直接实例化或将Employee.Builders或Office.Builders添加到父Company.Builder。 这是一个潜在的解决方案:

    inline fun Company.Builder.employee(
        buildEmployee: Employee.Builder.() -> Unit
    ) {
        val builder = Employee.Builder()
        builder.buildEmployee()
        addEmployee(builder)
    }
    
    inline fun Company.Builder.office(buildOffice: Office.Builder.() -> Unit) {
        val builder = Office.Builder()
        builder.buildOffice()
        addOffice(builder)
    }

    通过这些拓展函数,在Kotlin中的使用方式等效变成了:

    class KtxClient2 {    
        fun buildCompany(): Company {
            return company {
                employee {
                    setFirstName("Doug")
                    setLastName("Sigelbaum")
                    setIsManager(false)
                    setManagerId("XXX")
                }
                office {
                    setAddress("San Francisco")
                    setCapacity(2500)
                    setOccupancy(2400)
                }
            }
        }
    }

    几乎大功告成了! 我们已经完成了对Builder中API的优化,但是我们不得不面对一个新问题:

    class KtxBadClient {  
        fun buildBadCompany(): Company {
            return company {
                employee {
                    setFirstName("Doug")
                    setLastName("Sigelbaum")
                    setIsManager(false)
                    setManagerId("XXX")
                    employee {
                        setFirstName("Sean")
                        setLastName("Mcq")
                        setIsManager(false)
                        setManagerId("XXX")
                    }
                }
                office {
                    setAddress("San Francisco")
                    setCapacity(2500)
                    setOccupancy(2400)
                }
            }
        }
    }

    不幸的是,我们把一个employee的Builder嵌套进入了另外一个employee的Builder中,但是这样仍然会通过编译并运行!在Kotlin中,类的作用范围似乎发生了混乱,这意味着,company { … } 的lambda代码块中,这些嵌套的lambda代码块中都可以任意访问Employee.Builder和Company.Builder中的内容。现在,代码将两名员工(Employee)“Doug”和“Sean”添加到公司(Company),但是这两名员工实际上并没有直接的关系。

    当作用域发生混乱时,如何修改扩展函数以避免上例所示的错误呢? 换句话说,我们该如何才能使我们的DSL类型安全? 幸运的是,Kotlin 1.1引入了DslMarker注释类来解决这个问题。

    使用DslMarker注解保证DSL的类型安全

    让我们首先创建一个使用了DslMarker注解的注解类:

    @DslMarker
    annotation class CompanyDsl

    现在,如果使用@CompanyDsl注释了一些类,开发者将无法对多个接收器进行隐式地访问,这些接收器的类位于带注释的类集中。 相反,调用者只能使用最近的作用域隐式访问接收器。

    DslMarker注解类,位于Kotlin的stdlib包中,因此您需要添加其依赖。 如果没有的话,您可以尝试对构建器进行子类化,并在Kotlin封装好的函数中使用这些子类:

    @CompanyDsl
    class CompanyBuilderDsl : Company.Builder()
    
    @CompanyDsl
    class EmployeeBuilderDsl : Employee.Builder()
    
    @CompanyDsl
    class OfficeBuilderDsl : Office.Builder()
    
    inline fun company(buildCompany: CompanyBuilderDsl.() -> Unit): Company {
        val builder = CompanyBuilderDsl()
        // Since `buildCompany` is an extension function for Company.Builder,
        // buildCompany() is called on the Company.Builder object.
        builder.buildCompany()
        return builder.build()
    }
    
    inline fun CompanyBuilderDsl.employee(
        buildEmployee: EmployeeBuilderDsl.() -> Unit
    ) {
        val builder = EmployeeBuilderDsl()
        builder.buildEmployee()
        addEmployee(builder)
    }
    
    inline fun CompanyBuilderDsl.office(
        buildOffice: OfficeBuilderDsl.() -> Unit
    ) {
        val builder = OfficeBuilderDsl()
        builder.buildOffice()
        addOffice(builder)
    }

    现在,我们重复之前错误的行为,会得到下面的提示:

    …can’t be called in this context by implicit receiver. Use the explicit one if necessary.

    完美,大功告成!

    展开全文
  • 一个输出JSON模式DSL
  • 从轻量级DSL生成JSON模式。 最初是为了生成标准规范的definitions部分。 安装 从下载二进制文件,或者如果您已经设置了cargo ,请使用如下所示的`cargo install。 $ cargo install chema 用法 chema 0.0.8 ...
  • sql方式,会复制development数据库中的外键...而test:units执行的时候是根据environment.rb里的config.active_record.schema_format = sql设置(注释掉时为ruby dsl模式)来判断用哪种模式的。通过使用rake test:u...
    sql方式,会复制development数据库中的外键。相反,在schema模式下的外键是被完全忽略的,即使开发数据库里有,也不会复制到test数据库里。

    而test:units执行的时候是根据environment.rb里的config.active_record.schema_format = sql设置(注释掉时为ruby dsl模式)来判断用哪种模式的。通过使用rake test:units --trace我们可以看见两者的差别:(忽略invoke,只看execute)

    ruby dsl模式的schema下执行的task:
    ** Invoke test:units (first_time)
    ** Invoke db:test:prepare (first_time)
    ** Invoke environment (first_time)
    ** Execute environment
    ** Execute db:test:prepare
    ** Invoke db:test:clone (first_time)
    ** Invoke db:schema:dump (first_time)
    ** Invoke environment
    ** Execute db:schema:dump
    ** Execute db:test:clone
    ** Invoke db:schema:load (first_time)
    ** Invoke environment
    ** Execute db:schema:load
    ** Execute test:units
    ...

    sql模式的schema下执行的task:
    ** Invoke test:units (first_time)
    ** Invoke db:test:prepare (first_time)
    ** Invoke environment (first_time)
    ** Execute environment
    ** Execute db:test:prepare
    ** Invoke db:test:clone_structure (first_time)
    ** Invoke db:structure:dump (first_time)
    ** Invoke environment
    ** Execute db:structure:dump
    ** Invoke db:test:purge (first_time)
    ** Invoke environment
    [b]** Execute db:test:purge [/b]
    ** Execute db:test:clone_structure
    ** Execute test:units

    具体的task内部代码就不展开讨论了,关键差别是sql模式知道有外键存在,所以多了一个db:test:purge直接删整个数据库而不管表顺序一一删除的操作。而schema模式假设没有外键,只是简单用load。load这个操作就是删一个再建一个的,这某种程度上是ruby dsl风格的schema的限制所致(必须顺序执行,不能事先检查外键依赖关系)。

    所以解决办法就是:先purge掉test数据库,然后设好config.active_record.schema_format要外键的用sql格式,不要外键用ruby dsl格式(但是has_many之类关联设置后面最好设一下:dependent参数)。然后直接用test:units,不用事先自己建立test表结构。
    展开全文
  • 想必大家对建造者模式也有一定了解,我们今天不走寻常路,使用 DSL 的方法优雅地实现建造者模式。 先上代码 data class User(var id: String = "", var username: String = "default", var ...
  • groovy的dsl

    2011-02-10 02:57:41
    本文记录groovy dsl相关的内容,通过对语法层面的探索,描述...讨论一下常用的dsl模式   groovy利于dsl的语言特性: dsl的易用性取决于其语法结构是否贴近domain。groovy的动态特性有利于定义关键字和书写结构...
  • 用于 graphql-java 的 Kotlin GraphQL 测试 DSL 这是一个 kotlin DSL,可轻松为您的应用程序编写(集成)测试。 它受到启发,让您可以使用从响应中快速检索结果。 Gradle testImplementation( " ...
  • DSL

    2008-12-03 16:04:00
    数字用户线路(DSL)是基于普通电话线的宽带接入技术,DSL有许多模式,通常把所有DSL技术统称为XDSL。 按数据的上行和下行分类:对称与非对称两种。 对称:HDSL、SDSL等主要应用在视频会议、远程教学、移动电站基站...
  • Matchete 为基于 Ruby 模式匹配的方法重载提供了 DSL。 这只是受weissbier和使用的方法定义使用返回值DSL技术启发的快速黑客 它仅支持ruby 2.1+ 特征 on [:value, Integer]匹配具有相同内部结构的 arg on '#method...
  • 用于模式转换的Python DSL 文件: : 看,您可以将方钉放在圆Kong中: class SquarePeg ( Schema ): id = IntegerField () name = UnicodeField () width = NumberField () class RoundHole ( Schema ): id ...
  • jennifer.cr:使用ActiveRecord模式和灵活查询DSL的Crystal ORM
  • slick-migration-api:用于Slick的模式操作方言和DSL
  • RITA DSL 这是一种宽松地基于语言的语言,专注于编写手动语言规则,该规则可编译为兼容模式或纯正则表达式。 这些模式可用于执行以及在其他过程中使用,例如重新标记和纯匹配 简介视频 链接 支持 安装 pip install ...
  • DSL 模式编译到src\generated\java文件夹中并将其打包到target\model.jar 编译主程序,打包到target\dsl-platform-json-example.jar 最后,它将运行 jar(Main.java 程序)以显示一个工作示例 使用 JsonWriter...
  • 当您制作 Ruby DSL 时,您通常必须在以下各项之间做出决定: # Use a block variable to access the MyConfig instance. # This gives you the benefit of having access to the outer "self" inside of the block...
  • 为了为使用imgcook在多个平台上生成代码的用户提供更好的体验,我们提供了将imgcook模式转码为您喜欢的任何编程语言的Open DSL System(开放域特定语言系统)。 开发人员可以使用imgcook提供的默认DSL(React,React...
  • Phase提供了一种简单,直观,易于编写和易于处理的模式语言,用于声明可以转换为正式JSON Schema的类型信息,用于验证JSON数据。 有关更多信息,请参见以下内容: [JSON概述]( 概述) [JSON模式概述]( 模式概述...
  • 在寻找Builder模式的解释时,您可能会发现一些文章都展示了专门用于创建对象的类。 这很简单,我们可以进一步研究这种模式。... from: https://dev.to//vga/builder-pattern-a-first-step-to-dsl-47de
  • diffhask:用于在Haskell中进行正向和反向模式自动区分的DSL。 DiffSharp的港口
  • 在上个月的文章中 ,我展示了一些示例,这些示例使用特定于域的语言(DSL)来收集惯用模式 ,这些惯用模式在代码中被定义为常见的设计习惯用法。 (我在“ Composited method and SLAP ”中介绍了惯用模式的概念。)...
  • 在许多情况下...Java DSL只是一种组装一些复杂配置,然后将...
  • Scala的DSL生成JSON模式和为您的Web服务文档。 为什么不仅仅使用Swagger-core? 尽管在某种程度上可用于Scala项目,但受到一些严重限制: 它在很大程度上依赖Java运行时反射来为您的数据模型生成Json模式。 这...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 554
精华内容 221
热门标签
关键字:

dsl模式