text:
<!DOCTYPE html>

        <meta charset="utf-8">
        <meta http-equiv="X-UA-Compatible" content="IE=edge">
        <title></title>
        <meta name="description" content="">

        <link rel="stylesheet" href="css/normalize.css">
        <link rel="stylesheet" href="css/common.css">
        <link rel="stylesheet" href="css/result.css">

^

                HOME
                PROJECT
                MATERIALS&METHOD
                RESULT
                FUTURE
                TEAM

Origami

AuNPs

MNPs

Assemble

Control

Recognition

Result

                Step Ⅰ : Assembling of DNA tube

                1.1 Optimize the condition to assemble the DNA tube

To explore the best reaction condition, we designed a series of gradient experiment of Mg2+ concentration and reaction time. At first, we change the Mg2+ concentration from 15mM to 6mM when we set the reaction time for 2.5 hours. Fig1.1 shows the result of trial. From this trail we can find that the best Mg2+ concentration is 8mM. Then we need to make sure the time of origami reaction. Besides, we also wonder if 8mM is still the best concentration for origami when reaction time changes. And the result was shown in Fig 1.2.

Fig1.1 1% agarose gel electrophoresis of samples from reaction with different Mg2+ concentration.

Fig1.2 1% agarose gel electrophoresis Gradient of Mg2+ and time. Three lanes on the left was samples from reaction spending 2.5 hours, while three lanes on the right was samples from reaction spending 5 hours. The last one on the right is a control reaction reagents (Mg2+ concentration is 8mM) that was place at 4℃.

                Finally we were sure that the best concentration of Mg2+ of the assembling reaction is 8mM and 2.5 hours reaction time is better for origami reaction, the optimization result was demonstrated in Fig1.3.

Fig1.3 1% agarose gel electrophoresis Mg2+ concentration is 8mM and reaction time is 2.5 hours

Step Ⅱ:Synthesis and modification of gold nanoparticles

2.1 Synthesis of gold seed

Figure 2.1: hydrodynamic size of gold seed (Average size: 27.35nm )

                We adopted seed growth strategy to synthesize 30nm gold nanoparticle . So we synthesize 10nm nano-gold seed firstly. Having synthesized the gold seed, we measure the hydrodynamic sphere size with laser particle  analyzer. Figure 2.1 shows the hydrodynamic size of gold seed is 27.18 nm in diameter. According the previous data of our laboratory, the diameter of gold seed is about 10nm.

2.2 synthesis of gold nanoparticle

Figure 2.2: hydrodynamic size of unmarried Au NP

Figure 2.3: zeta potential of unmodified Au NP

Figure 2.4: TEM image of Au NP (TEM diameter: 30nm)

While incubating with Mercaptosuccinic acid (MSA) and HAuCl4, seeds grew up gradually. Finally we got the gold nanoparticle which is about 50nm in hydrate diameter and 30nm diameter under TEM.  We also measured the zeta potential.

2.3 linkage with sulfhydryl ssDNA

Figure 2.5: hydrdynamic of modified Au NP

Figure 2.6: zeta potential of modified Au NP

Figure 2.7: TEM image of modified Au NP

In order to link with DNA tube, we modified hundreds of sulfhydryl ssDNA on the surface. After incubating with ssDNA for two days, we measure the hydrate size and zeta potential again. Compared with unmodified  Au NP, hydrodynamic size and zeta potential became larger. So we conclude AuNP has conjugated ssDNA. The TEM image shows that Au NP has been totally surrounded by ssDNA.

Step Ⅲ:modification of gold nanoparticle

3.1 magnetic nanoparticle conjugated F-BAS

Figure 3.1: Hydrate size of unmodified MP

Figure 3.2: Hydrate size of modified MP

Figure3.3: TEM image of modified MP (accelerating voltage: 75KV Magnification 10000 X)

Before modification and after linked with F-BAS system, we measured the zeta potential and hydrodynamic size of magnetic nanoparticles. The result shows that the hydrodynamic size become larger after modification, which suggests the magnetic nanoparticles has linked with F-BAS.

Step Ⅳ:Assemble of Nano-robot

4.1 TEM image of Nano-robot

Figure 4.1: TEM image of Nano-robot (accelerating voltage: 75KV Magnification 10000 X)

We finally find our target structure under TEM. It is similar to our originally designed Nano-robot. The length is about 400nm. We also realized that the AuNP was surrounded by magnetic nanoparticles. As magnetic nanoparticles is tend to aggregate, it's understandable to find our nano-robot with excess magnetic nanoparticles aggregated.

Development

                Control

After assembling of nanotube to magnetic nanoparticles and gold nanoparticles, we still need to verify that our Nano-ship can move under the control of magnetic fields. Then we can tell that our Nano-ship can be used for targeted therapy. We plan to view result under Confocal Laser Scanning Microscope (CLSM) for our Nano-ship can fluoresce. Just like Fig5.1 and these video:

            http://www.rsc.org/suppdata/jm/c0/c0jm04014b/figs1.avi
            http://www.rsc.org/suppdata/jm/c0/c0jm04014b/figs2.avi
            http://www.rsc.org/suppdata/jm/c0/c0jm04014b/figs3.avi
            http://www.rsc.org/suppdata/jm/c0/c0jm04014b/figs4.avi

Fig 5.1 A demonstration of our Nano-ship swinging and advancing under the control of magnetic fields

                Recognition and damage

In our project, we linked aptamer[2] to the head of Nano-ship so that it can recognize cancer cells within a cell mass. (Fig 5.2). To reach this goal, we need to mark the cancer cells and normal cells in different fluorescence. Then we can test by viewing the fluorescence.

Fig5.2 Nano-ship can recognize cancer cells within a mass of cells.

                    HOME
                    PROJECT
                    MATERIALS&METHOD
                    RESULT
                    FUTURE
                    TEAM

CONTACT

BIOMOD-HUST

BiomodHUST2014@gmail.com


text:
name: Feature request
about: Suggest a feature for KEditor (not include component)
title: "[Feature request]"
labels: Request features
assignees: ''

---

**Functionality**
A clear and concise description of your suggestion.

redpajama_set_name: RedPajamaGithub


text:
class Manufacturer < ActiveRecord::Base
  has_many :products

  validates_length_of :name, :in => 2..255
  validates_uniqueness_of :name
  attr_accessible :name
end


text:
<?php

namespace AntiMattr\Tests\Sears\RequestHandler;

use AntiMattr\Sears\Format\XMLBuilder;
use AntiMattr\Sears\Model\Shipment;
use AntiMattr\Sears\RequestHandler\ShipmentRequestHandler;
use AntiMattr\Tests\AntiMattrTestCase;
use Buzz\Message\Request;
use DateTime;
use Doctrine\Common\Collections\ArrayCollection;

class ShipmentRequestHandlerTest extends AntiMattrTestCase
{
    private $requestHandler;

    private static $xml;

    public static function setUpBeforeClass()
    {
        self::$xml = file_get_contents(dirname(__DIR__).'/Resources/fixtures/rest_oms_import_v5_asn.xml');
    }

    public static function tearDownAfterClass()
    {
        self::$xml = NULL;
    }

    protected function setUp()
    {
        $this->xmlBuilder = new XMLBuilder();
        $this->requestHandler = new ShipmentRequestHandler($this->xmlBuilder);
    }

    public function testConstructor()
    {
        $this->assertInstanceOf('AntiMattr\Sears\RequestHandler\AbstractRequestHandler', $this->requestHandler);
    }

    public function testBindCollection()
    {
        $request = new Request();
        $collection = new ArrayCollection();
        $item = new Shipment();

        $item->setId('00601780002');
        $item->setPurchaseOrderId('0060180');
        $item->setPurchaseOrderDate($this->newDateTime('2009-09-26'));
        $item->setTrackingNumber('UPS1XXX');
        $item->setShipAt($this->newDateTime('2001-01-01'));
        $item->setCarrier('UPS');
        $item->setMethod('GROUND');
        $item->setLineItemNumber('1');
        $item->setProductId('AB12345678912345456789123456789CD');
        $item->setQuantity('1');
        $collection->add($item);

        $this->requestHandler->bindCollection($request, $collection);

        $content = $request->getContent();

        $this->assertXmlStringEqualsXmlString(self::$xml, $content);
    }

}


text:
> Bind all methods in an object

## Install

```
$ npm install --save bind-object
```

## Usage

```js
var bindObject = require('bind-object')
var object = {
  foo: function () {
    return this.bar
  },
  bar: 'baz'
}
bindObject(object)
var foo = object.foo
foo() // => 'baz'
```

## API

#### `bindObject(object)` -> `object`

Binds the functions in an object to the object itself and ignores other values. Returns the original object for convenience.

##### object

*Required*
Type: `object`

The object to bind.

## License

MIT © [Ben Drucker](http://bendrucker.me)


text:
class S2BooleanOperation {
 public:
  // The supported operation types.
  enum class OpType {
    UNION,                // Contained by either region.
    INTERSECTION,         // Contained by both regions.
    DIFFERENCE,           // Contained by the first region but not the second.
    SYMMETRIC_DIFFERENCE  // Contained by one region but not the other.
  };
  // Translates OpType to one of the strings above.
  static const char* OpTypeToString(OpType op_type);

  // Defines whether polygons are considered to contain their vertices and/or
  // edges (see definitions above).
  enum class PolygonModel { OPEN, SEMI_OPEN, CLOSED };

  // Defines whether polylines are considered to contain their endpoints
  // (see definitions above).
  enum class PolylineModel { OPEN, SEMI_OPEN, CLOSED };

  // With Precision::EXACT, the operation is evaluated using the exact input
  // geometry.  Predicates that use this option will produce exact results;
  // for example, they can distinguish between a polyline that barely
  // intersects a polygon from one that barely misses it.  Constructive
  // operations (ones that yield new geometry, as opposed to predicates) are
  // implemented by computing the exact result and then snap rounding it
  // according to the given snap_function() (see below).  This is as close as
  // it is possible to get to the exact result while requiring that vertex
  // coordinates have type "double".
  //
  // With Precision::SNAPPED, the input regions are snapped together *before*
  // the operation is evaluated.  So for example, two polygons that overlap
  // slightly will be treated as though they share a common boundary, and
  // similarly two polygons that are slightly separated from each other will
  // be treated as though they share a common boundary.  Snapped results are
  // useful for dealing with points, since in S2 the only points that lie
  // exactly on a polyline or polygon edge are the endpoints of that edge.
  //
  // Conceptually, the difference between these two options is that with
  // Precision::SNAPPED, the inputs are snap rounded (together), whereas with
  // Precision::EXACT only the result is snap rounded.
  enum class Precision { EXACT, SNAPPED };

  // SourceId identifies an edge from one of the two input S2ShapeIndexes.
  // It consists of a region id (0 or 1), a shape id within that region's
  // S2ShapeIndex, and an edge id within that shape.
  class SourceId {
   public:
    SourceId();
    SourceId(int region_id, int32 shape_id, int32 edge_id);
    explicit SourceId(int32 special_edge_id);
    int region_id() const { return region_id_; }
    int32 shape_id() const { return shape_id_; }
    int32 edge_id() const { return edge_id_; }
    // TODO(ericv): Convert to functions, define all 6 comparisons.
    bool operator==(SourceId other) const;
    bool operator<(SourceId other) const;

   private:
    uint32 region_id_ : 1;
    uint32 shape_id_ : 31;
    int32 edge_id_;
  };

  class Options {
   public:
    Options();

    // Convenience constructor that calls set_snap_function().
    explicit Options(const S2Builder::SnapFunction& snap_function);

    // Specifies the function to be used for snap rounding.
    //
    // DEFAULT: s2builderutil::IdentitySnapFunction(S1Angle::Zero())
    // [This does no snapping and preserves all input vertices exactly unless
    //  there are crossing edges, in which case the snap radius is increased
    //  to the maximum intersection point error (S2::kIntersectionError.]
    const S2Builder::SnapFunction& snap_function() const;
    void set_snap_function(const S2Builder::SnapFunction& snap_function);

    // Defines whether polygons are considered to contain their vertices
    // and/or edges (see comments above).
    //
    // DEFAULT: PolygonModel::SEMI_OPEN
    PolygonModel polygon_model() const;
    void set_polygon_model(PolygonModel model);

    // Defines whether polylines are considered to contain their vertices (see
    // comments above).
    //
    // DEFAULT: PolylineModel::CLOSED
    PolylineModel polyline_model() const;
    void set_polyline_model(PolylineModel model);

    // Specifies whether a polyline loop is considered to have a non-empty
    // boundary.  By default this option is true, meaning that even if the
    // first and last vertices of a polyline are the same, the polyline is
    // considered to have a well-defined "start" and "end".  For example, if
    // the polyline boundary model is OPEN then the polyline loop would not
    // include the start/end vertices.  These are the best semantics for most
    // applications, such as GPS tracks or road network segments.
    //
    // If the polyline forms a loop and this option is set to false, then
    // instead the first and last vertices are considered to represent a
    // single vertex in the interior of the polyline.  In this case the
    // boundary of the polyline is empty, meaning that the first/last vertex
    // will be contained by the polyline even if the boundary model is OPEN.
    // (Note that this option also has a small effect on the CLOSED boundary
    // model, because the first/last vertices of a polyline loop are
    // considered to represent one vertex rather than two.)
    //
    // The main reason for this option is to implement the "mod 2 union"
    // boundary semantics of the OpenGIS Simple Features spec.  This can be
    // achieved by making sure that all polylines are constructed using
    // S2Builder::Graph::PolylineType::WALK (which ensures that all polylines
    // are as long as possible), and then setting this option to false.
    //
    // DEFAULT: true
    bool polyline_loops_have_boundaries() const;
    void set_polyline_loops_have_boundaries(bool value);

    // Specifies whether the operation should use the exact input geometry
    // (Precision::EXACT), or whether the two input regions should be snapped
    // together first (Precision::SNAPPED).
    //
    // DEFAULT: Precision::EXACT
    Precision precision() const;
    // void set_precision(Precision precision);

    // If true, the input geometry is interpreted as representing nearby
    // geometry that has been snapped or simplified.  It then outputs a
    // conservative result based on the value of polygon_model() and
    // polyline_model().  For the most part, this only affects the handling of
    // degeneracies.
    //
    // - If the model is OPEN, the result is as open as possible.  For
    //   example, the intersection of two identical degenerate shells is empty
    //   under PolygonModel::OPEN because they could have been disjoint before
    //   snapping.  Similarly, two identical degenerate polylines have an
    //   empty intersection under PolylineModel::OPEN.
    //
    // - If the model is CLOSED, the result is as closed as possible.  In the
    //   case of the DIFFERENCE operation, this is equivalent to evaluating
    //   A - B as Closure(A) - Interior(B).  For other operations, it affects
    //   only the handling of degeneracies.  For example, the union of two
    //   identical degenerate holes is empty under PolygonModel::CLOSED
    //   (i.e., the hole disappears) because the holes could have been
    //   disjoint before snapping.
    //
    // - If the model is SEMI_OPEN, the result is as degenerate as possible.
    //   New degeneracies will not be created, but all degeneracies that
    //   coincide with the opposite region's boundary are retained unless this
    //   would cause a duplicate polygon edge to be created.  This model is
    //   is very useful for working with input data that has both positive and
    //   negative degeneracies (i.e., degenerate shells and holes).
    //
    // DEFAULT: false
    bool conservative_output() const;
    // void set_conservative_output(bool conservative);

    // If specified, then each output edge will be labelled with one or more
    // SourceIds indicating which input edge(s) it corresponds to.  This
    // can be useful if your input geometry has additional data that needs to
    // be propagated from the input to the output (e.g., elevations).
    //
    // You can access the labels by using an S2Builder::Layer type that
    // supports labels, such as S2PolygonLayer.  The layer outputs a
    // "label_set_lexicon" and an "label_set_id" for each edge.  You can then
    // look up the source information for each edge like this:
    //
    // for (int32 label : label_set_lexicon.id_set(label_set_id)) {
    //   const SourceId& src = source_id_lexicon.value(label);
    //   // region_id() specifies which S2ShapeIndex the edge is from (0 or 1).
    //   DoSomething(src.region_id(), src.shape_id(), src.edge_id());
    // }
    //
    // DEFAULT: nullptr
    ValueLexicon<SourceId>* source_id_lexicon() const;
    // void set_source_id_lexicon(ValueLexicon<SourceId>* source_id_lexicon);

    // Options may be assigned and copied.
    Options(const Options& options);
    Options& operator=(const Options& options);

   private:
    std::unique_ptr<S2Builder::SnapFunction> snap_function_;
    PolygonModel polygon_model_ = PolygonModel::SEMI_OPEN;;
    PolylineModel polyline_model_ = PolylineModel::CLOSED;
    bool polyline_loops_have_boundaries_ = true;
    Precision precision_ = Precision::EXACT;
    bool conservative_output_ = false;
    ValueLexicon<SourceId>* source_id_lexicon_ = nullptr;
  };

  S2BooleanOperation(OpType op_type,
                     std::unique_ptr<S2Builder::Layer> layer,
                     const Options& options = Options());

  // Specifies that the output boundary edges should be sent to three
  // different layers according to their dimension.  Points (represented by
  // degenerate edges) are sent to layer 0, polyline edges are sent to
  // layer 1, and polygon edges are sent to layer 2.
  //
  // The dimension of an edge is defined as the minimum dimension of the two
  // input edges that produced it.  For example, the intersection of two
  // crossing polyline edges is a considered to be a degenerate polyline
  // rather than a point, so it is sent to layer 1.  Clients can easily
  // reclassify such polylines as points if desired, but this rule makes it
  // easier for clients that want to process point, polyline, and polygon
  // inputs differently.
  //
  // The layers are always built in the order 0, 1, 2, and all arguments to
  // the Build() calls are guaranteed to be valid until the last call returns.
  // All Graph objects have the same set of vertices and the same lexicon
  // objects, in order to make it easier to write classes that process all the
  // edges in parallel.
  S2BooleanOperation(OpType op_type,
                     std::vector<std::unique_ptr<S2Builder::Layer>> layers,
                     const Options& options = Options());

  OpType op_type() const { return op_type_; }

  // Executes the given operation.  Returns true on success, and otherwise
  // sets "error" appropriately.  (This class does not generate any errors
  // itself, but the S2Builder::Layer might.)
  bool Build(const S2ShapeIndex& a, const S2ShapeIndex& b,
             S2Error* error);

  // Convenience method that returns true if the result of the given operation
  // is empty.
  static bool IsEmpty(OpType op_type,
                      const S2ShapeIndex& a, const S2ShapeIndex& b,
                      const Options& options = Options());

  // Convenience method that returns true if A intersects B.
  static bool Intersects(const S2ShapeIndex& a, const S2ShapeIndex& b,
                         const Options& options = Options()) {
    return !IsEmpty(OpType::INTERSECTION, b, a, options);
  }

  // Convenience method that returns true if A contains B, i.e., if the
  // difference (B - A) is empty.
  static bool Contains(const S2ShapeIndex& a, const S2ShapeIndex& b,
                       const Options& options = Options()) {
    return IsEmpty(OpType::DIFFERENCE, b, a, options);
  }

  // Convenience method that returns true if the symmetric difference of A and
  // B is empty.  (Note that A and B may still not be identical, e.g. A may
  // contain two copies of a polyline while B contains one.)
  static bool Equals(const S2ShapeIndex& a, const S2ShapeIndex& b,
                     const Options& options = Options()) {
    return IsEmpty(OpType::SYMMETRIC_DIFFERENCE, b, a, options);
  }

 private:
  class Impl;  // The actual implementation.

  // Internal constructor to reduce code duplication.
  S2BooleanOperation(OpType op_type, const Options& options);

  // Specifies that "result_empty" should be set to indicate whether the exact
  // result of the operation is empty (contains no edges).  This constructor
  // is used to efficiently test boolean relationships (see IsEmpty above).
  S2BooleanOperation(OpType op_type, bool* result_empty,
                     const Options& options = Options());

  OpType op_type_;
  Options options_;

  // The input regions.
  const S2ShapeIndex* regions_[2];

  // The output consists either of zero layers, one layer, or three layers.
  std::vector<std::unique_ptr<S2Builder::Layer>> layers_;

  // The following field is set if and only if there are no output layers.
  bool* result_empty_;
};

//////////////////   Implementation details follow   ////////////////////

inline S2BooleanOperation::SourceId::SourceId()
    : region_id_(0), shape_id_(0), edge_id_(-1) {
}

inline S2BooleanOperation::SourceId::SourceId(
    int region_id, int32 shape_id, int32 edge_id)
    : region_id_(region_id), shape_id_(shape_id), edge_id_(edge_id) {
}

inline S2BooleanOperation::SourceId::SourceId(int special_edge_id)
    : region_id_(0), shape_id_(0), edge_id_(special_edge_id) {
}

inline bool S2BooleanOperation::SourceId::operator==(SourceId other) const {
  return (region_id_ == other.region_id_ &&
          shape_id_ == other.shape_id_ &&
          edge_id_ == other.edge_id_);
}

inline bool S2BooleanOperation::SourceId::operator<(SourceId other) const {
  if (region_id_ < other.region_id_) return true;
  if (region_id_ > other.region_id_) return false;
  if (shape_id_ < other.shape_id_) return true;
  if (shape_id_ > other.shape_id_) return false;
  return edge_id_ < other.edge_id_;
}

#endif  // S2_S2BOOLEAN_OPERATION_H_


text:
module Basil
  module Email
    # This class represents a parsed email. Headers are accessed like
    # array indices and body is provided as a method. The parsing is
    # naive, but it works for our purpose.
    class Mail
      include Dispatchable

      attr_reader :body

      def self.parse(content)
        header_lines = []
        headers      = {}

        lines = content.split(/\r\n/)

        while !(line = lines.shift).empty?
          if line =~ /^\s+(.*)/ # continuation
            last = header_lines.pop
            line = "#{last} #{$1}" if last
          end

          header_lines << line
        end

        body = lines.join("\n")

        header_lines.each do |hl|
          if hl =~ /^([^:]+):(.*)$/
            headers[$1] = $2.strip
          end
        end

        new(headers, body)
      end

      def initialize(headers, body)
        @headers, @body = headers, body
      end

      def [](arg)
        @headers[arg]
      end

      def each_plugin(&block)
        Plugin.email_checkers.each(&block)
      end

      def match?(plugin)
        plugin.match?(self['Subject'])
      end

      def to_message
        Message.new(
          :to   => Config.me,
          :from => self['From'],
          :text => body,
          :chat => 'email'
        )
      end

      def to_s
        "#<Mail from: #{self['From']}, subject: #{self['Subject']} >"
      end

    end
  end
end


text:
layout: post
title: Max-Margin Tensor Neural Network for Chinese Word Segmentation
subtitle: Title of paper - Max-Margin Tensor Neural Network for Chinese Word Segmentation
category: NLP papers - Tagging
tags: [tagging]
permalink: /2020/05/03/Max-Margin_Tensor_Neural_Network_for_Chinese_Word_Segmentation/
css : /css/ForYouTubeByHyun.css
bigimg:
  - "/img/Image/BigImages/carmel.jpg" : "Carmel-by-the-Sea, CA (2016)"
  - "/img/Image/BigImages/monterey.jpg" : "Monterey, CA (2016)"
  - "/img/Image/BigImages/stanford_dish.jpg" : "Stanford Dish, CA (2016)"
  - "/img/Image/BigImages/marian_beach_in_sanfran.jpg" : "MRINA of San Francisco, CA (2016)"
  - "/img/Image/BigImages/carmel2.jpg" : "Carmel-by-the-Sea, CA (2016)"
  - "/img/Image/BigImages/marina.jpg" : "MRINA of San Francisco, CA (2016)"
  - "/img/Image/BigImages/sanfrancisco.jpg" : "San Francisco, CA (2016)"

---

This is a brief summary of paper for me to study and arrange for [Max-Margin Tensor Neural Network for Chinese Word Segmentation (Pei et al., ACL 2014)](https://www.aclweb.org/anthology/P14-1028/) I read and studied.
{% include MathJax.html %}

This paper is a research ralted to chinese word segmentation task.

They said that the existing study of chinese word segmeantationa used manual feature engineerings, however the neural network model alleviate the burden of manual feature engineering.

The following is an example of feature engineering they explained.

![Pei et al., ACL 2014](/img/Image/NaturalLanguageProcessing/NLPLabs/Paper_Investigation/Tagging/2020-05-03-Max-Margin_Tensor_Neural_Network_for_Chinese_Word_Segmentation/feature_engineering.PNG)

so they propose an model to utilize neural network with tensor.

The reason that they use tensor as alternative of non-linear transformation

That is because non-linear transformation poorly models the complex interaction wihch is between tags and characters(e.g. context and target character).

Frist of all, before diving into their model let's see conventional model for chines word segmenation.

The conventional model is as follows:

![Pei et al., ACL 2014](/img/Image/NaturalLanguageProcessing/NLPLabs/Paper_Investigation/Tagging/2020-05-03-Max-Margin_Tensor_Neural_Network_for_Chinese_Word_Segmentation/conventional_model.PNG)

The model is simple, they use an window for context character embedding and then compute hidden layer with concatenation of the center and context character embedding.

Finally it evaluates score for each tag types.

They propose Max-margin Tensor Neural Network to model tag-tag, tag-character and character-character interactions in neural network as follows:

![Pei et al., ACL 2014](/img/Image/NaturalLanguageProcessing/NLPLabs/Paper_Investigation/Tagging/2020-05-03-Max-Margin_Tensor_Neural_Network_for_Chinese_Word_Segmentation/feature_engineering.PNG)

They regarded each slice of the tensor as capturing a specific type of tag-character interaction and character-character interaction.

The following is bilinear form with tensor on vector a.

![Pei et al., ACL 2014](/img/Image/NaturalLanguageProcessing/NLPLabs/Paper_Investigation/Tagging/2020-05-03-Max-Margin_Tensor_Neural_Network_for_Chinese_Word_Segmentation/tensor-based_transformation.PNG)

For tensor operation, it is expensive and has the risk of overfitting so they proposed tesor factorization as follows:

![Pei et al., ACL 2014](/img/Image/NaturalLanguageProcessing/NLPLabs/Paper_Investigation/Tagging/2020-05-03-Max-Margin_Tensor_Neural_Network_for_Chinese_Word_Segmentation/tensor_factorization.PNG)

 Note(Abstract):
Recently, neural network models for natural language processing tasks have been increasingly focused on for their ability to alleviate the burden of manual feature engineering. In this paper, they propose a novel neural network model for Chinese word segmentation called Max-Margin Tensor Neural Network (MMTNN). By exploiting tag embeddings and tensorbased transformation, MMTNN has the ability to model complicated interactions between tags and context characters. Furthermore, a new tensor factorization approach is proposed to speed up the model and avoid overfitting. Their model can achieve a competitive performance with minimal feature engineering. Despite Chinese word segmentation being a specific case, MMTNN can be easily generalized and applied to other sequence labeling tasks.

 Download URL:

  The paper: Max-Margin Tensor Neural Network for Chinese Word Segmentation (Pei et al., ACL 2014)

# Reference

- Paper
  - [ACL Version: Max-Margin Tensor Neural Network for Chinese Word Segmentation (Pei et al., ACL 2014)](https://www.aclweb.org/anthology/P14-1028/)

- How to use html for alert
  - [how to use icon](http://idratherbewriting.com/documentation-theme-jekyll/mydoc_icons.html)


text:
<!doctype html>

		<title>Zabuun - Learn Egyptian Arabic for English speakers</title>
		<meta name="description" content="">
		<?php include $_SERVER['DOCUMENT_ROOT'].'/layout/head.php';?>

		<?php include $_SERVER['DOCUMENT_ROOT'].'/layout/ie8.php';?>
		<?php include $_SERVER['DOCUMENT_ROOT'].'/layout/header.php';?>

			<?php include $_SERVER['DOCUMENT_ROOT'].'/layout/side.php';?>

Essays > Who Is a Hero?

						Expand All | Collapse All

Who Is a Hero?

  Soldiers go to war. They fight the enemy. That is their job. Firemen go to fires. They rescue people in burning buildings. That is their job. Policemen go after dangerous criminals. They arrest dangerous criminals. That is their job. Phil was driving home. The car in front of him ran off the road. Phil pulled over behind the car. He ran to the car. He smelled gasoline. He saw an old woman inside the car. He pulled and pulled on the driver's door. It finally opened. He pulled her out of the car. He carried her toward his car. Suddenly, her car exploded. Metal flew through the air. Metal went into Phil's back. Phil fell to the ground. Ambulances took Phil and the old woman to the hospital. Doctors operated on both of them. They both survived. Phil said, "I'm not a hero. I did what anyone would do."

		<?php include $_SERVER['DOCUMENT_ROOT'].'/layout/footer.php';?>
		<?php include $_SERVER['DOCUMENT_ROOT'].'/layout/scripts.php';?>


text:
@echo OFF
if "%1"=="" goto blankplat
if "%2"=="" goto blankver
if "%1"=="wnt" goto goodbuild
if "%1"=="w2k" goto goodbuild
echo Unknown build platform: %1 %2
goto usage
:blankplat
echo Must specify build platform (wnt, w2k)!
goto usage
:blankver
echo Must specify build version (eg. 0.98)
:usage
echo usage: BINSTALLER plat ver
echo   where plat is wnt or w2k
echo   and ver is version (eg 0.98)
goto fini

:goodbuild
set plat=%1
set ver=%2
set tmpfile=iss.SetupVars.tmp
echo Building installer for platform %plat% for version %ver%
echo   Assuming existence of dist.%plat%.d!
echo SourceDir=dist.%plat%.d > %tmpfile%
goto %plat%

:wnt
echo AppVerName=Alpine %ver% >> %tmpfile%
echo OutputBaseFilename=setup_alpine_%ver% >> %tmpfile%
echo UninstallDisplayName=Alpine %ver% >> %tmpfile%
goto goodbuildcont
:w2k
echo AppVerName=Alpine %ver% (with Windows Kerberos) >> %tmpfile%
echo OutputBaseFilename=setup_alpine_%ver%_w2k >> %tmpfile%
echo UninstallDisplayName=Alpine %ver% (with Windows Kerberos) >> %tmpfile%
goto goodbuildcont

:goodbuildcont
iscc alpine.iss
del %tmpfile%
echo Done.

:fini


text:
<!DOCTYPE html>

	<meta charset="utf-8" />
  <meta name="viewport" content="width=device-width" />
  <title>Ben Taylor</title>
  <link href='http://fonts.googleapis.com/css?family=Lato:100,300,400,700,400italic' rel='stylesheet' type='text/css'>
  <link href='http://fonts.googleapis.com/css?family=Open+Sans:400italic,400,300,600' rel='stylesheet' type='text/css'>
  <link href='http://fonts.googleapis.com/css?family=Hind:400,300,600' rel='stylesheet' type='text/css'>
	<link rel="stylesheet" href="foundation/css/foundation.css" />

	<link rel="stylesheet" href="css/style.css" />

			Home

			Teaching

			Publications

			Bio

Hi, I'm Ben.


text:
namespace Spyder.Client.Common
{
    public enum CalcType
    {
        Linear,
        Velocity,
        Bezier,
        Hermite
    }
}


text:
=begin

Copyright (c) 2015, Koichiro Tamura/Toshinari Naminatsu/Yuki Ishikawa/Tatsuya Onishi/Mamoru Endo/Kenji Suzuki

This software is released under the BSD 2-Clause License.

http://opensource.org/licenses/BSD-2-Clause

=end

require 'set'

# for schedule tables ("スケジュール" in old intrasite)
class SchedulesController < ArticlesController

  skip_before_filter :login_required, :only => [:index, :set_schedule_span, :move_schedule_span, :move_simple_calendar]

  Schedule_Header_Local_Info = ["スケジュール情報の交換の場です.",
                                "一般メッセージと同様,記事の宛先(すなわち閲覧者)を個人,グループ,組織で指定できますから,
                                 一般のカレンダと異なり,利用範囲は広大です.",
                                "他人の予定も(許可される範囲で)知ることが出来ます.",
                                "メッセージコーナーで作成した記事に日時を指定すると,このスケジュールコーナーにも載ります."]
  Space_Schedule_Header_Local_Info = ["会議室やミーティングルームなど,場所使用予定の情報を交換します.",
                                      "場所は,「スペース」の木構造で指定します."]

  # :schedule_span parameters
  MONTH = "月(通常形式)"
  WEEK  = "週"
  DAY   = "日"
  MONTH2=  "月(今週から)"
  Default_Span = MONTH

  Holiday = "祝日"

  # for schedules
  Article_Schedule_Item =
    {:id             => "articles.id",
     :run_id         => "articles.run_id",
     :banner_run_id  => "articles.banner_run_id",
     :start_datetime =>  "articles.start_datetime",
     :end_datetime   =>  "articles.end_datetime",
     :title          =>  "articles.title",
     :thread_id      =>  "thread.id",
     :created_by     =>  "articles.created_by",
     :article_class  =>  "article_class",
     :schedule_class => "articles.schedule_class"}

  # for finding lectures current_user attends.
  Articles_AS_Lecture_Schedule =
     ":Article     [(.schedule_class = '授業日' )
                    (.schedule_day_of_week = .day_of_week)
                    (.season in .season) ]
      :LectureTime  >>
      :Lecture     [( >> :Course)
                    (*memberable << :Member)]"

  Lecture_Schedule_Item =
    {:id           => "articles.id",
     :date         => "articles.start_date",
     :lecture_time => "lecture_times.lecture_time",
     :campus       => "lecture_times.campus",
     :lecture_id   => "lectures.id",
     :title        => "courses.name"}

  def index
    @mobile = params[:mobile] == "true"
    catch :flash_now do
      find_collection
    end
    if @mobile
      render :partial => "day_calendar_for_mobile", :layout => "mobiles"
      return false
    end
  end

  def show
    # call ArticlesControler#find_detail
    # this will get its thread detail.
    catch :flash_now do find_detail end
    # render thread detail which includes the schedule article.
    render :update do |page|
      page.replace_html "working_div", :partial => "article_threads/detail"
      page.insert_html :top, "working_div" , :partial => "shared/flash_notice"
      page.insert_html :bottom, "working_div" , :partial => "back_to_calendar"
    end
  end

  # new is for schedule not article.
  #  the controller should be different through the sequence of this action.
  def new
    catch :flash_now do prepare_for_new end
    render :update do |page|
      page.replace_html "working_div", :partial => "shared/committing_template", :locals => {:content_template => "article_threads/new"}
      page.insert_html :bottom, "working_div" , :partial => "back_to_calendar", :locals => {:text => "キャンセル"}
    end
  end

  # move to previous or next schedule_span(MONH, WEEK or DAY)
  # move_direction param is either "+" (next) or "-" (previous) or "0" (today)
  def move_schedule_span
    move_direction = params[:move_direction]
    receive_and_set_background_params

    if move_direction == "0"
      target_date = @show_time
    else
      original_display_time = @background_params[:date].to_datetime(:local)
      move_span =
        case @background_params[:schedule_span]
          when MONTH, MONTH2
            1.month
          when WEEK
            1.week
          when DAY
            1.day
      end
      target_date = original_display_time.send(move_direction, move_span)
    end

    @background_params.merge! :date => target_date.to_s(:db)

    list_again
  end

  # move to previous or next simple calendar
  def move_simple_calendar
    template       = "schedules/simple_calendar"
    div_id         = "simple_calendar"
    move_direction = params[:move_direction]

    if move_direction == "0"
      display_time = @show_time
    else
      original_display_time = params[:display_time].to_datetime(:local)
      display_time = original_display_time.send(move_direction, 1.month)
    end
    render :update do |page|
      page.replace div_id , :partial => template, :locals => {:display_time => display_time}
    end
  end

  def set_schedule_span
    @schedule_span = params[:schedule_span]
    receive_and_set_background_params
    @background_params.merge! :schedule_span => @schedule_span
    list_again
  end

  protected

  # display schdules for month, week, or day of given show_time
  # "dispaly_mode" is "schedules" or "space schedules".
  # MONTH, WEEK, or DAY for input_params[:schedule_span]
  # @schedules is an array of each day with articles including lectures attended by receiver.
  def find_collection(input_params = params)
    @background_params = input_params.symbolize_keys

    @display_mode = input_params[:display_mode] || "schedules"
    @background_params.merge! :display_mode => @display_mode

    if @display_mode == "space_schedules"
      @background_params.merge! :space_span => input_params[:space_span] || Space::Default
    end

    @mobile = input_params[:mobile] == "true"
    @background_params.merge! :mobile => @mobile

    @header_local_info = case @display_mode
      when "schedules"       then Schedule_Header_Local_Info
      when "space_schedules" then Space_Schedule_Header_Local_Info
    end

    # if not logged in, regard user as guest temporally.
    if @current_account.blank?
      Run.current_account = Account.guest_account
      @current_user = Run.current_user
    end

    @academic_year   = input_params[:academic_year]
    @academic_season = input_params[:academic_season]
    date             = input_params[:date]
    @display_time    = date.nil? ? nil : date.to_datetime(:local)

    # when called by "move_calendar", @display_time is given
    # when called as lecture schedule, @academic_year && @academic_season are given.
    @display_time ||= (@academic_year && @academic_season ?
                        [@show_time, end_of_academic_season(@academic_year, @academic_season)].min :
                         @show_time)
    @background_params.merge! :date => @display_time.to_s(:db)

    @forum = input_params[:forum]

    @schedule_span   = input_params[:schedule_span].blank? ? Default_Span  : input_params[:schedule_span]
    @background_params.merge! :schedule_span => @schedule_span

    @article_class   = input_params[:article_class]
    @receive_mode    = input_params[:receive_mode]
    @other_user_name = input_params[:other_user_name]

    # item structs of whole items
    @def_items = Def_Thread_Items

    # items for query bar
    @queries = [:sender_name_to_query, :title, :content_to_query]

    # time range(in :db format) to display
    @dates = date_span(@display_time, @schedule_span)

    # query for other user's schedule
    if @other_user_name.blank?
      @other_user = nil
    else
      @other_user = UserInfo.find :first, :assert_time => (@dates.begin.to_datetime..@dates.end.to_datetime),
                                  :select => "id, run_id",
                                  :scope => ":self",
                                  :conditions => {:name => @other_user_name}
      # forcing receive_mode as EXTENDED
      @receive_mode = EXTENDED
    end

    # SQL conditions for articles whose schedule dates are overlapped with display span(db format)
    date_cond = Run.intersect_in_db_ranges?( "articles.start_date".."articles.end_date",  "'#{@dates.begin}'".."'#{@dates.end}'")

    # array of arrays each of which has one day schedules(article objects) through the @schedule_span.
    datetime_span = [@dates.first.to_datetime, @dates.last.to_datetime]
    total_schedules = article_schedule(date_cond) + lecture_schedule(date_cond, datetime_span)
    schedules = partition_schedules_per_day(total_schedules.sort_by(&:start_datetime), datetime_span)
    @schedules =
      case @schedule_span
        when MONTH
         month_arrange(schedules)
        when WEEK
         schedules
        when DAY
         schedules
        when MONTH2
         month_arrange(schedules)
       end
    @calendar_template =
      case @schedule_span
        when MONTH, MONTH2
          "month_calendar"
        when WEEK
          "week_calendar"
        when DAY
          "day_calendar"
      end
    # set special template for collection with @calendar_template or template for mobile
    @response_template = @mobile ? "/schedules/day_calendar_for_mobile" : "/schedules/collection"
  end

  # special version for schedules to display new calender.
  def list_again(options = {})
    catch :flash_now do find_collection(@background_params) end
    div_id       = options[:div_id]     || "collection"
    template     = options.delete(:collection_template) || @response_template || "shared/collection"
    render :update do |page|
      page.replace div_id , :partial => template, :locals => options
    end
  end

  def find_detail
    a_thread = find_entity.a_thread
    find_detail_of_thread(a_thread)
  end

  # time range given in :db format
  def date_span(now, span = MONTH)
    date_pair =
      case span
        when MONTH
          [now.beginning_of_month.since(-86400*now.beginning_of_month.wday).beginning_of_day, now.end_of_month.since(86400*(6-now.end_of_month.wday)).end_of_day]
        when WEEK
          [now.since(-86400*now.wday).beginning_of_day, now.since(86400*(6 - now.wday)).end_of_day]
        when DAY
          [now.beginning_of_day, now.end_of_day]
        when MONTH2
          [now.since(-86400*now.wday).beginning_of_day, now.since(86400*4*7).since(86400*(6-now.since(86400*4*7).wday)).end_of_day]
      end
    result = date_pair.map do |d| d.to_date.to_s(:db) end
    result.first..result.last
  end

  # find article schedule during dates(range, db_format)
  def article_schedule(date_cond)
    # current_user's schedules
    schedule_ids = schedule_ids_during(date_cond, @current_user)

    unless @other_user.blank?
      other_schedule_ids = schedule_ids_during(date_cond, @other_user)
      schedule_ids = (schedule_ids.to_set & other_schedule_ids.to_set).to_a
    end
#    return [] if schedule_ids.blank?
    schedule_ids.blank? and return []

    Article.find schedule_ids,
                        :select => Article_Schedule_Item,
                        :scope  => ":self >> thread:ArticleThread",
                        :conditions=> forum_cond,
                        :group => "articles.id"
  end

  # find schedule_ids during the dates(range, db format) for user
  def schedule_ids_during(date_cond, user = @current_user)
    # regarding space schedule condition
    a_net = [] << Basic_A_Net

    if @display_mode == "space_schedules"
      @space_span = @background_params[:space_span] || Space::Default
      a_net << ":Article .place_run_id >> space:Space .fullname contained_by '#{@space_span}'"
      space_cond = nil
      # when space schedule required,  receive_mode is forced to be extended
      @receive_mode = EXTENDED
      @background_params.merge! :space_span => @space_span, :receive_mode => @receive_mode
    end

    ArticleThread.find :all,
                 :scope      => a_net << personal_setting,
                 :local_assert_time => local_assert_time_for_destination("articles.start_date"),
                 :select     => "articles.id",
                 :conditions => merge_conditions(date_cond, space_cond, forum_cond, *basic_cond(user)),
                 :group      => "articles.id"
  end

  def lecture_schedule(date_cond, datetime_span)

    # for the moment
#    return [] if @display_mode == "space_schedules"
    @display_mode == "space_schedules" and return []

    user = @other_user ||  @current_user

    # lecture schedules for teacher, student, or ta
    schedules = Article.find :all,
                  :scope       => Articles_AS_Lecture_Schedule,
                  :local_assert_time => local_assert_time_for_lecture(Run.get_academic_season_range_for_time(@display_time)),
                  :select      => Lecture_Schedule_Item,
                  :conditions  => merge_conditions(date_cond, member_user_cond(user), forum_schedule_cond),
                  :group       => "articles.start_date, lecture_times.lecture_time"

    schedules.each do |a|
      campus = a.campus.blank? ? nil : a.campus
      real_time = LectureTimeToRealTime.real_time(a.lecture_time.to_i, campus)
      a.start_datetime = a.date + " " + real_time.first
      a.end_datetime   = a.date + " " + real_time.last
      a.title          = "[#{a.lecture_time}限]#{a.title}"  # title with lecture time
    end
  end

  def local_assert_time_for_lecture(time)
    {:lecture_times => time,
     :lectures => time,
     :courses => time,
     :members => time}
  end

  def member_user_cond(user = @current_user)
    "members.user_info_run_id = #{user.run_id}"
  end

  def forum_schedule_cond
    @forum.blank? and return "TRUE"
    forum_id, forum_model = @forum.to_id_and_model
    "#{forum_model.table_name}.run_id=#{forum_id}"
  end

  def space_tree(parent)
    Space.find_descendants(parent)
  end

  # partition schdules to each day schedules by its datetime(datetime format)
  # schedules are supposed to be already sorted by start_datetime.
  # result is array of arrays each of which is [date, [schedules of the date]]
  def partition_schedules_per_day(schedules, datetime_span)
    date = datetime_span.first.to_date
    end_date = datetime_span.last.to_date
    result = []
    while date <= end_date do
      day_sch = schedules.select do |sch| sch.start_datetime.to_date == date end
#      day_sch = [] if day_sch.nil?
      day_sch.nil? and day_sch = []
      result << [date, day_sch]
      schedules = schedules[day_sch.length..-1]
      date += 1.day
    end
    result
  end

  def month_arrange(schedules, result = [])
    schedules.blank?  and  return result
    top_week = schedules[0,7]
    month_arrange(schedules[7..-1], result << top_week)
  end

  # -- Altering --

end


text:
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation.
// All rights reserved.
//
// This code is licensed under the MIT License.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files(the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions :
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
//
//------------------------------------------------------------------------------

#import <Foundation/Foundation.h>

NS_ASSUME_NONNULL_BEGIN

/**
 A protocol that objects adopt to provide deserialization from JSON.
 */
@protocol MSALJsonDeserializable <NSObject>

/**
 Initialize with a JSON string.
 @param jsonString JSON string to deserialize from.
 @param error The error that occurred during deserialization.
 */
- (instancetype)initWithJsonString:(NSString *)jsonString
                             error:(NSError * _Nullable * _Nullable)error;

@end

NS_ASSUME_NONNULL_END


text:
在Android中,要模拟SD卡,要首先使用adb的mksdcard命令来建立SD卡的镜像,如何建立,大家上网查一下吧,应该很容易找到,这里不说这个问题。
但是在应用程序执行起来以后,我们可以看到sdcard的执行权限很有问题.懂Linux的人都知道,这样的权限是无法在SD开中写入内容的,也就无法建立目录.Android中对sd卡的读写权限问题。
但是,我们在adb shell命令中,依然可以在sdcard中建立目录,写入文件.这倒是也是见鬼的事情。但是,如果你想把权限更改成777,命令行并不报错,再使用ls -l查看一下,权限依然没有改变过来.我们急中生智,使用su命令将自己变成root用户,在使用chmod 777 sdcard来改变权限,发现结果依然无效。
网上多有介绍,在Android的manifest.xml文档中加入下面的声名:
```
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
<uses-permission android:name="android.permission.MOUNT_UNMOUNT_FILESYSTEMS"/>
```
试验之后,大多数人发现依然无效.没有人再把问题叙述得更详细些,不知道是什么样的心态?我的一个弟兄终于找到了问题所在.
```
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="byd.eagle"
    android:versionCode="1"
    android:versionName="1.0" >
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
    <uses-permission android:name="android.permission.MOUNT_UNMOUNT_FILESYSTEMS" />
    <application
        android:icon="@drawable/icon"
        android:label="@string/app_name" >
        <activity
            android:name=".EagleBackup"
            android:label="@string/app_name" >
            <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>
    <uses-sdk android:minSdkVersion="8" />
</manifest>
```
注意一下uses-permission在manifest.xml中的位置,这是解决问题的关键。
那么我们再来写个试验程序:
```
public class TestMakePath extends Activity {
	@Override
	public void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.main);
		try {
			Log.v("EagleTag", ".......hahhha");
			Log.v("EagleTag", Environment.getExternalStorageState());
			File tPath = new File("/mnt/sdcard/tmp1");
			if (tPath.canRead())
				Log.v("EagleTag", "very bad");
			if (tPath.canWrite())
				Log.v("EagleTag", "very good");
			File tPathSon = new File("/mnt/sdcard/tmp1/good");

			tPathSon.mkdirs();
		} catch (Exception e) {
			Log.v("EagleTag", "file create error");
		}
	}
}
```


text:
using System;

namespace Xceed.Wpf.Toolkit.Core
{
  public class InvalidContentException : Exception
  {
    #region Constructors

    public InvalidContentException( string message )
      : base( message )
    {
    }

    public InvalidContentException( string message, Exception innerException )
      : base( message, innerException )
    {
    }

    #endregion
  }
}


text:
package java.util;

import java.io.Serializable;
import libcore.icu.TimeZones;
import libcore.util.ZoneInfoDB;

/**
 * {@code TimeZone} represents a time zone, primarily used for configuring a {@link Calendar} or
 * {@link java.text.SimpleDateFormat} instance.
 *
 *
Most applications will use {@link #getDefault} which returns a {@code TimeZone} based on
 * the time zone where the program is running.
 *
 *
You can also get a specific {@code TimeZone} {@link #getTimeZone by id}.
 *
 *
It is highly unlikely you'll ever want to use anything but the factory methods yourself.
 * Let classes like {@link Calendar} and {@link java.text.SimpleDateFormat} do the date
 * computations for you.
 *
 *
If you do need to do date computations manually, there are two common cases to take into
 * account:
 *

 *
Somewhere like California, where daylight time is used.
 * The {@link #useDaylightTime} method will always return true, and {@link #inDaylightTime}
 * must be used to determine whether or not daylight time applies to a given {@code Date}.
 * The {@link #getRawOffset} method will return a raw offset of (in this case) -8 hours from UTC,
 * which isn't usually very useful. More usefully, the {@link #getOffset} methods return the
 * actual offset from UTC for a given point in time; this is the raw offset plus (if the
 * point in time is {@link #inDaylightTime in daylight time}) the applicable
 * {@link #getDSTSavings DST savings} (usually, but not necessarily, 1 hour).
 *
Somewhere like Japan, where daylight time is not used.
 * The {@link #useDaylightTime} and {@link #inDaylightTime} methods both always return false,
 * and the raw and actual offsets will always be the same.
 *

 *
 *
Note the type returned by the factory methods {@link #getDefault} and {@link #getTimeZone} is
 * implementation dependent. This may introduce serialization incompatibility issues between
 * different implementations. Android returns instances of {@link SimpleTimeZone} so that
 * the bytes serialized by Android can be deserialized successfully on other
 * implementations, but the reverse compatibility cannot be guaranteed.
 *
 * @see Calendar
 * @see GregorianCalendar
 * @see SimpleDateFormat
 * @see SimpleTimeZone
 */
public abstract class TimeZone implements Serializable, Cloneable {
    private static final long serialVersionUID = 3581463369166924961L;

    /**
     * The short display name style, such as {@code PDT}. Requests for this
     * style may yield GMT offsets like {@code GMT-08:00}.
     */
    public static final int SHORT = 0;

    /**
     * The long display name style, such as {@code Pacific Daylight Time}.
     * Requests for this style may yield GMT offsets like {@code GMT-08:00}.
     */
    public static final int LONG = 1;

    static final TimeZone GMT = new SimpleTimeZone(0, "GMT"); // Greenwich Mean Time

    private static TimeZone defaultTimeZone;

    private String ID;

    public TimeZone() {}

    /**
     * Returns a new time zone with the same ID, raw offset, and daylight
     * savings time rules as this time zone.
     */
    @Override public Object clone() {
        try {
            return super.clone();
        } catch (CloneNotSupportedException e) {
            throw new AssertionError(e);
        }
    }

    /**
     * Returns the system's installed time zone IDs. Any of these IDs can be
     * passed to {@link #getTimeZone} to lookup the corresponding time zone
     * instance.
     */
    public static synchronized String[] getAvailableIDs() {
        return ZoneInfoDB.getAvailableIDs();
    }

    /**
     * Returns the IDs of the time zones whose offset from UTC is {@code
     * offsetMillis}. Any of these IDs can be passed to {@link #getTimeZone} to
     * lookup the corresponding time zone instance.
     *
     * @return a possibly-empty array.
     */
    public static synchronized String[] getAvailableIDs(int offsetMillis) {
        return ZoneInfoDB.getAvailableIDs(offsetMillis);
    }

    /**
     * Returns the user's preferred time zone. This may have been overridden for
     * this process with {@link #setDefault}.
     *
     *
Since the user's time zone changes dynamically, avoid caching this
     * value. Instead, use this method to look it up for each use.
     */
    public static synchronized TimeZone getDefault() {
        if (defaultTimeZone == null) {
            defaultTimeZone = ZoneInfoDB.getSystemDefault();
        }
        return (TimeZone) defaultTimeZone.clone();
    }

    /**
     * Equivalent to {@code getDisplayName(false, TimeZone.LONG, Locale.getDefault())}.
     * Be wary of the default locale.
     */
    public final String getDisplayName() {
        return getDisplayName(false, LONG, Locale.getDefault());
    }

    /**
     * Equivalent to {@code getDisplayName(false, TimeZone.LONG, locale)}.
     */
    public final String getDisplayName(Locale locale) {
        return getDisplayName(false, LONG, locale);
    }

    /**
     * Equivalent to {@code getDisplayName(daylightTime, style, Locale.getDefault())}.
     * Be wary of the default locale.
     */
    public final String getDisplayName(boolean daylightTime, int style) {
        return getDisplayName(daylightTime, style, Locale.getDefault());
    }

    /**
     * Returns the {@link #SHORT short} or {@link #LONG long} name of this time
     * zone with either standard or daylight time, as written in {@code locale}.
     * If the name is not available, the result is in the format
     * {@code GMT[+-]hh:mm}.
     *
     * @param daylightTime true for daylight time, false for standard time.
     * @param style either {@link TimeZone#LONG} or {@link TimeZone#SHORT}.
     * @param locale the display locale.
     */
    public String getDisplayName(boolean daylightTime, int style, Locale locale) {
        if (style != SHORT && style != LONG) {
            throw new IllegalArgumentException();
        }

        boolean useDaylight = daylightTime && useDaylightTime();

        String[][] zoneStrings = TimeZones.getZoneStrings(locale);
        String result = TimeZones.getDisplayName(zoneStrings, getID(), daylightTime, style);
        if (result != null) {
            return result;
        }

        // TODO: do we ever get here?

        int offset = getRawOffset();
        if (useDaylight && this instanceof SimpleTimeZone) {
            offset += getDSTSavings();
        }
        offset /= 60000;
        char sign = '+';
        if (offset < 0) {
            sign = '-';
            offset = -offset;
        }
        StringBuilder builder = new StringBuilder(9);
        builder.append("GMT");
        builder.append(sign);
        appendNumber(builder, 2, offset / 60);
        builder.append(':');
        appendNumber(builder, 2, offset % 60);
        return builder.toString();
    }

    private void appendNumber(StringBuilder builder, int count, int value) {
        String string = Integer.toString(value);
        for (int i = 0; i < count - string.length(); i++) {
            builder.append('0');
        }
        builder.append(string);
    }

    /**
     * Returns the ID of this {@code TimeZone}, such as
     * {@code America/Los_Angeles}, {@code GMT-08:00} or {@code UTC}.
     */
    public String getID() {
        return ID;
    }

    /**
     * Returns the daylight savings offset in milliseconds for this time zone.
     * The base implementation returns {@code 3600000} (1 hour) for time zones
     * that use daylight savings time and {@code 0} for timezones that do not.
     * Subclasses should override this method for other daylight savings
     * offsets.
     *
     *
Note that this method doesn't tell you whether or not to apply the
     * offset: you need to call {@code inDaylightTime} for the specific time
     * you're interested in. If this method returns a non-zero offset, that only
     * tells you that this {@code TimeZone} sometimes observes daylight savings.
     */
    public int getDSTSavings() {
        return useDaylightTime() ? 3600000 : 0;
    }

    /**
     * Returns the offset in milliseconds from UTC for this time zone at {@code
     * time}. The offset includes daylight savings time if the specified
     * date is within the daylight savings time period.
     *
     * @param time the date in milliseconds since January 1, 1970 00:00:00 UTC
     */
    public int getOffset(long time) {
        if (inDaylightTime(new Date(time))) {
            return getRawOffset() + getDSTSavings();
        }
        return getRawOffset();
    }

    /**
     * Returns this time zone's offset in milliseconds from UTC at the specified
     * date and time. The offset includes daylight savings time if the date
     * and time is within the daylight savings time period.
     *
     *
This method is intended to be used by {@link Calendar} to compute
     * {@link Calendar#DST_OFFSET} and {@link Calendar#ZONE_OFFSET}. Application
     * code should have no reason to call this method directly. Each parameter
     * is interpreted in the same way as the corresponding {@code Calendar}
     * field. Refer to {@link Calendar} for specific definitions of this
     * method's parameters.
     */
    public abstract int getOffset(int era, int year, int month, int day,
            int dayOfWeek, int timeOfDayMillis);

    /**
     * Returns the offset in milliseconds from UTC of this time zone's standard
     * time.
     */
    public abstract int getRawOffset();

    /**
     * Returns a {@code TimeZone} suitable for {@code id}, or {@code GMT} on failure.
     *
     *
An id can be an Olson name of the form Area/Location, such
     * as {@code America/Los_Angeles}. The {@link #getAvailableIDs} method returns
     * the supported names.
     *
     *
This method can also create a custom {@code TimeZone} using the following
     * syntax: {@code GMT[+|-]hh[[:]mm]}. For example, {@code TimeZone.getTimeZone("GMT+14:00")}
     * would return an object with a raw offset of +14 hours from UTC, and which does not
     * use daylight savings. These are rarely useful, because they don't correspond to time
     * zones actually in use.
     *
     *
Other than the special cases "UTC" and "GMT" (which are synonymous in this context,
     * both corresponding to UTC), Android does not support the deprecated three-letter time
     * zone IDs used in Java 1.1.
     */
    public static synchronized TimeZone getTimeZone(String id) {
        TimeZone zone = ZoneInfoDB.getTimeZone(id);
        if (zone != null) {
            return zone;
        }
        if (zone == null && id.length() > 3 && id.startsWith("GMT")) {
            zone = getCustomTimeZone(id);
        }
        if (zone == null) {
            zone = (TimeZone) GMT.clone();
        }
        return zone;
    }

    /**
     * Returns a new SimpleTimeZone for an id of the form "GMT[+|-]hh[[:]mm]", or null.
     */
    private static TimeZone getCustomTimeZone(String id) {
        char sign = id.charAt(3);
        if (sign != '+' && sign != '-') {
            return null;
        }
        int[] position = new int[1];
        String formattedName = formatTimeZoneName(id, 4);
        int hour = parseNumber(formattedName, 4, position);
        if (hour < 0 || hour > 23) {
            return null;
        }
        int index = position[0];
        if (index == -1) {
            return null;
        }
        int raw = hour * 3600000;
        if (index < formattedName.length() && formattedName.charAt(index) == ':') {
            int minute = parseNumber(formattedName, index + 1, position);
            if (position[0] == -1 || minute < 0 || minute > 59) {
                return null;
            }
            raw += minute * 60000;
        } else if (hour >= 30 || index > 6) {
            raw = (hour / 100 * 3600000) + (hour % 100 * 60000);
        }
        if (sign == '-') {
            raw = -raw;
        }
        return new SimpleTimeZone(raw, formattedName);
    }

    private static String formatTimeZoneName(String name, int offset) {
        StringBuilder buf = new StringBuilder();
        int index = offset, length = name.length();
        buf.append(name.substring(0, offset));

        while (index < length) {
            if (Character.digit(name.charAt(index), 10) != -1) {
                buf.append(name.charAt(index));
                if ((length - (index + 1)) == 2) {
                    buf.append(':');
                }
            } else if (name.charAt(index) == ':') {
                buf.append(':');
            }
            index++;
        }

        if (buf.toString().indexOf(":") == -1) {
            buf.append(':');
            buf.append("00");
        }

        if (buf.toString().indexOf(":") == 5) {
            buf.insert(4, '0');
        }

        return buf.toString();
    }

    /**
     * Returns true if {@code timeZone} has the same rules as this time zone.
     *
     *
The base implementation returns true if both time zones have the same
     * raw offset.
     */
    public boolean hasSameRules(TimeZone timeZone) {
        if (timeZone == null) {
            return false;
        }
        return getRawOffset() == timeZone.getRawOffset();
    }

    /**
     * Returns true if {@code time} is in a daylight savings time period for
     * this time zone.
     */
    public abstract boolean inDaylightTime(Date time);

    private static int parseNumber(String string, int offset, int[] position) {
        int index = offset, length = string.length(), digit, result = 0;
        while (index < length
                && (digit = Character.digit(string.charAt(index), 10)) != -1) {
            index++;
            result = result * 10 + digit;
        }
        position[0] = index == offset ? -1 : index;
        return result;
    }

    /**
     * Overrides the default time zone for the current process only.
     *
     *
Warning: avoid using this method to use a custom time
     * zone in your process. This value may be cleared or overwritten at any
     * time, which can cause unexpected behavior. Instead, manually supply a
     * custom time zone as needed.
     *
     * @param timeZone a custom time zone, or {@code null} to set the default to
     *     the user's preferred value.
     */
    public static synchronized void setDefault(TimeZone timeZone) {
        defaultTimeZone = timeZone != null ? (TimeZone) timeZone.clone() : null;
    }

    /**
     * Sets the ID of this {@code TimeZone}.
     */
    public void setID(String id) {
        if (id == null) {
            throw new NullPointerException();
        }
        ID = id;
    }

    /**
     * Sets the offset in milliseconds from UTC of this time zone's standard
     * time.
     */
    public abstract void setRawOffset(int offsetMillis);

    /**
     * Returns true if this time zone has a future transition to or from
     * daylight savings time.
     *
     *
Warning: this returns false for time zones like
     * {@code Asia/Kuala_Lumpur} that have previously used DST but do not
     * currently. A hypothetical country that has never observed daylight
     * savings before but plans to start next year would return true.
     *
     *
Warning: this returns true for time zones that use
     * DST, even when it is not active.
     *
     *
Use {@link #inDaylightTime} to find out whether daylight savings is
     * in effect at a specific time.
     *
     *
Most applications should not use this method.
     */
    public abstract boolean useDaylightTime();
}


text:
LEVEL = ../..

EXTRA_DIST = LibDeps.txt FinalLibDeps.txt llvm-config.in.in find-cycles.pl

include $(LEVEL)/Makefile.common

# If we don't have Perl, we can't generate the library dependencies upon which
# llvm-config depends. Therefore, only if we detect perl will we do anything
# useful.
ifeq ($(HAVE_PERL),1)

# Combine preprocessor flags (except for -I) and CXX flags.
SUB_CPPFLAGS = ${CPP.BaseFlags}
SUB_CFLAGS   = ${CPP.BaseFlags} ${C.Flags}
SUB_CXXFLAGS = ${CPP.BaseFlags} ${CXX.Flags}

# This is blank for now.  We need to be careful about adding stuff here:
# LDFLAGS tend not to be portable, and we don't currently require the
# user to use libtool when linking against LLVM.
SUB_LDFLAGS =

FinalLibDeps = $(PROJ_OBJ_DIR)/FinalLibDeps.txt
LibDeps      = $(PROJ_OBJ_DIR)/LibDeps.txt
LibDepsTemp  = $(PROJ_OBJ_DIR)/LibDeps.txt.tmp
GenLibDeps   = $(PROJ_SRC_ROOT)/utils/GenLibDeps.pl

$(LibDepsTemp): $(GenLibDeps) $(LibDir) $(wildcard $(LibDir)/*.a $(LibDir)/*.o)
	$(Echo) "Regenerating LibDeps.txt.tmp"
	$(Verb) $(PERL) $(GenLibDeps) -flat $(LibDir) "$(NM_PATH)" > $(LibDepsTemp)

$(LibDeps): $(LibDepsTemp)
	$(Verb) $(CMP) -s $@ $< || ( $(CP) $< $@ && \
	  $(EchoCmd) Updated LibDeps.txt because dependencies changed )

# Find all the cyclic dependencies between various LLVM libraries, so we
# don't have to process them at runtime.
$(FinalLibDeps): find-cycles.pl $(LibDeps)
	$(Echo) "Checking for cyclic dependencies between LLVM libraries."
	$(Verb) $(PERL) $< < $(LibDeps) > $@ || rm -f $@

# Rerun our configure substitutions as needed.
ConfigInIn = $(PROJ_SRC_DIR)/llvm-config.in.in
llvm-config.in: $(ConfigInIn) $(ConfigStatusScript)
	$(Verb) cd $(PROJ_OBJ_ROOT) ; \
		$(ConfigStatusScript) tools/llvm-config/llvm-config.in

llvm-config-perobj: llvm-config.in $(GenLibDeps) $(LibDir) $(wildcard $(LibDir)/*.a)
	$(Echo) "Generating llvm-config-perobj"
	$(Verb) $(PERL) $(GenLibDeps) -perobj -flat $(LibDir) "$(NM_PATH)" >PerobjDeps.txt
	$(Echo) "Checking for cyclic dependencies between LLVM objects."
	$(Verb) $(PERL) $(PROJ_SRC_DIR)/find-cycles.pl < PerobjDepsIncl.txt > PerobjDepsInclFinal.txt || rm -f $@
	$(Verb) $(ECHO) 's/@LLVM_CPPFLAGS@/$(subst /,\/,$(SUB_CPPFLAGS))/' \
	> temp.sed
	$(Verb) $(ECHO) 's/@LLVM_CFLAGS@/$(subst /,\/,$(SUB_CFLAGS))/' \
	>> temp.sed
	$(Verb) $(ECHO) 's/@LLVM_CXXFLAGS@/$(subst /,\/,$(SUB_CXXFLAGS))/' \
	>> temp.sed
	$(Verb) $(ECHO) 's/@LLVM_LDFLAGS@/$(subst /,\/,$(SUB_LDFLAGS))/' \
	>> temp.sed
	$(Verb) $(ECHO) 's/@LLVM_BUILDMODE@/$(subst /,\/,$(BuildMode))/' \
	>> temp.sed
	$(Verb) $(SED) -f temp.sed < $< > $@
	$(Verb) $(RM) temp.sed
	$(Verb) cat PerobjDepsFinal.txt >> $@
	$(Verb) chmod +x $@

llvm-config-perobjincl: llvm-config.in $(GenLibDeps) $(LibDir) $(wildcard $(LibDir)/*.a)
	$(Echo) "Generating llvm-config-perobjincl"
	$(Verb) $(PERL) $(GenLibDeps) -perobj -perobjincl -flat $(LibDir) "$(NM_PATH)" >PerobjDepsIncl.txt
	$(Echo) "Checking for cyclic dependencies between LLVM objects."
	$(Verb) $(PERL) $(PROJ_SRC_DIR)/find-cycles.pl < PerobjDepsIncl.txt > PerobjDepsInclFinal.txt
	$(Verb) $(ECHO) 's/@LLVM_CPPFLAGS@/$(subst /,\/,$(SUB_CPPFLAGS))/' \
	> temp.sed
	$(Verb) $(ECHO) 's/@LLVM_CFLAGS@/$(subst /,\/,$(SUB_CFLAGS))/' \
	>> temp.sed
	$(Verb) $(ECHO) 's/@LLVM_CXXFLAGS@/$(subst /,\/,$(SUB_CXXFLAGS))/' \
	>> temp.sed
	$(Verb) $(ECHO) 's/@LLVM_LDFLAGS@/$(subst /,\/,$(SUB_LDFLAGS))/' \
	>> temp.sed
	$(Verb) $(ECHO) 's/@LLVM_BUILDMODE@/$(subst /,\/,$(BuildMode))/' \
	>> temp.sed
	$(Verb) $(SED) -f temp.sed < $< > $@
	$(Verb) $(RM) temp.sed
	$(Verb) cat PerobjDepsInclFinal.txt >> $@
	$(Verb) chmod +x $@

# Build our final script.
$(ToolDir)/llvm-config: llvm-config.in $(FinalLibDeps)
	$(Echo) "Building llvm-config script."
	$(Verb) $(ECHO) 's/@LLVM_CPPFLAGS@/$(subst /,\/,$(SUB_CPPFLAGS))/' \
	  > temp.sed
	$(Verb) $(ECHO) 's/@LLVM_CFLAGS@/$(subst /,\/,$(SUB_CFLAGS))/' \
	  >> temp.sed
	$(Verb) $(ECHO) 's/@LLVM_CXXFLAGS@/$(subst /,\/,$(SUB_CXXFLAGS))/' \
	  >> temp.sed
	$(Verb) $(ECHO) 's/@LLVM_LDFLAGS@/$(subst /,\/,$(SUB_LDFLAGS))/' \
	  >> temp.sed
	$(Verb) $(ECHO) 's/@LLVM_BUILDMODE@/$(subst /,\/,$(BuildMode))/' \
	  >> temp.sed
	$(Verb) $(SED) -f temp.sed < $< > $@
	$(Verb) $(RM) temp.sed
	$(Verb) cat $(FinalLibDeps) >> $@
	$(Verb) chmod +x $@

else
# We don't have perl, just generate a dummy llvm-config
$(ToolDir)/llvm-config:
	$(Echo) "Building place holder llvm-config script."
	$(Verb) $(ECHO) 'echo llvm-config: Perl not found so llvm-config could not be generated' >> $@
	$(Verb) chmod +x $@

endif
# Hook into the standard Makefile rules.
all-local:: $(ToolDir)/llvm-config
clean-local::
	$(Verb) $(RM) -f $(ToolDir)/llvm-config llvm-config.in $(FinalLibDeps) \
	  $(LibDeps) GenLibDeps.out
install-local:: all-local
	$(Echo) Installing llvm-config
	$(Verb) $(MKDIR) $(DESTDIR)$(PROJ_bindir)
	$(Verb) $(ScriptInstall) $(ToolDir)/llvm-config $(DESTDIR)$(PROJ_bindir)


text: class Skroutz::Resources::Review < Skroutz::Resource; end


text:
package android.example.com.visualizerpreferences;

import android.support.v4.app.NavUtils;
import android.support.v7.app.ActionBar;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.MenuItem;

public class SettingsActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_settings);
        ActionBar actionBar = this.getSupportActionBar();

        // Set the action bar back button to look like an up button
        if (actionBar != null) {
            actionBar.setDisplayHomeAsUpEnabled(true);
        }
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        int id = item.getItemId();
        // When the home button is pressed, take the user back to the VisualizerActivity
        if (id == android.R.id.home) {
            NavUtils.navigateUpFromSameTask(this);
        }
        return super.onOptionsItemSelected(item);
    }

    // COMPLETED (2) Create a class called SettingsFragment that extends PreferenceFragmentCompat
    // COMPLETED (3) In res->xml create a file called pref_visualizer
    // COMPLETED (4) In pref_visualizer create a preference screen containing a single check box preference
    // This check box preference should have a default value of true, the key 'show_bass', a
    // summaryOff of Hidden, a summaryOn of Shown and a title of 'Show Bass'

    // COMPLETED (5) In SettingsFragment's onCreatePreferences method add the preference file using the
    // addPreferencesFromResource method

    // COMPLETED (7) Set the root layout of activity_settings to our newly created SettingsFragment
    // and remove the padding.
    // [HINT] Use a <fragment> element in xml
}


text:
<!DOCTYPE html>

        <meta charset="UTF-8" />
        <meta name="robots" content="index, follow, all" />
        <title>Thelia\Model\Tools\ModelEventDispatcherTrait | </title>
                    <link rel="stylesheet" type="text/css" href="../../../stylesheet.css">

Classes

Namespaces

Interfaces

Traits

Index

Trait

Thelia\Model\Tools\ModelEventDispatcherTrait

    trait
    ModelEventDispatcherTrait

A trait to provide event dispatching mechanism to Model objects

Methods

                    $this

                    setDispatcher(EventDispatcherInterface $dispatcher)

                    getDispatcher()

Details

at line 44

                    public            $this
    setDispatcher(EventDispatcherInterface $dispatcher)

Parameters

                EventDispatcherInterface
                $dispatcher

Return Value

            $this

at line 51

                    public
    getDispatcher()

        Generated by Sami, the API Documentation Generator.


text:
package com.nasa.pic.ds;

import io.realm.RealmObject;
import io.realm.annotations.PrimaryKey;
import io.realm.annotations.RealmClass;

@RealmClass
public   class RequestPhotoLastThreeListDB extends RealmObject {
	@PrimaryKey
	private String reqId;
	private long   reqTime;
	private int    status;

	private String timeZone;

	public String getReqId() {
		return reqId;
	}

	public void setReqId( String reqId ) {
		this.reqId = reqId;
	}

	public long getReqTime() {
		return reqTime;
	}

	public void setReqTime( long reqTime ) {
		this.reqTime = reqTime;
	}

	public int getStatus() {
		return status;
	}

	public void setStatus( int status ) {
		this.status = status;
	}

	public String getTimeZone() {
		return timeZone;
	}

	public void setTimeZone( String timeZone ) {
		this.timeZone = timeZone;
	}
}


text:
layout: post
date: 2017-09-18
title: "Nicole Spose Collection NICOLE NIAB15101IV 2015 2015 Sleeveless Chapel Train Mermaid/Trumpet"
category: Nicole Spose
tags: [Nicole Spose,Mermaid/Trumpet,Illusion,Chapel Train,Sleeveless,2015]
---
### Nicole Spose Collection NICOLE NIAB15101IV 2015
Just **$369.99**
### 2015  Sleeveless Chapel Train Mermaid/Trumpet

BRANDS	Nicole Spose

Silhouette	Mermaid/Trumpet

Neckline	Illusion

Hemline/Train	Chapel Train

Sleeve	Sleeveless

Years	2015

Buy it: [https://www.readybrides.com/en/nicole-spose/3896-nicole-spose-niab15101iv.html](https://www.readybrides.com/en/nicole-spose/3896-nicole-spose-niab15101iv.html)


text:
<!DOCTYPE html>

      <title>Pipeline</title>
      <link href="pipeline.css" rel="stylesheet">
      <meta name="viewport" content="width=device-width, initial-scale=1">
      <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap.min.css" integrity="sha384-BVYiiSIFeK1dGmJRAkycuHAHRg32OmUcww7on3RYdg4Va+PmSTsz/K68vbdEjh4u" crossorigin="anonymous">
      <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap-theme.min.css" integrity="sha384-rHyoN1iRsVXV4nD0JutlnGaslCJuC7uwjduW9SVrLvRYooPp2bWYgmgJQIXwl/Sp" crossorigin="anonymous">

Dashboard

Data Pipelines

                            Name
                            Namespace
                            Storage


text:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using Mn.NewsCms.Common;
using Mn.NewsCms.Common.Models;
using Mn.NewsCms.Web.Models.Shared;

namespace Mn.NewsCms.Web.Models
{
    public class HomeItemsPanelViewModel
    {
        public HomeItemsPanelViewModel()
        {
            ShowMoreBtn = true;
            CssClass = string.Empty;
        }
        public SliderModel slider { get; set; }
        public List<FeedItem> Items { get; set; }
        public Category Cat { get; set; }
        public string CssClass { get; set; }
        public bool ShowMoreBtn { get; set; }
    }
}


text:
@interface ZFRemovePhotoSetTitlePhotoHttpGetIn : FLModelObject {
@private
    NSString* _photoSetId;
}

@property (readwrite, strong, nonatomic) NSString* photoSetId;

+ (ZFRemovePhotoSetTitlePhotoHttpGetIn*) removePhotoSetTitlePhotoHttpGetIn;

@end


text:
/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * Written (W) 2013 Kevin Hughes
 * ported from scikit-learn
 */

#ifndef FASTICA_H_
#define FASTICA_H_

#include <shogun/lib/config.h>
#ifdef HAVE_EIGEN3
#include <shogun/converter/ica/ICAConverter.h>
#include <shogun/features/Features.h>

namespace shogun
{

class CFeatures;

/** @brief class FastICA
 *
 * Implements the FastICA (Independent
 * Component Analysis) algorithm
 *
 * A. Hyvarinen and E. Oja, Independent Component Analysis:
 * Algorithms and Applications, Neural Networks, 13(4-5), 2000,
 * pp. 411-430`
 */
class CFastICA: public CICAConverter
{
	public:

		/** constructor */
		CFastICA();

		/** destructor */
		virtual ~CFastICA();

		/** apply to features
		 * @param features features to embed
		 */
		virtual CFeatures* apply(CFeatures* features);

		/** setter for whiten flag
		 * whether to whiten the data or not
		 * @param whiten
		 */
		void set_whiten(bool whiten);

		/** getter for whiten flag
		 * @return whiten
		 */
		bool get_whiten() const;

		/** @return object name */
		virtual const char* get_name() const { return "FastICA"; };

	protected:

		/** init */
		void init();

	private:

		/** whiten */
		bool whiten;

};
}
#endif // HAVE_EIGEN3
#endif // FASTICA


text:
layout: post
title: htaccess tester
date: '2013-03-01 08:43:17 -0800'
comments: true
categories:
- Hosting
tags:
- htaccess
---

I'm not sure how one would use this, but it looks like it's supposed to be
useful.

[http://htaccess.madewithlove.be/]


text:
curl -sL https://deb.nodesource.com/setup_8.x | bash -
apt-get install -y nodejs

# Yarn
curl -sS https://dl.yarnpkg.com/debian/pubkey.gpg | apt-key add -
echo "deb https://dl.yarnpkg.com/debian/ stable main" | tee /etc/apt/sources.list.d/yarn.list
apt-get update && apt-get install yarn

# Ruby & Jekyll
apt-get install -y ruby ruby-dev build-essential zlib1g-dev
gem install bundler jekyll nokogiri json jekyll-lunr-js-search --no-document

echo "One-time setup complete!"


text:
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">

	<modelVersion>4.0.0</modelVersion>

	<parent>
		<groupId>com.rometools</groupId>
		<artifactId>rome-parent</artifactId>
		<version>1.6.0-SNAPSHOT</version>
	</parent>

	<artifactId>rome-modules</artifactId>
	<version>1.6.0-SNAPSHOT</version>
	<packaging>jar</packaging>

	<name>rome-modules</name>

	<description>Plugin collection for the ROME RSS and Atom Utilities</description>

	<url>http://rometools.github.io/rome-modules/</url>

	<scm>
		<connection>scm:git:ssh://github.com/rometools/rome-modules.git</connection>
		<developerConnection>scm:git:ssh://git@github.com/rometools/rome-modules.git</developerConnection>
		<url>https://github.com/rometools/rome-modules</url>
	</scm>

	<developers>
		<developer>
			<id>kebernet</id>
			<email>kebernet@gmail.com</email>
			<name>Robert Cooper</name>
		</developer>
	</developers>

    <repositories>
        <repository>
            <id>sonatype-nexus-snapshots</id>
            <url>https://oss.sonatype.org/content/repositories/snapshots</url>
            <releases>
                <enabled>false</enabled>
            </releases>
            <snapshots>
                <enabled>true</enabled>
            </snapshots>
        </repository>
    </repositories>

	<build>
		<plugins>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-scm-publish-plugin</artifactId>
				<configuration>
					<scmBranch>gh-pages</scmBranch>
					<pubScmUrl>${project.scm.developerConnection}</pubScmUrl>
					<content>${project.build.directory}/site</content>
				</configuration>
			</plugin>
		</plugins>
	</build>

	<dependencies>
		<dependency>
			<groupId>com.rometools</groupId>
			<artifactId>rome</artifactId>
            <version>1.6.0-SNAPSHOT</version>
		</dependency>
		<dependency>
			<groupId>ch.qos.logback</groupId>
			<artifactId>logback-classic</artifactId>
			<scope>test</scope>
		</dependency>
		<dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <artifactId>hamcrest-core</artifactId>
                    <groupId>org.hamcrest</groupId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.hamcrest</groupId>
            <artifactId>hamcrest-all</artifactId>
            <scope>test</scope>
        </dependency>
	</dependencies>

</project>


text:
package com.interview.tree;

/**
 * Date 03/22/2016
 * @author Tushar Roy
 *
 * Given a binary tree, find the maximum path sum. For this problem, a path is defined as any sequence of nodes
 * from some starting node to any node in the tree along the parent-child connections.
 *
 * Time complexity O(n)
 * Space complexity depends on depth of tree.
 *
 * https://leetcode.com/problems/binary-tree-maximum-path-sum/
 */
public class BinaryTreeMaximumPathSum {
    int max = 0;

    public int maxPathSum(Node root) {
        max = Integer.MIN_VALUE;
        maxPathSumUtil(root);
        return max;
    }

    private int maxPathSumUtil(Node root) {
        if (root == null) {
            return 0;
        }
        int left = maxPathSumUtil(root.left);
        int right = maxPathSumUtil(root.right);
        if (left < 0) {
            left = 0;
        }
        if (right < 0) {
            right = 0;
        }
        max = Math.max(max, root.data + left + right);
        return root.data + Math.max(left, right);
    }
}


text:
import json

from django import template

register = template.Library()

@register.tag
def filterset_to_json(parser, token):
    tokens = token.split_contents()
    var_name = tokens[1]
    options = {}
    if len(tokens) >= 3 and tokens[2] == "with":
        for option in tokens[3:]:
            try:
                key, value = option.split("=")
                if value.isdigit():
                    value = int(value)
                else:
                    value = value[1:-1]
            except ValueError:
                key, value = option, None
            options[key] = value
    return FiltersetToJSONNode(var_name, **options)

class FiltersetToJSONNode(template.Node):
    """Convert a form filterset to a big JSON string"""

    def __init__(self, filterset, **options):
        self.filterset = template.Variable(filterset)
        self.options = options

    def render(self, context):
        filterset = self.filterset.resolve(context)
        fields = []
        for field in filterset:
            field_struct = {
                "name": field.name,
                "options": [],
            }
            # additional keys potentially assigned to the fields
            for key in ("key", "cls", "switchable", "is_default_and"):
                if hasattr(field, key):
                    field_struct[key] = getattr(field, key)
            for option in field:
                field_struct["options"].append([
                    option.label,
                    option.selected,
                    option.value
                ])

            fields.append(field_struct)
        data = {
            "options": self.options,
            "fields": fields,
        }
        # JSON permits but does not require forward slashes to be escaped.
        # This is useful when json data is emitted in a <script> tag
        # in HTML, as it prevents </script> tags from prematurely terminating
        # the javscript. Some json libraries do this escaping by default,
        # although python's standard library does not, so we do it here.
        # http://stackoverflow.com/q/1580647/205832
        return json.dumps(data).replace("</", "<\\/")


text:
local cFunc = {};		-- Local Functions
local cSetting = {};	-- Local Settings

ContainerJobContainer = {};
ContainerJobContainer.__index = ContainerJobContainer;

--[[
for index, object in pairs(getElementsByType("object")) do
	if(getElementModel(object) == 2935) then
		x, y, z = getElementPosition(object)
		rx, ry, rz = getElementRotation(object)
		outputChatBox("{"..x..", "..y..", "..z..", "..rx..", "..ry..", "..rz.."},");
	end
end
]]

-- ///////////////////////////////
-- ///// New 				//////
-- ///// Returns: Object	//////
-- ///////////////////////////////

function ContainerJobContainer:New(...)
	local obj = setmetatable({}, {__index = self});
	if obj.Constructor then
		obj:Constructor(...);
	end
	return obj;
end

-- ///////////////////////////////
-- ///// Constructor 		//////
-- ///// Returns: void		//////
-- ///////////////////////////////

function ContainerJobContainer:Constructor(iType, iX, iY, iZ, rX, rY, rZ, iDim)
	-- Klassenvariablen --

	self.models		=
	{
		[1] = 2934, -- Roter Container
		[2] = 2935,	-- Gelber Container
		[3] = 2932,	-- Blauer Container

	}

	self.position 	= {iX, iY, iZ};
	self.rotation 	= {rX, rY, rZ};

	self.modell		= (self.models[iType] or 2943)

	self.uObject	= createObject(self.modell, iX, iY, iZ, rX, rY, rZ)
	self.marker		= createMarker(iX, iY, iZ, "arrow", 2.0, 0, 255, 255, 255);

	attachElements(self.marker, self.uObject, 0, 0, 3+getElementDistanceFromCentreOfMassToBaseOfModel(self.uObject))

	setElementDimension(self.uObject, (iDim) or 0)
	setElementData(self.uObject, "cj:crate", true)

	-- Methoden --

	-- Events --

	--logger:OutputInfo("[CALLING] ContainerJobContainer: Constructor");
end

-- EVENT HANDLER --


text:
package test.dcm4chee.arr.jmx;

import javax.management.MBeanServer;
import javax.management.MBeanServerFactory;
import javax.management.ObjectName;

import org.dcm4chee.arr.jmx.UDPServerMBean;
import org.jboss.annotation.ejb.Service;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;

/**
 * Unit test for UDPServer MBean
 *
 * @author Fang Yang (fang.yang@agfa.com)
 * @version $Id: UDPServerTest.java 62 2006-08-28 13:33:27Z fangatagfa $
 * @since Aug 25, 2006
 */
@Test(groups = "jmx")
public class UDPServerTest {

    private ObjectName objectName;

    private MBeanServer server;

    @BeforeClass
    public void setUp() throws Exception {
        // Need to find its ObjectName first
        server = (MBeanServer) MBeanServerFactory.findMBeanServer(null).get(0);
        Service service = UDPServerMBean.class.getAnnotation(Service.class);
        objectName = new ObjectName(service.objectName());
        assert server.isRegistered(objectName);
    }

    public void isRunning() throws Exception {
        boolean isRunning = (Boolean) server
                .getAttribute(objectName, "Running");
        assert isRunning;
    }

    @AfterClass
    public void tearDown() {
    }
}


text:
<TITLE>Review for Mystery Science Theater 3000: The Movie (1996)</TITLE>
<LINK REL="STYLESHEET" TYPE="text/css" HREF="/ramr.css">

Mystery Science Theater 3000: The Movie (1996)

reviewed by
Michael J. Legeros

                      MYSTERY SCIENCE THEATER 3000: THE MOVIE
                       A film review by Michael John Legeros
                        Copyright 1996 Michael John Legeros

(Gramercy)
Directed by     Jim Mallon
Written by      Michael J. Nelson, Trace Beaulieu, Jim Mallon, Kevin
                Murphy, Mary Jo Pehl, Paul Chaplin, Bridget Jones
MPAA Rating     "PG-13"
Running Time    74 minutes
Reviewed at     The Colony, Raleigh, NC (8MAY96)

==

     Mike Nelson, Tom Servo, and Craig T. Robot bring their cable-TV
shtick to the big screen in MYSTERY SCIENCE THEATER 3000: THE MOVIE,
though with a substantially less-awful target to take aim at.  The
three, who sit silhouetted at the bottom of the frame, wisecrack their
way through the cheesy 1955 classic THIS ISLAND EARTH.  From sitcoms to
"Star Trek" to DR. STRANGELOVE, their comments come from every corner of
the pop-culture spectrum.  More gags fail than fly, sure, but they all
contribute to an atmosphere of mirth and merriment that lasts the
duration of the film.  You'll laugh; you'll howl.  (Unfortunately, the
other sequences-- those set in the dog bone-shaped space station, where
the characters live, breathe, and watch movies-- are cheap-looking and
largely unfunny.) The best part of MST3K: THE MOVIE is that the humor
lacks either a mean-spirited or condescending edge.  The writers don't
attempt to outsmart the viewer; instead, they invite us to laugh along
with them.  They know, as we do, that bad movies are best heckled at.

     Grade: B

--

Mike Legeros - Raleigh, NC
legeros@nando.net (h) - legeros@unx.sas.com (w)
Visit me in MOVIE HELL <URL ">http://www.n-vision.com/hell/>

The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).

The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.

Please direct comments/criticisms of the review to relevant newsgroups.

Broken URLs inthe reviews are the responsibility of the author.

The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.

Related links: index of all rec.arts.movies.reviews reviews


text:
(function webpackUniversalModuleDefinition(root, factory) {
	if(typeof exports === 'object' && typeof module === 'object')
		module.exports = factory();
	else if(typeof define === 'function' && define.amd)
		define([], factory);
	else if(typeof exports === 'object')
		exports["VueMaterial"] = factory();
	else
		root["VueMaterial"] = factory();
})(this, (function() {
return /******/ (function(modules) { // webpackBootstrap
/******/ 	// The module cache
/******/ 	var installedModules = {};

/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {

/******/ 		// Check if module is in cache
/******/ 		if(installedModules[moduleId])
/******/ 			return installedModules[moduleId].exports;

/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = installedModules[moduleId] = {
/******/ 			exports: {},
/******/ 			id: moduleId,
/******/ 			loaded: false
/******/ 		};

/******/ 		// Execute the module function
/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);

/******/ 		// Flag the module as loaded
/******/ 		module.loaded = true;

/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}

/******/ 	// expose the modules object (__webpack_modules__)
/******/ 	__webpack_require__.m = modules;

/******/ 	// expose the module cache
/******/ 	__webpack_require__.c = installedModules;

/******/ 	// __webpack_public_path__
/******/ 	__webpack_require__.p = "/";

/******/ 	// Load entry module and return exports
/******/ 	return __webpack_require__(0);
/******/ })
/************************************************************************/
/******/ ({

/***/ 0:
/***/ function(module, exports, __webpack_require__) {

	module.exports = __webpack_require__(84);

/***/ },

/***/ 66:
/***/ function(module, exports) {

	'use strict';

	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	var getImageLightness = function getImageLightness(image, onLoad) {
	  var canvas = document.createElement('canvas');

	  image.onload = function () {
	    var colorSum = 0;
	    var ctx = void 0;
	    var imageData = void 0;
	    var imageMetadata = void 0;
	    var r = void 0;
	    var g = void 0;
	    var b = void 0;
	    var average = void 0;

	    canvas.width = this.width;
	    canvas.height = this.height;
	    ctx = canvas.getContext('2d');

	    ctx.drawImage(this, 0, 0);

	    imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
	    imageMetadata = imageData.data;

	    for (var x = 0, len = imageMetadata.length; x < len; x += 4) {
	      r = imageMetadata[x];
	      g = imageMetadata[x + 1];
	      b = imageMetadata[x + 2];

	      average = Math.floor((r + g + b) / 3);
	      colorSum += average;
	    }

	    onLoad(Math.floor(colorSum / (this.width * this.height)));
	  };
	};

	exports.default = getImageLightness;
	module.exports = exports['default'];

/***/ },

/***/ 84:
/***/ function(module, exports, __webpack_require__) {

	'use strict';

	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = install;

	var _mdImage = __webpack_require__(277);

	var _mdImage2 = _interopRequireDefault(_mdImage);

	var _mdImage3 = __webpack_require__(232);

	var _mdImage4 = _interopRequireDefault(_mdImage3);

	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

	function install(Vue) {
	  Vue.component('md-image', Vue.extend(_mdImage2.default));

	  Vue.material.styles.push(_mdImage4.default);
	}
	module.exports = exports['default'];

/***/ },

/***/ 131:
/***/ function(module, exports, __webpack_require__) {

	'use strict';

	Object.defineProperty(exports, "__esModule", {
	  value: true
	});

	var _getImageLightness = __webpack_require__(66);

	var _getImageLightness2 = _interopRequireDefault(_getImageLightness);

	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

	exports.default = {
	  props: {
	    mdSrc: String
	  },
	  data: function data() {
	    return {
	      loaded: false,
	      applyBlack: true,
	      imageElement: null
	    };
	  },
	  watch: {
	    mdSrc: function mdSrc() {
	      this.createImage();
	    }
	  },
	  computed: {
	    classes: function classes() {
	      return {
	        'md-loaded': this.loaded,
	        'md-black-output': this.applyBlack
	      };
	    }
	  },
	  methods: {
	    analyzeLightness: function analyzeLightness(image) {
	      var _this = this;

	      (0, _getImageLightness2.default)(image, (function (lightness) {
	        var limit = 256;
	        var darkness = (Math.abs(limit - lightness) * 100 / limit + 15) / 100;

	        if (darkness >= 0.7) {
	          _this.applyBlack = true;
	        }

	        _this.$nextTick((function () {
	          _this.loaded = true;
	        }));
	      }));
	    },
	    createImage: function createImage() {
	      this.loaded = false;
	      this.applyBlack = false;
	      this.imageElement = null;

	      if (this.mdSrc) {
	        this.imageElement = document.createElement('img');
	        this.imageElement.crossOrigin = '';
	        this.imageElement.src = this.mdSrc;
	        this.analyzeLightness(this.imageElement);
	      }
	    }
	  },
	  created: function created() {
	    this.createImage();
	  }
	}; //
	//
	//
	//
	//
	//

	module.exports = exports['default'];

/***/ },

/***/ 199:
/***/ function(module, exports) {

	// removed by extract-text-webpack-plugin

/***/ },

/***/ 232:
/***/ function(module, exports) {

	module.exports = ""

/***/ },

/***/ 277:
/***/ function(module, exports, __webpack_require__) {

	var __vue_exports__, __vue_options__
	var __vue_styles__ = {}

	/* styles */
	__webpack_require__(199)

	/* script */
	__vue_exports__ = __webpack_require__(131)

	/* template */
	var __vue_template__ = __webpack_require__(329)
	__vue_options__ = __vue_exports__ = __vue_exports__ || {}
	if (
	  typeof __vue_exports__.default === "object" ||
	  typeof __vue_exports__.default === "function"
	) {
	if (Object.keys(__vue_exports__).some((function (key) { return key !== "default" && key !== "__esModule" }))) {console.error("named exports are not supported in *.vue files.")}
	__vue_options__ = __vue_exports__ = __vue_exports__.default
	}
	if (typeof __vue_options__ === "function") {
	  __vue_options__ = __vue_options__.options
	}
	__vue_options__.__file = "/Users/marcosmoura/Projects/github/vue-material/src/components/mdImage/mdImage.vue"
	__vue_options__.render = __vue_template__.render
	__vue_options__.staticRenderFns = __vue_template__.staticRenderFns

	/* hot reload */
	if (false) {(function () {
	  var hotAPI = require("vue-hot-reload-api")
	  hotAPI.install(require("vue"), false)
	  if (!hotAPI.compatible) return
	  module.hot.accept()
	  if (!module.hot.data) {
	    hotAPI.createRecord("data-v-2bb54057", __vue_options__)
	  } else {
	    hotAPI.reload("data-v-2bb54057", __vue_options__)
	  }
	})()}
	if (__vue_options__.functional) {console.error("[vue-loader] mdImage.vue: functional components are not supported and should be defined in plain js files using render functions.")}

	module.exports = __vue_exports__

/***/ },

/***/ 329:
/***/ function(module, exports, __webpack_require__) {

	module.exports={render:function (){var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;
	  return _c('img', {
	    staticClass: "md-image",
	    class: _vm.classes,
	    attrs: {
	      "src": _vm.mdSrc
	    }
	  })
	},staticRenderFns: []}
	module.exports.render._withStripped = true
	if (false) {
	  module.hot.accept()
	  if (module.hot.data) {
	     require("vue-hot-reload-api").rerender("data-v-2bb54057", module.exports)
	  }
	}

/***/ }

/******/ })
}));
;


text:
using System;
using System.Globalization;
using ElasticEPi.Configuration;
using EPiServer.ServiceLocation;
using EPiServer.Web;

namespace ElasticEPi {
    public abstract class IndexResolver {
        public static string GetIndex() {
            return ServiceLocator.Current.GetInstance<IndexResolver>().ResolveIndex();
        }
        internal abstract string ResolveIndex();
    }

    internal class ConfigurationIndexResolver : IndexResolver {
        internal override string ResolveIndex() {
            return ClientConfigurationSection.GetConfiguration().DefaultIndex;
        }
    }

}


text:
#!/bin/sh
javadoc -locale ja -charset "UTF-8" -encoding UTF-8 -d doc -sourcepath src/com/slowhand/monaka/**/*.java