text:
class FlexStyleImpl
{
public:
    FlexStyleImpl()
    {
    }
};

FlexStyle::FlexStyle(QStyle* style) : QProxyStyle(style), impl(new FlexStyleImpl)
{
    setObjectName(QLatin1String("FlexStyle"));
}

FlexStyle::~FlexStyle()
{

}

void FlexStyle::drawPrimitive(PrimitiveElement pe, const QStyleOption *opt, QPainter *p, const QWidget *w) const
{
    switch (pe)
    {
    case QStyle::PE_IndicatorTabClose:
        if (!w || !w->parent()->property("Flex").isValid())
        {
            break;
        }
        else
        {
            bool active = w->parentWidget()->property("active").toBool();
            bool highlight = (opt->state & State_Selected) && active;
            bool mouseover = opt->state & State_MouseOver;

            p->setPen(QColor("#E5C365"));
            p->setBrush(QColor("#FFFCF4"));

            if (mouseover)
            {
                p->drawRect(opt->rect.adjusted(0, 0, -1, -1));
            }

            FlexManager::instance()->icon(Flex::Close).paint(p, opt->rect, Qt::AlignCenter, (mouseover || highlight) ? QIcon::Active : QIcon::Normal, mouseover ? QIcon::On : QIcon::Off);
        }
        return;
    case QStyle::PE_Frame:
        if (!w || !w->property("Flex").isValid())
        {
            break;
        }
        if (auto tmp = qstyleoption_cast<const QStyleOptionFrame*>(opt))
        {
            p->setPen(QColor("#8692B1"));
            p->drawRect(opt->rect.adjusted(0, 0, -1, -1));
            if (tmp->midLineWidth >= 2)
            {
                p->setPen(tmp->palette.color(QPalette::Highlight));
                p->drawRect(opt->rect.adjusted(1, 1, -2, -2));
                p->drawRect(opt->rect.adjusted(2, 2, -3, -3));
            }
            return;
        }
        break;
    case PE_FrameTabBarBase:
        if (!w || !w->property("Flex").isValid())
        {
            break;
        }
        if (auto tbb = qstyleoption_cast<const QStyleOptionTabBarBase*>(opt))
        {
            auto active = w->property("active").toBool();
            auto colour = tbb->palette.color(active ? QPalette::Active : QPalette::Inactive, QPalette::Highlight);
            p->save();
            switch (tbb->shape)
            {
            case QTabBar::RoundedNorth:
                p->setPen(QPen(colour, 0));
                p->drawLine(tbb->rect.topLeft() + QPoint(0, -1), tbb->rect.topRight() + QPoint(0, -1));
                p->drawLine(tbb->rect.topLeft() + QPoint(0, +0), tbb->rect.topRight() + QPoint(0, +0));
                break;
            case QTabBar::RoundedSouth:
                p->setPen(QPen(QColor("#8692B1"), 0));
                p->drawLine(tbb->rect.left(), tbb->rect.top() + 0, tbb->rect.right(), tbb->rect.top() + 0);
                break;
            }
            p->restore();
        }
        return;
    }
    QProxyStyle::drawPrimitive(pe, opt, p, w);
}

void FlexStyle::drawControl(ControlElement ce, const QStyleOption *opt, QPainter *p, const QWidget *w) const
{
    switch (ce)
    {
    case CE_TabBarTabShape:
        if (!w || !w->property("Flex").isValid())
        {
            break;
        }
        if (auto tab = qstyleoption_cast<const QStyleOptionTabV3*>(opt))
        {
            bool highlight = tab->state & State_Selected;
            bool mouseover = tab->state & State_MouseOver;
            bool active = w->property("active").toBool();

            QRect rect = tab->rect;

            switch (tab->shape)
            {
            case QTabBar::RoundedNorth:
                rect.adjust(0, 0, 0, highlight ? -2 : -3);
                break;
            case QTabBar::RoundedSouth:
                rect.adjust(0, highlight ? -1 : 1, 0, highlight ? -1 : 1);
                break;
            }

            auto bgColor = tab->palette.color(QPalette::Inactive, w->backgroundRole());

            if (highlight)
            {
                bgColor = tab->palette.color(active ? QPalette::Active : QPalette::Inactive, QPalette::Highlight);
            }
            else if (mouseover)
            {
                bgColor = tab->palette.color(QPalette::Active, w->backgroundRole());
            }

            p->setBrush(bgColor);

            p->setPen(tab->shape == QTabBar::RoundedSouth && highlight ? QColor("#8692B1") : bgColor);

            p->drawRect(rect);

            if (tab->shape == QTabBar::RoundedSouth && !highlight)
            {
                p->setPen(QColor("#4B5C74"));
                p->drawLine(tab->rect.bottomLeft() - QPoint(0, 0), tab->rect.bottomRight() - QPoint(0, 0));
                p->drawLine(tab->rect.bottomLeft() - QPoint(0, 1), tab->rect.bottomRight() - QPoint(0, 1));
            }

            return;
        }
        break;
    case CE_TabBarTabLabel:
        if (!w || !w->property("Flex").isValid())
        {
            break;
        }
        if (auto tab = qstyleoption_cast<const QStyleOptionTabV3*>(opt))
        {
            bool active = w->property("active").toBool();
            bool highlight = tab->state & State_Selected;
            auto palette = tab->palette;
            if (tab->shape == QTabBar::RoundedNorth)
            {
                palette.setCurrentColorGroup(active && highlight ? QPalette::Active : QPalette::Inactive);
            }
            else
            {
                palette.setCurrentColorGroup(highlight ? QPalette::Active : QPalette::Inactive);
            }
            QStyleOptionTabV3 tmp = *tab;
            tmp.palette = palette;
            QProxyStyle::drawControl(ce, &tmp, p, w);
            return;
        }
        break;
    }
    QProxyStyle::drawControl(ce, opt, p, w);
}

int FlexStyle::pixelMetric(PixelMetric pm, const QStyleOption *opt, const QWidget *w) const
{
    switch (pm)
    {
    case PM_TabBarTabShiftVertical:
        if (!w || !w->property("Flex").isValid())
        {
            break;
        }
        return 0;
    case PM_TabBarTabHSpace:
        if (!w || !w->property("Flex").isValid())
        {
            break;
        }
        return 8;
    }
    return QProxyStyle::pixelMetric(pm, opt, w);
}

QRect FlexStyle::subElementRect(SubElement se, const QStyleOption *opt, const QWidget *w) const
{
    return QProxyStyle::subElementRect(se, opt, w);
}


text:
@extends('layouts.master')

@section('content')

    <div class="container">

        D:\Works\www\basaltosegranitos.com.br\app/views/settings/create.blade.php

    </div>

@stop

redpajama_set_name: RedPajamaGithub


text:
package nodash.test.functional.implementations;

import java.security.PublicKey;

import nodash.models.NoInfluence;
import nodash.models.NoUser;

public class TestIncreaseMoneyReceipted extends NoInfluence {
  private static final long serialVersionUID = 1L;
  private int increaseBy;
  private PublicKey receiptTarget;

  public TestIncreaseMoneyReceipted(PublicKey receiptTarget, int increaseBy) {
    this.receiptTarget = receiptTarget;
    this.increaseBy = increaseBy;
  }

  @Override
  public void applyTo(NoUser user) {
    TestNoUser testUser = (TestNoUser) user;
    testUser.setMoney(testUser.getMoney() + increaseBy);
    testUser.addAction(new TestSendReceipt(receiptTarget, "Money received - " + testUser.getUsername()));
  }

}


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

#include "ui/base/metadata/base_type_conversion.h"

#include <cmath>
#include <string>

#include "base/containers/fixed_flat_set.h"
#include "base/cxx17_backports.h"
#include "base/no_destructor.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/string_split.h"
#include "base/strings/string_tokenizer.h"
#include "base/strings/string_util.h"
#include "base/strings/stringprintf.h"
#include "base/strings/sys_string_conversions.h"
#include "base/strings/utf_string_conversions.h"
#include "base/time/time_delta_from_string.h"
#include "third_party/abseil-cpp/absl/types/optional.h"
#include "third_party/skia/include/core/SkScalar.h"
#include "ui/gfx/color_utils.h"
#include "ui/gfx/geometry/rect.h"

namespace ui {
namespace metadata {

const char kNoPrefix[] = "";
const char kSkColorPrefix[] = "--";

std::u16string PointerToString(const void* pointer_val) {
  return pointer_val ? u"(assigned)" : u"(not assigned)";
}

const std::u16string& GetNullOptStr() {
  static const base::NoDestructor<std::u16string> kNullOptStr(u"<Empty>");
  return *kNullOptStr;
}

/***** String Conversions *****/

#define CONVERT_NUMBER_TO_STRING(T)                           \
  std::u16string TypeConverter<T>::ToString(T source_value) { \
    return base::NumberToString16(source_value);              \
  }

CONVERT_NUMBER_TO_STRING(int8_t)
CONVERT_NUMBER_TO_STRING(int16_t)
CONVERT_NUMBER_TO_STRING(int32_t)
CONVERT_NUMBER_TO_STRING(int64_t)
CONVERT_NUMBER_TO_STRING(uint8_t)
CONVERT_NUMBER_TO_STRING(uint16_t)
CONVERT_NUMBER_TO_STRING(uint32_t)
CONVERT_NUMBER_TO_STRING(uint64_t)
CONVERT_NUMBER_TO_STRING(float)
CONVERT_NUMBER_TO_STRING(double)

std::u16string TypeConverter<bool>::ToString(bool source_value) {
  return source_value ? u"true" : u"false";
}

ValidStrings TypeConverter<bool>::GetValidStrings() {
  return {u"false", u"true"};
}

std::u16string TypeConverter<const char*>::ToString(const char* source_value) {
  return base::UTF8ToUTF16(source_value);
}

std::u16string TypeConverter<base::FilePath>::ToString(
    const base::FilePath& source_value) {
  return source_value.AsUTF16Unsafe();
}

std::u16string TypeConverter<std::u16string>::ToString(
    const std::u16string& source_value) {
  return source_value;
}

std::u16string TypeConverter<base::TimeDelta>::ToString(
    const base::TimeDelta& source_value) {
  return base::NumberToString16(source_value.InSecondsF()) + u"s";
}

std::u16string TypeConverter<gfx::Insets>::ToString(
    const gfx::Insets& source_value) {
  return base::ASCIIToUTF16(source_value.ToString());
}

std::u16string TypeConverter<gfx::Point>::ToString(
    const gfx::Point& source_value) {
  return base::ASCIIToUTF16(source_value.ToString());
}

std::u16string TypeConverter<gfx::PointF>::ToString(
    const gfx::PointF& source_value) {
  return base::ASCIIToUTF16(source_value.ToString());
}

std::u16string TypeConverter<gfx::Range>::ToString(
    const gfx::Range& source_value) {
  return base::ASCIIToUTF16(source_value.ToString());
}

std::u16string TypeConverter<gfx::Rect>::ToString(
    const gfx::Rect& source_value) {
  return base::ASCIIToUTF16(source_value.ToString());
}

std::u16string TypeConverter<gfx::RectF>::ToString(
    const gfx::RectF& source_value) {
  return base::ASCIIToUTF16(source_value.ToString());
}

std::u16string TypeConverter<gfx::ShadowValues>::ToString(
    const gfx::ShadowValues& source_value) {
  std::u16string ret = u"[";
  for (auto shadow_value : source_value) {
    ret += u" " + base::ASCIIToUTF16(shadow_value.ToString()) + u";";
  }

  ret[ret.length() - 1] = ' ';
  ret += u"]";
  return ret;
}

std::u16string TypeConverter<gfx::Size>::ToString(
    const gfx::Size& source_value) {
  return base::ASCIIToUTF16(source_value.ToString());
}

std::u16string TypeConverter<gfx::SizeF>::ToString(
    const gfx::SizeF& source_value) {
  return base::ASCIIToUTF16(source_value.ToString());
}

std::u16string TypeConverter<std::string>::ToString(
    const std::string& source_value) {
  return base::UTF8ToUTF16(source_value);
}

std::u16string TypeConverter<url::Component>::ToString(
    const url::Component& source_value) {
  return base::ASCIIToUTF16(
      base::StringPrintf("{%d,%d}", source_value.begin, source_value.len));
}

absl::optional<int8_t> TypeConverter<int8_t>::FromString(
    const std::u16string& source_value) {
  int32_t ret = 0;
  if (base::StringToInt(source_value, &ret) &&
      base::IsValueInRangeForNumericType<int8_t>(ret)) {
    return static_cast<int8_t>(ret);
  }
  return absl::nullopt;
}

absl::optional<int16_t> TypeConverter<int16_t>::FromString(
    const std::u16string& source_value) {
  int32_t ret = 0;
  if (base::StringToInt(source_value, &ret) &&
      base::IsValueInRangeForNumericType<int16_t>(ret)) {
    return static_cast<int16_t>(ret);
  }
  return absl::nullopt;
}

absl::optional<int32_t> TypeConverter<int32_t>::FromString(
    const std::u16string& source_value) {
  int value;
  return base::StringToInt(source_value, &value) ? absl::make_optional(value)
                                                 : absl::nullopt;
}

absl::optional<int64_t> TypeConverter<int64_t>::FromString(
    const std::u16string& source_value) {
  int64_t value;
  return base::StringToInt64(source_value, &value) ? absl::make_optional(value)
                                                   : absl::nullopt;
}

absl::optional<uint8_t> TypeConverter<uint8_t>::FromString(
    const std::u16string& source_value) {
  unsigned ret = 0;
  if (base::StringToUint(source_value, &ret) &&
      base::IsValueInRangeForNumericType<uint8_t>(ret)) {
    return static_cast<uint8_t>(ret);
  }
  return absl::nullopt;
}

absl::optional<uint16_t> TypeConverter<uint16_t>::FromString(
    const std::u16string& source_value) {
  unsigned ret = 0;
  if (base::StringToUint(source_value, &ret) &&
      base::IsValueInRangeForNumericType<uint16_t>(ret)) {
    return static_cast<uint16_t>(ret);
  }
  return absl::nullopt;
}

absl::optional<uint32_t> TypeConverter<uint32_t>::FromString(
    const std::u16string& source_value) {
  unsigned value;
  return base::StringToUint(source_value, &value) ? absl::make_optional(value)
                                                  : absl::nullopt;
}

absl::optional<uint64_t> TypeConverter<uint64_t>::FromString(
    const std::u16string& source_value) {
  uint64_t value;
  return base::StringToUint64(source_value, &value) ? absl::make_optional(value)
                                                    : absl::nullopt;
}

absl::optional<float> TypeConverter<float>::FromString(
    const std::u16string& source_value) {
  if (absl::optional<double> temp =
          TypeConverter<double>::FromString(source_value))
    return static_cast<float>(temp.value());
  return absl::nullopt;
}

absl::optional<double> TypeConverter<double>::FromString(
    const std::u16string& source_value) {
  double value;
  return base::StringToDouble(base::UTF16ToUTF8(source_value), &value)
             ? absl::make_optional(value)
             : absl::nullopt;
}

absl::optional<bool> TypeConverter<bool>::FromString(
    const std::u16string& source_value) {
  const bool is_true = source_value == u"true";
  if (is_true || source_value == u"false")
    return is_true;
  return absl::nullopt;
}

absl::optional<std::u16string> TypeConverter<std::u16string>::FromString(
    const std::u16string& source_value) {
  return source_value;
}

absl::optional<base::FilePath> TypeConverter<base::FilePath>::FromString(
    const std::u16string& source_value) {
  return base::FilePath::FromUTF16Unsafe(source_value);
}

absl::optional<base::TimeDelta> TypeConverter<base::TimeDelta>::FromString(
    const std::u16string& source_value) {
  std::string source = base::UTF16ToUTF8(source_value);
  return base::TimeDeltaFromString(source);
}

absl::optional<gfx::Insets> TypeConverter<gfx::Insets>::FromString(
    const std::u16string& source_value) {
  const auto values = base::SplitStringPiece(
      source_value, u",", base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
  int top, left, bottom, right;
  if ((values.size() == 4) && base::StringToInt(values[0], &top) &&
      base::StringToInt(values[1], &left) &&
      base::StringToInt(values[2], &bottom) &&
      base::StringToInt(values[3], &right)) {
    return gfx::Insets(top, left, bottom, right);
  }
  return absl::nullopt;
}

absl::optional<gfx::Point> TypeConverter<gfx::Point>::FromString(
    const std::u16string& source_value) {
  const auto values = base::SplitStringPiece(
      source_value, u",", base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
  int x, y;
  if ((values.size() == 2) && base::StringToInt(values[0], &x) &&
      base::StringToInt(values[1], &y)) {
    return gfx::Point(x, y);
  }
  return absl::nullopt;
}

absl::optional<gfx::PointF> TypeConverter<gfx::PointF>::FromString(
    const std::u16string& source_value) {
  const auto values = base::SplitStringPiece(
      source_value, u",", base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
  double x, y;
  if ((values.size() == 2) && base::StringToDouble(values[0], &x) &&
      base::StringToDouble(values[1], &y)) {
    return gfx::PointF(x, y);
  }
  return absl::nullopt;
}

absl::optional<gfx::Range> TypeConverter<gfx::Range>::FromString(
    const std::u16string& source_value) {
  const auto values = base::SplitStringPiece(
      source_value, u"{,}", base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
  unsigned min, max;
  if ((values.size() == 2) && base::StringToUint(values[0], &min) &&
      base::StringToUint(values[1], &max)) {
    return gfx::Range(min, max);
  }
  return absl::nullopt;
}

absl::optional<gfx::Rect> TypeConverter<gfx::Rect>::FromString(
    const std::u16string& source_value) {
  const auto values = base::SplitString(
      source_value, u" ", base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
  if (values.size() != 2)
    return absl::nullopt;
  const absl::optional<gfx::Point> origin =
      TypeConverter<gfx::Point>::FromString(values[0]);
  const absl::optional<gfx::Size> size =
      TypeConverter<gfx::Size>::FromString(values[1]);
  if (origin && size)
    return gfx::Rect(*origin, *size);
  return absl::nullopt;
}

absl::optional<gfx::RectF> TypeConverter<gfx::RectF>::FromString(
    const std::u16string& source_value) {
  const auto values = base::SplitString(
      source_value, u" ", base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
  if (values.size() != 2)
    return absl::nullopt;
  const absl::optional<gfx::PointF> origin =
      TypeConverter<gfx::PointF>::FromString(values[0]);
  const absl::optional<gfx::SizeF> size =
      TypeConverter<gfx::SizeF>::FromString(values[1]);
  if (origin && size)
    return gfx::RectF(*origin, *size);
  return absl::nullopt;
}

absl::optional<gfx::ShadowValues> TypeConverter<gfx::ShadowValues>::FromString(
    const std::u16string& source_value) {
  gfx::ShadowValues ret;
  const auto shadow_value_strings = base::SplitStringPiece(
      source_value, u"[;]", base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY);

  for (auto v : shadow_value_strings) {
    std::u16string value = std::u16string(v);
    base::String16Tokenizer tokenizer(
        value, u"(,)", base::String16Tokenizer::WhitespacePolicy::kSkipOver);
    tokenizer.set_options(base::String16Tokenizer::RETURN_DELIMS);
    int x, y;
    double blur;
    if (tokenizer.GetNext() && tokenizer.token_piece() == u"(" &&
        tokenizer.GetNext() && base::StringToInt(tokenizer.token_piece(), &x) &&
        tokenizer.GetNext() && tokenizer.token_piece() == u"," &&
        tokenizer.GetNext() && base::StringToInt(tokenizer.token_piece(), &y) &&
        tokenizer.GetNext() && tokenizer.token_piece() == u")" &&
        tokenizer.GetNext() && tokenizer.token_piece() == u"," &&
        tokenizer.GetNext() &&
        base::StringToDouble(tokenizer.token_piece(), &blur) &&
        tokenizer.GetNext() && tokenizer.token_piece() == u"," &&
        tokenizer.GetNext()) {
      const auto color =
          SkColorConverter::GetNextColor(tokenizer.token_begin(), value.cend());
      if (color)
        ret.emplace_back(gfx::Vector2d(x, y), blur, color.value());
    }
  }
  return ret;
}

absl::optional<gfx::Size> TypeConverter<gfx::Size>::FromString(
    const std::u16string& source_value) {
  const auto values = base::SplitStringPiece(
      source_value, u"x", base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
  int width, height;
  if ((values.size() == 2) && base::StringToInt(values[0], &width) &&
      base::StringToInt(values[1], &height)) {
    return gfx::Size(width, height);
  }
  return absl::nullopt;
}

absl::optional<gfx::SizeF> TypeConverter<gfx::SizeF>::FromString(
    const std::u16string& source_value) {
  const auto values = base::SplitStringPiece(
      source_value, u"x", base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
  double width, height;
  if ((values.size() == 2) && base::StringToDouble(values[0], &width) &&
      base::StringToDouble(values[1], &height)) {
    return gfx::SizeF(width, height);
  }
  return absl::nullopt;
}

absl::optional<std::string> TypeConverter<std::string>::FromString(
    const std::u16string& source_value) {
  return base::UTF16ToUTF8(source_value);
}

absl::optional<url::Component> TypeConverter<url::Component>::FromString(
    const std::u16string& source_value) {
  const auto values = base::SplitStringPiece(
      source_value, u"{,}", base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
  int begin, len;
  if ((values.size() == 2) && base::StringToInt(values[0], &begin) &&
      base::StringToInt(values[1], &len) && len >= -1) {
    return url::Component(begin, len);
  }
  return absl::nullopt;
}

std::u16string TypeConverter<UNIQUE_TYPE_NAME(SkColor)>::ToString(
    SkColor source_value) {
  return base::UTF8ToUTF16(color_utils::SkColorToRgbaString(source_value));
}

absl::optional<SkColor> TypeConverter<UNIQUE_TYPE_NAME(SkColor)>::FromString(
    const std::u16string& source_value) {
  return GetNextColor(source_value.cbegin(), source_value.cend());
}

ValidStrings TypeConverter<UNIQUE_TYPE_NAME(SkColor)>::GetValidStrings() {
  return {};
}

bool TypeConverter<UNIQUE_TYPE_NAME(SkColor)>::GetNextColor(
    std::u16string::const_iterator start,
    std::u16string::const_iterator end,
    std::u16string& color,
    std::u16string::const_iterator& next_token) {
  static const auto open_paren = u'(';
  static const auto close_paren = u')';
  static constexpr auto schemes = base::MakeFixedFlatSet<base::StringPiece16>(
      {u"hsl", u"hsla", u"rgb", u"rgba"});

  base::String16Tokenizer tokenizer(
      start, end, u"(,)", base::String16Tokenizer::WhitespacePolicy::kSkipOver);
  tokenizer.set_options(base::String16Tokenizer::RETURN_DELIMS);
  for (; tokenizer.GetNext();) {
    if (!tokenizer.token_is_delim()) {
      base::StringPiece16 token = tokenizer.token_piece();
      std::u16string::const_iterator start_color = tokenizer.token_begin();
      if (base::ranges::find(schemes.begin(), schemes.end(), token) !=
          schemes.end()) {
        if (!tokenizer.GetNext() || *tokenizer.token_begin() != open_paren)
          return false;
        for (;
             tokenizer.GetNext() && *tokenizer.token_begin() != close_paren;) {
        }
        if (*tokenizer.token_begin() != close_paren)
          return false;
      }
      next_token = tokenizer.token_end();
      color = std::u16string(start_color, next_token);
      return true;
    }
  }
  return false;
}

bool TypeConverter<UNIQUE_TYPE_NAME(SkColor)>::GetNextColor(
    std::u16string::const_iterator start,
    std::u16string::const_iterator end,
    std::u16string& color) {
  std::u16string::const_iterator next_token;
  return GetNextColor(start, end, color, next_token);
}

absl::optional<SkColor> TypeConverter<UNIQUE_TYPE_NAME(SkColor)>::GetNextColor(
    std::u16string::const_iterator start,
    std::u16string::const_iterator end,
    std::u16string::const_iterator& next_token) {
  std::u16string color;
  if (GetNextColor(start, end, color, next_token)) {
    if (base::StartsWith(color, u"hsl", base::CompareCase::SENSITIVE))
      return ParseHslString(color);
    if (base::StartsWith(color, u"rgb", base::CompareCase::SENSITIVE))
      return ParseRgbString(color);
    if (base::StartsWith(color, u"0x", base::CompareCase::INSENSITIVE_ASCII))
      return ParseHexString(color);
    SkColor value;
    if (base::StringToUint(color, &value))
      return absl::make_optional(value);
  }
  return absl::nullopt;
}

absl::optional<SkColor> TypeConverter<UNIQUE_TYPE_NAME(SkColor)>::GetNextColor(
    std::u16string::const_iterator start,
    std::u16string::const_iterator end) {
  std::u16string::const_iterator next_token;
  return GetNextColor(start, end, next_token);
}

absl::optional<SkColor>
TypeConverter<UNIQUE_TYPE_NAME(SkColor)>::RgbaPiecesToSkColor(
    const std::vector<base::StringPiece16>& pieces,
    size_t start_piece) {
  int r, g, b;
  double a;
  return ((pieces.size() >= start_piece + 4) &&
          base::StringToInt(pieces[start_piece], &r) &&
          base::IsValueInRangeForNumericType<uint8_t>(r) &&
          base::StringToInt(pieces[start_piece + 1], &g) &&
          base::IsValueInRangeForNumericType<uint8_t>(g) &&
          base::StringToInt(pieces[start_piece + 2], &b) &&
          base::IsValueInRangeForNumericType<uint8_t>(b) &&
          base::StringToDouble(pieces[start_piece + 3], &a) && a >= 0.0 &&
          a <= 1.0)
             ? absl::make_optional(SkColorSetARGB(
                   base::ClampRound<SkAlpha>(a * SK_AlphaOPAQUE), r, g, b))
             : absl::nullopt;
}

absl::optional<SkColor>
TypeConverter<UNIQUE_TYPE_NAME(SkColor)>::ParseHexString(
    const std::u16string& hex_string) {
  SkColor value;
  if (base::HexStringToUInt(base::UTF16ToUTF8(hex_string), &value)) {
    // Add in a 1.0 alpha channel if it wasn't included in the input.
    if (hex_string.length() <= 8)
      value = SkColorSetA(value, 0xFF);
    return absl::make_optional(value);
  }
  return absl::nullopt;
}

absl::optional<SkColor>
TypeConverter<UNIQUE_TYPE_NAME(SkColor)>::ParseHslString(
    const std::u16string& hsl_string) {
  std::u16string pruned_string;
  base::RemoveChars(hsl_string, u"(%)hsla", &pruned_string);
  const auto values = base::SplitStringPiece(
      pruned_string, u", ", base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
  double h, s, v;
  double a = 1.0;
  if (values.size() >= 3 && values.size() <= 4 &&
      base::StringToDouble(values[0], &h) &&
      base::StringToDouble(values[1], &s) &&
      base::StringToDouble(values[2], &v) &&
      (values.size() == 3 ||
       (base::StringToDouble(values[3], &a) && a >= 0.0 && a <= 1.0))) {
    SkScalar hsv[3];
    hsv[0] = base::clamp(std::fmod(h, 360.0), 0.0, 360.0);
    hsv[1] =
        s > 1.0 ? base::clamp(s, 0.0, 100.0) / 100.0 : base::clamp(s, 0.0, 1.0);
    hsv[2] =
        v > 1.0 ? base::clamp(v, 0.0, 100.0) / 100.0 : base::clamp(v, 0.0, 1.0);
    return absl::make_optional(
        SkHSVToColor(base::ClampRound<SkAlpha>(a * SK_AlphaOPAQUE), hsv));
  }
  return absl::nullopt;
}

absl::optional<SkColor>
TypeConverter<UNIQUE_TYPE_NAME(SkColor)>::ParseRgbString(
    const std::u16string& rgb_string) {
  // Declare a constant string here for use below since it might trigger an
  // ASAN error due to the stack temp going out of scope before the call to
  // RgbaPiecesToSkColor.
  std::u16string pruned_string;
  base::RemoveChars(rgb_string, u"()rgba", &pruned_string);
  auto values = base::SplitStringPiece(
      pruned_string, u", ", base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
  // if it was just an rgb string, add the 1.0 alpha
  if (values.size() == 3)
    values.push_back(u"1.0");
  return RgbaPiecesToSkColor(values, 0);
}

}  // namespace metadata
}  // namespace ui

DEFINE_ENUM_CONVERTERS(gfx::HorizontalAlignment,
                       {gfx::HorizontalAlignment::ALIGN_LEFT, u"ALIGN_LEFT"},
                       {gfx::HorizontalAlignment::ALIGN_CENTER,
                        u"ALIGN_CENTER"},
                       {gfx::HorizontalAlignment::ALIGN_RIGHT, u"ALIGN_RIGHT"},
                       {gfx::HorizontalAlignment::ALIGN_TO_HEAD,
                        u"ALIGN_TO_HEAD"})

DEFINE_ENUM_CONVERTERS(gfx::VerticalAlignment,
                       {gfx::VerticalAlignment::ALIGN_TOP, u"ALIGN_TOP"},
                       {gfx::VerticalAlignment::ALIGN_MIDDLE, u"ALIGN_MIDDLE"},
                       {gfx::VerticalAlignment::ALIGN_BOTTOM, u"ALIGN_BOTTOM"})

DEFINE_ENUM_CONVERTERS(gfx::ElideBehavior,
                       {gfx::ElideBehavior::NO_ELIDE, u"NO_ELIDE"},
                       {gfx::ElideBehavior::TRUNCATE, u"TRUNCATE"},
                       {gfx::ElideBehavior::ELIDE_HEAD, u"ELIDE_HEAD"},
                       {gfx::ElideBehavior::ELIDE_MIDDLE, u"ELIDE_MIDDLE"},
                       {gfx::ElideBehavior::ELIDE_TAIL, u"ELIDE_TAIL"},
                       {gfx::ElideBehavior::ELIDE_EMAIL, u"ELIDE_EMAIL"},
                       {gfx::ElideBehavior::FADE_TAIL, u"FADE_TAIL"})

DEFINE_ENUM_CONVERTERS(
    ui::MenuSeparatorType,
    {ui::MenuSeparatorType::NORMAL_SEPARATOR, u"NORMAL_SEPARATOR"},
    {ui::MenuSeparatorType::DOUBLE_SEPARATOR, u"DOUBLE_SEPARATOR"},
    {ui::MenuSeparatorType::UPPER_SEPARATOR, u"UPPER_SEPARATOR"},
    {ui::MenuSeparatorType::LOWER_SEPARATOR, u"LOWER_SEPARATOR"},
    {ui::MenuSeparatorType::SPACING_SEPARATOR, u"SPACING_SEPARATOR"},
    {ui::MenuSeparatorType::VERTICAL_SEPARATOR, u"VERTICAL_SEPARATOR"},
    {ui::MenuSeparatorType::PADDED_SEPARATOR, u"PADDED_SEPARATOR"})


text:
/**
 * @author Igor Ostapenko
 */
'use strict';

module.exports = class MapSerializer {
  constructor(ioc) {
    this.ioc = ioc;
    this.ioc.serializers[ioc.DataType.MAP] = this;
  }

  canBeUsedFor(value) {
    if (value === null || value === undefined) {
      return false;
    }
    if (value instanceof Map) {
      return true;
    }
    if (Array.isArray(value)) {
      return false;
    }

    return typeof value === 'object';
  }

  serialize(item, fullyQualifiedFormat = true) {
    if (item === undefined || item === null) {
      if (fullyQualifiedFormat) {
        return Buffer.from([this.ioc.DataType.MAP, 0x01]);
      }
      return this.ioc.intSerializer.serialize(0, false);
    }

    const isMap = item instanceof Map;

    const keys = isMap ? Array.from(item.keys()) : Object.keys(item);
    let map_length = keys.length;
    if (map_length < 0) {
      map_length = 0;
    } else if (map_length > this.ioc.intSerializer.INT32_MAX) {
      map_length = this.ioc.intSerializer.INT32_MAX; // TODO: is it expected to be silenced? or it's better to error instead?
    }

    const bufs = [];
    if (fullyQualifiedFormat) {
      bufs.push(Buffer.from([this.ioc.DataType.MAP, 0x00]));
    }
    bufs.push(this.ioc.intSerializer.serialize(map_length, false));
    for (let i = 0; i < map_length; i++) {
      const key = keys[i];
      const value = isMap ? item.get(key) : item[key];
      bufs.push(this.ioc.anySerializer.serialize(key), this.ioc.anySerializer.serialize(value));
    }
    return Buffer.concat(bufs);
  }

  deserialize(buffer, fullyQualifiedFormat = true) {
    let len = 0;
    let cursor = buffer;

    try {
      if (buffer === undefined || buffer === null || !(buffer instanceof Buffer)) {
        throw new Error('buffer is missing');
      }
      if (buffer.length < 1) {
        throw new Error('buffer is empty');
      }

      if (fullyQualifiedFormat) {
        const type_code = cursor.readUInt8();
        len++;
        if (type_code !== this.ioc.DataType.MAP) {
          throw new Error('unexpected {type_code}');
        }
        cursor = cursor.slice(1);

        if (cursor.length < 1) {
          throw new Error('{value_flag} is missing');
        }
        const value_flag = cursor.readUInt8();
        len++;
        if (value_flag === 1) {
          return { v: null, len };
        }
        if (value_flag !== 0) {
          throw new Error('unexpected {value_flag}');
        }
        cursor = cursor.slice(1);
      }

      let length, length_len;
      try {
        ({ v: length, len: length_len } = this.ioc.intSerializer.deserialize(cursor, false));
        len += length_len;
      } catch (err) {
        err.message = '{length}: ' + err.message;
        throw err;
      }
      if (length < 0) {
        throw new Error('{length} is less than zero');
      }
      cursor = cursor.slice(length_len);

      const v = new Map();
      for (let i = 0; i < length; i++) {
        let key, key_len;
        try {
          ({ v: key, len: key_len } = this.ioc.anySerializer.deserialize(cursor));
          len += key_len;
        } catch (err) {
          err.message = `{item_${i}} key: ` + err.message;
          throw err;
        }
        cursor = cursor.slice(key_len);

        let value, value_len;
        try {
          ({ v: value, len: value_len } = this.ioc.anySerializer.deserialize(cursor));
          len += value_len;
        } catch (err) {
          err.message = `{item_${i}} value: ` + err.message;
          throw err;
        }
        cursor = cursor.slice(value_len);

        v.set(key, value);
      }

      return { v, len };
    } catch (err) {
      throw this.ioc.utils.des_error({ serializer: this, args: arguments, cursor, err });
    }
  }
};


text:
package org.kie.workbench.common.stunner.bpmn.client.marshall.converters.tostunner;

import java.util.Map;

import org.eclipse.bpmn2.Association;
import org.eclipse.bpmn2.BaseElement;
import org.eclipse.bpmn2.BoundaryEvent;
import org.eclipse.bpmn2.SequenceFlow;
import org.kie.workbench.common.stunner.bpmn.client.marshall.MarshallingRequest.Mode;
import org.kie.workbench.common.stunner.bpmn.client.marshall.converters.Match;
import org.kie.workbench.common.stunner.bpmn.client.marshall.converters.Result;
import org.kie.workbench.common.stunner.bpmn.client.marshall.converters.TypedFactoryManager;
import org.kie.workbench.common.stunner.bpmn.client.marshall.converters.tostunner.associations.AssociationConverter;
import org.kie.workbench.common.stunner.bpmn.client.marshall.converters.tostunner.events.BoundaryEventConverter;
import org.kie.workbench.common.stunner.bpmn.client.marshall.converters.tostunner.properties.PropertyReaderFactory;
import org.kie.workbench.common.stunner.bpmn.client.marshall.converters.tostunner.sequenceflows.SequenceFlowConverter;

public class EdgeConverterManager extends AbstractConverter {

    private final SequenceFlowConverter sequenceFlowConverter;
    private final BoundaryEventConverter boundaryEventConverter;
    private final AssociationConverter associationConverter;

    public EdgeConverterManager(
            TypedFactoryManager factoryManager,
            PropertyReaderFactory propertyReaderFactory,
            Mode mode) {
        super(mode);
        this.sequenceFlowConverter = new SequenceFlowConverter(factoryManager, propertyReaderFactory);
        this.boundaryEventConverter = new BoundaryEventConverter();
        this.associationConverter = new AssociationConverter(factoryManager, propertyReaderFactory);
    }

    public Result<BpmnEdge> convertEdge(BaseElement baseElement, Map<String, BpmnNode> nodes) {
        return Match.<BaseElement, Result<BpmnEdge>>of()
                .<SequenceFlow>when(e -> e instanceof SequenceFlow, e -> sequenceFlowConverter.convertEdge(e, nodes))
                .<BoundaryEvent>when(e -> e instanceof BoundaryEvent, e -> boundaryEventConverter.convertEdge(e, nodes))
                .<Association>when(e -> e instanceof Association, e -> associationConverter.convertEdge(e, nodes))
                .defaultValue(Result.ignored("Not an Edge element", getNotFoundMessage(baseElement)))
                .apply(baseElement)
                .value();
    }
}


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

import java.util.List;

public class ScriptBuilder {
    private Script.Writer writer = new Script.Writer();

    public ScriptBuilder concat(Script other) {
        writer.writeBytes(other.toByteArray());
        return this;
    }

    public ScriptBuilder rawData(byte[] data) {
        writer.writeBytes(data);
        return this;
    }

    public ScriptBuilder data(byte[] data) {
        if (data.length <= 75) {
            writer.writeByte(data.length);
        } else if (data.length <= 0xff) {
            writer.writeByte(Opcode.OP_PUSHDATA1.o)
                    .writeByte(data.length);
        } else if (data.length <= 0xffff) {
            writer.writeByte(Opcode.OP_PUSHDATA2.o)
                    .writeInt16(data.length);
        } else {
            writer.writeByte(Opcode.OP_PUSHDATA4.o)
                    .writeInt32(data.length);
        }
        writer.writeBytes(data);
        return this;
    }

    public ScriptBuilder op(int index) {
        return op(Opcode.fromIndex(index));
    }

    public ScriptBuilder op(Opcode opcode) {
        return token(new Script.Token(opcode));
    }

    public ScriptBuilder token(Script.Token token) {
        writer.writeByte(token.op.o);
        if (token.data != null) {
            if (token.op.o == Opcode.OP_PUSHDATA1.o) {
                writer.writeByte(token.data.length);
            }
            if (token.op.o == Opcode.OP_PUSHDATA2.o) {
                writer.writeInt16(token.data.length);
            }
            if (token.op.o == Opcode.OP_PUSHDATA4.o) {
                writer.writeInt32(token.data.length);
            }
            writer.writeBytes(token.data);
        }
        return this;
    }

    public ScriptBuilder payTo(Address address) throws HyperLedgerException {
        if (address.getType() == Address.Type.COMMON) {
            op(Opcode.OP_DUP);
            op(Opcode.OP_HASH160);
            data(address.toByteArray());
            op(Opcode.OP_EQUALVERIFY);
            op(Opcode.OP_CHECKSIG);
        } else if (address.getType() == Address.Type.P2SH) {
            op(Opcode.OP_HASH160);
            data(address.toByteArray());
            op(Opcode.OP_EQUAL);
        } else if (address.getType() == Address.Type.P2KEY) {
            throw new HyperLedgerException("Use the LegacyAddressType for pay-to-key addresses");
        } else {
            throw new HyperLedgerException("unknown sink address type");
        }
        return this;
    }

    public ScriptBuilder payToPublicKey(PublicKey pub) {
        data(pub.toByteArray());
        op(Opcode.OP_CHECKSIG);
        return this;
    }

    public ScriptBuilder payToPublicKeyHashSpend(byte[] signature, PublicKey pub) {
        data(signature);
        data(pub.toByteArray());
        return this;
    }

    public ScriptBuilder payToOnlySigSpend(byte[] signature) {
        return data(signature);
    }

    public ScriptBuilder burn() {
        return op(Opcode.OP_RETURN);
    }

    public ScriptBuilder multiSig(List<PublicKey> keys, int signaturesNeeded) {
        op(Opcode.getNumberOp(signaturesNeeded));
        for (Key key : keys) {
            if (key instanceof PrivateKey) {
                key = ((PrivateKey) key).getPublic();
            }
            data(key.toByteArray());
        }
        op(Opcode.getNumberOp(keys.size()));
        op(Opcode.OP_CHECKMULTISIG);
        return this;
    }

    public ScriptBuilder multiSigSpend(List<byte[]> signatures) {
        satoshiBug();
        if (signatures.isEmpty()) {
            return data(new byte[0]);
        }
        signatures.forEach((sig) -> data(sig));
        return this;
    }

    private ScriptBuilder satoshiBug() {
        return data(new byte[0]);
    }

    public ScriptBuilder ifElseBlock(Script onTrue, Script onFalse) {
        op(Opcode.OP_IF);
        concat(onTrue);
        op(Opcode.OP_ELSE);
        concat(onFalse);
        op(Opcode.OP_ENDIF);
        return this;
    }

    public ScriptBuilder blockSignature(int signaturesNeeded, List<PublicKey> keys) {
        int zeroOffset = Opcode.OP_1.ordinal() - 1;

        ScriptBuilder sb = Script.create().op(Opcode.fromIndex(signaturesNeeded + zeroOffset)).op(Opcode.OP_DEPTH).op(Opcode.OP_1SUB).op(Opcode.OP_ROLL).op(Opcode.OP_HASH160);
        for (Key key : keys) {
            if (key instanceof PrivateKey) {
                key = ((PrivateKey) key).getPublic();
            }
            sb.data(key.toByteArray());
        }
        return sb.op(Opcode.fromIndex(keys.size() + zeroOffset)).op(Opcode.OP_CHECKMULTISIGONSTACKVERIFY);
    }

    public Script build() {
        return writer.toScript();
    }
}


text:
<?php

namespace Metide\CrashloggerCore;

use Illuminate\Support\ServiceProvider;

class CrashloggerCoreServiceProvider extends ServiceProvider
{
    /**
     * Perform post-registration booting of services.
     *
     * @return void
     */
    public function boot()
    {
        dd('testing');
    }

    /**
     * Register any package services.
     *
     * @return void
     */
    public function register()
    {
        //
    }
}


text:
require 'bundler'
Bundler.setup

if RUBY_ENGINE == 'rbx'
  require "codeclimate-test-reporter"
  CodeClimate::TestReporter.start
end

require 'rom-influxdb'

root = Pathname(__FILE__).dirname

Dir[root.join('shared/*.rb').to_s].each { |f| require f }

RSpec.configure do |config|
  config.before do
    @constants = Object.constants
    create_db
  end

  config.after do
    added_constants = Object.constants - @constants
    added_constants.each { |name| Object.send(:remove_const, name) }
    drop_db
  end

  def create_db
    ::InfluxDB::Client.new.create_database("db")
  end

  def drop_db
    ::InfluxDB::Client.new.delete_database("db")
  end
end


text:
.. _diffs:

Generating Diffs
================

A common problem when dealing with version-controlled text is generating diffs to highlight changes between different versions.

django-reversion comes with a number of helper functions that make generating diffs easy.  They all rely on the `google-diff-match-patch <http://code.google.com/p/google-diff-match-patch/>`_ library, so make sure you have this installed before trying to use the functions.

Low-Level API
-------------

It is possible to generate two types of diff using the diff helper functions.  For the purpose of these examples, it is assumed that you have created a model called ``Page``, which contains a text field called ``content``.

First of all, you need to use the :ref:`low level API <api>` to retrieve the versions you want to compare.

::

    from reversion.helpers import generate_patch

    # Get the page object to generate diffs for.
    page = Page.objects.all()[0]

    # Get the two versions to compare.
    available_versions = reversion.get_for_object(page)

    new_version = available_versions[0]
    old_version = available_versions[1]

Now, in order to generate a text patch::

    from reversion.helpers import generate_patch

    patch = generate_patch(old_version, new_version, "content")

Or, to generate a pretty HTML patch::

    from reversion.helpers import generate_patch_html

    patch_html = generate_patch_html(old_version, new_version, "content")

Because text diffs can often be fragmented and hard to read, an optional ``cleanup`` parameter may be passed to generate friendlier diffs.

::

    patch_html = generate_patch_html(old_version, new_version, "content", cleanup="semantic")
    patch_html = generate_patch_html(old_version, new_version, "content", cleanup="efficiency")

Of the two cleanup styles, the one that generally produces the best result is 'semantic'.

Admin Integration
-----------------

The admin integration for django-reversion does not currently support diff generation.  This is a deliberate design decision, as it would make the framework a lot more heavyweight, as well as carrying the risk of confusing non-technical end users.

While future versions may support a more advanced admin class, for the time being it is left up to your own imagination for ways in which to integrate diffs with your project.


text:
module BenchTool
  class AppConfig

    CONFIG_DIR = File.expand_path('./config')
    CONFIG_FILE = 'configuration.yml'
    CONFIG_PATH = File.join(CONFIG_DIR, CONFIG_FILE)
    APP_CONFIG_DIR = File.expand_path(File.dirname(__FILE__))

    def initialize
      @options ||= fetch
    end

    # Return config as hash
    def to_hash
      @options
    end

    private

    # Get options from configuration file
    def fetch
      setup unless config_exists?
      console "Loading config from #{CONFIG_PATH}"
      @options = YAML::load(File.open(CONFIG_PATH))
      @options.deep_symbolize
    end

    def config_exists?
      File.exists?(CONFIG_PATH)
    end

    def setup
      FileUtils.mkdir_p(CONFIG_DIR)
      FileUtils.cp(File.join(APP_CONFIG_DIR, 'configuration.yml.base'), CONFIG_PATH)
      console "Default configuration was established in the cwd!"
      console ""
      console "NOTICE: The application will exit now. Edit the contents of the config file before proceeeding!"
      console ""
      console "Config file path:"
      console "  #{CONFIG_PATH}"
      exit 0
    end

  end # module AppConfig
end # module BenchTool


text:
def Setup(Settings,DefaultModel):
    Settings["experiment_name"] = "Mix_model"

    Settings["graph_histories"] = ['together'] #['all','together',[],[1,0],[0,0,0],[]]

    Settings["models"][0]["model_type"] = 'img_osm_mix'
    Settings["models"][0]["unique_id"] = '1fc'
    Settings["models"][0]["top_repeat_FC_block"] = 1

    Settings["models"].append(DefaultModel.copy())

    Settings["models"][1]["dataset_pointer"] = 0 # 0 - reuse the first dataset
    Settings["models"][1]["model_type"] = 'img_osm_mix'
    Settings["models"][1]["unique_id"] = '2fc'
    Settings["models"][1]["top_repeat_FC_block"] = 2

    Settings["models"].append(DefaultModel.copy())

    Settings["models"][2]["dataset_pointer"] = 0 # 0 - reuse the first dataset
    Settings["models"][2]["model_type"] = 'img_osm_mix'
    Settings["models"][2]["unique_id"] = '3fc'
    Settings["models"][2]["top_repeat_FC_block"] = 3

    return Settings


text:
Ejercicio 15

Crea una directiva "ejercicio-heroes5" como las anteriores pero:

tendrá un atributo heroe-seleccionado="vm.seleccionado = $heroe"

en el html externo a la directiva se pintará el valor de vm.seleccionado.

dentro de la directiva, junto a cada nombre aparece un botón con el texto "Seleccionar".

al hacer click en el botón, se invocará la expresión del atributo heroe-seleccionado
    pasando el heroe asociado en la variable $heroe.

usar también sintaxis "controllerAs" y el "bindToController"

Resultado

<ejercicio-heroes5
  equipo='vm.listadoHeroes'
  heroe-seleccionado="heroe = $heroe; vm.seleccionado = $heroe"
  ></ejercicio-heroes5>

Héroe seleccionado:
    {{vm.seleccionado.nombre}}

Héroe seleccionado:
    {{heroe.nombre}}

Código ejecutado

  <ejercicio-heroes5 equipo='vm.listadoHeroes'
    heroe-seleccionado="heroe = $heroe; vm.seleccionado = $heroe"></ejercicio-heroes5>
  Héroe seleccionado: {{"{{"}}vm.seleccionado.nombre}}
  Héroe seleccionado: {{"{{"}}v}}

Anterior
|
Siguiente


text:
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<categories>
    <category name="Business">
        <products-count>28</products-count>
        <average-price>761.034643</average-price>
        <total-revenue>21308.97</total-revenue>
    </category>
    <category name="For Children">
        <products-count>23</products-count>
        <average-price>808.577391</average-price>
        <total-revenue>18597.28</total-revenue>
    </category>
    <category name="Other">
        <products-count>22</products-count>
        <average-price>864.916364</average-price>
        <total-revenue>19028.16</total-revenue>
    </category>
    <category name="Autoparts">
        <products-count>20</products-count>
        <average-price>787.3255</average-price>
        <total-revenue>15746.51</total-revenue>
    </category>
    <category name="Sports">
        <products-count>18</products-count>
        <average-price>851.922222</average-price>
        <total-revenue>15334.6</total-revenue>
    </category>
    <category name="Weapons">
        <products-count>17</products-count>
        <average-price>894.575882</average-price>
        <total-revenue>15207.79</total-revenue>
    </category>
    <category name="Drugs">
        <products-count>17</products-count>
        <average-price>558.483529</average-price>
        <total-revenue>9494.22</total-revenue>
    </category>
    <category name="Garden">
        <products-count>17</products-count>
        <average-price>637.731765</average-price>
        <total-revenue>10841.44</total-revenue>
    </category>
    <category name="Fashion">
        <products-count>15</products-count>
        <average-price>652.729333</average-price>
        <total-revenue>9790.94</total-revenue>
    </category>
    <category name="Electronics">
        <products-count>12</products-count>
        <average-price>734.888333</average-price>
        <total-revenue>8818.66</total-revenue>
    </category>
    <category name="Adult">
        <products-count>11</products-count>
        <average-price>898.6</average-price>
        <total-revenue>9884.6</total-revenue>
    </category>
</categories>


text:
package com.microsoft.azure.documentdb;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.commons.lang3.StringUtils;

import com.microsoft.azure.documentdb.internal.Constants;
import com.microsoft.azure.documentdb.internal.HttpConstants;

public class FeedResponsePage<T extends Resource> {

    private final List<T> results;
    private final Map<String, String> header;
    private final HashMap<String, Long> usageHeaders;
    private final HashMap<String, Long> quotaHeaders;

    public FeedResponsePage(List<T> results, Map<String, String> header) {
        this.results = results;
        this.header = header;
        this.usageHeaders = new HashMap<String, Long>();
        this.quotaHeaders = new HashMap<String, Long>();
    }

    public List<T> getResults() {
        return results;
    }

    /**
     * Max Quota.
     *
     * @return the database quota.
     */
    public long getDatabaseQuota() {
        return this.getMaxQuotaHeader(Constants.Quota.DATABASE);
    }

    /**
     * Current Usage.
     *
     * @return the current database usage.
     */
    public long getDatabaseUsage() {
        return this.getCurrentQuotaHeader(Constants.Quota.DATABASE);
    }

    /**
     * Max Quota.
     *
     * @return the collection quota.
     */
    public long getCollectionQuota() {
        return this.getMaxQuotaHeader(Constants.Quota.COLLECTION);
    }

    /**
     * Current Usage.
     *
     * @return the current collection usage.
     */
    public long getCollectionUsage() {
        return this.getCurrentQuotaHeader(Constants.Quota.COLLECTION);
    }

    /**
     * Max Quota.
     *
     * @return the user quota.
     */
    public long getUserQuota() {
        return this.getMaxQuotaHeader(Constants.Quota.USER);
    }

    /**
     * Current Usage.
     *
     * @return the current user usage.
     */
    public long getUserUsage() {
        return this.getCurrentQuotaHeader(Constants.Quota.USER);
    }

    /**
     * Max Quota.
     *
     * @return the permission quota.
     */
    public long getPermissionQuota() {
        return this.getMaxQuotaHeader(Constants.Quota.PERMISSION);
    }

    /**
     * Current Usage.
     *
     * @return the current permission usage.
     */
    public long getPermissionUsage() {
        return this.getCurrentQuotaHeader(Constants.Quota.PERMISSION);
    }

    /**
     * Max Quota.
     *
     * @return the collection size quota.
     */
    public long getCollectionSizeQuota() {
        return this.getMaxQuotaHeader(Constants.Quota.COLLECTION_SIZE);
    }

    /**
     * Current Usage.
     *
     * @return the current collection size usage.
     */
    public long getCollectionSizeUsage() {
        return this.getCurrentQuotaHeader(Constants.Quota.COLLECTION_SIZE);
    }

    /**
     * Max Quota.
     *
     * @return the stored procedure quota.
     */
    public long getStoredProceduresQuota() {
        return this.getMaxQuotaHeader(Constants.Quota.STORED_PROCEDURE);
    }

    /**
     * Current Usage.
     *
     * @return the current stored procedure usage.
     */
    public long getStoredProceduresUsage() {
        return this.getCurrentQuotaHeader(Constants.Quota.STORED_PROCEDURE);
    }

    /**
     * Max Quota.
     *
     * @return the triggers quota.
     */
    public long getTriggersQuota() {
        return this.getMaxQuotaHeader(Constants.Quota.TRIGGER);
    }

    /**
     * Current Usage.
     *
     * @return the current triggers usage.
     */
    public long getTriggersUsage() {
        return this.getCurrentQuotaHeader(Constants.Quota.TRIGGER);
    }

    /**
     * Max Quota.
     *
     * @return the user defined functions quota.
     */
    public long getUserDefinedFunctionsQuota() {
        return this.getMaxQuotaHeader(Constants.Quota.USER_DEFINED_FUNCTION);
    }

    /**
     * Current Usage.
     *
     * @return the current user defined functions usage.
     */
    public long getUserDefinedFunctionsUsage() {
        return this.getCurrentQuotaHeader(Constants.Quota.USER_DEFINED_FUNCTION);
    }

    /**
     * Gets the maximum size limit for this entity (in megabytes (MB) for server resources and in count for master
     * resources).
     *
     * @return the max resource quota.
     */
    public String getMaxResourceQuota() {
        return getValueOrNull(header,
                HttpConstants.HttpHeaders.MAX_RESOURCE_QUOTA);
    }

    /**
     * Gets the current size of this entity (in megabytes (MB) for server resources and in count for master resources).
     *
     * @return the current resource quota usage.
     */
    public String getCurrentResourceQuotaUsage() {
        return getValueOrNull(header,
                HttpConstants.HttpHeaders.CURRENT_RESOURCE_QUOTA_USAGE);
    }

    /**
     * Gets the number of index paths (terms) generated by the operation.
     *
     * @return the request charge.
     */
    public double getRequestCharge() {
        String value = getValueOrNull(header,
                HttpConstants.HttpHeaders.REQUEST_CHARGE);
        if (StringUtils.isEmpty(value)) {
            return 0;
        }
        return Double.valueOf(value);
    }

    /**
     * Gets the activity ID for the request.
     *
     * @return the activity id.
     */
    public String getActivityId() {
        return getValueOrNull(header, HttpConstants.HttpHeaders.ACTIVITY_ID);
    }

    /**
     * Gets the continuation token to be used for continuing the enumeration.
     *
     * @return the response continuation.
     */
    public String getResponseContinuation() {
        return getValueOrNull(header, HttpConstants.HttpHeaders.CONTINUATION);
    }

    /**
     * Gets the session token for use in session consistency.
     *
     * @return the session token.
     */
    public String getSessionToken() {
        return getValueOrNull(header, HttpConstants.HttpHeaders.SESSION_TOKEN);
    }

    /**
     * Gets the response headers.
     *
     * @return the response headers.
     */
    public Map<String, String> getResponseHeaders() {
        return header;
    }

    private long getCurrentQuotaHeader(String headerName) {
        if (this.usageHeaders.size() == 0 && !this.getMaxResourceQuota().isEmpty() &&
                !this.getCurrentResourceQuotaUsage().isEmpty()) {
            this.populateQuotaHeader(this.getMaxResourceQuota(), this.getCurrentResourceQuotaUsage());
        }

        if (this.usageHeaders.containsKey(headerName)) {
            return this.usageHeaders.get(headerName);
        }

        return 0;
    }

    private long getMaxQuotaHeader(String headerName) {
        if (this.quotaHeaders.size() == 0 &&
                !this.getMaxResourceQuota().isEmpty() &&
                !this.getCurrentResourceQuotaUsage().isEmpty()) {
            this.populateQuotaHeader(this.getMaxResourceQuota(), this.getCurrentResourceQuotaUsage());
        }

        if (this.quotaHeaders.containsKey(headerName)) {
            return this.quotaHeaders.get(headerName);
        }

        return 0;
    }

    private void populateQuotaHeader(String headerMaxQuota,
                                     String headerCurrentUsage) {
        String[] headerMaxQuotaWords = headerMaxQuota.split(Constants.Quota.DELIMITER_CHARS, -1);
        String[] headerCurrentUsageWords = headerCurrentUsage.split(Constants.Quota.DELIMITER_CHARS, -1);

        for (int i = 0; i < headerMaxQuotaWords.length; ++i) {
            if (headerMaxQuotaWords[i].equalsIgnoreCase(Constants.Quota.DATABASE)) {
                this.quotaHeaders.put(Constants.Quota.DATABASE, Long.valueOf(headerMaxQuotaWords[i + 1]));
                this.usageHeaders.put(Constants.Quota.DATABASE, Long.valueOf(headerCurrentUsageWords[i + 1]));
            } else if (headerMaxQuotaWords[i].equalsIgnoreCase(Constants.Quota.COLLECTION)) {
                this.quotaHeaders.put(Constants.Quota.COLLECTION, Long.valueOf(headerMaxQuotaWords[i + 1]));
                this.usageHeaders.put(Constants.Quota.COLLECTION, Long.valueOf(headerCurrentUsageWords[i + 1]));
            } else if (headerMaxQuotaWords[i].equalsIgnoreCase(Constants.Quota.USER)) {
                this.quotaHeaders.put(Constants.Quota.USER, Long.valueOf(headerMaxQuotaWords[i + 1]));
                this.usageHeaders.put(Constants.Quota.USER, Long.valueOf(headerCurrentUsageWords[i + 1]));
            } else if (headerMaxQuotaWords[i].equalsIgnoreCase(Constants.Quota.PERMISSION)) {
                this.quotaHeaders.put(Constants.Quota.PERMISSION, Long.valueOf(headerMaxQuotaWords[i + 1]));
                this.usageHeaders.put(Constants.Quota.PERMISSION, Long.valueOf(headerCurrentUsageWords[i + 1]));
            } else if (headerMaxQuotaWords[i].equalsIgnoreCase(Constants.Quota.COLLECTION_SIZE)) {
                this.quotaHeaders.put(Constants.Quota.COLLECTION_SIZE, Long.valueOf(headerMaxQuotaWords[i + 1]));
                this.usageHeaders.put(Constants.Quota.COLLECTION_SIZE, Long.valueOf(headerCurrentUsageWords[i + 1]));
            } else if (headerMaxQuotaWords[i].equalsIgnoreCase(Constants.Quota.STORED_PROCEDURE)) {
                this.quotaHeaders.put(Constants.Quota.STORED_PROCEDURE, Long.valueOf(headerMaxQuotaWords[i + 1]));
                this.usageHeaders.put(Constants.Quota.STORED_PROCEDURE, Long.valueOf(headerCurrentUsageWords[i + 1]));
            } else if (headerMaxQuotaWords[i].equalsIgnoreCase(Constants.Quota.TRIGGER)) {
                this.quotaHeaders.put(Constants.Quota.TRIGGER, Long.valueOf(headerMaxQuotaWords[i + 1]));
                this.usageHeaders.put(Constants.Quota.TRIGGER, Long.valueOf(headerCurrentUsageWords[i + 1]));
            } else if (headerMaxQuotaWords[i].equalsIgnoreCase(Constants.Quota.USER_DEFINED_FUNCTION)) {
                this.quotaHeaders.put(Constants.Quota.USER_DEFINED_FUNCTION, Long.valueOf(headerMaxQuotaWords[i + 1]));
                this.usageHeaders.put(Constants.Quota.USER_DEFINED_FUNCTION,
                        Long.valueOf(headerCurrentUsageWords[i + 1]));
            }
        }
    }

    private static String getValueOrNull(Map<String, String> map, String key) {
        if (map != null) {
            return map.get(key);
        }
        return null;
    }
}


text:
<?php

define('PHPUNIT', true);

// Composer autoloader
require 'vendor/autoload.php';


text:
<?php
/*!
 * yii2 - module - backend
 * xiewulong <xiewulong@vip.qq.com>
 * https://github.com/xiewulong/yii2-cms
 * https://raw.githubusercontent.com/xiewulong/yii2-cms/master/LICENSE
 * create: 2016/8/7
 * update: 2016/10/12
 * since: 0.0.1
 */

namespace yii\cms;

use Yii;
use yii\components\Module;

use yii\cms\models\Site;

class BackendModule extends Module {

	public $siteId;

	public $attachmentPath;

	public $attachmentUrl;

	public $frontendHost;

	public $frontendModuleId;

	public $controllerNamespace = 'yii\cms\controllers\backend';

	public $defaultRoute = 'dashboard';

	public $layout = 'backend';

	public $customViewsPath = '@vendor/xiewulong/yii2-cms/views/backend';

	public $permissions = ['@'];

	public $addMenuItems = [];

	public $addSidebarItems = [];

	public $messageCategory = 'cms';

	private $_site;

	public function init() {
		parent::init();

		$this->setSite();
		$this->setAttachmentModule('attachment');
	}

	public function attachmentRoute($id) {
		return [$this->url('attachment'), 'id' => $id];
	}

	public function getFrontendUrl($url = null) {
		$frontendModuleId = $this->siteId ? : $this->id;

		return rtrim($this->frontendHost ? : null, '/') . \Yii::$app->urlManager->createUrl([$this->frontendModuleId ? : $frontendModuleId]) . ($url ? \Yii::$app->urlManager->createUrl($url) : null);
	}

	public function url($url) {
		return '/' . $this->uniqueId . '/' . $url;
	}

	private function setAttachmentModule($id, $options = []) {
		$module = [
			'class' => 'yii\attachment\Module',
			'write' => $this->permissions,
		];
		$modules = $this->modules;
		$modules[$id] = array_merge($module, isset($modules[$id]) ? $modules[$id] : [], $options);
		$this->modules = $modules;
	}

	public function getSite() {
		return $this->_site;
	}

	private function setSite() {
		if(!$this->siteId) {
			$this->siteId = $this->id;
		}

		$this->_site = Site::findOne($this->siteId);
		if(!$this->_site) {
			$this->_site = new Site;
			$this->_site->scenario = 'add';
			$this->_site->id = $this->siteId;
			$this->_site->powered = \Yii::t($this->messageCategory, 'Nanning Automan Technology Co., Ltd.');
			if(!$this->_site->commonHandler()) {
				\Yii::$app->end($this->_site->getFirstError('id'));
			}
		}
	}

}


text:
<!DOCTYPE html>

<link rel="import" href="/components/iron-flex-layout/iron-flex-layout-classes.html">
<link rel="import" href="/components/iron-form-element-behavior/iron-form-element-behavior.html">
<link rel="import" href="/components/iron-validatable-behavior/iron-validatable-behavior.html">
<link rel="import" href="/components/paper-input/paper-input.html">
<link rel="import" href="/components/paper-item/paper-item.html">
<link rel="import" href="/components/paper-material/paper-material.html">
<link rel="import" href="/components/paper-menu/paper-menu.html">

<link rel="import" href="/static/autocomplete.html">

<dom-module id="autocomplete-box">
  <template>

      <paper-input label="{{placeholder}}"
                   on-click="onClickInput"
                   on-focus="onFocusInput"
                   on-blur="onBlurInput"
                   on-keydown="onInputKeydown"
                   disabled$="{{disabled}}"
                   id="textbox"
                   required$="[[required]]"
                   value="{{query::input}}">
        <paper-icon-button suffix on-tap="onClearInput_"
          id="clear" icon="clear" alt="clear" title="clear">
        </paper-icon-button>
      </paper-input>
      <paper-material
          id="dropdown-container"
          hidden$="[[!showDropdown]]">
        <paper-menu id="dropdown"
                    tabindex="-1"
                    on-mousedown="onDropdownMouseDown"
                    on-iron-select="onDropdownSelect"
                    on-iron-items-changed="onItemsChanged">
          <template is="dom-repeat" items="[[suggestedItems]]">
              <paper-item
                  item="[[item]]"
                  head$="[[item.head]]"
                  hidden$="[[!showDropdown]]"
                  class$="layout horizontal [[locusClassIfLocus(locusItem, item)]]">

[[item.name]]

[[item.tag]]

            </paper-item>
          </template>
        </paper-menu>
      </paper-material>

    {{value}}

  </template>
</dom-module>


text:
package android.net;

import android.os.Parcel;
import android.os.Parcelable;

/**
 * Way Lin, 20171024.
 * <p>
 * Information about quota status on a specific network.
 *
 * @hide
 */
public class NetworkQuotaInfo implements Parcelable {
    private final long mEstimatedBytes;
    private final long mSoftLimitBytes;
    private final long mHardLimitBytes;

    public static final long NO_LIMIT = -1;

    /**
     * {@hide}
     */
    public NetworkQuotaInfo(long estimatedBytes, long softLimitBytes, long hardLimitBytes) {
        mEstimatedBytes = estimatedBytes;
        mSoftLimitBytes = softLimitBytes;
        mHardLimitBytes = hardLimitBytes;
    }

    /**
     * {@hide}
     */
    public NetworkQuotaInfo(Parcel in) {
        mEstimatedBytes = in.readLong();
        mSoftLimitBytes = in.readLong();
        mHardLimitBytes = in.readLong();
    }

    public long getEstimatedBytes() {
        return mEstimatedBytes;
    }

    public long getSoftLimitBytes() {
        return mSoftLimitBytes;
    }

    public long getHardLimitBytes() {
        return mHardLimitBytes;
    }

    @Override
    public int describeContents() {
        return 0;
    }

    @Override
    public void writeToParcel(Parcel out, int flags) {
        out.writeLong(mEstimatedBytes);
        out.writeLong(mSoftLimitBytes);
        out.writeLong(mHardLimitBytes);
    }

    public static final Creator<NetworkQuotaInfo> CREATOR = new Creator<NetworkQuotaInfo>() {
        @Override
        public NetworkQuotaInfo createFromParcel(Parcel in) {
            return new NetworkQuotaInfo(in);
        }

        @Override
        public NetworkQuotaInfo[] newArray(int size) {
            return new NetworkQuotaInfo[size];
        }
    };
}


text:
package io.datarouter.web.dispatcher;

import java.util.function.Supplier;

import javax.servlet.http.HttpServletRequest;

import io.datarouter.httpclient.security.SecurityParameters;

public class DefaultApiKeyPredicate extends ApiKeyPredicate{

	private final Supplier<String> apiKeySupplier;

	public DefaultApiKeyPredicate(Supplier<String> apiKeySupplier){
		super(SecurityParameters.API_KEY);
		this.apiKeySupplier = apiKeySupplier;
	}

	@Override
	public ApiKeyPredicateCheck innerCheck(DispatchRule rule, HttpServletRequest request, String apiKeyCandidate){
		if(apiKeySupplier.get().equals(apiKeyCandidate)){
			return new ApiKeyPredicateCheck(true, "");
		}
		return new ApiKeyPredicateCheck(false, "no match for " + obfuscate(apiKeyCandidate));
	}

}


text:
<T3DataStructure>
	<meta>
		<langDisable>1</langDisable>
	</meta>
	<sheets>
		<sDEF>
			<ROOT>
				<TCEforms>
					<sheetTitle>Vordefiniert</sheetTitle>
				</TCEforms>
				<type>array</type>
				<el>

					<field_option>
						<TCEforms>
							Funktion:
							<config>
								<type>select</type>
								<items type="array">
									<numIndex index="0" type="array">
										<numIndex index="0">Übergeordnetes HMENU zeigen</numIndex>
										<numIndex index="1">parent_hmenu</numIndex>
									</numIndex>
								</items>

								<default></default>
							</config>
						</TCEforms>
					</field_option>

				</el>
			</ROOT>
		</sDEF>

    </sheets>
</T3DataStructure>


text:
class CreateAddressTypes < ActiveRecord::Migration[4.2]
  def change
    create_table :address_types do |t|
      t.string :key
      t.string :label

      t.timestamps
    end
  end
end


text:
class Gws::Board::Topic
  include Gws::Referenceable
  include Gws::Board::Postable
  include Gws::Addon::Contributor
  include SS::Addon::Markdown
  include Gws::Addon::File
  include Gws::Addon::Link
  include Gws::Board::DescendantsFileInfo
  include Gws::Addon::Board::Category
  include Gws::Addon::Board::NotifySetting
  include SS::Addon::Release
  include Gws::Addon::Member
  include Gws::Addon::ReadableSetting
  include Gws::Addon::GroupPermission
  include Gws::Addon::History
  include Gws::Board::BrowsingState

  member_include_custom_groups
  member_ids_optional
  readable_setting_include_custom_groups
  no_needs_read_permission_to_read
  permission_include_custom_groups
  hide_released_field

  validates :category_ids, presence: true
  after_validation :set_descendants_updated_with_released, if: -> { released.present? && released_changed? }

  # indexing to elasticsearch via companion object
  around_save ::Gws::Elasticsearch::Indexer::BoardTopicJob.callback
  around_destroy ::Gws::Elasticsearch::Indexer::BoardTopicJob.callback

  def updated?
    created.to_i != updated.to_i || created.to_i != descendants_updated.to_i
  end

  def subscribed_users
    return Gws::User.none if new_record?

    conds = []
    conds << { id: { '$in' => members.active.pluck(:id) } } if members.active.present?
    conds << { group_ids: { '$in' => member_groups.active.pluck(:id) } } if member_groups.active.present?
    if member_custom_groups.present?
      ids = member_custom_groups.to_a.map { |custom_group| custom_group.overall_members.active.pluck(:id) }.flatten.uniq
      conds << { id: { '$in' => ids } } if ids.present?
    end
    if categories.present?
      conds << { id: { '$in' => categories.pluck(:subscribed_member_ids).flatten } }
      conds << { group_ids: { '$in' => categories.pluck(:subscribed_group_ids).flatten } }
    end
    return Gws::User.none if conds.blank?

    Gws::User.where('$and' => [ { '$or' => conds } ])
  end

  private

  def set_descendants_updated_with_released
    if descendants_updated.present?
      self.descendants_updated = released if descendants_updated < released
    else
      self.descendants_updated = released
    end
  end
end


text:
const DrawCard = require('../../drawcard.js');

class MirumotoProdigy extends DrawCard {
    setupCardAbilities(ability) {
        this.persistentEffect({
            condition: context =>
                context.source.isAttacking() &&
                this.game.currentConflict.getNumberOfParticipantsFor('attacker') === 1,
            effect: ability.effects.restrictNumberOfDefenders(1)
        });
    }
}

MirumotoProdigy.id = 'mirumoto-prodigy';

module.exports = MirumotoProdigy;


text:
#pragma once
#include <aws/appsync/AppSync_EXPORTS.h>
#include <aws/appsync/AppSyncRequest.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <utility>

namespace Aws
{
namespace AppSync
{
namespace Model
{

  /**
   */
  class AWS_APPSYNC_API CreateDomainNameRequest : public AppSyncRequest
  {
  public:
    CreateDomainNameRequest();

    // Service request name is the Operation name which will send this request out,
    // each operation should has unique request name, so that we can get operation's name from this request.
    // Note: this is not true for response, multiple operations may have the same response name,
    // so we can not get operation's name from response.
    inline virtual const char* GetServiceRequestName() const override { return "CreateDomainName"; }

    Aws::String SerializePayload() const override;

    /**
     *
The domain name.

     */
    inline const Aws::String& GetDomainName() const{ return m_domainName; }

    /**
     *
The domain name.

     */
    inline bool DomainNameHasBeenSet() const { return m_domainNameHasBeenSet; }

    /**
     *
The domain name.

     */
    inline void SetDomainName(const Aws::String& value) { m_domainNameHasBeenSet = true; m_domainName = value; }

    /**
     *
The domain name.

     */
    inline void SetDomainName(Aws::String&& value) { m_domainNameHasBeenSet = true; m_domainName = std::move(value); }

    /**
     *
The domain name.

     */
    inline void SetDomainName(const char* value) { m_domainNameHasBeenSet = true; m_domainName.assign(value); }

    /**
     *
The domain name.

     */
    inline CreateDomainNameRequest& WithDomainName(const Aws::String& value) { SetDomainName(value); return *this;}

    /**
     *
The domain name.

     */
    inline CreateDomainNameRequest& WithDomainName(Aws::String&& value) { SetDomainName(std::move(value)); return *this;}

    /**
     *
The domain name.

     */
    inline CreateDomainNameRequest& WithDomainName(const char* value) { SetDomainName(value); return *this;}

    /**
     *
The Amazon Resource Name (ARN) of the certificate. This can be an Certificate
     * Manager (ACM) certificate or an Identity and Access Management (IAM) server
     * certificate.

     */
    inline const Aws::String& GetCertificateArn() const{ return m_certificateArn; }

    /**
     *
The Amazon Resource Name (ARN) of the certificate. This can be an Certificate
     * Manager (ACM) certificate or an Identity and Access Management (IAM) server
     * certificate.

     */
    inline bool CertificateArnHasBeenSet() const { return m_certificateArnHasBeenSet; }

    /**
     *
The Amazon Resource Name (ARN) of the certificate. This can be an Certificate
     * Manager (ACM) certificate or an Identity and Access Management (IAM) server
     * certificate.

     */
    inline void SetCertificateArn(const Aws::String& value) { m_certificateArnHasBeenSet = true; m_certificateArn = value; }

    /**
     *
The Amazon Resource Name (ARN) of the certificate. This can be an Certificate
     * Manager (ACM) certificate or an Identity and Access Management (IAM) server
     * certificate.

     */
    inline void SetCertificateArn(Aws::String&& value) { m_certificateArnHasBeenSet = true; m_certificateArn = std::move(value); }

    /**
     *
The Amazon Resource Name (ARN) of the certificate. This can be an Certificate
     * Manager (ACM) certificate or an Identity and Access Management (IAM) server
     * certificate.

     */
    inline void SetCertificateArn(const char* value) { m_certificateArnHasBeenSet = true; m_certificateArn.assign(value); }

    /**
     *
The Amazon Resource Name (ARN) of the certificate. This can be an Certificate
     * Manager (ACM) certificate or an Identity and Access Management (IAM) server
     * certificate.

     */
    inline CreateDomainNameRequest& WithCertificateArn(const Aws::String& value) { SetCertificateArn(value); return *this;}

    /**
     *
The Amazon Resource Name (ARN) of the certificate. This can be an Certificate
     * Manager (ACM) certificate or an Identity and Access Management (IAM) server
     * certificate.

     */
    inline CreateDomainNameRequest& WithCertificateArn(Aws::String&& value) { SetCertificateArn(std::move(value)); return *this;}

    /**
     *
The Amazon Resource Name (ARN) of the certificate. This can be an Certificate
     * Manager (ACM) certificate or an Identity and Access Management (IAM) server
     * certificate.

     */
    inline CreateDomainNameRequest& WithCertificateArn(const char* value) { SetCertificateArn(value); return *this;}

    /**
     *
A description of the DomainName.

     */
    inline const Aws::String& GetDescription() const{ return m_description; }

    /**
     *
A description of the DomainName.

     */
    inline bool DescriptionHasBeenSet() const { return m_descriptionHasBeenSet; }

    /**
     *
A description of the DomainName.

     */
    inline void SetDescription(const Aws::String& value) { m_descriptionHasBeenSet = true; m_description = value; }

    /**
     *
A description of the DomainName.

     */
    inline void SetDescription(Aws::String&& value) { m_descriptionHasBeenSet = true; m_description = std::move(value); }

    /**
     *
A description of the DomainName.

     */
    inline void SetDescription(const char* value) { m_descriptionHasBeenSet = true; m_description.assign(value); }

    /**
     *
A description of the DomainName.

     */
    inline CreateDomainNameRequest& WithDescription(const Aws::String& value) { SetDescription(value); return *this;}

    /**
     *
A description of the DomainName.

     */
    inline CreateDomainNameRequest& WithDescription(Aws::String&& value) { SetDescription(std::move(value)); return *this;}

    /**
     *
A description of the DomainName.

     */
    inline CreateDomainNameRequest& WithDescription(const char* value) { SetDescription(value); return *this;}

  private:

    Aws::String m_domainName;
    bool m_domainNameHasBeenSet;

    Aws::String m_certificateArn;
    bool m_certificateArnHasBeenSet;

    Aws::String m_description;
    bool m_descriptionHasBeenSet;
  };

} // namespace Model
} // namespace AppSync
} // namespace Aws


text:
<?php
/**
 * Created by PhpStorm.
 * User: sz
 * Date: 04.02.15
 * Time: 15:48
 */

namespace common\actions;

class DeleteAction extends Action{

    public function run(){
        $model = $this->getModel();
        if($model->delete()){
            if($this->redirectUrl){
                $this->controller->redirect($this->redirectUrl);
                \Yii::$app->end();
            }
            return true;
        }
        else{
            throw new ServerErrorHttpException('Failed to delete the object for unknown reason.');
        }

//        \Yii::$app->getResponse()->setStatusCode(204);
    }

    public function loadData($model, $post){

    }
}


text:
class WithInstallerManual < TestCask
  version '1.2.3'
  sha256 '9203c30951f9aab41ac294bbeb1dcef7bed401ff0b353dcb34d68af32ea51853'

  url TestHelper.local_binary_url('caffeine.zip')
  homepage 'http://example.com/local-caffeine'

  installer :manual => 'Caffeine.app'
end


text:
import vTimeline from './Timeline.vue'
import vTimelineItem from './TimelineItem.vue'

vTimeline.vTimelineItem = vTimelineItem

export default vTimeline


text:
require "google/cloud/compute/v1/node_groups/rest/client"

module Google
  module Cloud
    module Compute
      module V1
        module NodeGroups
          # Client for the REST transport
          module Rest
          end
        end
      end
    end
  end
end


text:
module ActiveRecord
  module AttributeMethods
    module Serialization
      extend ActiveSupport::Concern

      included do
        # Returns a hash of all the attributes that have been specified for serialization as
        # keys and their class restriction as values.
        class_attribute :serialized_attributes
        self.serialized_attributes = {}
      end

      class Attribute < Struct.new(:coder, :value, :state)
        def unserialized_value
          state == :serialized ? unserialize : value
        end

        def serialized_value
          state == :unserialized ? serialize : value
        end

        def unserialize
          self.state = :unserialized
          self.value = coder.load(value)
        end

        def serialize
          self.state = :serialized
          self.value = coder.dump(value)
        end
      end

      module ClassMethods
        # If you have an attribute that needs to be saved to the database as an object, and retrieved as the same object,
        # then specify the name of that attribute using this method and it will be handled automatically.
        # The serialization is done through YAML. If +class_name+ is specified, the serialized object must be of that
        # class on retrieval or SerializationTypeMismatch will be raised.
        #
        # ==== Parameters
        #
        # * +attr_name+ - The field name that should be serialized.
        # * +class_name+ - Optional, class name that the object type should be equal to.
        #
        # ==== Example
        #   # Serialize a preferences attribute
        #   class User < ActiveRecord::Base
        #     serialize :preferences
        #   end
        def serialize(attr_name, class_name = Object)
          coder = if [:load, :dump].all? { |x| class_name.respond_to?(x) }
                    class_name
                  else
                    Coders::YAMLColumn.new(class_name)
                  end

          # merge new serialized attribute and create new hash to ensure that each class in inheritance hierarchy
          # has its own hash of own serialized attributes
          self.serialized_attributes = serialized_attributes.merge(attr_name.to_s => coder)
        end

        def initialize_attributes(attributes, options = {}) #:nodoc:
          serialized = (options.delete(:serialized) { true }) ? :serialized : :unserialized
          super(attributes, options)

          serialized_attributes.each do |key, coder|
            if attributes.key?(key)
              attributes[key] = Attribute.new(coder, attributes[key], serialized)
            end
          end

          attributes
        end

        private

        def attribute_cast_code(attr_name)
          if serialized_attributes.include?(attr_name)
            "v.unserialized_value"
          else
            super
          end
        end
      end

      def type_cast_attribute_for_write(column, value)
        if column && coder = self.class.serialized_attributes[column.name]
          Attribute.new(coder, value, :unserialized)
        else
          super
        end
      end

      def read_attribute_before_type_cast(attr_name)
        if serialized_attributes.include?(attr_name)
          super.unserialized_value
        else
          super
        end
      end

      def attributes_before_type_cast
        super.dup.tap do |attributes|
          self.class.serialized_attributes.each_key do |key|
            if attributes.key?(key)
              attributes[key] = attributes[key].unserialized_value
            end
          end
        end
      end
    end
  end
end


text:
SELECT DISTINCT
    process.name
  , listening.address
  , listening.port
  , process.pid
FROM processes AS process
JOIN listening_ports AS listening
    ON process.pid = listening.pid
WHERE listening.address IS NOT null
    AND listening.address <> ''
ORDER BY listening.port
;


text:
+++
images = []
banner = ""
menu = ""
description = ""
categories = []
tags = ["tools"]
title = "Building a Better Blog - Work Flow"
series = ["blog"]
date = "2017-04-05"
draft = true
+++

In the last article in this series, I explained how I decided to write
my articles in simple markdown text format, generate my site
using [Hugo](http://gohugo.io), and store and manage my content
in a Github repository. But that's like a bunch of potential energy -
it doesn't actually product a website. In this chapter, I'm going
to show you my entire work flow.

Here's a summary of the process by which I publish a new article:

* Copy template article
* Compose new article (in Markdown)
* Preview new article (using hugo server -w)
* When satisfied, push new article to Github
* CircleCI re-builds site and publishes to Firebase Hosting service

Here's a screencast, which gives a better sense of what goes on:


text:
.class public Lcom/adobe/xmp/XMPUtils;
.super Ljava/lang/Object;
.source "XMPUtils.java"

# direct methods
.method private constructor <init>()V
    .locals 0

    .prologue
    .line 28
    invoke-direct {p0}, Ljava/lang/Object;-><init>()V

    .line 30
    return-void
.end method

.method public static appendProperties(Lcom/adobe/xmp/XMPMeta;Lcom/adobe/xmp/XMPMeta;ZZ)V
    .locals 1
    .parameter "source"
    .parameter "dest"
    .parameter "doAllProperties"
    .parameter "replaceOldValues"
    .annotation system Ldalvik/annotation/Throws;
        value = {
            Lcom/adobe/xmp/XMPException;
        }
    .end annotation

    .prologue
    .line 157
    const/4 v0, 0x0

    invoke-static {p0, p1, p2, p3, v0}, Lcom/adobe/xmp/XMPUtils;->appendProperties(Lcom/adobe/xmp/XMPMeta;Lcom/adobe/xmp/XMPMeta;ZZZ)V

    .line 158
    return-void
.end method

.method public static appendProperties(Lcom/adobe/xmp/XMPMeta;Lcom/adobe/xmp/XMPMeta;ZZZ)V
    .locals 0
    .parameter "source"
    .parameter "dest"
    .parameter "doAllProperties"
    .parameter "replaceOldValues"
    .parameter "deleteEmptyValues"
    .annotation system Ldalvik/annotation/Throws;
        value = {
            Lcom/adobe/xmp/XMPException;
        }
    .end annotation

    .prologue
    .line 241
    invoke-static {p0, p1, p2, p3, p4}, Lcom/adobe/xmp/impl/XMPUtilsImpl;->appendProperties(Lcom/adobe/xmp/XMPMeta;Lcom/adobe/xmp/XMPMeta;ZZZ)V

    .line 243
    return-void
.end method

.method public static catenateArrayItems(Lcom/adobe/xmp/XMPMeta;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Z)Ljava/lang/String;
    .locals 1
    .parameter "xmp"
    .parameter "schemaNS"
    .parameter "arrayName"
    .parameter "separator"
    .parameter "quotes"
    .parameter "allowCommas"
    .annotation system Ldalvik/annotation/Throws;
        value = {
            Lcom/adobe/xmp/XMPException;
        }
    .end annotation

    .prologue
    .line 60
    invoke-static/range {p0 .. p5}, Lcom/adobe/xmp/impl/XMPUtilsImpl;->catenateArrayItems(Lcom/adobe/xmp/XMPMeta;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Z)Ljava/lang/String;

    move-result-object v0

    return-object v0
.end method

.method public static convertFromBoolean(Z)Ljava/lang/String;
    .locals 1
    .parameter "value"

    .prologue
    .line 297
    if-eqz p0, :cond_0

    const-string v0, "True"

    :goto_0
    return-object v0

    :cond_0
    const-string v0, "False"

    goto :goto_0
.end method

.method public static convertFromDate(Lcom/adobe/xmp/XMPDateTime;)Ljava/lang/String;
    .locals 1
    .parameter "value"

    .prologue
    .line 470
    invoke-static {p0}, Lcom/adobe/xmp/impl/ISO8601Converter;->render(Lcom/adobe/xmp/XMPDateTime;)Ljava/lang/String;

    move-result-object v0

    return-object v0
.end method

.method public static convertFromDouble(D)Ljava/lang/String;
    .locals 1
    .parameter "value"

    .prologue
    .line 434
    invoke-static {p0, p1}, Ljava/lang/String;->valueOf(D)Ljava/lang/String;

    move-result-object v0

    return-object v0
.end method

.method public static convertFromInteger(I)Ljava/lang/String;
    .locals 1
    .parameter "value"

    .prologue
    .line 344
    invoke-static {p0}, Ljava/lang/String;->valueOf(I)Ljava/lang/String;

    move-result-object v0

    return-object v0
.end method

.method public static convertFromLong(J)Ljava/lang/String;
    .locals 1
    .parameter "value"

    .prologue
    .line 391
    invoke-static {p0, p1}, Ljava/lang/String;->valueOf(J)Ljava/lang/String;

    move-result-object v0

    return-object v0
.end method

.method public static convertToBoolean(Ljava/lang/String;)Z
    .locals 4
    .parameter "value"
    .annotation system Ldalvik/annotation/Throws;
        value = {
            Lcom/adobe/xmp/XMPException;
        }
    .end annotation

    .prologue
    const/4 v1, 0x1

    const/4 v2, 0x0

    .line 264
    if-eqz p0, :cond_0

    invoke-virtual {p0}, Ljava/lang/String;->length()I

    move-result v3

    if-nez v3, :cond_1

    .line 266
    :cond_0
    new-instance v1, Lcom/adobe/xmp/XMPException;

    const-string v2, "Empty convert-string"

    const/4 v3, 0x5

    invoke-direct {v1, v2, v3}, Lcom/adobe/xmp/XMPException;-><init>(Ljava/lang/String;I)V

    throw v1

    .line 268
    :cond_1
    invoke-virtual {p0}, Ljava/lang/String;->toLowerCase()Ljava/lang/String;

    move-result-object p0

    .line 273
    :try_start_0
    invoke-static {p0}, Ljava/lang/Integer;->parseInt(Ljava/lang/String;)I
    :try_end_0
    .catch Ljava/lang/NumberFormatException; {:try_start_0 .. :try_end_0} :catch_0

    move-result v3

    if-eqz v3, :cond_2

    .line 277
    :goto_0
    return v1

    :cond_2
    move v1, v2

    .line 273
    goto :goto_0

    .line 275
    :catch_0
    move-exception v0

    .line 277
    .local v0, e:Ljava/lang/NumberFormatException;
    const-string v3, "true"

    invoke-virtual {v3, p0}, Ljava/lang/String;->equals(Ljava/lang/Object;)Z

    move-result v3

    if-nez v3, :cond_3

    const-string v3, "t"

    invoke-virtual {v3, p0}, Ljava/lang/String;->equals(Ljava/lang/Object;)Z

    move-result v3

    if-nez v3, :cond_3

    const-string v3, "on"

    invoke-virtual {v3, p0}, Ljava/lang/String;->equals(Ljava/lang/Object;)Z

    move-result v3

    if-nez v3, :cond_3

    const-string v3, "yes"

    invoke-virtual {v3, p0}, Ljava/lang/String;->equals(Ljava/lang/Object;)Z

    move-result v3

    if-eqz v3, :cond_4

    :cond_3
    move v2, v1

    :cond_4
    move v1, v2

    goto :goto_0
.end method

.method public static convertToDate(Ljava/lang/String;)Lcom/adobe/xmp/XMPDateTime;
    .locals 3
    .parameter "rawValue"
    .annotation system Ldalvik/annotation/Throws;
        value = {
            Lcom/adobe/xmp/XMPException;
        }
    .end annotation

    .prologue
    .line 450
    if-eqz p0, :cond_0

    invoke-virtual {p0}, Ljava/lang/String;->length()I

    move-result v0

    if-nez v0, :cond_1

    .line 452
    :cond_0
    new-instance v0, Lcom/adobe/xmp/XMPException;

    const-string v1, "Empty convert-string"

    const/4 v2, 0x5

    invoke-direct {v0, v1, v2}, Lcom/adobe/xmp/XMPException;-><init>(Ljava/lang/String;I)V

    throw v0

    .line 456
    :cond_1
    invoke-static {p0}, Lcom/adobe/xmp/impl/ISO8601Converter;->parse(Ljava/lang/String;)Lcom/adobe/xmp/XMPDateTime;

    move-result-object v0

    return-object v0
.end method

.method public static convertToDouble(Ljava/lang/String;)D
    .locals 5
    .parameter "rawValue"
    .annotation system Ldalvik/annotation/Throws;
        value = {
            Lcom/adobe/xmp/XMPException;
        }
    .end annotation

    .prologue
    const/4 v4, 0x5

    .line 409
    if-eqz p0, :cond_0

    :try_start_0
    invoke-virtual {p0}, Ljava/lang/String;->length()I

    move-result v1

    if-nez v1, :cond_1

    .line 411
    :cond_0
    new-instance v1, Lcom/adobe/xmp/XMPException;

    const-string v2, "Empty convert-string"

    const/4 v3, 0x5

    invoke-direct {v1, v2, v3}, Lcom/adobe/xmp/XMPException;-><init>(Ljava/lang/String;I)V

    throw v1
    :try_end_0
    .catch Ljava/lang/NumberFormatException; {:try_start_0 .. :try_end_0} :catch_0

    .line 418
    :catch_0
    move-exception v0

    .line 420
    .local v0, e:Ljava/lang/NumberFormatException;
    new-instance v1, Lcom/adobe/xmp/XMPException;

    const-string v2, "Invalid double string"

    invoke-direct {v1, v2, v4}, Lcom/adobe/xmp/XMPException;-><init>(Ljava/lang/String;I)V

    throw v1

    .line 415
    .end local v0           #e:Ljava/lang/NumberFormatException;
    :cond_1
    :try_start_1
    invoke-static {p0}, Ljava/lang/Double;->parseDouble(Ljava/lang/String;)D
    :try_end_1
    .catch Ljava/lang/NumberFormatException; {:try_start_1 .. :try_end_1} :catch_0

    move-result-wide v1

    return-wide v1
.end method

.method public static convertToInteger(Ljava/lang/String;)I
    .locals 5
    .parameter "rawValue"
    .annotation system Ldalvik/annotation/Throws;
        value = {
            Lcom/adobe/xmp/XMPException;
        }
    .end annotation

    .prologue
    const/4 v4, 0x5

    .line 315
    if-eqz p0, :cond_0

    :try_start_0
    invoke-virtual {p0}, Ljava/lang/String;->length()I

    move-result v1

    if-nez v1, :cond_1

    .line 317
    :cond_0
    new-instance v1, Lcom/adobe/xmp/XMPException;

    const-string v2, "Empty convert-string"

    const/4 v3, 0x5

    invoke-direct {v1, v2, v3}, Lcom/adobe/xmp/XMPException;-><init>(Ljava/lang/String;I)V

    throw v1
    :try_end_0
    .catch Ljava/lang/NumberFormatException; {:try_start_0 .. :try_end_0} :catch_0

    .line 328
    :catch_0
    move-exception v0

    .line 330
    .local v0, e:Ljava/lang/NumberFormatException;
    new-instance v1, Lcom/adobe/xmp/XMPException;

    const-string v2, "Invalid integer string"

    invoke-direct {v1, v2, v4}, Lcom/adobe/xmp/XMPException;-><init>(Ljava/lang/String;I)V

    throw v1

    .line 319
    .end local v0           #e:Ljava/lang/NumberFormatException;
    :cond_1
    :try_start_1
    const-string v1, "0x"

    invoke-virtual {p0, v1}, Ljava/lang/String;->startsWith(Ljava/lang/String;)Z

    move-result v1

    if-eqz v1, :cond_2

    .line 321
    const/4 v1, 0x2

    invoke-virtual {p0, v1}, Ljava/lang/String;->substring(I)Ljava/lang/String;

    move-result-object v1

    const/16 v2, 0x10

    invoke-static {v1, v2}, Ljava/lang/Integer;->parseInt(Ljava/lang/String;I)I

    move-result v1

    .line 325
    :goto_0
    return v1

    :cond_2
    invoke-static {p0}, Ljava/lang/Integer;->parseInt(Ljava/lang/String;)I
    :try_end_1
    .catch Ljava/lang/NumberFormatException; {:try_start_1 .. :try_end_1} :catch_0

    move-result v1

    goto :goto_0
.end method

.method public static convertToLong(Ljava/lang/String;)J
    .locals 5
    .parameter "rawValue"
    .annotation system Ldalvik/annotation/Throws;
        value = {
            Lcom/adobe/xmp/XMPException;
        }
    .end annotation

    .prologue
    const/4 v4, 0x5

    .line 362
    if-eqz p0, :cond_0

    :try_start_0
    invoke-virtual {p0}, Ljava/lang/String;->length()I

    move-result v1

    if-nez v1, :cond_1

    .line 364
    :cond_0
    new-instance v1, Lcom/adobe/xmp/XMPException;

    const-string v2, "Empty convert-string"

    const/4 v3, 0x5

    invoke-direct {v1, v2, v3}, Lcom/adobe/xmp/XMPException;-><init>(Ljava/lang/String;I)V

    throw v1
    :try_end_0
    .catch Ljava/lang/NumberFormatException; {:try_start_0 .. :try_end_0} :catch_0

    .line 375
    :catch_0
    move-exception v0

    .line 377
    .local v0, e:Ljava/lang/NumberFormatException;
    new-instance v1, Lcom/adobe/xmp/XMPException;

    const-string v2, "Invalid long string"

    invoke-direct {v1, v2, v4}, Lcom/adobe/xmp/XMPException;-><init>(Ljava/lang/String;I)V

    throw v1

    .line 366
    .end local v0           #e:Ljava/lang/NumberFormatException;
    :cond_1
    :try_start_1
    const-string v1, "0x"

    invoke-virtual {p0, v1}, Ljava/lang/String;->startsWith(Ljava/lang/String;)Z

    move-result v1

    if-eqz v1, :cond_2

    .line 368
    const/4 v1, 0x2

    invoke-virtual {p0, v1}, Ljava/lang/String;->substring(I)Ljava/lang/String;

    move-result-object v1

    const/16 v2, 0x10

    invoke-static {v1, v2}, Ljava/lang/Long;->parseLong(Ljava/lang/String;I)J

    move-result-wide v1

    .line 372
    :goto_0
    return-wide v1

    :cond_2
    invoke-static {p0}, Ljava/lang/Long;->parseLong(Ljava/lang/String;)J
    :try_end_1
    .catch Ljava/lang/NumberFormatException; {:try_start_1 .. :try_end_1} :catch_0

    move-result-wide v1

    goto :goto_0
.end method

.method public static decodeBase64(Ljava/lang/String;)[B
    .locals 4
    .parameter "base64String"
    .annotation system Ldalvik/annotation/Throws;
        value = {
            Lcom/adobe/xmp/XMPException;
        }
    .end annotation

    .prologue
    .line 499
    :try_start_0
    invoke-virtual {p0}, Ljava/lang/String;->getBytes()[B

    move-result-object v1

    invoke-static {v1}, Lcom/adobe/xmp/impl/Base64;->decode([B)[B
    :try_end_0
    .catch Ljava/lang/Throwable; {:try_start_0 .. :try_end_0} :catch_0

    move-result-object v1

    return-object v1

    .line 501
    :catch_0
    move-exception v0

    .line 503
    .local v0, e:Ljava/lang/Throwable;
    new-instance v1, Lcom/adobe/xmp/XMPException;

    const-string v2, "Invalid base64 string"

    const/4 v3, 0x5

    invoke-direct {v1, v2, v3, v0}, Lcom/adobe/xmp/XMPException;-><init>(Ljava/lang/String;ILjava/lang/Throwable;)V

    throw v1
.end method

.method public static encodeBase64([B)Ljava/lang/String;
    .locals 2
    .parameter "buffer"

    .prologue
    .line 483
    new-instance v0, Ljava/lang/String;

    invoke-static {p0}, Lcom/adobe/xmp/impl/Base64;->encode([B)[B

    move-result-object v1

    invoke-direct {v0, v1}, Ljava/lang/String;-><init>([B)V

    return-object v0
.end method

.method public static removeProperties(Lcom/adobe/xmp/XMPMeta;Ljava/lang/String;Ljava/lang/String;ZZ)V
    .locals 0
    .parameter "xmp"
    .parameter "schemaNS"
    .parameter "propName"
    .parameter "doAllProperties"
    .parameter "includeAliases"
    .annotation system Ldalvik/annotation/Throws;
        value = {
            Lcom/adobe/xmp/XMPException;
        }
    .end annotation

    .prologue
    .line 141
    invoke-static {p0, p1, p2, p3, p4}, Lcom/adobe/xmp/impl/XMPUtilsImpl;->removeProperties(Lcom/adobe/xmp/XMPMeta;Ljava/lang/String;Ljava/lang/String;ZZ)V

    .line 142
    return-void
.end method

.method public static separateArrayItems(Lcom/adobe/xmp/XMPMeta;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lcom/adobe/xmp/options/PropertyOptions;Z)V
    .locals 0
    .parameter "xmp"
    .parameter "schemaNS"
    .parameter "arrayName"
    .parameter "catedStr"
    .parameter "arrayOptions"
    .parameter "preserveCommas"
    .annotation system Ldalvik/annotation/Throws;
        value = {
            Lcom/adobe/xmp/XMPException;
        }
    .end annotation

    .prologue
    .line 87
    invoke-static/range {p0 .. p5}, Lcom/adobe/xmp/impl/XMPUtilsImpl;->separateArrayItems(Lcom/adobe/xmp/XMPMeta;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lcom/adobe/xmp/options/PropertyOptions;Z)V

    .line 89
    return-void
.end method


text:
Editar Automóvel

	<form name="editarAutomovelCtrl.form" ng-submit="editarAutomovelCtrl.editarAutomovel()" novalidate>

	    Placa
	    <input type="text" class="form-control" min-length="8" max-length="8" name="placa" ng-model="editarAutomovelCtrl.automovel.placa" required="required" mask="AAA-9999" placeholder="XXX-0000">

	    Modelo
	    <input type="text" class="form-control" name="modelo" ng-model="editarAutomovelCtrl.automovel.modelo" required="required" placeholder="CIVIC LXR 2.0">

	    Ano
	    <input type="text" class="form-control" name="ano" ng-model="editarAutomovelCtrl.automovel.ano" required="required" mask="9?" repeat="4" placeholder="0000">

	    Fabricante
	    <input type="text" class="form-control" name="fabricante" ng-model="editarAutomovelCtrl.automovel.fabricante" required="required" placeholder="HONDA">

	    Capacidade do Tanque de Combustível
	    <input type="number" class="form-control" name="capacidade" ng-model="editarAutomovelCtrl.automovel.capacidade" required="required" mask="9?" repeat="3" placeholder="00">

	    Valor atual do odômetro
	    <input type="number" class="form-control" name="odometro" ng-model="editarAutomovelCtrl.automovel.odometro" required="required" mask="9?" repeat="6" placeholder="0000">

	  <button type="submit" class="btn btn-primary" ng-disabled="editarAutomovelCtrl.salvando">Salvar</button>
	  Veículo editado com sucesso
	  Existem problemas no formulário
	</form>


text:
author: luizsanches
comments: true
date: 2009-06-14 21:19:25+00:00
layout: post
slug: tasafo-no-fisl10
title: tasafo no fisl10
wordpress_id: 313
categories:
- Relatos
tags:
- fisl
- Porto Alegre
---

[![fisl10-blog-rectangle180x150](http://tasafo.files.wordpress.com/2009/06/fisl10-blog-rectangle180x150.png)](http://www.fisl.org.br/)

Anunciamos no Visão Ágil Academic Meeting (dia 30/05) que vamos (de mala e cuia :p) como [caravana para o fisl10](http://www.fisl.org.br/10/www/lista-caravanas). Relataremos, aqui pelo blog, os   acontecimentos do fisl deste ano. Esperamos encontrar com mais paraenses por lá, como no ano passado. "Rumbora" moçada!

Integrantes:

  * Carlos Amorim - IESAM

  * Flávio Ferreira - CESUPA

  * Gilmar Almeida - IESAM

  * Jaime Schettini - IESAM

  * Luiz Sanches - IESAM

  * Myller Sakaguchi - CESUPA