标签: behavior

我在表单上有一些控件,我将它们固定在表单的左侧和右侧,以确保它们随表单增长和缩小.我的表单也设置为自动增长和缩小,以适应可能获得长字符串的一些标签.当这些标签移除长字符串时,我希望我的表单恢复到之前的宽度.在我的表格上左右固定的所述控件似乎阻止了这种情况.我可以按照我的意图使它工作吗？

我已经谷歌了一段时间试图找到一个解决方案没有真正的运气.我试图运行jBehave测试时得到这个 -

org.jbehave.scenario.errors.ScenarioNotFoundException: Path '$Path_to_jBehave_Directory' 
could not be found by classloader sun.misc.Launcher$AppClassLoader@f4a24a ...

我的文本场景,Steps类和scenario类都在同一目录中($ Path_to_jBehave_Directory).

这是我在我的maven pom中使用的:

<dependency>
  <groupId>org.jbehave</groupId>
  <artifactId>jbehave-core</artifactId>
  <version>2.5</version>
</dependency>

任何帮助将不胜感激!

我遇到了一个具有挑战性的问题,并希望得到一些建议.我有活动数据,我想以图形方式显示,我正在寻找可用于解决我的问题的包或程序(最好是R).

数据是Activity每小时()收集的运动计数(Time of day)持续3周(Calendar Date)或更多与相关变量(Food/ Vegetation).

通常情况下,正如我所知,数据可以在一个名为Clocklab的程序中处理和绘制,这是一个Matlab产品.然而,增加的复杂性是希望根据饲喂组的分类绘制该数据.我试图在R中找到一个公平的程序/包,但是已经很短了.

数据看起来很简单:

Activity     time of day      Food type         Calendar Date
       0           01:00              B            03/24/2007
      13           02:00            ---            03/24/2007
       0           03:00              B            03/24/2007
       0           04:00              B            03/24/2007
       :               :              :                     :
    1246           18:00              C            03/24/2007
    3423           19:00              C            03/24/2007
       :               :              :                     :
       0           00:00            ---            03/25/2007

这个数据是昼夜节律,循环,活动预算,我希望有一个可能是3-D的图表,它将显示饮食选择以及与该饮食相关的多少活动随着时间的推移绘制多天/周.我会通过个人然后在人口水平上做到这一点.我已经通过程序Clocklab通常生成的程序和示例图的链接.

在团结CSHARP,我想打一个GetOrAddComponent方法,这将简化respectives GetComponent和AddComponent(没有充分的理由,我想).

通常的方法是:

// this is just for illustrating a context
using UnityEngine;
class whatever : MonoBehavior {
public Transform child;
void whateverMethod () {

    BoxCollider boxCollider = child.GetComponent<BoxCollider>();
    if (boxCollider == null) {
        boxCollider = child.gameObject.AddComponent<BoxCollider>();
    }

}}

现在我可以上这堂课...:

public class MyMonoBehaviour : MonoBehaviour {

    static public Component GetOrAddComponent (Transform child, System.Type type) {
        Component result = child.GetComponent(type);
        if (result == null) {
            result = child.gameObject.AddComponent(type);
        }
        return result;
    }

}

...这样可行: …

我在以下代码中体验了(对我来说)奇怪的运行时行为:

public class Main{

    private final static long ROUNDS = 1000000;
    private final static double INITIAL_NUMBER = 0.45781929d;
    private final static double DIFFERENCE = 0.1250120303d;


    public static void main(String[] args){

        doSomething();
        doSomething();
        doSomething();
    }


    private static void doSomething(){

        long begin, end;
        double numberToConvert, difference;


        numberToConvert = INITIAL_NUMBER;
        difference = DIFFERENCE;

        begin = System.currentTimeMillis();

        for(long i=0; i<ROUNDS; i++){

            String s = "" + numberToConvert;

            if(i % 2 == 0){
                numberToConvert += difference;
            }
            else{
                numberToConvert -= difference;
            }
        }

        end = …

使用json_encode编码日期的阵列,它有时做一两件事,有时做另一个.

例如,如果我正在尝试编码如下:

array(6) {
  [0]=>
  string(6) "Jun-24"
  [1]=>
  string(6) "Jun-25"
  [2]=>
  string(6) "Jun-28"
  [3]=>
  string(11) "Training-24"
  [4]=>
  string(6) "Jun-29"
  [5]=>
  string(6) "Jun-30"
}

它会输出

["Jun-24","Jun-25","Jun-28","Training-24","Jun-29","Jun-30"]

但是,当我尝试编码类似的东西时:

array(17) {
  [0]=>
  string(6) "Jun-23"
  [1]=>
  string(6) "Jun-24"
  [2]=>
  string(6) "Jun-28"
  [3]=>
  string(11) "Training-24"
  [4]=>
  string(6) "Jun-29"
  [5]=>
  string(6) "Jun-30"
  [6]=>
  string(6) "Jul-06"
  [7]=>
  string(6) "Jul-07"
  [9]=>
  string(6) "Jul-09"
  [10]=>
  string(6) "Jul-16"
  [11]=>
  string(6) "Jul-17"
  [12]=>
  string(6) "Jul-20"
  [13]=>
  string(6) "Jul-23"
  [14]=>
  string(6) "Jul-24"
  [15]=>
  string(6) "Jul-30"
  [16]=>
  string(6) "Aug-01"
  [17]=>
  string(6) …

我已经default在接口中创建了用于实现equals(Object)和hashCode()以可预测方式的方法.我使用反射来迭代类型(类)中的所有字段以提取值并进行比较.代码依赖于Apache Commons Lang及其HashCodeBuilder和EqualsBuilder.

问题是我的测试告诉我,第一次调用这些方法时,第一次调用需要花费更多的时间.计时器使用System.nanoTime().以下是日志中的示例:

Time spent hashCode: 192444
Time spent hashCode: 45453
Time spent hashCode: 48386
Time spent hashCode: 50951

实际代码:

public interface HashAndEquals {

    default <T> int getHashCode(final T type) {
        final List<Field> fields = Arrays.asList(type.getClass().getDeclaredFields());
        final HashCodeBuilder builder = new HashCodeBuilder(31, 7);
        fields.forEach( f -> {
            try {
                f.setAccessible(true);
                builder.append(f.get(type));
            } catch (IllegalAccessException e) {
                throw new GenericException(e.toString(), 500);
            }
        });
        return builder.toHashCode();
    }

    default <T, …

我在Python 2.7.8的命令行上玩,我遇到了这种行为:

>>> "902".isdigit() == True
True
>>> "902".isdigit(), "2".isdigit() == True
(True, True)
>>> "902".isdigit(), "2".isdigit() == True,True
(True, True, True)
>>> ("902".isdigit(), "2".isdigit()) == (True,True)

我发现这令人惊讶.我本来希望>>> "902".isdigit(), "2".isdigit() == True,True简单地返回True,好像我已经用括号中的两个表达式包围它们使它们成为元组.为什么Python会返回这个布尔元组而不是单个元素？这个元组代表什么布尔比较？

在聚合物1.0中,我有一个定义属性和方法的行为脚本:

<script>
dataBehavior = {
  properties: {
    data: {
      type: Array,
      value: null,
      observer: 'dataChanged'
    }
  },
  dataChanged: function(newValue, oldValue) {
    console.log('default stuff');
  }
};
</script>

以及使用该行为的组件:

<dom-module id="my-module">
  <template>
  </template>
  <script>
  Polymer({
    is: "my-module",
    behaviors: [dataBehavior],
    dataChanged: function(newValue, oldValue) {
      // How to call the dataChanged method from dataBehavior?
      // this.super.dataChanged(); <- don't works!
      console.log('custom stuff');
    }
  });
  </script>
</dom-module>

当我更改数据属性时,执行的方法来自my-module,因此它会生成"自定义内容".如果我删除my-module中的dataChanged方法,则执行"default stuff".

如何执行默认行为的方法和组件的方法？

如果可能,我不想将代码从"dataBehavior.dataChanged"复制到"my-module.dataChanged".我想在组件的方法中调用行为的方法; 我可以使用"超级"之类的东西来引用行为脚本吗？

非常感谢你的答案!

对于编写一个非常大的程序，我认为没有办法减轻必须为每个使用某种共享行为的结构编写相同的代码。

例如，Dog 可能会“吠叫”：

struct Dog {
    is_barking: bool,
    ....
}
impl Dog {
    pub fn bark(self) {
        self.is_barking = true;
        emit_sound("b");
        emit_sound("a");
        emit_sound("r");
        emit_sound("k");
        self.is_barking = false;
    }
    ....
}

这种狗的许多品种可能存在：

struct Poodle {
    unique_poodle_val: &str
}
impl Poodle {
    pub fn unique_behaviour(self) {
        self.some_behaviour();
    }
}

struct Rottweiler {
    unique_rottweiler_val: u32
}
impl Rottweiler{
    pub fn unique_behaviour(self) {
        self.some_behaviour();
    }
}

问题是，以我目前的知识来看，Rust 似乎无法做到这一点，但它需要完成，我需要一个解决方法：

1. 允许贵宾犬和罗威纳犬使用该品种不需要考虑的完全相同的行为吠叫。
2. 无需在每个品种模块中重新编码 bark() 就可以实现这一点，这是编程地狱，因为它会导致重复的代码，并且每个模块都必须实现 bark()。
3. Traits 是相反的，不能访问结构体，因此 default-trait 实现不起作用。Rust 不支持类似 OOP 的继承，这里也不需要它。

因此，我问：既然贵宾犬和罗威纳犬的吠叫方式完全相同，那么如何在不重写每个模块中的 bark() 的情况下实现 bark() …