repo_name
stringlengths 4
116
| path
stringlengths 3
942
| size
stringlengths 1
7
| content
stringlengths 3
1.05M
| license
stringclasses 15
values |
|---|---|---|---|---|
malob/homebrew-cask | Casks/operadriver.rb | 501 | cask "operadriver" do
version "96.0.4664.45"
sha256 "fe712310d8577056442bf7146cde2b1db69181873ff3cb2311335b784829cac6"
url "https://github.com/operasoftware/operachromiumdriver/releases/download/v.#{version}/operadriver_mac64.zip"
name "OperaChromiumDriver"
desc "Driver for Chromium-based Opera releases"
homepage "https://github.com/operasoftware/operachromiumdriver"
livecheck do
url :url
regex(/^v?\.?(\d+(?:\.\d+)+)$/i)
end
binary "operadriver_mac64/operadriver"
end
| bsd-2-clause |
jiashuw/homebrew-cask | Casks/wifispoof.rb | 579 | cask 'wifispoof' do
version '3.0.2'
sha256 'ee0b4e0941f20f4cd71b7f6fa4f56da695cd1d6e1c4e49daec3a460463bd9946'
# sweetpproductions.com/products was verified as official when first introduced to the cask
url "https://sweetpproductions.com/products/wifispoof#{version.major}/WiFiSpoof#{version.major}.dmg"
appcast 'https://sweetpproductions.com/products/wifispoof3/appcast.xml',
checkpoint: 'e4a7cf391172f201bbd706624b22df970cb05e7b095b05a45713744c66e3b58a'
name 'WiFiSpoof'
homepage 'https://wifispoof.com/'
auto_updates true
app 'WiFiSpoof.app'
end
| bsd-2-clause |
bosr/homebrew-cask | Casks/arduino.rb | 418 | cask 'arduino' do
version '1.8.7'
sha256 'bc5fae3e0b54f000d335d93f2e6da66fc8549def015e3b136d34a10e171c1501'
url "https://downloads.arduino.cc/arduino-#{version}-macosx.zip"
appcast 'https://www.arduino.cc/en/Main/ReleaseNotes'
name 'Arduino'
homepage 'https://www.arduino.cc/'
app 'Arduino.app'
binary "#{appdir}/Arduino.app/Contents/Java/arduino-builder"
caveats do
depends_on_java
end
end
| bsd-2-clause |
glycerine/bigbird | r-3.0.2/doc/html/index-default.html | 2178 | <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>The R Language</title>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
<link rel="stylesheet" type="text/css" href="R.css">
</head>
<body>
<h1>Statistical Data Analysis
<img class="toplogo" src="logo.jpg" alt="[R logo]">
</h1>
<hr width="100%">
<h2>Manuals</h2>
<table cols="2" width="100%">
<tr>
<td align="center" width="50%">
<a href="../manual/R-intro.html">An Introduction to R</a>
</td>
<td align="center" width="50%">
<a href="../manual/R-lang.html">The R Language Definition</a>
</td>
</tr>
<tr>
<td align="center" width="50%">
<a href="../manual/R-exts.html">Writing R Extensions</a>
</td>
<td align="center" width="50%">
<a href="../manual/R-admin.html">R Installation and Administration</a>
</td>
</tr>
<tr>
<td align="center" width="50%">
<a href="../manual/R-data.html">R Data Import/Export</a>
</td>
<td align="center" width="50%">
<a href="../manual/R-ints.html">R Internals</a>
</td>
</tr>
</table>
<h2>Reference</h2>
<table cols="2" width="100%">
<tr>
<td align="center" width="50%"><a href="packages.html">Packages</a></td>
<td align="center" width="50%"><a href="Search.html">Search Engine & Keywords</a></td>
</tr>
</table>
<h2>Miscellaneous Material</h2>
<table cols="3" width="100%">
<tr>
<td align="center" width="33%"><a href="about.html">About R</a> </td>
<td align="center" width="33%"><a href="../AUTHORS">Authors</a> </td>
<td align="center" width="33%"><a href="resources.html">Resources</a></td>
</tr>
<tr>
<td align="center" width="33%"><a href="../COPYING">License</a></td>
<td align="center" width="33%"><a href="../manual/R-FAQ.html">Frequently Asked Questions</a> </td>
<td align="center" width="33%"><a href="../THANKS">Thanks</a> </td>
</tr>
<tr>
<td align="center" width="33%"><a href="NEWS.html">NEWS</a></td>
<td align="center" width="33%"><a href="UserManuals.html">User Manuals</a></td>
<td align="center" width="33%"><a href="http://developer.R-project.org/TechDocs">Technical papers</a></td>
</tr>
</table>
</body>
</html>
| bsd-2-clause |
santoshn/softboundcets-34 | softboundcets-llvm-clang34/tools/clang/test/CXX/temp/temp.decls/temp.fct/temp.func.order/p3.cpp | 574 | // RUN: %clang_cc1 -fsyntax-only -verify %s
// expected-no-diagnostics
namespace DeduceVsMember {
template<typename T>
struct X {
template<typename U>
int &operator==(const U& other) const;
};
template<typename T, typename U>
float &operator==(const T&, const X<U>&);
void test(X<int> xi, X<float> xf) {
float& ir = (xi == xf);
}
}
namespace OrderWithStaticMember {
struct A {
template<class T> int g(T**, int=0) { return 0; }
template<class T> static int g(T*) { return 1; }
};
void f() {
A a;
int **p;
a.g(p);
}
}
| bsd-3-clause |
js0701/chromium-crosswalk | components/user_prefs/tracked/pref_hash_filter.h | 5207 | // Copyright 2013 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.
#ifndef COMPONENTS_USER_PREFS_TRACKED_PREF_HASH_FILTER_H_
#define COMPONENTS_USER_PREFS_TRACKED_PREF_HASH_FILTER_H_
#include <stddef.h>
#include <map>
#include <set>
#include <vector>
#include "base/callback.h"
#include "base/compiler_specific.h"
#include "base/containers/scoped_ptr_hash_map.h"
#include "base/macros.h"
#include "base/memory/scoped_ptr.h"
#include "components/user_prefs/tracked/interceptable_pref_filter.h"
#include "components/user_prefs/tracked/tracked_preference.h"
class PrefHashStore;
class PrefService;
class PrefStore;
class TrackedPreferenceValidationDelegate;
namespace base {
class DictionaryValue;
class Time;
class Value;
} // namespace base
namespace user_prefs {
class PrefRegistrySyncable;
} // namespace user_prefs
// Intercepts preference values as they are loaded from disk and verifies them
// using a PrefHashStore. Keeps the PrefHashStore contents up to date as values
// are changed.
class PrefHashFilter : public InterceptablePrefFilter {
public:
enum EnforcementLevel { NO_ENFORCEMENT, ENFORCE_ON_LOAD };
enum PrefTrackingStrategy {
// Atomic preferences are tracked as a whole.
TRACKING_STRATEGY_ATOMIC,
// Split preferences are dictionaries for which each top-level entry is
// tracked independently. Note: preferences using this strategy must be kept
// in sync with TrackedSplitPreferences in histograms.xml.
TRACKING_STRATEGY_SPLIT,
};
enum ValueType {
VALUE_IMPERSONAL,
// The preference value may contain personal information.
VALUE_PERSONAL,
};
struct TrackedPreferenceMetadata {
size_t reporting_id;
const char* name;
EnforcementLevel enforcement_level;
PrefTrackingStrategy strategy;
ValueType value_type;
};
// Constructs a PrefHashFilter tracking the specified |tracked_preferences|
// using |pref_hash_store| to check/store hashes. An optional |delegate| is
// notified of the status of each preference as it is checked.
// If |on_reset_on_load| is provided, it will be invoked if a reset occurs in
// FilterOnLoad.
// |reporting_ids_count| is the count of all possible IDs (possibly greater
// than |tracked_preferences.size()|). If |report_super_mac_validity| is true,
// the state of the super MAC will be reported via UMA during
// FinalizeFilterOnLoad.
PrefHashFilter(
scoped_ptr<PrefHashStore> pref_hash_store,
const std::vector<TrackedPreferenceMetadata>& tracked_preferences,
const base::Closure& on_reset_on_load,
TrackedPreferenceValidationDelegate* delegate,
size_t reporting_ids_count,
bool report_super_mac_validity);
~PrefHashFilter() override;
// Registers required user preferences.
static void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry);
// Retrieves the time of the last reset event, if any, for the provided user
// preferences. If no reset has occurred, Returns a null |Time|.
static base::Time GetResetTime(PrefService* user_prefs);
// Clears the time of the last reset event, if any, for the provided user
// preferences.
static void ClearResetTime(PrefService* user_prefs);
// Initializes the PrefHashStore with hashes of the tracked preferences in
// |pref_store_contents|. |pref_store_contents| will be the |storage| passed
// to PrefHashStore::BeginTransaction().
void Initialize(base::DictionaryValue* pref_store_contents);
// PrefFilter remaining implementation.
void FilterUpdate(const std::string& path) override;
void FilterSerializeData(base::DictionaryValue* pref_store_contents) override;
private:
// InterceptablePrefFilter implementation.
void FinalizeFilterOnLoad(
const PostFilterOnLoadCallback& post_filter_on_load_callback,
scoped_ptr<base::DictionaryValue> pref_store_contents,
bool prefs_altered) override;
// Callback to be invoked only once (and subsequently reset) on the next
// FilterOnLoad event. It will be allowed to modify the |prefs| handed to
// FilterOnLoad before handing them back to this PrefHashFilter.
FilterOnLoadInterceptor filter_on_load_interceptor_;
// A map of paths to TrackedPreferences; this map owns this individual
// TrackedPreference objects.
typedef base::ScopedPtrHashMap<std::string, scoped_ptr<TrackedPreference>>
TrackedPreferencesMap;
// A map from changed paths to their corresponding TrackedPreferences (which
// aren't owned by this map).
typedef std::map<std::string, const TrackedPreference*> ChangedPathsMap;
scoped_ptr<PrefHashStore> pref_hash_store_;
// Invoked if a reset occurs in a call to FilterOnLoad.
const base::Closure on_reset_on_load_;
TrackedPreferencesMap tracked_paths_;
// The set of all paths whose value has changed since the last call to
// FilterSerializeData.
ChangedPathsMap changed_paths_;
// Whether to report the validity of the super MAC at load time (via UMA).
bool report_super_mac_validity_;
DISALLOW_COPY_AND_ASSIGN(PrefHashFilter);
};
#endif // COMPONENTS_PREFS_TRACKED_PREF_HASH_FILTER_H_
| bsd-3-clause |
scheib/chromium | third_party/pyjson5/src/tests/host_test.py | 1346 | # Copyright 2019 Google Inc. All rights reserved.
#
# 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.
import io
import unittest
from json5.host import Host
class HostTest(unittest.TestCase):
maxDiff = None
def test_directory_and_file_operations(self):
h = Host()
orig_cwd = h.getcwd()
try:
d = h.mkdtemp()
h.chdir(d)
h.write_text_file('foo', 'bar')
contents = h.read_text_file('foo')
self.assertEqual(contents, 'bar')
h.chdir('..')
h.rmtree(d)
finally:
h.chdir(orig_cwd)
def test_print(self):
s = io.StringIO()
h = Host()
h.print_('hello, world', stream=s)
self.assertEqual('hello, world\n', s.getvalue())
if __name__ == '__main__': # pragma: no cover
unittest.main()
| bsd-3-clause |
nwjs/chromium.src | third_party/blink/web_tests/external/wpt/html/canvas/offscreen/fill-and-stroke-styles/2d.gradient.interpolate.solid.worker.js | 758 | // DO NOT EDIT! This test has been generated by /html/canvas/tools/gentest.py.
// OffscreenCanvas test in a worker:2d.gradient.interpolate.solid
// Description:
// Note:
importScripts("/resources/testharness.js");
importScripts("/html/canvas/resources/canvas-tests.js");
var t = async_test("");
var t_pass = t.done.bind(t);
var t_fail = t.step_func(function(reason) {
throw reason;
});
t.step(function() {
var offscreenCanvas = new OffscreenCanvas(100, 50);
var ctx = offscreenCanvas.getContext('2d');
var g = ctx.createLinearGradient(0, 0, 100, 0);
g.addColorStop(0, '#0f0');
g.addColorStop(1, '#0f0');
ctx.fillStyle = g;
ctx.fillRect(0, 0, 100, 50);
_assertPixel(offscreenCanvas, 50,25, 0,255,0,255, "50,25", "0,255,0,255");
t.done();
});
done();
| bsd-3-clause |
miranov25/AliRoot | TEvtGen/EvtGen/EvtGenBase/EvtVector3R.hh | 3395 | //--------------------------------------------------------------------------
//
// Environment:
// This software is part of the EvtGen package developed jointly
// for the BaBar and CLEO collaborations. If you use all or part
// of it, please give an appropriate acknowledgement.
//
// Copyright Information: See EvtGen/COPYRIGHT
// Copyright (C) 1998 Caltech, UCSB
//
// Module: EvtGen/EvtVector3R.hh
//
// Description: Class to describe real 3 vectors
//
// Modification history:
//
// RYD Sept. 5, 1997 Module created
//
//------------------------------------------------------------------------
#ifndef EVTVECTOR3R_HH
#define EVTVECTOR3R_HH
#include <iosfwd>
class EvtVector3R {
friend EvtVector3R rotateEuler(const EvtVector3R& v,
double phi,double theta,double ksi);
inline friend EvtVector3R operator*(double c,const EvtVector3R& v2);
inline friend double operator*(const EvtVector3R& v1,const EvtVector3R& v2);
inline friend EvtVector3R operator+(const EvtVector3R& v1,const EvtVector3R& v2);
inline friend EvtVector3R operator-(const EvtVector3R& v1,const EvtVector3R& v2);
inline friend EvtVector3R operator*(const EvtVector3R& v1,double c);
inline friend EvtVector3R operator/(const EvtVector3R& v1,double c);
friend EvtVector3R cross(const EvtVector3R& v1,const EvtVector3R& v2);
public:
EvtVector3R();
EvtVector3R(double x,double y ,double z);
virtual ~EvtVector3R();
inline EvtVector3R& operator*=(const double c);
inline EvtVector3R& operator/=(const double c);
inline EvtVector3R& operator+=(const EvtVector3R& v2);
inline EvtVector3R& operator-=(const EvtVector3R& v2);
inline void set(int i,double d);
inline void set(double x,double y ,double z);
void applyRotateEuler(double phi,double theta,double ksi);
inline double get(int i) const;
friend std::ostream& operator<<(std::ostream& s,const EvtVector3R& v);
double dot(const EvtVector3R& v2);
double d3mag() const;
private:
double v[3];
};
inline EvtVector3R& EvtVector3R::operator*=(const double c){
v[0]*=c;
v[1]*=c;
v[2]*=c;
return *this;
}
inline EvtVector3R& EvtVector3R::operator/=(const double c){
v[0]/=c;
v[1]/=c;
v[2]/=c;
return *this;
}
inline EvtVector3R& EvtVector3R::operator+=(const EvtVector3R& v2){
v[0]+=v2.v[0];
v[1]+=v2.v[1];
v[2]+=v2.v[2];
return *this;
}
inline EvtVector3R& EvtVector3R::operator-=(const EvtVector3R& v2){
v[0]-=v2.v[0];
v[1]-=v2.v[1];
v[2]-=v2.v[2];
return *this;
}
inline EvtVector3R operator*(double c,const EvtVector3R& v2){
return EvtVector3R(v2)*=c;
}
inline EvtVector3R operator*(const EvtVector3R& v1,double c){
return EvtVector3R(v1)*=c;
}
inline EvtVector3R operator/(const EvtVector3R& v1,double c){
return EvtVector3R(v1)/=c;
}
inline double operator*(const EvtVector3R& v1,const EvtVector3R& v2){
return v1.v[0]*v2.v[0]+v1.v[1]*v2.v[1]+v1.v[2]*v2.v[2];
}
inline EvtVector3R operator+(const EvtVector3R& v1,const EvtVector3R& v2) {
return EvtVector3R(v1)+=v2;
}
inline EvtVector3R operator-(const EvtVector3R& v1,const EvtVector3R& v2) {
return EvtVector3R(v1)-=v2;
}
inline double EvtVector3R::get(int i) const {
return v[i];
}
inline void EvtVector3R::set(int i,double d){
v[i]=d;
}
inline void EvtVector3R::set(double x,double y, double z){
v[0]=x;
v[1]=y;
v[2]=z;
}
#endif
| bsd-3-clause |
kaedroho/django | django/contrib/postgres/constraints.py | 4221 | from django.db.backends.ddl_references import Statement, Table
from django.db.models import F, Q
from django.db.models.constraints import BaseConstraint
from django.db.models.sql import Query
__all__ = ['ExclusionConstraint']
class ExclusionConstraint(BaseConstraint):
template = 'CONSTRAINT %(name)s EXCLUDE USING %(index_type)s (%(expressions)s)%(where)s'
def __init__(self, *, name, expressions, index_type=None, condition=None):
if index_type and index_type.lower() not in {'gist', 'spgist'}:
raise ValueError(
'Exclusion constraints only support GiST or SP-GiST indexes.'
)
if not expressions:
raise ValueError(
'At least one expression is required to define an exclusion '
'constraint.'
)
if not all(
isinstance(expr, (list, tuple)) and len(expr) == 2
for expr in expressions
):
raise ValueError('The expressions must be a list of 2-tuples.')
if not isinstance(condition, (type(None), Q)):
raise ValueError(
'ExclusionConstraint.condition must be a Q instance.'
)
self.expressions = expressions
self.index_type = index_type or 'GIST'
self.condition = condition
super().__init__(name=name)
def _get_expression_sql(self, compiler, connection, query):
expressions = []
for expression, operator in self.expressions:
if isinstance(expression, str):
expression = F(expression)
expression = expression.resolve_expression(query=query)
sql, params = expression.as_sql(compiler, connection)
expressions.append('%s WITH %s' % (sql % params, operator))
return expressions
def _get_condition_sql(self, compiler, schema_editor, query):
if self.condition is None:
return None
where = query.build_where(self.condition)
sql, params = where.as_sql(compiler, schema_editor.connection)
return sql % tuple(schema_editor.quote_value(p) for p in params)
def constraint_sql(self, model, schema_editor):
query = Query(model, alias_cols=False)
compiler = query.get_compiler(connection=schema_editor.connection)
expressions = self._get_expression_sql(compiler, schema_editor.connection, query)
condition = self._get_condition_sql(compiler, schema_editor, query)
return self.template % {
'name': schema_editor.quote_name(self.name),
'index_type': self.index_type,
'expressions': ', '.join(expressions),
'where': ' WHERE (%s)' % condition if condition else '',
}
def create_sql(self, model, schema_editor):
return Statement(
'ALTER TABLE %(table)s ADD %(constraint)s',
table=Table(model._meta.db_table, schema_editor.quote_name),
constraint=self.constraint_sql(model, schema_editor),
)
def remove_sql(self, model, schema_editor):
return schema_editor._delete_constraint_sql(
schema_editor.sql_delete_check,
model,
schema_editor.quote_name(self.name),
)
def deconstruct(self):
path, args, kwargs = super().deconstruct()
kwargs['expressions'] = self.expressions
if self.condition is not None:
kwargs['condition'] = self.condition
if self.index_type.lower() != 'gist':
kwargs['index_type'] = self.index_type
return path, args, kwargs
def __eq__(self, other):
if isinstance(other, self.__class__):
return (
self.name == other.name and
self.index_type == other.index_type and
self.expressions == other.expressions and
self.condition == other.condition
)
return super().__eq__(other)
def __repr__(self):
return '<%s: index_type=%s, expressions=%s%s>' % (
self.__class__.__qualname__,
self.index_type,
self.expressions,
'' if self.condition is None else ', condition=%s' % self.condition,
)
| bsd-3-clause |
jaruba/chromium.src | remoting/codec/audio_encoder_opus.h | 1604 | // Copyright (c) 2012 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.
#ifndef REMOTING_CODEC_AUDIO_ENCODER_OPUS_H_
#define REMOTING_CODEC_AUDIO_ENCODER_OPUS_H_
#include "remoting/codec/audio_encoder.h"
#include "remoting/proto/audio.pb.h"
struct OpusEncoder;
namespace media {
class AudioBus;
class MultiChannelResampler;
} // namespace media
namespace remoting {
class AudioPacket;
class AudioEncoderOpus : public AudioEncoder {
public:
AudioEncoderOpus();
~AudioEncoderOpus() override;
// AudioEncoder interface.
scoped_ptr<AudioPacket> Encode(scoped_ptr<AudioPacket> packet) override;
private:
void InitEncoder();
void DestroyEncoder();
bool ResetForPacket(AudioPacket* packet);
void FetchBytesToResample(int resampler_frame_delay,
media::AudioBus* audio_bus);
int sampling_rate_;
AudioPacket::Channels channels_;
OpusEncoder* encoder_;
int frame_size_;
scoped_ptr<media::MultiChannelResampler> resampler_;
scoped_ptr<char[]> resample_buffer_;
scoped_ptr<media::AudioBus> resampler_bus_;
// Used to pass packet to the FetchBytesToResampler() callback.
const char* resampling_data_;
int resampling_data_size_;
int resampling_data_pos_;
// Left-over unencoded samples from the previous AudioPacket.
scoped_ptr<int16[]> leftover_buffer_;
int leftover_buffer_size_;
int leftover_samples_;
DISALLOW_COPY_AND_ASSIGN(AudioEncoderOpus);
};
} // namespace remoting
#endif // REMOTING_CODEC_AUDIO_ENCODER_OPUS_H_
| bsd-3-clause |
kzhong1991/Flight-AR.Drone-2 | src/3rdparty/Qt4.8.4/include/QtDeclarative/private/qdeclarativetypenotavailable_p.h | 73 | #include "../../../src/declarative/qml/qdeclarativetypenotavailable_p.h"
| bsd-3-clause |
aYukiSekiguchi/ACCESS-Chromium | chrome/renderer/safe_browsing/malware_dom_details.h | 2096 | // Copyright (c) 2011 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.
//
// MalwareDOMDetails iterates over a document's frames and gathers
// interesting URLs such as those of scripts and frames. When done, it sends
// them to the MalwareDetails that requested them.
#ifndef CHROME_RENDERER_SAFE_BROWSING_MALWARE_DOM_DETAILS_H_
#define CHROME_RENDERER_SAFE_BROWSING_MALWARE_DOM_DETAILS_H_
#include <string>
#include <vector>
#include "base/basictypes.h"
#include "base/memory/scoped_ptr.h"
#include "content/public/renderer/render_view_observer.h"
namespace WebKit {
class WebElement;
}
struct SafeBrowsingHostMsg_MalwareDOMDetails_Node;
namespace safe_browsing {
// There is one MalwareDOMDetails per RenderView.
class MalwareDOMDetails : public content::RenderViewObserver {
public:
// An upper limit on the number of nodes we collect. Not const for the test.
static uint32 kMaxNodes;
static MalwareDOMDetails* Create(content::RenderView* render_view);
virtual ~MalwareDOMDetails();
// Begins extracting resource urls for the page currently loaded in
// this object's RenderView.
void ExtractResources(
std::vector<SafeBrowsingHostMsg_MalwareDOMDetails_Node>* resources);
private:
// Creates a MalwareDOMDetails for the specified RenderView.
// The MalwareDOMDetails should be destroyed prior to destroying
// the RenderView.
explicit MalwareDOMDetails(content::RenderView* render_view);
// RenderViewObserver implementation.
virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
void OnGetMalwareDOMDetails();
// Handler for the various HTML elements that we extract URLs from.
void HandleElement(
const WebKit::WebElement& element,
SafeBrowsingHostMsg_MalwareDOMDetails_Node* parent_node,
std::vector<SafeBrowsingHostMsg_MalwareDOMDetails_Node>* resources);
DISALLOW_COPY_AND_ASSIGN(MalwareDOMDetails);
};
} // namespace safe_browsing
#endif // CHROME_RENDERER_SAFE_BROWSING_MALWARE_DOM_DETAILS_H_
| bsd-3-clause |
hamidgoharjoo/test | vendor/facebook/webdriver/lib/WebDriverWindow.php | 3841 | <?php
// Copyright 2004-present Facebook. All Rights Reserved.
//
// 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.
/**
* An abstraction allowing the driver to manipulate the browser's window
*/
class WebDriverWindow {
protected $executor;
public function __construct($executor) {
$this->executor = $executor;
}
/**
* Get the position of the current window, relative to the upper left corner
* of the screen.
*
* @return array The current window position.
*/
public function getPosition() {
$position = $this->executor->execute(
DriverCommand::GET_WINDOW_POSITION,
array(':windowHandle' => 'current')
);
return new WebDriverPoint(
$position['x'],
$position['y']
);
}
/**
* Get the size of the current window. This will return the outer window
* dimension, not just the view port.
*
* @return array The current window size.
*/
public function getSize() {
$size = $this->executor->execute(
DriverCommand::GET_WINDOW_SIZE,
array(':windowHandle' => 'current')
);
return new WebDriverDimension(
$size['width'],
$size['height']
);
}
/**
* Maximizes the current window if it is not already maximized
*
* @return WebDriverWindow The instance.
*/
public function maximize() {
$this->executor->execute(
DriverCommand::MAXIMIZE_WINDOW,
array(':windowHandle' => 'current')
);
return $this;
}
/**
* Set the size of the current window. This will change the outer window
* dimension, not just the view port.
*
* @param WebDriverDimension $size
* @return WebDriverWindow The instance.
*/
public function setSize(WebDriverDimension $size) {
$params = array(
'width' => $size->getWidth(),
'height' => $size->getHeight(),
':windowHandle' => 'current',
);
$this->executor->execute(DriverCommand::SET_WINDOW_SIZE, $params);
return $this;
}
/**
* Set the position of the current window. This is relative to the upper left
* corner of the screen.
*
* @param WebDriverPoint $position
* @return WebDriverWindow The instance.
*/
public function setPosition(WebDriverPoint $position) {
$params = array(
'x' => $position->getX(),
'y' => $position->getY(),
':windowHandle' => 'current',
);
$this->executor->execute(DriverCommand::SET_WINDOW_POSITION, $params);
return $this;
}
/**
* Get the current browser orientation.
*
* @return string Either LANDSCAPE|PORTRAIT
*/
public function getScreenOrientation() {
return $this->executor->execute(DriverCommand::GET_SCREEN_ORIENTATION);
}
/**
* Set the browser orientation. The orientation should either
* LANDSCAPE|PORTRAIT
*
* @param string $orientation
* @return WebDriverWindow The instance.
* @throws IndexOutOfBoundsException
*/
public function setScreenOrientation($orientation) {
$orientation = strtoupper($orientation);
if (!in_array($orientation, array('PORTRAIT', 'LANDSCAPE'))) {
throw new IndexOutOfBoundsException(
"Orientation must be either PORTRAIT, or LANDSCAPE"
);
}
$this->executor->execute(
DriverCommand::SET_SCREEN_ORIENTATION,
array('orientation' => $orientation)
);
return $this;
}
}
| bsd-3-clause |
nwjs/chromium.src | third_party/blink/web_tests/fast/block/float/relayout-nested-float-after-line.html | 719 | <!DOCTYPE html>
<p>The word "BONZER" should be adjacent to the hotpink square.</p>
<div style="position:relative; overflow:hidden;">
<div style="float:left; width:100%; height:1px;"></div>
<div style="float:left; width:100%;">
<div id="innerFloat" style="float:left; width:666px; height:20px; background:hotpink;"></div>
<span id="targetSpan">BONZER<br></span>
</div>
</div>
<script src="../../../resources/testharness.js"></script>
<script src="../../../resources/testharnessreport.js"></script>
<script>
test(() => {
document.body.offsetTop;
innerFloat.style.width = "20px";
assert_equals(targetSpan.offsetLeft, 20);
}, "Resize inner float next to line");
</script>
| bsd-3-clause |
scheib/chromium | components/web_modal/modal_dialog_host.cc | 437 | // Copyright 2013 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 "components/web_modal/modal_dialog_host.h"
namespace web_modal {
ModalDialogHostObserver::~ModalDialogHostObserver() {
}
ModalDialogHost::~ModalDialogHost() {
}
bool ModalDialogHost::ShouldActivateDialog() const {
return true;
}
} // namespace web_modal
| bsd-3-clause |
sheldonh/whois | spec/whois/record/parser/responses/whois.ax/status_available_spec.rb | 1395 | # encoding: utf-8
# This file is autogenerated. Do not edit it manually.
# If you want change the content of this file, edit
#
# /spec/fixtures/responses/whois.ax/status_available.expected
#
# and regenerate the tests with the following rake task
#
# $ rake spec:generate
#
require 'spec_helper'
require 'whois/record/parser/whois.ax.rb'
describe Whois::Record::Parser::WhoisAx, "status_available.expected" do
subject do
file = fixture("responses", "whois.ax/status_available.txt")
part = Whois::Record::Part.new(body: File.read(file))
described_class.new(part)
end
describe "#status" do
it do
expect(subject.status).to eq(:available)
end
end
describe "#available?" do
it do
expect(subject.available?).to eq(true)
end
end
describe "#registered?" do
it do
expect(subject.registered?).to eq(false)
end
end
describe "#created_on" do
it do
expect(subject.created_on).to eq(nil)
end
end
describe "#updated_on" do
it do
expect { subject.updated_on }.to raise_error(Whois::AttributeNotSupported)
end
end
describe "#expires_on" do
it do
expect { subject.expires_on }.to raise_error(Whois::AttributeNotSupported)
end
end
describe "#nameservers" do
it do
expect(subject.nameservers).to be_a(Array)
expect(subject.nameservers).to eq([])
end
end
end
| mit |
yesudeep/puppy | tools/google-closure-library/closure/goog/ui/customcolorpalette.js | 4792 | // 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.
// Copyright 2007 Google Inc. All Rights Reserved.
/**
* @fileoverview A color palette with a button for adding additional colors
* manually.
*
*/
goog.provide('goog.ui.CustomColorPalette');
goog.require('goog.color');
goog.require('goog.dom');
goog.require('goog.ui.ColorPalette');
/**
* A custom color palette is a grid of color swatches and a button that allows
* the user to add additional colors to the palette
*
* @param {Array.<string>} initColors Array of initial colors to populate the
* palette with.
* @param {goog.ui.PaletteRenderer} opt_renderer Renderer used to render or
* decorate the palette; defaults to {@link goog.ui.PaletteRenderer}.
* @param {goog.dom.DomHelper} opt_domHelper Optional DOM helper, used for
* document interaction.
* @constructor
* @extends {goog.ui.ColorPalette}
*/
goog.ui.CustomColorPalette = function(initColors, opt_renderer, opt_domHelper) {
goog.ui.ColorPalette.call(this, initColors, opt_renderer, opt_domHelper);
this.setSupportedState(goog.ui.Component.State.OPENED, true);
};
goog.inherits(goog.ui.CustomColorPalette, goog.ui.ColorPalette);
/**
* Returns an array of DOM nodes for each color, and an additional cell with a
* '+'.
* @return {Array.<Node>} Array of div elements.
* @private
*/
goog.ui.CustomColorPalette.prototype.createColorNodes_ = function() {
/** @desc Hover caption for the button that allows the user to add a color. */
var MSG_CLOSURE_CUSTOM_COLOR_BUTTON = goog.getMsg('Add a color');
var nl = goog.ui.CustomColorPalette.superClass_.createColorNodes_.call(this);
nl.push(goog.dom.createDom('div', {
'class': goog.getCssName('goog-palette-customcolor'),
'title': MSG_CLOSURE_CUSTOM_COLOR_BUTTON
}, '+'));
return nl;
};
/**
* @inheritDoc
* @param {goog.events.Event} e Mouse or key event that triggered the action.
* @return {boolean} True if the action was allowed to proceed, false otherwise.
*/
goog.ui.CustomColorPalette.prototype.performActionInternal = function(e) {
var item = /** @type {Element} */ (this.getHighlightedItem());
if (item) {
if (goog.dom.classes.has(
item, goog.getCssName('goog-palette-customcolor'))) {
// User activated the special "add custom color" swatch.
this.promptForCustomColor();
} else {
// User activated a normal color swatch.
this.setSelectedItem(item);
return this.dispatchEvent(goog.ui.Component.EventType.ACTION);
}
}
return false;
};
/**
* Prompts the user to enter a custom color. Currently uses a window.prompt
* but could be updated to use a dialog box with a WheelColorPalette.
*/
goog.ui.CustomColorPalette.prototype.promptForCustomColor = function() {
/** @desc Default custom color dialog. */
var MSG_CLOSURE_CUSTOM_COLOR_PROMPT = goog.getMsg(
'Input custom color, i.e. pink, #F00, #D015FF or rgb(100, 50, 25)');
// A CustomColorPalette is considered "open" while the color selection prompt
// is open. Enabling state transition events for the OPENED state and
// listening for OPEN events allows clients to save the selection before
// it is destroyed (see e.g. bug 1064701).
var response = null;
this.setOpen(true);
if (this.isOpen()) {
// The OPEN event wasn't canceled; prompt for custom color.
response = window.prompt(MSG_CLOSURE_CUSTOM_COLOR_PROMPT, '#FFFFFF');
this.setOpen(false);
}
if (!response) {
// The user hit cancel
return;
}
var color;
/** @preserveTry */
try {
color = goog.color.parse(response).hex;
} catch (er) {
/** @desc Alert message sent when the input string is not a valid color. */
var MSG_CLOSURE_CUSTOM_COLOR_INVALID_INPUT = goog.getMsg(
'ERROR: "{$color}" is not a valid color.', {'color': response});
alert(MSG_CLOSURE_CUSTOM_COLOR_INVALID_INPUT);
return;
}
// TODO: This is relatively inefficient. Consider adding
// functionality to palette to add individual items after render time.
var colors = this.getColors();
colors.push(color)
this.setColors(colors);
// Set the selected color to the new color and notify listeners of the action.
this.setSelectedColor(color);
this.dispatchEvent(goog.ui.Component.EventType.ACTION);
};
| mit |
Growmies/handsontable | src/editors.js | 2723 | /**
* Utility to register editors and common namespace for keeping reference to all editor classes
*/
import Handsontable from './browser';
import {toUpperCaseFirst} from './helpers/string';
export {registerEditor, getEditor, hasEditor, getEditorConstructor};
var
registeredEditorNames = {},
registeredEditorClasses = new WeakMap();
// support for older versions of Handsontable
Handsontable.editors = Handsontable.editors || {};
Handsontable.editors.registerEditor = registerEditor;
Handsontable.editors.getEditor = getEditor;
function RegisteredEditor(editorClass) {
var Clazz, instances;
instances = {};
Clazz = editorClass;
this.getConstructor = function() {
return editorClass;
};
this.getInstance = function(hotInstance) {
if (!(hotInstance.guid in instances)) {
instances[hotInstance.guid] = new Clazz(hotInstance);
}
return instances[hotInstance.guid];
};
}
/**
* Registers editor under given name
* @param {String} editorName
* @param {Function} editorClass
*/
function registerEditor(editorName, editorClass) {
var editor = new RegisteredEditor(editorClass);
if (typeof editorName === 'string') {
registeredEditorNames[editorName] = editor;
Handsontable.editors[toUpperCaseFirst(editorName) + 'Editor'] = editorClass;
}
registeredEditorClasses.set(editorClass, editor);
}
/**
* Returns instance (singleton) of editor class
*
* @param {String} editorName
* @param {Object} hotInstance
* @returns {Function} editorClass
*/
function getEditor(editorName, hotInstance) {
var editor;
if (typeof editorName == 'function') {
if (!(registeredEditorClasses.get(editorName))) {
registerEditor(null, editorName);
}
editor = registeredEditorClasses.get(editorName);
} else if (typeof editorName == 'string') {
editor = registeredEditorNames[editorName];
} else {
throw Error('Only strings and functions can be passed as "editor" parameter ');
}
if (!editor) {
throw Error('No editor registered under name "' + editorName + '"');
}
return editor.getInstance(hotInstance);
}
/**
* Get editor constructor class
*
* @param {String} editorName
* @returns {Function}
*/
function getEditorConstructor(editorName) {
var editor;
if (typeof editorName == 'string') {
editor = registeredEditorNames[editorName];
} else {
throw Error('Only strings and functions can be passed as "editor" parameter ');
}
if (!editor) {
throw Error('No editor registered under name "' + editorName + '"');
}
return editor.getConstructor();
}
/**
* @param editorName
* @returns {Boolean}
*/
function hasEditor(editorName) {
return registeredEditorNames[editorName] ? true : false;
}
| mit |
glamb/TCMS-Frontend | node_modules/typedoc/lib/converter/factories/reference.js | 505 | "use strict";
var index_1 = require("../../models/types/index");
function createReferenceType(context, symbol, includeParent) {
var checker = context.checker;
var id = context.getSymbolID(symbol);
var name = checker.symbolToString(symbol);
if (includeParent && symbol.parent) {
name = checker.symbolToString(symbol.parent) + '.' + name;
}
return new index_1.ReferenceType(name, id);
}
exports.createReferenceType = createReferenceType;
//# sourceMappingURL=reference.js.map | mit |
rainlike/justshop | vendor/sylius/sylius/src/Sylius/Behat/Service/SecurityService.php | 2802 | <?php
/*
* This file is part of the Sylius package.
*
* (c) Paweł Jędrzejewski
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
declare(strict_types=1);
namespace Sylius\Behat\Service;
use Sylius\Behat\Service\Setter\CookieSetterInterface;
use Sylius\Component\User\Model\UserInterface;
use Symfony\Component\HttpFoundation\Session\SessionInterface;
use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
use Symfony\Component\Security\Core\Authentication\Token\UsernamePasswordToken;
use Symfony\Component\Security\Core\Exception\TokenNotFoundException;
/**
* @author Arkadiusz Krakowiak <[email protected]>
* @author Kamil Kokot <[email protected]>
*/
final class SecurityService implements SecurityServiceInterface
{
/**
* @var SessionInterface
*/
private $session;
/**
* @var CookieSetterInterface
*/
private $cookieSetter;
/**
* @var string
*/
private $sessionTokenVariable;
/**
* @param SessionInterface $session
* @param CookieSetterInterface $cookieSetter
* @param string $firewallContextName
*/
public function __construct(SessionInterface $session, CookieSetterInterface $cookieSetter, $firewallContextName)
{
$this->session = $session;
$this->cookieSetter = $cookieSetter;
$this->sessionTokenVariable = sprintf('_security_%s', $firewallContextName);
}
/**
* {@inheritdoc}
*/
public function logIn(UserInterface $user)
{
$token = new UsernamePasswordToken($user, $user->getPassword(), 'randomstringbutnotnull', $user->getRoles());
$this->setToken($token);
}
public function logOut()
{
$this->session->set($this->sessionTokenVariable, null);
$this->session->save();
$this->cookieSetter->setCookie($this->session->getName(), $this->session->getId());
}
/**
* {@inheritdoc}
*/
public function getCurrentToken()
{
$serializedToken = $this->session->get($this->sessionTokenVariable);
if (null === $serializedToken) {
throw new TokenNotFoundException();
}
return unserialize($serializedToken);
}
/**
* {@inheritdoc}
*/
public function restoreToken(TokenInterface $token)
{
$this->setToken($token);
}
/**
* @param TokenInterface $token
*/
private function setToken(TokenInterface $token)
{
$serializedToken = serialize($token);
$this->session->set($this->sessionTokenVariable, $serializedToken);
$this->session->save();
$this->cookieSetter->setCookie($this->session->getName(), $this->session->getId());
}
}
| mit |
sly7-7/ember.js | .github/ISSUE_TEMPLATE/1-bug-report.md | 975 | ---
name: 🐞 Bug report
about: Report a bug in the Ember Framework. Before you create a new issue, please
search for similar issues. It's possible somebody has encountered this bug already.
title: "[Bug] Bug report"
labels: ''
assignees: ''
---
### 🐞 Describe the Bug
A clear and concise description of what the bug is.
### 🔬 Minimal Reproduction
Describe steps to reproduce. If possible, please, share a link with a minimal reproduction.
<!--
Create a minimal reproduction using one of the following:
- Ember Twiddle: http://ember-twiddle.com/
- Create a GitHub repository: https://guides.emberjs.com/release/getting-started/quick-start/
-->
### 😕 Actual Behavior
A clear and concise description of what is happening.
### 🤔 Expected Behavior
A clear and concise description of what you expected to happen.
### 🌍 Environment
- Ember: -
- Node.js/npm: -
- OS: -
- Browser: -
### ➕ Additional Context
Add any other context about the problem here.
| mit |
fabianwilliams/aalpix | XamarinPagesDemo/Droid/obj/Debug/android/src/md5530bd51e982e6e7b340b73e88efe666e/FormsApplicationActivity.java | 3159 | package md5530bd51e982e6e7b340b73e88efe666e;
public class FormsApplicationActivity
extends android.app.Activity
implements
mono.android.IGCUserPeer
{
static final String __md_methods;
static {
__md_methods =
"n_onCreate:(Landroid/os/Bundle;)V:GetOnCreate_Landroid_os_Bundle_Handler\n" +
"n_onStart:()V:GetOnStartHandler\n" +
"n_onResume:()V:GetOnResumeHandler\n" +
"n_onPause:()V:GetOnPauseHandler\n" +
"n_onStop:()V:GetOnStopHandler\n" +
"n_onRestart:()V:GetOnRestartHandler\n" +
"n_onDestroy:()V:GetOnDestroyHandler\n" +
"n_onBackPressed:()V:GetOnBackPressedHandler\n" +
"n_onOptionsItemSelected:(Landroid/view/MenuItem;)Z:GetOnOptionsItemSelected_Landroid_view_MenuItem_Handler\n" +
"n_onPrepareOptionsMenu:(Landroid/view/Menu;)Z:GetOnPrepareOptionsMenu_Landroid_view_Menu_Handler\n" +
"n_onConfigurationChanged:(Landroid/content/res/Configuration;)V:GetOnConfigurationChanged_Landroid_content_res_Configuration_Handler\n" +
"";
mono.android.Runtime.register ("Xamarin.Forms.Platform.Android.FormsApplicationActivity, Xamarin.Forms.Platform.Android, Version=1.4.0.0, Culture=neutral, PublicKeyToken=null", FormsApplicationActivity.class, __md_methods);
}
public FormsApplicationActivity () throws java.lang.Throwable
{
super ();
if (getClass () == FormsApplicationActivity.class)
mono.android.TypeManager.Activate ("Xamarin.Forms.Platform.Android.FormsApplicationActivity, Xamarin.Forms.Platform.Android, Version=1.4.0.0, Culture=neutral, PublicKeyToken=null", "", this, new java.lang.Object[] { });
}
public void onCreate (android.os.Bundle p0)
{
n_onCreate (p0);
}
private native void n_onCreate (android.os.Bundle p0);
public void onStart ()
{
n_onStart ();
}
private native void n_onStart ();
public void onResume ()
{
n_onResume ();
}
private native void n_onResume ();
public void onPause ()
{
n_onPause ();
}
private native void n_onPause ();
public void onStop ()
{
n_onStop ();
}
private native void n_onStop ();
public void onRestart ()
{
n_onRestart ();
}
private native void n_onRestart ();
public void onDestroy ()
{
n_onDestroy ();
}
private native void n_onDestroy ();
public void onBackPressed ()
{
n_onBackPressed ();
}
private native void n_onBackPressed ();
public boolean onOptionsItemSelected (android.view.MenuItem p0)
{
return n_onOptionsItemSelected (p0);
}
private native boolean n_onOptionsItemSelected (android.view.MenuItem p0);
public boolean onPrepareOptionsMenu (android.view.Menu p0)
{
return n_onPrepareOptionsMenu (p0);
}
private native boolean n_onPrepareOptionsMenu (android.view.Menu p0);
public void onConfigurationChanged (android.content.res.Configuration p0)
{
n_onConfigurationChanged (p0);
}
private native void n_onConfigurationChanged (android.content.res.Configuration p0);
java.util.ArrayList refList;
public void monodroidAddReference (java.lang.Object obj)
{
if (refList == null)
refList = new java.util.ArrayList ();
refList.add (obj);
}
public void monodroidClearReferences ()
{
if (refList != null)
refList.clear ();
}
}
| mit |
carldai0106/aspnetboilerplate | src/Abp.MailKit/AbpMailKitModule.cs | 670 | using Abp.Dependency;
using Abp.Configuration.Startup;
using Abp.Modules;
using Abp.Net.Mail;
using Abp.Reflection.Extensions;
namespace Abp.MailKit
{
[DependsOn(typeof(AbpKernelModule))]
public class AbpMailKitModule : AbpModule
{
public override void PreInitialize()
{
IocManager.Register<IAbpMailKitConfiguration, AbpMailKitConfiguration>();
Configuration.ReplaceService<IEmailSender, MailKitEmailSender>(DependencyLifeStyle.Transient);
}
public override void Initialize()
{
IocManager.RegisterAssemblyByConvention(typeof(AbpMailKitModule).GetAssembly());
}
}
}
| mit |
jmesmon/winapi-rs | lib/msvfw32-sys/README.md | 103 | # msvfw32-sys #
FFI bindings to msvfw32.
[Documentation](https://retep998.github.io/doc/msvfw32-sys/)
| mit |
guileschool/beagleboard | u-boot/include/ubispl.h | 2737 | /*
* Copyright (c) Thomas Gleixner <[email protected]>
*
* SPDX-License-Identifier: GPL 2.0+ BSD-3-Clause
*/
#ifndef __UBOOT_UBISPL_H
#define __UBOOT_UBISPL_H
/*
* The following CONFIG options are relevant for UBISPL
*
* #define CONFIG_SPL_UBI_MAX_VOL_LEBS 256
*
* Defines the maximum number of logical erase blocks per loadable
* (static) volume to size the ubispl internal arrays.
*
* #define CONFIG_SPL_UBI_MAX_PEB_SIZE (256*1024)
*
* Defines the maximum physical erase block size to size the fastmap
* buffer for ubispl.
*
* #define CONFIG_SPL_UBI_MAX_PEBS 4096
*
* Define the maximum number of physical erase blocks to size the
* ubispl internal arrays.
*
* #define CONFIG_SPL_UBI_VOL_IDS 8
*
* Defines the maximum number of volumes in which UBISPL is
* interested. Limits the amount of memory for the scan data and
* speeds up the scan process as we simply ignore stuff which we dont
* want to load from the SPL anyway. So the volumes which can be
* loaded in the above example are ids 0 - 7
*/
/*
* The struct definition is in drivers/mtd/ubispl/ubispl.h. It does
* not fit into the BSS due to the large buffer requirement of the
* upstream fastmap code. So the caller of ubispl_load_volumes needs
* to hand in a pointer to a free memory area where ubispl will place
* its data. The area is not required to be initialized.
*/
struct ubi_scan_info;
typedef int (*ubispl_read_flash)(int pnum, int offset, int len, void *dst);
/**
* struct ubispl_info - description structure for fast ubi scan
* @ubi: Pointer to memory space for ubi scan info structure
* @peb_size: Physical erase block size
* @vid_offset: Offset of the VID header
* @leb_start: Start of the logical erase block, i.e. offset of data
* @peb_count: Number of physical erase blocks in the UBI FLASH area
* aka MTD partition.
* @peb_offset: Offset of PEB0 in the UBI FLASH area (aka MTD partition)
* to the real start of the FLASH in erase blocks.
* @fastmap: Enable fastmap attachment
* @read: Read function to access the flash
*/
struct ubispl_info {
struct ubi_scan_info *ubi;
u32 peb_size;
u32 vid_offset;
u32 leb_start;
u32 peb_count;
u32 peb_offset;
int fastmap;
ubispl_read_flash read;
};
/**
* struct ubispl_load - structure to describe a volume to load
* @vol_id: Volume id
* @load_addr: Load address of the volume
*/
struct ubispl_load {
int vol_id;
void *load_addr;
};
/**
* ubispl_load_volumes - Scan flash and load volumes
* @info: Pointer to the ubi scan info structure
* @lovls: Pointer to array of volumes to load
* @nrvols: Array size of @lovls
*/
int ubispl_load_volumes(struct ubispl_info *info,
struct ubispl_load *lvols, int nrvols);
#endif
| mit |
MarkAufdencamp/junit | src/main/java/org/junit/internal/runners/statements/RunAfters.java | 948 | /**
*
*/
package org.junit.internal.runners.statements;
import java.util.ArrayList;
import java.util.List;
import org.junit.runners.model.FrameworkMethod;
import org.junit.runners.model.MultipleFailureException;
import org.junit.runners.model.Statement;
public class RunAfters extends Statement {
private final Statement fNext;
private final Object fTarget;
private final List<FrameworkMethod> fAfters;
public RunAfters(Statement next, List<FrameworkMethod> afters, Object target) {
fNext= next;
fAfters= afters;
fTarget= target;
}
@Override
public void evaluate() throws Throwable {
List<Throwable> errors = new ArrayList<Throwable>();
try {
fNext.evaluate();
} catch (Throwable e) {
errors.add(e);
} finally {
for (FrameworkMethod each : fAfters)
try {
each.invokeExplosively(fTarget);
} catch (Throwable e) {
errors.add(e);
}
}
MultipleFailureException.assertEmpty(errors);
}
} | epl-1.0 |
brasadesign/wpecotemporadas | wp-content/plugins/screets-chat/assets/css/style.css | 328 | /**
* Screets Chat
* Default Stylesheet
*
*/
/**
* Helpers
*/
.img-circle {
-webkit-border-radius: 500px;
-moz-border-radius: 500px;
border-radius: 500px;
}
.clearfix { *zoom: 1; }
.clearfix:before, .clearfix:after { display: table; line-height: 0; content: ""; }
.clearfix:after { clear: both; }
| gpl-2.0 |
dorimanx/Dorimanx-LG-G2-D802-Kernel | drivers/leds/leds-lp5521.c | 54379 | /*
* LP5521 LED chip driver.
*
* Copyright (C) 2010 Nokia Corporation
*
* Contact: Samu Onkalo <[email protected]>
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* version 2 as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA
*/
#include <linux/module.h>
#include <linux/init.h>
#include <linux/i2c.h>
#include <linux/mutex.h>
#include <linux/gpio.h>
#include <linux/interrupt.h>
#include <linux/delay.h>
#include <linux/ctype.h>
#include <linux/spinlock.h>
#include <linux/wait.h>
#include <linux/leds.h>
#include <linux/leds-lp5521.h>
#include <linux/workqueue.h>
#include <linux/slab.h>
#if defined(CONFIG_MACH_MSM8974_VU3_KR) || defined(CONFIG_MACH_MSM8974_Z_KR) || defined(CONFIG_MACH_MSM8974_Z_KDDI )|| defined(CONFIG_MACH_MSM8974_Z_TMO_US)|| defined(CONFIG_MACH_MSM8974_Z_SPR)|| defined(CONFIG_MACH_MSM8974_Z_ATT_US) || defined(CONFIG_MACH_MSM8974_B1_KR)
#include <mach/board_lge.h>
#include <linux/regulator/consumer.h>
#include <linux/of_gpio.h>
#endif
#define LP5521_PROGRAM_LENGTH 32 /* in bytes */
#define LP5521_ENG_MASK_BASE 0x30 /* 00110000 */
#define LP5521_ENG_STATUS_MASK 0x07 /* 00000111 */
#define LP5521_CMD_LOAD 0x15 /* 00010101 */
#define LP5521_CMD_RUN 0x2a /* 00101010 */
#define LP5521_CMD_DIRECT 0x3f /* 00111111 */
#define LP5521_CMD_DISABLED 0x00 /* 00000000 */
/* Registers */
#define LP5521_REG_ENABLE 0x00
#define LP5521_REG_OP_MODE 0x01
#define LP5521_REG_R_PWM 0x02
#define LP5521_REG_R_CURRENT 0x05
#define LP5521_REG_CONFIG 0x08
#define LP5521_REG_R_CHANNEL_PC 0x09
#define LP5521_REG_STATUS 0x0C
#define LP5521_REG_RESET 0x0D
#define LP5521_REG_GPO 0x0E
#define LP5521_REG_R_PROG_MEM 0x10
#if defined(CONFIG_MACH_MSM8974_VU3_KR)
#define LP5521_REG_G_PWM 0x04
#define LP5521_REG_B_PWM 0x03
#define LP5521_REG_G_CURRENT 0x07
#define LP5521_REG_B_CURRENT 0x06
#define LP5521_REG_G_CHANNEL_PC 0x0B
#define LP5521_REG_B_CHANNEL_PC 0x0A
#define LP5521_REG_G_PROG_MEM 0x50
#define LP5521_REG_B_PROG_MEM 0x30
#else
#define LP5521_REG_G_PWM 0x03
#define LP5521_REG_B_PWM 0x04
#define LP5521_REG_G_CURRENT 0x06
#define LP5521_REG_B_CURRENT 0x07
#define LP5521_REG_G_CHANNEL_PC 0x0A
#define LP5521_REG_B_CHANNEL_PC 0x0B
#define LP5521_REG_G_PROG_MEM 0x30
#define LP5521_REG_B_PROG_MEM 0x50
#endif
#define LP5521_PROG_MEM_BASE LP5521_REG_R_PROG_MEM
#define LP5521_PROG_MEM_SIZE 0x20
/* Base register to set LED current */
#define LP5521_REG_LED_CURRENT_BASE LP5521_REG_R_CURRENT
/* Base register to set the brightness */
#define LP5521_REG_LED_PWM_BASE LP5521_REG_R_PWM
/* Bits in ENABLE register */
#define LP5521_MASTER_ENABLE 0x40 /* Chip master enable */
#define LP5521_LOGARITHMIC_PWM 0x80 /* Logarithmic PWM adjustment */
#define LP5521_EXEC_RUN 0x2A
#define LP5521_ENABLE_DEFAULT \
(LP5521_MASTER_ENABLE | LP5521_LOGARITHMIC_PWM)
#define LP5521_ENABLE_RUN_PROGRAM \
(LP5521_ENABLE_DEFAULT | LP5521_EXEC_RUN)
/* Status */
#define LP5521_EXT_CLK_USED 0x08
/* default R channel current register value */
#define LP5521_REG_R_CURR_DEFAULT 0xAF
/* Current index max step */
#define PATTERN_CURRENT_INDEX_STEP_HAL 255
/* Pattern Mode */
#define PATTERN_OFF 0
#define PATTERN_BLINK_ON -1
/*GV DCM Felica Pattern Mode*/
#define PATTERN_FELICA_ON 101
#define PATTERN_GPS_ON 102
/*GK Favorite MissedNoit Pattern Mode*/
#define PATTERN_FAVORITE_MISSED_NOTI 14
/*GK ATT Power off charged Mode (charge complete brightness 50%)*/
#define PATTERN_CHARGING_COMPLETE_50 15
#define PATTERN_CHARGING_50 16
/* Program Commands */
#define CMD_SET_PWM 0x40
#define CMD_WAIT_LSB 0x00
#define MAX_BLINK_TIME 60000 /* 60 sec */
enum lp5521_wait_type {
LP5521_CYCLE_INVALID,
LP5521_CYCLE_50ms,
LP5521_CYCLE_100ms,
LP5521_CYCLE_200ms,
LP5521_CYCLE_500ms,
LP5521_CYCLE_700ms,
LP5521_CYCLE_920ms,
LP5521_CYCLE_982ms,
LP5521_CYCLE_MAX,
};
struct lp5521_pattern_cmd {
u8 r[LP5521_PROGRAM_LENGTH];
u8 g[LP5521_PROGRAM_LENGTH];
u8 b[LP5521_PROGRAM_LENGTH];
unsigned pc_r;
unsigned pc_g;
unsigned pc_b;
};
struct lp5521_wait_param {
unsigned cycle;
unsigned limit;
u8 cmd;
};
static const struct lp5521_wait_param lp5521_wait_params[LP5521_CYCLE_MAX] = {
[LP5521_CYCLE_50ms] = {
.cycle = 50,
.limit = 3000,
.cmd = 0x43,
},
[LP5521_CYCLE_100ms] = {
.cycle = 100,
.limit = 6000,
.cmd = 0x46,
},
[LP5521_CYCLE_200ms] = {
.cycle = 200,
.limit = 10000,
.cmd = 0x4d,
},
[LP5521_CYCLE_500ms] = {
.cycle = 500,
.limit = 30000,
.cmd = 0x60,
},
[LP5521_CYCLE_700ms] = {
.cycle = 700,
.limit = 40000,
.cmd = 0x6d,
},
[LP5521_CYCLE_920ms] = {
.cycle = 920,
.limit = 50000,
.cmd = 0x7b,
},
[LP5521_CYCLE_982ms] = {
.cycle = 982,
.limit = 60000,
.cmd = 0x7f,
},
};
#if defined(CONFIG_MACH_MSM8974_VU3_KR)
static struct lp5521_led_config lp5521_led_config_rev_a[] = {
{
.name = "R",
.chan_nr = 0,
.led_current = 180,
.max_current = 180,
},
{
.name = "B",
.chan_nr = 1,
.led_current = 180,
.max_current = 180,
},
{
.name = "G",
.chan_nr = 2,
.led_current = 180,
.max_current = 180,
},
};
static struct lp5521_led_pattern board_led_patterns_rev_a[] = {
{
/* ID_POWER_ON = 1 */
.r = mode1_red,
.g = mode1_green,
.b = mode1_blue,
.size_r = ARRAY_SIZE(mode1_red),
.size_g = ARRAY_SIZE(mode1_green),
.size_b = ARRAY_SIZE(mode1_blue),
},
{
/* ID_LCD_ON = 2 */
.r = mode2_red,
.g = mode2_green,
.b = mode2_blue,
.size_r = ARRAY_SIZE(mode2_red),
.size_g = ARRAY_SIZE(mode2_green),
.size_b = ARRAY_SIZE(mode2_blue),
},
{
/* ID_CHARGING = 3 */
.r = mode3_red,
.size_r = ARRAY_SIZE(mode3_red),
},
{
/* ID_CHARGING_FULL = 4 */
.g = mode4_green,
.size_g = ARRAY_SIZE(mode4_green),
},
{
/* ID_CALENDAR_REMIND = 5 */
.r = mode5_red_rev_a,
.g = mode5_green_rev_a,
.size_r = ARRAY_SIZE(mode5_red_rev_a),
.size_g = ARRAY_SIZE(mode5_green_rev_a),
},
{
/* ID_POWER_OFF = 6 */
.r = mode6_red,
.g = mode6_green,
.b = mode6_blue,
.size_r = ARRAY_SIZE(mode6_red),
.size_g = ARRAY_SIZE(mode6_green),
.size_b = ARRAY_SIZE(mode6_blue),
},
{
/* ID_MISSED_NOTI = 7 */
.r = mode7_red,
.g = mode7_green,
.b = mode7_blue,
.size_r = ARRAY_SIZE(mode7_red),
.size_g = ARRAY_SIZE(mode7_green),
.size_b = ARRAY_SIZE(mode7_blue),
},
/* for dummy pattern IDs (defined LGLedRecord.java) */
{
/* ID_ALARM = 8 */
},
{
/* ID_CALL_01 = 9 */
},
{
/* ID_CALL_02 = 10 */
},
{
/* ID_CALL_03 = 11 */
},
{
/* ID_VOLUME_UP = 12 */
},
{
/* ID_VOLUME_DOWN = 13 */
},
{
/* ID_FAVORITE_MISSED_NOTI = 14 */
.r = mode8_red,
.g = mode8_green,
.b = mode8_blue,
.size_r = ARRAY_SIZE(mode8_red),
.size_g = ARRAY_SIZE(mode8_green),
.size_b = ARRAY_SIZE(mode8_blue),
},
{
/* CHARGING_100_FOR_ATT = 15 (use chargerlogo, only AT&T) */
.g = mode4_green_50,
.size_g = ARRAY_SIZE(mode4_green_50),
},
{
/* CHARGING_FOR_ATT = 16 (use chargerlogo, only AT&T) */
.r = mode3_red_50,
.size_r = ARRAY_SIZE(mode3_red_50),
},
{
/* ID_MISSED_NOTI_PINK = 17 */
.r = mode9_red_rev_a,
.g = mode9_green_rev_a,
.b = mode9_blue_rev_a,
.size_r = ARRAY_SIZE(mode9_red_rev_a),
.size_g = ARRAY_SIZE(mode9_green_rev_a),
.size_b = ARRAY_SIZE(mode9_blue_rev_a),
},
{
/* ID_MISSED_NOTI_BLUE = 18 */
.r = mode10_red,
.g = mode10_green,
.b = mode10_blue,
.size_r = ARRAY_SIZE(mode10_red),
.size_g = ARRAY_SIZE(mode10_green),
.size_b = ARRAY_SIZE(mode10_blue),
},
{
/* ID_MISSED_NOTI_ORANGE = 19 */
.r = mode11_red_rev_a,
.g = mode11_green_rev_a,
.b = mode11_blue_rev_a,
.size_r = ARRAY_SIZE(mode11_red_rev_a),
.size_g = ARRAY_SIZE(mode11_green_rev_a),
.size_b = ARRAY_SIZE(mode11_blue_rev_a),
},
{
/* ID_MISSED_NOTI_YELLOW = 20 */
.r = mode12_red_rev_a,
.g = mode12_green_rev_a,
.b = mode12_blue_rev_a,
.size_r = ARRAY_SIZE(mode12_red_rev_a),
.size_g = ARRAY_SIZE(mode12_green_rev_a),
.size_b = ARRAY_SIZE(mode12_blue_rev_a),
},
/* for dummy pattern IDs (defined LGLedRecord.java) */
{
/* ID_INCALL_PINK = 21 */
},
{
/* ID_INCALL_BLUE = 22 */
},
{
/* ID_INCALL_ORANGE = 23 */
},
{
/* ID_INCALL_YELLOW = 24 */
},
{
/* ID_INCALL_TURQUOISE = 25 */
},
{
/* ID_INCALL_PURPLE = 26 */
},
{
/* ID_INCALL_RED = 27 */
},
{
/* ID_INCALL_LIME = 28 */
},
{
/* ID_MISSED_NOTI_TURQUOISE = 29 */
.r = mode13_red_rev_a,
.g = mode13_green_rev_a,
.b = mode13_blue_rev_a,
.size_r = ARRAY_SIZE(mode13_red_rev_a),
.size_g = ARRAY_SIZE(mode13_green_rev_a),
.size_b = ARRAY_SIZE(mode13_blue_rev_a),
},
{
/* ID_MISSED_NOTI_PURPLE = 30 */
.r = mode14_red_rev_a,
.g = mode14_green_rev_a,
.b = mode14_blue_rev_a,
.size_r = ARRAY_SIZE(mode14_red_rev_a),
.size_g = ARRAY_SIZE(mode14_green_rev_a),
.size_b = ARRAY_SIZE(mode14_blue_rev_a),
},
{
/* ID_MISSED_NOTI_RED = 31 */
.r = mode15_red,
.g = mode15_green,
.b = mode15_blue,
.size_r = ARRAY_SIZE(mode15_red),
.size_g = ARRAY_SIZE(mode15_green),
.size_b = ARRAY_SIZE(mode15_blue),
},
{
/* ID_MISSED_NOTI_LIME = 32 */
.r = mode16_red_rev_a,
.g = mode16_green_rev_a,
.b = mode16_blue_rev_a,
.size_r = ARRAY_SIZE(mode16_red_rev_a),
.size_g = ARRAY_SIZE(mode16_green_rev_a),
.size_b = ARRAY_SIZE(mode16_blue_rev_a),
},
};
static struct lp5521_led_config lp5521_led_config[] = {
{
.name = "R",
.chan_nr = 0,
.led_current = 180,
.max_current = 180,
},
{
.name = "G",
.chan_nr = 1,
.led_current = 180,
.max_current = 180,
},
{
.name = "B",
.chan_nr = 2,
.led_current = 180,
.max_current = 180,
},
};
static struct lp5521_led_pattern board_led_patterns[] = {
{
/* ID_POWER_ON = 1 */
.r = mode1_red,
.g = mode1_green,
.b = mode1_blue,
.size_r = ARRAY_SIZE(mode1_red),
.size_g = ARRAY_SIZE(mode1_green),
.size_b = ARRAY_SIZE(mode1_blue),
},
{
/* ID_LCD_ON = 2 */
.r = mode2_red,
.g = mode2_green,
.b = mode2_blue,
.size_r = ARRAY_SIZE(mode2_red),
.size_g = ARRAY_SIZE(mode2_green),
.size_b = ARRAY_SIZE(mode2_blue),
},
{
/* ID_CHARGING = 3 */
.r = mode3_red,
.size_r = ARRAY_SIZE(mode3_red),
},
{
/* ID_CHARGING_FULL = 4 */
.g = mode4_green,
.size_g = ARRAY_SIZE(mode4_green),
},
{
/* ID_CALENDAR_REMIND = 5 */
.r = mode5_red,
.g = mode5_green,
.size_r = ARRAY_SIZE(mode5_red),
.size_g = ARRAY_SIZE(mode5_green),
},
{
/* ID_POWER_OFF = 6 */
.r = mode6_red,
.g = mode6_green,
.b = mode6_blue,
.size_r = ARRAY_SIZE(mode6_red),
.size_g = ARRAY_SIZE(mode6_green),
.size_b = ARRAY_SIZE(mode6_blue),
},
{
/* ID_MISSED_NOTI = 7 */
.r = mode7_red,
.g = mode7_green,
.b = mode7_blue,
.size_r = ARRAY_SIZE(mode7_red),
.size_g = ARRAY_SIZE(mode7_green),
.size_b = ARRAY_SIZE(mode7_blue),
},
/* for dummy pattern IDs (defined LGLedRecord.java) */
{
/* ID_ALARM = 8 */
},
{
/* ID_CALL_01 = 9 */
},
{
/* ID_CALL_02 = 10 */
},
{
/* ID_CALL_03 = 11 */
},
{
/* ID_VOLUME_UP = 12 */
},
{
/* ID_VOLUME_DOWN = 13 */
},
{
/* ID_FAVORITE_MISSED_NOTI = 14 */
.r = mode8_red,
.g = mode8_green,
.b = mode8_blue,
.size_r = ARRAY_SIZE(mode8_red),
.size_g = ARRAY_SIZE(mode8_green),
.size_b = ARRAY_SIZE(mode8_blue),
},
{
/* CHARGING_100_FOR_ATT = 15 (use chargerlogo, only AT&T) */
.g = mode4_green_50,
.size_g = ARRAY_SIZE(mode4_green_50),
},
{
/* CHARGING_FOR_ATT = 16 (use chargerlogo, only AT&T) */
.r = mode3_red_50,
.size_r = ARRAY_SIZE(mode3_red_50),
},
{
/* ID_MISSED_NOTI_PINK = 17 */
.r = mode9_red,
.g = mode9_green,
.b = mode9_blue,
.size_r = ARRAY_SIZE(mode9_red),
.size_g = ARRAY_SIZE(mode9_green),
.size_b = ARRAY_SIZE(mode9_blue),
},
{
/* ID_MISSED_NOTI_BLUE = 18 */
.r = mode10_red,
.g = mode10_green,
.b = mode10_blue,
.size_r = ARRAY_SIZE(mode10_red),
.size_g = ARRAY_SIZE(mode10_green),
.size_b = ARRAY_SIZE(mode10_blue),
},
{
/* ID_MISSED_NOTI_ORANGE = 19 */
.r = mode11_red,
.g = mode11_green,
.b = mode11_blue,
.size_r = ARRAY_SIZE(mode11_red),
.size_g = ARRAY_SIZE(mode11_green),
.size_b = ARRAY_SIZE(mode11_blue),
},
{
/* ID_MISSED_NOTI_YELLOW = 20 */
.r = mode12_red,
.g = mode12_green,
.b = mode12_blue,
.size_r = ARRAY_SIZE(mode12_red),
.size_g = ARRAY_SIZE(mode12_green),
.size_b = ARRAY_SIZE(mode12_blue),
},
/* for dummy pattern IDs (defined LGLedRecord.java) */
{
/* ID_INCALL_PINK = 21 */
},
{
/* ID_INCALL_BLUE = 22 */
},
{
/* ID_INCALL_ORANGE = 23 */
},
{
/* ID_INCALL_YELLOW = 24 */
},
{
/* ID_INCALL_TURQUOISE = 25 */
},
{
/* ID_INCALL_PURPLE = 26 */
},
{
/* ID_INCALL_RED = 27 */
},
{
/* ID_INCALL_LIME = 28 */
},
{
/* ID_MISSED_NOTI_TURQUOISE = 29 */
.r = mode13_red,
.g = mode13_green,
.b = mode13_blue,
.size_r = ARRAY_SIZE(mode13_red),
.size_g = ARRAY_SIZE(mode13_green),
.size_b = ARRAY_SIZE(mode13_blue),
},
{
/* ID_MISSED_NOTI_PURPLE = 30 */
.r = mode14_red,
.g = mode14_green,
.b = mode14_blue,
.size_r = ARRAY_SIZE(mode14_red),
.size_g = ARRAY_SIZE(mode14_green),
.size_b = ARRAY_SIZE(mode14_blue),
},
{
/* ID_MISSED_NOTI_RED = 31 */
.r = mode15_red,
.g = mode15_green,
.b = mode15_blue,
.size_r = ARRAY_SIZE(mode15_red),
.size_g = ARRAY_SIZE(mode15_green),
.size_b = ARRAY_SIZE(mode15_blue),
},
{
/* ID_MISSED_NOTI_LIME = 32 */
.r = mode16_red,
.g = mode16_green,
.b = mode16_blue,
.size_r = ARRAY_SIZE(mode16_red),
.size_g = ARRAY_SIZE(mode16_green),
.size_b = ARRAY_SIZE(mode16_blue),
},
};
#else
static struct lp5521_led_config lp5521_led_config[] = {
{
#if defined(CONFIG_MACH_MSM8974_B1_KR)
.name = "R",
.chan_nr = 0,
.led_current = 37,
.max_current = 180,
#else
.name = "R",
.chan_nr = 0,
.led_current = 180,
.max_current = 180,
#endif
},
{
.name = "G",
.chan_nr = 1,
.led_current = 180,
.max_current = 180,
},
{
.name = "B",
.chan_nr = 2,
.led_current = 180,
.max_current = 180,
},
};
static struct lp5521_led_pattern board_led_patterns[] = {
{
/* ID_POWER_ON = 1 */
.r = mode1_red,
.g = mode1_green,
.b = mode1_blue,
.size_r = ARRAY_SIZE(mode1_red),
.size_g = ARRAY_SIZE(mode1_green),
.size_b = ARRAY_SIZE(mode1_blue),
},
{
/* ID_LCD_ON = 2 */
.r = mode2_red,
.g = mode2_green,
.b = mode2_blue,
.size_r = ARRAY_SIZE(mode2_red),
.size_g = ARRAY_SIZE(mode2_green),
.size_b = ARRAY_SIZE(mode2_blue),
},
{
/* ID_CHARGING = 3 */
.r = mode3_red,
.size_r = ARRAY_SIZE(mode3_red),
},
{
/* ID_CHARGING_FULL = 4 */
.g = mode4_green,
.size_g = ARRAY_SIZE(mode4_green),
},
{
/* ID_CALENDAR_REMIND = 5 */
.r = mode5_red,
.g = mode5_green,
.size_r = ARRAY_SIZE(mode5_red),
.size_g = ARRAY_SIZE(mode5_green),
},
{
/* ID_POWER_OFF = 6 */
.r = mode6_red,
.g = mode6_green,
.b = mode6_blue,
.size_r = ARRAY_SIZE(mode6_red),
.size_g = ARRAY_SIZE(mode6_green),
.size_b = ARRAY_SIZE(mode6_blue),
},
{
/* ID_MISSED_NOTI = 7 */
.r = mode7_red,
.g = mode7_green,
.b = mode7_blue,
.size_r = ARRAY_SIZE(mode7_red),
.size_g = ARRAY_SIZE(mode7_green),
.size_b = ARRAY_SIZE(mode7_blue),
},
#if defined(CONFIG_MACH_APQ8064_GK_KR) || defined(CONFIG_MACH_APQ8064_GKATT) || defined(CONFIG_MACH_APQ8064_GKOPENHK) || defined(CONFIG_MACH_APQ8064_GV_KR) || defined(CONFIG_MACH_APQ8064_GKOPENTW) || defined(CONFIG_MACH_APQ8064_GKSHBSG) || defined(CONFIG_MACH_APQ8064_GKOPENEU) || defined(CONFIG_MACH_MSM8974_Z_KR) || defined(CONFIG_MACH_MSM8974_Z_KDDI)|| defined(CONFIG_MACH_MSM8974_Z_TMO_US)|| defined(CONFIG_MACH_MSM8974_Z_SPR)|| defined(CONFIG_MACH_MSM8974_Z_ATT_US) || defined(CONFIG_MACH_MSM8974_B1_KR)
/* for dummy pattern IDs (defined LGLedRecord.java) */
{
/* ID_ALARM = 8 */
},
{
/* ID_CALL_01 = 9 */
},
{
/* ID_CALL_02 = 10 */
},
{
/* ID_CALL_03 = 11 */
},
{
/* ID_VOLUME_UP = 12 */
},
{
/* ID_VOLUME_DOWN = 13 */
},
#endif
{
/* ID_FAVORITE_MISSED_NOTI = 14 */
.r = mode8_red,
.g = mode8_green,
.b = mode8_blue,
.size_r = ARRAY_SIZE(mode8_red),
.size_g = ARRAY_SIZE(mode8_green),
.size_b = ARRAY_SIZE(mode8_blue),
},
{
/* CHARGING_100_FOR_ATT = 15 (use chargerlogo, only AT&T) */
.g = mode4_green_50,
.size_g = ARRAY_SIZE(mode4_green_50),
},
{
/* CHARGING_FOR_ATT = 16 (use chargerlogo, only AT&T) */
.r = mode3_red_50,
.size_r = ARRAY_SIZE(mode3_red_50),
},
{
/* ID_MISSED_NOTI_PINK = 17 */
.r = mode9_red,
.g = mode9_green,
.b = mode9_blue,
.size_r = ARRAY_SIZE(mode9_red),
.size_g = ARRAY_SIZE(mode9_green),
.size_b = ARRAY_SIZE(mode9_blue),
},
{
/* ID_MISSED_NOTI_BLUE = 18 */
.r = mode10_red,
.g = mode10_green,
.b = mode10_blue,
.size_r = ARRAY_SIZE(mode10_red),
.size_g = ARRAY_SIZE(mode10_green),
.size_b = ARRAY_SIZE(mode10_blue),
},
{
/* ID_MISSED_NOTI_ORANGE = 19 */
.r = mode11_red,
.g = mode11_green,
.b = mode11_blue,
.size_r = ARRAY_SIZE(mode11_red),
.size_g = ARRAY_SIZE(mode11_green),
.size_b = ARRAY_SIZE(mode11_blue),
},
{
/* ID_MISSED_NOTI_YELLOW = 20 */
.r = mode12_red,
.g = mode12_green,
.b = mode12_blue,
.size_r = ARRAY_SIZE(mode12_red),
.size_g = ARRAY_SIZE(mode12_green),
.size_b = ARRAY_SIZE(mode12_blue),
},
/* for dummy pattern IDs (defined LGLedRecord.java) */
{
/* ID_INCALL_PINK = 21 */
},
{
/* ID_INCALL_BLUE = 22 */
},
{
/* ID_INCALL_ORANGE = 23 */
},
{
/* ID_INCALL_YELLOW = 24 */
},
{
/* ID_INCALL_TURQUOISE = 25 */
},
{
/* ID_INCALL_PURPLE = 26 */
},
{
/* ID_INCALL_RED = 27 */
},
{
/* ID_INCALL_LIME = 28 */
},
{
/* ID_MISSED_NOTI_TURQUOISE = 29 */
.r = mode13_red,
.g = mode13_green,
.b = mode13_blue,
.size_r = ARRAY_SIZE(mode13_red),
.size_g = ARRAY_SIZE(mode13_green),
.size_b = ARRAY_SIZE(mode13_blue),
},
{
/* ID_MISSED_NOTI_PURPLE = 30 */
.r = mode14_red,
.g = mode14_green,
.b = mode14_blue,
.size_r = ARRAY_SIZE(mode14_red),
.size_g = ARRAY_SIZE(mode14_green),
.size_b = ARRAY_SIZE(mode14_blue),
},
{
/* ID_MISSED_NOTI_RED = 31 */
.r = mode15_red,
.g = mode15_green,
.b = mode15_blue,
.size_r = ARRAY_SIZE(mode15_red),
.size_g = ARRAY_SIZE(mode15_green),
.size_b = ARRAY_SIZE(mode15_blue),
},
{
/* ID_MISSED_NOTI_LIME = 32 */
.r = mode16_red,
.g = mode16_green,
.b = mode16_blue,
.size_r = ARRAY_SIZE(mode16_red),
.size_g = ARRAY_SIZE(mode16_green),
.size_b = ARRAY_SIZE(mode16_blue),
},
{
/* ID_NONE = 33 */
},
{
/* ID_NONE = 34 */
},
{
/* ID_INCALL = 35 */
.r = mode17_red,
.g = mode17_green,
.b = mode17_blue,
.size_r = ARRAY_SIZE(mode17_red),
.size_g = ARRAY_SIZE(mode17_green),
.size_b = ARRAY_SIZE(mode17_blue),
},
};
#endif
#define LP5521_CONFIGS (LP5521_PWM_HF | LP5521_PWRSAVE_EN | \
LP5521_CP_MODE_AUTO | \
LP5521_CLOCK_INT)
struct lp5521_chip *chip;
static void lp5521_enable(bool state)
{
int ret = 0;
LP5521_INFO_MSG("LP5521: [%s] state = %d\n", __func__, state);
if (!gpio_is_valid(chip->rgb_led_en)) {
pr_err("rgb_led_en gpio_request failed for %d ret=%d\n", chip->rgb_led_en, ret);
return;
}
if(lge_get_board_revno()> HW_REV_EVB2)
{
if(state){
gpio_set_value(chip->rgb_led_en, 1);
LP5521_INFO_MSG("LP5521: [%s] RGB_EN(gpio #%d) set to HIGH\n", __func__, chip->rgb_led_en);
}
else{
gpio_set_value(chip->rgb_led_en, 0);
LP5521_INFO_MSG("LP5521: [%s] RGB_EN(gpio #%d) set to LOW\n", __func__, chip->rgb_led_en);
}
}
return;
}
static struct lp5521_platform_data lp5521_pdata = {
.led_config = lp5521_led_config,
.num_channels = ARRAY_SIZE(lp5521_led_config),
.clock_mode = LP5521_CLOCK_INT,
.update_config = LP5521_CONFIGS,
.patterns = board_led_patterns,
.num_patterns = ARRAY_SIZE(board_led_patterns),
.enable = lp5521_enable
};
static inline struct lp5521_led *cdev_to_led(struct led_classdev *cdev)
{
return container_of(cdev, struct lp5521_led, cdev);
}
static inline struct lp5521_chip *engine_to_lp5521(struct lp5521_engine *engine)
{
return container_of(engine, struct lp5521_chip,
engines[engine->id - 1]);
}
static inline struct lp5521_chip *led_to_lp5521(struct lp5521_led *led)
{
return container_of(led, struct lp5521_chip,
leds[led->id]);
}
static void lp5521_led_brightness_work(struct work_struct *work);
static inline int lp5521_write(struct i2c_client *client, u8 reg, u8 value)
{
return i2c_smbus_write_byte_data(client, reg, value);
}
static int lp5521_read(struct i2c_client *client, u8 reg, u8 *buf)
{
s32 ret;
ret = i2c_smbus_read_byte_data(client, reg);
if (ret < 0)
return -EIO;
*buf = ret;
return 0;
}
static int lp5521_set_engine_mode(struct lp5521_engine *engine, u8 mode)
{
struct lp5521_chip *chip = engine_to_lp5521(engine);
struct i2c_client *client = chip->client;
int ret;
u8 engine_state;
/* Only transition between RUN and DIRECT mode are handled here */
if (mode == LP5521_CMD_LOAD)
return 0;
if (mode == LP5521_CMD_DISABLED)
mode = LP5521_CMD_DIRECT;
ret = lp5521_read(client, LP5521_REG_OP_MODE, &engine_state);
if (ret < 0)
return ret;
/* set mode only for this engine */
engine_state &= ~(engine->engine_mask);
mode &= engine->engine_mask;
engine_state |= mode;
return lp5521_write(client, LP5521_REG_OP_MODE, engine_state);
}
static int lp5521_load_program(struct lp5521_engine *eng, const u8 *pattern)
{
struct lp5521_chip *chip = engine_to_lp5521(eng);
struct i2c_client *client = chip->client;
int ret;
int addr;
u8 mode = 0;
/* move current engine to direct mode and remember the state */
ret = lp5521_set_engine_mode(eng, LP5521_CMD_DIRECT);
if (ret)
return ret;
/* Mode change requires min 500 us delay. 1 - 2 ms with margin */
usleep_range(1000, 2000);
ret = lp5521_read(client, LP5521_REG_OP_MODE, &mode);
if (ret)
return ret;
/* For loading, all the engines to load mode */
lp5521_write(client, LP5521_REG_OP_MODE, LP5521_CMD_DIRECT);
/* Mode change requires min 500 us delay. 1 - 2 ms with margin */
usleep_range(1000, 2000);
lp5521_write(client, LP5521_REG_OP_MODE, LP5521_CMD_LOAD);
/* Mode change requires min 500 us delay. 1 - 2 ms with margin */
usleep_range(1000, 2000);
addr = LP5521_PROG_MEM_BASE + eng->prog_page * LP5521_PROG_MEM_SIZE;
i2c_smbus_write_i2c_block_data(client,
addr,
LP5521_PROG_MEM_SIZE,
pattern);
return lp5521_write(client, LP5521_REG_OP_MODE, mode);
}
static int lp5521_set_led_current(struct lp5521_chip *chip, int led, u8 curr)
{
return lp5521_write(chip->client,
LP5521_REG_LED_CURRENT_BASE + chip->leds[led].chan_nr,
curr);
}
static void lp5521_init_engine(struct lp5521_chip *chip)
{
int i;
for (i = 0; i < ARRAY_SIZE(chip->engines); i++) {
chip->engines[i].id = i + 1;
chip->engines[i].engine_mask = LP5521_ENG_MASK_BASE >> (i * 2);
chip->engines[i].prog_page = i;
}
}
static int lp5521_configure(struct i2c_client *client)
{
struct lp5521_chip *chip = i2c_get_clientdata(client);
int ret;
u8 cfg;
lp5521_init_engine(chip);
/* Set all PWMs to direct control mode */
ret = lp5521_write(client, LP5521_REG_OP_MODE, LP5521_CMD_DIRECT);
cfg = chip->pdata->update_config ?
: (LP5521_PWRSAVE_EN | LP5521_CP_MODE_AUTO | LP5521_R_TO_BATT);
ret |= lp5521_write(client, LP5521_REG_CONFIG, cfg);
/* Initialize all channels PWM to zero -> leds off */
ret |= lp5521_write(client, LP5521_REG_R_PWM, 0);
ret |= lp5521_write(client, LP5521_REG_G_PWM, 0);
ret |= lp5521_write(client, LP5521_REG_B_PWM, 0);
/* Set engines are set to run state when OP_MODE enables engines */
ret |= lp5521_write(client, LP5521_REG_ENABLE,
LP5521_ENABLE_RUN_PROGRAM);
/* enable takes 500us. 1 - 2 ms leaves some margin */
usleep_range(1000, 2000);
return ret;
}
static int lp5521_run_selftest(struct lp5521_chip *chip, char *buf)
{
int ret;
u8 status;
ret = lp5521_read(chip->client, LP5521_REG_STATUS, &status);
if (ret < 0)
return ret;
/* Check that ext clock is really in use if requested */
if (chip->pdata && chip->pdata->clock_mode == LP5521_CLOCK_EXT)
if ((status & LP5521_EXT_CLK_USED) == 0)
return -EIO;
return 0;
}
static void lp5521_set_brightness(struct led_classdev *cdev,
enum led_brightness brightness)
{
struct lp5521_led *led = cdev_to_led(cdev);
static unsigned long log_counter;
led->brightness = (u8)brightness;
if (log_counter++ % 100 == 0) {
LP5521_INFO_MSG("[%s] brightness : %d", __func__, brightness);
}
schedule_work(&led->brightness_work);
}
static void lp5521_led_brightness_work(struct work_struct *work)
{
struct lp5521_led *led = container_of(work,
struct lp5521_led,
brightness_work);
struct lp5521_chip *chip = led_to_lp5521(led);
struct i2c_client *client = chip->client;
mutex_lock(&chip->lock);
lp5521_write(client, LP5521_REG_LED_PWM_BASE + led->chan_nr,
led->brightness);
mutex_unlock(&chip->lock);
}
/* Detect the chip by setting its ENABLE register and reading it back. */
static int lp5521_detect(struct i2c_client *client)
{
int ret;
u8 buf = 0;
ret = lp5521_write(client, LP5521_REG_ENABLE, LP5521_ENABLE_DEFAULT);
if (ret)
return ret;
/* enable takes 500us. 1 - 2 ms leaves some margin */
usleep_range(1000, 2000);
ret = lp5521_read(client, LP5521_REG_ENABLE, &buf);
if (ret)
return ret;
if (buf != LP5521_ENABLE_DEFAULT)
return -ENODEV;
return 0;
}
/* Set engine mode and create appropriate sysfs attributes, if required. */
static int lp5521_set_mode(struct lp5521_engine *engine, u8 mode)
{
int ret = 0;
/* if in that mode already do nothing, except for run */
if (mode == engine->mode && mode != LP5521_CMD_RUN)
return 0;
if (mode == LP5521_CMD_RUN) {
ret = lp5521_set_engine_mode(engine, LP5521_CMD_RUN);
} else if (mode == LP5521_CMD_LOAD) {
lp5521_set_engine_mode(engine, LP5521_CMD_DISABLED);
lp5521_set_engine_mode(engine, LP5521_CMD_LOAD);
} else if (mode == LP5521_CMD_DISABLED) {
lp5521_set_engine_mode(engine, LP5521_CMD_DISABLED);
}
engine->mode = mode;
return ret;
}
static int lp5521_do_store_load(struct lp5521_engine *engine,
const char *buf, size_t len)
{
struct lp5521_chip *chip = engine_to_lp5521(engine);
struct i2c_client *client = chip->client;
int ret, nrchars, offset = 0, i = 0;
char c[3];
unsigned cmd;
u8 pattern[LP5521_PROGRAM_LENGTH] = {0};
while ((offset < len - 1) && (i < LP5521_PROGRAM_LENGTH)) {
/* separate sscanfs because length is working only for %s */
ret = sscanf(buf + offset, "%2s%n ", c, &nrchars);
if (ret != 2)
goto fail;
ret = sscanf(c, "%2x", &cmd);
if (ret != 1)
goto fail;
pattern[i] = (u8)cmd;
offset += nrchars;
i++;
}
/* Each instruction is 16bit long. Check that length is even */
if (i % 2)
goto fail;
mutex_lock(&chip->lock);
if (engine->mode == LP5521_CMD_LOAD)
ret = lp5521_load_program(engine, pattern);
else
ret = -EINVAL;
mutex_unlock(&chip->lock);
if (ret) {
dev_err(&client->dev, "failed loading pattern\n");
return ret;
}
return len;
fail:
dev_err(&client->dev, "wrong pattern format\n");
return -EINVAL;
}
static ssize_t store_engine_load(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t len, int nr)
{
struct i2c_client *client = to_i2c_client(dev);
struct lp5521_chip *chip = i2c_get_clientdata(client);
return lp5521_do_store_load(&chip->engines[nr - 1], buf, len);
}
#define store_load(nr) \
static ssize_t store_engine##nr##_load(struct device *dev, \
struct device_attribute *attr, \
const char *buf, size_t len) \
{ \
return store_engine_load(dev, attr, buf, len, nr); \
}
store_load(1)
store_load(2)
store_load(3)
static ssize_t show_engine_mode(struct device *dev,
struct device_attribute *attr,
char *buf, int nr)
{
struct i2c_client *client = to_i2c_client(dev);
struct lp5521_chip *chip = i2c_get_clientdata(client);
switch (chip->engines[nr - 1].mode) {
case LP5521_CMD_RUN:
return sprintf(buf, "run\n");
case LP5521_CMD_LOAD:
return sprintf(buf, "load\n");
case LP5521_CMD_DISABLED:
return sprintf(buf, "disabled\n");
default:
return sprintf(buf, "disabled\n");
}
}
#define show_mode(nr) \
static ssize_t show_engine##nr##_mode(struct device *dev, \
struct device_attribute *attr, \
char *buf) \
{ \
return show_engine_mode(dev, attr, buf, nr); \
}
show_mode(1)
show_mode(2)
show_mode(3)
static ssize_t store_engine_mode(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t len, int nr)
{
struct i2c_client *client = to_i2c_client(dev);
struct lp5521_chip *chip = i2c_get_clientdata(client);
struct lp5521_engine *engine = &chip->engines[nr - 1];
mutex_lock(&chip->lock);
if (!strncmp(buf, "run", 3))
lp5521_set_mode(engine, LP5521_CMD_RUN);
else if (!strncmp(buf, "load", 4))
lp5521_set_mode(engine, LP5521_CMD_LOAD);
else if (!strncmp(buf, "disabled", 8))
lp5521_set_mode(engine, LP5521_CMD_DISABLED);
mutex_unlock(&chip->lock);
return len;
}
#define store_mode(nr) \
static ssize_t store_engine##nr##_mode(struct device *dev, \
struct device_attribute *attr, \
const char *buf, size_t len) \
{ \
return store_engine_mode(dev, attr, buf, len, nr); \
}
store_mode(1)
store_mode(2)
store_mode(3)
static ssize_t show_max_current(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct led_classdev *led_cdev = dev_get_drvdata(dev);
struct lp5521_led *led = cdev_to_led(led_cdev);
return sprintf(buf, "%d\n", led->max_current);
}
static ssize_t show_current(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct led_classdev *led_cdev = dev_get_drvdata(dev);
struct lp5521_led *led = cdev_to_led(led_cdev);
return sprintf(buf, "%d\n", led->led_current);
}
static ssize_t store_current(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t len)
{
struct led_classdev *led_cdev = dev_get_drvdata(dev);
struct lp5521_led *led = cdev_to_led(led_cdev);
struct lp5521_chip *chip = led_to_lp5521(led);
ssize_t ret;
unsigned long curr;
if (kstrtoul(buf, 0, &curr))
return -EINVAL;
if (curr > led->max_current)
return -EINVAL;
mutex_lock(&chip->lock);
ret = lp5521_set_led_current(chip, led->id, curr);
mutex_unlock(&chip->lock);
if (ret < 0)
return ret;
led->led_current = (u8)curr;
LP5521_INFO_MSG("[%s] brightness : %d", __func__, (u8)curr);
return len;
}
static ssize_t lp5521_selftest(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct i2c_client *client = to_i2c_client(dev);
struct lp5521_chip *chip = i2c_get_clientdata(client);
int ret;
mutex_lock(&chip->lock);
ret = lp5521_run_selftest(chip, buf);
mutex_unlock(&chip->lock);
return sprintf(buf, "%s\n", ret ? "FAIL" : "OK");
}
static void lp5521_clear_program_memory(struct i2c_client *cl)
{
int i;
u8 rgb_mem[] = {
LP5521_REG_R_PROG_MEM,
LP5521_REG_G_PROG_MEM,
LP5521_REG_B_PROG_MEM,
};
for (i = 0; i < ARRAY_SIZE(rgb_mem); i++) {
lp5521_write(cl, rgb_mem[i], 0);
lp5521_write(cl, rgb_mem[i] + 1, 0);
}
}
static void lp5521_write_program_memory(struct i2c_client *cl,
u8 base, const u8 *rgb, int size)
{
int i;
if (!rgb || size <= 0)
return;
for (i = 0; i < size; i++)
lp5521_write(cl, base + i, *(rgb + i));
lp5521_write(cl, base + i, 0);
lp5521_write(cl, base + i + 1, 0);
}
static inline struct lp5521_led_pattern *lp5521_get_pattern
(struct lp5521_chip *chip, u8 offset)
{
struct lp5521_led_pattern *ptn;
ptn = chip->pdata->patterns + (offset - 1);
return ptn;
}
static void _run_led_pattern(struct lp5521_chip *chip,
struct lp5521_led_pattern *ptn)
{
struct i2c_client *cl = chip->client;
lp5521_write(cl, LP5521_REG_OP_MODE, LP5521_CMD_LOAD);
usleep_range(1000, 2000);
lp5521_clear_program_memory(cl);
lp5521_write_program_memory(cl, LP5521_REG_R_PROG_MEM,
ptn->r, ptn->size_r);
#if defined(CONFIG_MACH_MSM8974_VU3_KR)
if(lge_get_board_revno() == HW_REV_B)
{
lp5521_write_program_memory(cl, LP5521_REG_B_PROG_MEM,
ptn->g, ptn->size_g);
lp5521_write_program_memory(cl, LP5521_REG_G_PROG_MEM,
ptn->b, ptn->size_b);
}
else
{
lp5521_write_program_memory(cl, LP5521_REG_G_PROG_MEM,
ptn->g, ptn->size_g);
lp5521_write_program_memory(cl, LP5521_REG_B_PROG_MEM,
ptn->b, ptn->size_b);
}
#else
lp5521_write_program_memory(cl, LP5521_REG_G_PROG_MEM,
ptn->g, ptn->size_g);
lp5521_write_program_memory(cl, LP5521_REG_B_PROG_MEM,
ptn->b, ptn->size_b);
#endif
lp5521_write(cl, LP5521_REG_OP_MODE, LP5521_CMD_RUN);
usleep_range(1000, 2000);
lp5521_write(cl, LP5521_REG_ENABLE, LP5521_ENABLE_RUN_PROGRAM);
}
static void lp5521_run_led_pattern(int mode, struct lp5521_chip *chip)
{
struct lp5521_led_pattern *ptn;
struct i2c_client *cl = chip->client;
int num_patterns = chip->pdata->num_patterns;
#if defined(CONFIG_MACH_MSM8974_Z_KR) || defined(CONFIG_MACH_MSM8974_Z_KDDI) || defined(CONFIG_MACH_MSM8974_B1_KR)
if (mode >= 1000) {
mode = mode - 1000;
}
#endif
chip->id_pattern_play = mode;
#ifdef CONFIG_MACH_APQ8064_GVDCM
if(mode == PATTERN_FELICA_ON || mode == PATTERN_GPS_ON)
{
mode = num_patterns - (PATTERN_GPS_ON - mode);
}
#endif
#if defined(CONFIG_MACH_MSM8974_VU3_KR) || defined(CONFIG_MACH_MSM8974_Z_KR) || defined(CONFIG_MACH_MSM8974_Z_KDDI)|| defined(CONFIG_MACH_MSM8974_Z_TMO_US)|| defined(CONFIG_MACH_MSM8974_Z_SPR)|| defined(CONFIG_MACH_MSM8974_Z_ATT_US) || defined(CONFIG_MACH_MSM8974_B1_KR)
#if 0
/* this process is not need, because dummy pattern defined in board file */
if (mode == PATTERN_FAVORITE_MISSED_NOTI || mode == PATTERN_CHARGING_COMPLETE_50 || mode == PATTERN_CHARGING_50) {
mode = num_patterns - (PATTERN_CHARGING_50 - mode);
}
#endif
#endif
if (mode > num_patterns || !(chip->pdata->patterns)) {
chip->id_pattern_play = PATTERN_OFF;
LP5521_INFO_MSG("[%s] invalid pattern!", __func__);
return;
}
if (mode == PATTERN_OFF) {
lp5521_write(cl, LP5521_REG_ENABLE, LP5521_ENABLE_DEFAULT);
usleep_range(1000, 2000);
lp5521_write(cl, LP5521_REG_OP_MODE, LP5521_CMD_DIRECT);
LP5521_INFO_MSG("[%s] PATTERN_PLAY_OFF", __func__);
} else {
ptn = lp5521_get_pattern(chip, mode);
if (!ptn)
return;
_run_led_pattern(chip, ptn);
LP5521_INFO_MSG("[%s] PATTERN_PLAY_ON", __func__);
}
}
static u8 get_led_current_value(u8 current_index)
{
return current_index_mapped_value[current_index];
}
static ssize_t show_led_pattern(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct lp5521_chip *chip = i2c_get_clientdata(to_i2c_client(dev));
return sprintf(buf, "%d\n", chip->id_pattern_play);
}
static ssize_t store_led_pattern(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t len)
{
struct lp5521_chip *chip = i2c_get_clientdata(to_i2c_client(dev));
unsigned long val;
int ret;
LP5521_INFO_MSG("[%s] pattern id : %s", __func__, buf);
ret = strict_strtoul(buf, 10, &val);
if (ret)
return ret;
lp5521_run_led_pattern(val, chip);
return len;
}
static ssize_t show_led_current_index(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct lp5521_chip *chip = i2c_get_clientdata(to_i2c_client(dev));
if (!chip)
return 0;
return sprintf(buf, "%d\n", chip->current_index);
}
static ssize_t store_led_current_index(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t len)
{
struct lp5521_chip *chip = i2c_get_clientdata(to_i2c_client(dev));
unsigned long val;
int ret, i;
u8 max_current, modify_current;
LP5521_INFO_MSG("[%s] current index (0~255) : %s", __func__, buf);
ret = strict_strtoul(buf, 10, &val);
if (ret)
return ret;
if (val > PATTERN_CURRENT_INDEX_STEP_HAL || val < 0)
return -EINVAL;
if (!chip)
return 0;
chip->current_index = val;
mutex_lock(&chip->lock);
for (i = 0; i < LP5521_MAX_LEDS ; i++) {
max_current = chip->leds[i].max_current;
modify_current = get_led_current_value(val);
if (modify_current > max_current)
modify_current = max_current;
LP5521_INFO_MSG("[%s] modify_current : %d", __func__, modify_current);
ret = lp5521_set_led_current(chip, i, modify_current);
if (ret)
break;
chip->leds[i].led_current = modify_current;
}
mutex_unlock(&chip->lock);
if (ret)
return ret;
return len;
}
static void _set_pwm_cmd(struct lp5521_pattern_cmd *cmd, unsigned int color)
{
u8 r = (color >> 16) & 0xFF;
u8 g = (color >> 8) & 0xFF;
u8 b = color & 0xFF;
cmd->r[cmd->pc_r++] = CMD_SET_PWM;
cmd->r[cmd->pc_r++] = r;
cmd->g[cmd->pc_g++] = CMD_SET_PWM;
cmd->g[cmd->pc_g++] = g;
cmd->b[cmd->pc_b++] = CMD_SET_PWM;
cmd->b[cmd->pc_b++] = b;
}
static enum lp5521_wait_type _find_wait_cycle_type(unsigned int ms)
{
int i;
for (i = LP5521_CYCLE_50ms ; i < LP5521_CYCLE_MAX ; i++) {
if (ms > lp5521_wait_params[i-1].limit &&
ms <= lp5521_wait_params[i].limit)
return i;
}
return LP5521_CYCLE_INVALID;
}
static void _set_wait_cmd(struct lp5521_pattern_cmd *cmd,
unsigned int ms, u8 jump, unsigned int off)
{
enum lp5521_wait_type type = _find_wait_cycle_type(ms);
unsigned int loop = ms / lp5521_wait_params[type].cycle;
u8 cmd_msb = lp5521_wait_params[type].cmd;
u8 msb;
u8 lsb;
u16 branch;
WARN_ON(!cmd_msb);
WARN_ON(loop > 64);
if(off)
{
if(loop > 1)
{
if(loop > 128)
loop = 128;
lsb = ((loop-1) & 0xff) | 0x80;
/* wait command */
cmd->r[cmd->pc_r++] = cmd_msb;
cmd->r[cmd->pc_r++] = lsb;
cmd->g[cmd->pc_g++] = cmd_msb;
cmd->g[cmd->pc_g++] = lsb;
cmd->b[cmd->pc_b++] = cmd_msb;
cmd->b[cmd->pc_b++] = lsb;
}
else
{
/* wait command */
cmd->r[cmd->pc_r++] = cmd_msb;
cmd->r[cmd->pc_r++] = CMD_WAIT_LSB;
cmd->g[cmd->pc_g++] = cmd_msb;
cmd->g[cmd->pc_g++] = CMD_WAIT_LSB;
cmd->b[cmd->pc_b++] = cmd_msb;
cmd->b[cmd->pc_b++] = CMD_WAIT_LSB;
}
}
else
{
/* wait command */
cmd->r[cmd->pc_r++] = cmd_msb;
cmd->r[cmd->pc_r++] = CMD_WAIT_LSB;
cmd->g[cmd->pc_g++] = cmd_msb;
cmd->g[cmd->pc_g++] = CMD_WAIT_LSB;
cmd->b[cmd->pc_b++] = cmd_msb;
cmd->b[cmd->pc_b++] = CMD_WAIT_LSB;
/* branch command : if wait time is bigger than cycle msec,
branch is used for command looping */
if (loop > 1) {
branch = (5 << 13) | ((loop - 1) << 7) | jump;
msb = (branch >> 8) & 0xFF;
lsb = branch & 0xFF;
cmd->r[cmd->pc_r++] = msb;
cmd->r[cmd->pc_r++] = lsb;
cmd->g[cmd->pc_g++] = msb;
cmd->g[cmd->pc_g++] = lsb;
cmd->b[cmd->pc_b++] = msb;
cmd->b[cmd->pc_b++] = lsb;
}
}
}
static inline bool _is_pc_overflow(struct lp5521_led_pattern *ptn)
{
return (ptn->size_r >= LP5521_PROGRAM_LENGTH ||
ptn->size_g >= LP5521_PROGRAM_LENGTH ||
ptn->size_b >= LP5521_PROGRAM_LENGTH);
}
static ssize_t store_led_blink(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t len)
{
struct lp5521_chip *chip = i2c_get_clientdata(to_i2c_client(dev));
unsigned int rgb = 0;
unsigned int on = 0;
unsigned int off = 0;
struct lp5521_led_pattern ptn = { };
struct lp5521_pattern_cmd cmd = { };
u8 jump_pc = 0;
sscanf(buf, "0x%06x %d %d", &rgb, &on, &off);
LP5521_INFO_MSG("[%s] rgb=0x%06x, on=%d, off=%d\n",__func__, rgb, on, off);
lp5521_run_led_pattern(PATTERN_OFF, chip);
on = min_t(unsigned int, on, MAX_BLINK_TIME);
off = min_t(unsigned int, off, MAX_BLINK_TIME);
if (!rgb || !on || !off) {
chip->id_pattern_play = PATTERN_OFF;
return len;
} else {
chip->id_pattern_play = PATTERN_BLINK_ON;
}
/* on */
_set_pwm_cmd(&cmd, rgb);
_set_wait_cmd(&cmd, on, jump_pc, 0);
jump_pc = cmd.pc_r / 2; /* 16bit size program counter */
/* off */
_set_pwm_cmd(&cmd, 0);
_set_wait_cmd(&cmd, off, jump_pc, 1);
ptn.r = cmd.r;
ptn.size_r = cmd.pc_r;
ptn.g = cmd.g;
ptn.size_g = cmd.pc_g;
ptn.b = cmd.b;
ptn.size_b = cmd.pc_b;
WARN_ON(_is_pc_overflow(&ptn));
_run_led_pattern(chip, &ptn);
return len;
}
/* led class device attributes */
static DEVICE_ATTR(led_current, S_IRUGO | S_IWUSR, show_current, store_current);
static DEVICE_ATTR(max_current, S_IRUGO , show_max_current, NULL);
static struct attribute *lp5521_led_attributes[] = {
&dev_attr_led_current.attr,
&dev_attr_max_current.attr,
NULL,
};
static struct attribute_group lp5521_led_attribute_group = {
.attrs = lp5521_led_attributes
};
/* device attributes */
static DEVICE_ATTR(engine1_mode, S_IRUGO | S_IWUSR,
show_engine1_mode, store_engine1_mode);
static DEVICE_ATTR(engine2_mode, S_IRUGO | S_IWUSR,
show_engine2_mode, store_engine2_mode);
static DEVICE_ATTR(engine3_mode, S_IRUGO | S_IWUSR,
show_engine3_mode, store_engine3_mode);
static DEVICE_ATTR(engine1_load, S_IWUSR, NULL, store_engine1_load);
static DEVICE_ATTR(engine2_load, S_IWUSR, NULL, store_engine2_load);
static DEVICE_ATTR(engine3_load, S_IWUSR, NULL, store_engine3_load);
static DEVICE_ATTR(selftest, S_IRUGO, lp5521_selftest, NULL);
static DEVICE_ATTR(led_pattern, S_IRUGO | S_IWUSR, show_led_pattern, store_led_pattern);
static DEVICE_ATTR(led_blink, S_IRUGO | S_IWUSR, NULL, store_led_blink);
static DEVICE_ATTR(led_current_index, S_IRUGO | S_IWUSR, show_led_current_index, store_led_current_index);
static struct attribute *lp5521_attributes[] = {
&dev_attr_engine1_mode.attr,
&dev_attr_engine2_mode.attr,
&dev_attr_engine3_mode.attr,
&dev_attr_selftest.attr,
&dev_attr_engine1_load.attr,
&dev_attr_engine2_load.attr,
&dev_attr_engine3_load.attr,
&dev_attr_led_pattern.attr,
&dev_attr_led_blink.attr,
&dev_attr_led_current_index.attr,
NULL
};
static const struct attribute_group lp5521_group = {
.attrs = lp5521_attributes,
};
static int lp5521_register_sysfs(struct i2c_client *client)
{
struct device *dev = &client->dev;
return sysfs_create_group(&dev->kobj, &lp5521_group);
}
static void lp5521_unregister_sysfs(struct i2c_client *client)
{
struct lp5521_chip *chip = i2c_get_clientdata(client);
struct device *dev = &client->dev;
int i;
sysfs_remove_group(&dev->kobj, &lp5521_group);
for (i = 0; i < chip->num_leds; i++)
sysfs_remove_group(&chip->leds[i].cdev.dev->kobj,
&lp5521_led_attribute_group);
}
static int lp5521_init_led(struct lp5521_led *led,
struct i2c_client *client,
int chan, struct lp5521_platform_data pdata)
{
struct device *dev = &client->dev;
char name[32];
int res;
if (chan >= LP5521_MAX_LEDS)
return -EINVAL;
if (lp5521_pdata.led_config[chan].led_current == 0)
return 0;
led->led_current = lp5521_pdata.led_config[chan].led_current;
led->max_current = lp5521_pdata.led_config[chan].max_current;
led->chan_nr = lp5521_pdata.led_config[chan].chan_nr;
if (led->chan_nr >= LP5521_MAX_LEDS) {
dev_err(dev, "Use channel numbers between 0 and %d\n",
LP5521_MAX_LEDS - 1);
return -EINVAL;
}
led->cdev.brightness_set = lp5521_set_brightness;
if (lp5521_pdata.led_config[chan].name) {
led->cdev.name = lp5521_pdata.led_config[chan].name;
} else {
snprintf(name, sizeof(name), "%s:channel%d",
lp5521_pdata.label ?: client->name, chan);
led->cdev.name = name;
}
res = led_classdev_register(dev, &led->cdev);
if (res < 0) {
dev_err(dev, "couldn't register led on channel %d\n", chan);
return res;
}
res = sysfs_create_group(&led->cdev.dev->kobj,
&lp5521_led_attribute_group);
if (res < 0) {
dev_err(dev, "couldn't register current attribute\n");
led_classdev_unregister(&led->cdev);
return res;
}
return 0;
}
static int lp5521_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int ret =0, i, led;
u8 buf = 0;
LP5521_INFO_MSG("[%s] start\n", __func__);
#ifdef CONFIG_OF
if (&client->dev.of_node)
{
chip = devm_kzalloc(&client->dev, sizeof(struct lp5521_chip), GFP_KERNEL);
if (!chip)
{
pr_err("%s: Failed to allocate memory\n", __func__);
return -ENOMEM;
}
if(lge_get_board_revno()> HW_REV_EVB2)
{
chip->rgb_led_en = of_get_named_gpio(client->dev.of_node, "ti,led_en", 0);
LP5521_INFO_MSG("chip->rgb_led_en ==%d \n", chip->rgb_led_en);
if (!gpio_is_valid(chip->rgb_led_en))
{
pr_err("Fail to get named gpio for rgb_led_en.\n");
goto fail0;
}
else
{
ret = gpio_request(chip->rgb_led_en, "rgb_led_en");
if(ret) {
pr_err("request reset gpio failed, rc=%d\n", ret);
gpio_free(chip->rgb_led_en);
goto fail0;
}
}
}
}
else
{
dev_err(&client->dev, "lp5521 probe of_node fail\n");
return -ENODEV;
}
#else
chip = devm_kzalloc(&client->dev, sizeof(*chip), GFP_KERNEL);
if (!chip) {
LP5521_INFO_MSG("[%s] Can not allocate memory!\n", __func__);
return -ENOMEM;
}
#endif
i2c_set_clientdata(client, chip);
chip->client = client;
mutex_init(&chip->lock);
#if defined(CONFIG_MACH_MSM8974_VU3_KR)
if(lge_get_board_revno() != HW_REV_B)
{
lp5521_pdata.led_config = lp5521_led_config_rev_a;
lp5521_pdata.patterns = board_led_patterns_rev_a;
}
#endif
chip->pdata = &lp5521_pdata;
if(lge_get_board_revno()> HW_REV_EVB2)
{
gpio_set_value((chip->rgb_led_en), 0);
usleep_range(1000, 2000); /* Keep enable down at least 1ms */
#ifdef CONFIG_MACH_MSM8974_Z_KR
if(lge_get_board_revno() >= HW_REV_E)
{
gpio_set_value((chip->rgb_led_en), 1);
usleep_range(1000, 2000); /* Keep enable down at least 1ms */
}
#elif defined(CONFIG_MACH_MSM8974_Z_KDDI)|| defined(CONFIG_MACH_MSM8974_Z_ATT_US)
if(lge_get_board_revno() >= HW_REV_B)
{
gpio_set_value((chip->rgb_led_en), 1);
usleep_range(1000, 2000); /* Keep enable down at least 1ms */
}
#elif defined(CONFIG_MACH_MSM8974_Z_TMO_US)|| defined(CONFIG_MACH_MSM8974_Z_SPR)
if(lge_get_board_revno() >= HW_REV_D)
{
gpio_set_value((chip->rgb_led_en), 1);
usleep_range(1000, 2000); /* Keep enable down at least 1ms */
}
#else
gpio_set_value((chip->rgb_led_en), 1);
usleep_range(1000, 2000); /* Keep enable down at least 1ms */
#endif
}
lp5521_write(client, LP5521_REG_RESET, 0xff);
usleep_range(10000, 20000); /*
* Exact value is not available. 10 - 20ms
* appears to be enough for reset.
*/
/*
* Make sure that the chip is reset by reading back the r channel
* current reg. This is dummy read is required on some platforms -
* otherwise further access to the R G B channels in the
* LP5521_REG_ENABLE register will not have any effect - strange!
*/
ret = lp5521_read(client, LP5521_REG_R_CURRENT, &buf);
if (ret || buf != LP5521_REG_R_CURR_DEFAULT) {
dev_err(&client->dev, "error in resetting chip\n");
goto fail2;
}
usleep_range(10000, 20000);
ret = lp5521_detect(client);
if (ret) {
dev_err(&client->dev, "Chip not found\n");
goto fail2;
}
dev_info(&client->dev, "%s programmable led chip found\n", id->name);
ret = lp5521_configure(client);
if (ret < 0) {
dev_err(&client->dev, "error configuring chip\n");
goto fail1;
}
/* Initialize leds */
chip->num_channels = lp5521_pdata.num_channels;
chip->num_leds = 0;
led = 0;
for (i = 0; i < lp5521_pdata.num_channels; i++) {
/* Do not initialize channels that are not connected */
if (lp5521_pdata.led_config[i].led_current == 0)
continue;
ret = lp5521_init_led(&chip->leds[led], client, i, lp5521_pdata);
if (ret) {
dev_err(&client->dev, "error initializing leds\n");
goto fail2;
}
chip->num_leds++;
chip->leds[led].id = led;
/* Set initial LED current */
lp5521_set_led_current(chip, led,
chip->leds[led].led_current);
INIT_WORK(&(chip->leds[led].brightness_work),
lp5521_led_brightness_work);
led++;
}
/* Initialize current index for auto brightness (max step) */
chip->current_index = PATTERN_CURRENT_INDEX_STEP_HAL;
ret = lp5521_register_sysfs(client);
if (ret) {
dev_err(&client->dev, "registering sysfs failed\n");
goto fail2;
}
#if !defined(CONFIG_MACH_MSM8974_Z_KR) && !defined(CONFIG_MACH_MSM8974_Z_KDDI)&& !defined(CONFIG_MACH_MSM8974_Z_TMO_US)&& !defined(CONFIG_MACH_MSM8974_Z_SPR)&& !defined(CONFIG_MACH_MSM8974_Z_ATT_US) && !defined(CONFIG_MACH_MSM8974_B1_KR)
lp5521_run_led_pattern(1, chip); //1: Power On pattern number
LP5521_INFO_MSG("[%s] pattern id : 1(Power on)", __func__);
LP5521_INFO_MSG("[%s] complete\n", __func__);
#endif
return ret;
fail2:
for (i = 0; i < chip->num_leds; i++) {
led_classdev_unregister(&chip->leds[i].cdev);
cancel_work_sync(&chip->leds[i].brightness_work);
}
fail1:
if(lge_get_board_revno()> HW_REV_EVB2)
{
if (lp5521_pdata.enable)
lp5521_pdata.enable(0);
}
fail0:
gpio_free(chip->rgb_led_en);
return ret;
}
static int lp5521_remove(struct i2c_client *client)
{
struct lp5521_chip *chip = i2c_get_clientdata(client);
int i;
LP5521_INFO_MSG("[%s] start\n", __func__);
lp5521_run_led_pattern(PATTERN_OFF, chip);
lp5521_unregister_sysfs(client);
for (i = 0; i < chip->num_leds; i++) {
led_classdev_unregister(&chip->leds[i].cdev);
cancel_work_sync(&chip->leds[i].brightness_work);
}
if(lge_get_board_revno()> HW_REV_EVB2)
{
if (chip->pdata->enable)
chip->pdata->enable(0);
}
if (chip->pdata->release_resources)
chip->pdata->release_resources();
devm_kfree(&client->dev, chip);
LP5521_INFO_MSG("[%s] complete\n", __func__);
return 0;
}
static void lp5521_shutdown(struct i2c_client *client)
{
struct lp5521_chip *chip = i2c_get_clientdata(client);
int i;
if (!chip) {
LP5521_INFO_MSG("[%s] null pointer check!\n", __func__);
return;
}
LP5521_INFO_MSG("[%s] start\n", __func__);
lp5521_set_led_current(chip, 0, 0);
lp5521_set_led_current(chip, 1, 0);
lp5521_set_led_current(chip, 2, 0);
lp5521_run_led_pattern(PATTERN_OFF, chip);
lp5521_unregister_sysfs(client);
for (i = 0; i < chip->num_leds; i++) {
led_classdev_unregister(&chip->leds[i].cdev);
cancel_work_sync(&chip->leds[i].brightness_work);
}
if(lge_get_board_revno()> HW_REV_EVB2)
{
if (chip->pdata->enable)
chip->pdata->enable(0);
}
if (chip->pdata->release_resources)
chip->pdata->release_resources();
devm_kfree(&client->dev, chip);
LP5521_INFO_MSG("[%s] complete\n", __func__);
}
static int lp5521_suspend(struct i2c_client *client, pm_message_t mesg)
{
struct lp5521_chip *chip = i2c_get_clientdata(client);
if (!chip || !chip->pdata) {
LP5521_INFO_MSG("[%s] null pointer check!\n", __func__);
return 0;
}
LP5521_INFO_MSG("[%s] id_pattern_play = %d\n", __func__, chip->id_pattern_play);
if(lge_get_board_revno()> HW_REV_EVB2)
{
if (chip->pdata->enable && chip->id_pattern_play == PATTERN_OFF) {
LP5521_INFO_MSG("[%s] RGB_EN set to LOW\n", __func__);
chip->pdata->enable(0);
}
}
return 0;
}
static int lp5521_resume(struct i2c_client *client)
{
struct lp5521_chip *chip = i2c_get_clientdata(client);
int ret = 0;
if (!chip || !chip->pdata) {
LP5521_INFO_MSG("[%s] null pointer check!\n", __func__);
return 0;
}
LP5521_INFO_MSG("[%s] id_pattern_play = %d\n", __func__, chip->id_pattern_play);
if(lge_get_board_revno()> HW_REV_EVB2)
{
if (chip->pdata->enable && chip->id_pattern_play == PATTERN_OFF) {
LP5521_INFO_MSG("[%s] RGB_EN set to HIGH\n", __func__);
chip->pdata->enable(0);
usleep_range(1000, 2000); /* Keep enable down at least 1ms */
chip->pdata->enable(1);
usleep_range(1000, 2000); /* 500us abs min. */
lp5521_write(client, LP5521_REG_RESET, 0xff);
usleep_range(10000, 20000);
ret = lp5521_configure(client);
if (ret < 0) {
dev_err(&client->dev, "error configuring chip\n");
}
}
}
else
{
if (chip->id_pattern_play == PATTERN_OFF) {
LP5521_INFO_MSG("[%s] RGB_EN set to HIGH\n", __func__);
lp5521_write(client, LP5521_REG_RESET, 0xff);
usleep_range(10000, 20000);
ret = lp5521_configure(client);
if (ret < 0) {
dev_err(&client->dev, "error configuring chip\n");
}
}
}
return ret;
}
static const struct i2c_device_id lp5521_id[] = {
{ "lp5521", 0 }, /* Three channel chip */
{ }
};
#ifdef CONFIG_OF
static struct of_device_id lp5521_match_table[] = {
{ .compatible = "ti,lp5521",},
{ },
};
#endif
static struct i2c_driver lp5521_driver = {
.driver = {
.owner = THIS_MODULE,
.name = "lp5521",
#ifdef CONFIG_OF
.of_match_table = lp5521_match_table,
#endif
},
.probe = lp5521_probe,
.remove = lp5521_remove,
.shutdown = lp5521_shutdown,
.suspend = lp5521_suspend,
.resume = lp5521_resume,
.id_table = lp5521_id,
};
/*
* module load/unload record keeping
*/
static int __init lp5521_dev_init(void)
{
return i2c_add_driver(&lp5521_driver);
}
module_init(lp5521_dev_init);
static void __exit lp5521_dev_exit(void)
{
i2c_del_driver(&lp5521_driver);
}
module_exit(lp5521_dev_exit);
MODULE_DEVICE_TABLE(i2c, lp5521_id);
MODULE_AUTHOR("Mathias Nyman, Yuri Zaporozhets, Samu Onkalo");
MODULE_DESCRIPTION("LP5521 LED engine");
MODULE_LICENSE("GPL v2");
| gpl-2.0 |
Yberion/stats_mod | codemp/rd-dedicated/tr_skin.cpp | 8848 | /*
===========================================================================
Copyright (C) 2000 - 2013, Raven Software, Inc.
Copyright (C) 2001 - 2013, Activision, Inc.
Copyright (C) 2013 - 2015, OpenJK contributors
This file is part of the OpenJK source code.
OpenJK is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License version 2 as
published by the Free Software Foundation.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, see <http://www.gnu.org/licenses/>.
===========================================================================
*/
// tr_image.c
#include "tr_local.h"
#include <map>
bool gServerSkinHack = false;
shader_t *R_FindServerShader( const char *name, const int *lightmapIndex, const byte *styles, qboolean mipRawImage );
static char *CommaParse( char **data_p );
/*
===============
RE_SplitSkins
input = skinname, possibly being a macro for three skins
return= true if three part skins found
output= qualified names to three skins if return is true, undefined if false
===============
*/
bool RE_SplitSkins(const char *INname, char *skinhead, char *skintorso, char *skinlower)
{ //INname= "models/players/jedi_tf/|head01_skin1|torso01|lower01";
if (strchr(INname, '|'))
{
char name[MAX_QPATH];
strcpy(name, INname);
char *p = strchr(name, '|');
*p=0;
p++;
//fill in the base path
strcpy (skinhead, name);
strcpy (skintorso, name);
strcpy (skinlower, name);
//now get the the individual files
//advance to second
char *p2 = strchr(p, '|');
assert(p2);
if (!p2)
{
return false;
}
*p2=0;
p2++;
strcat (skinhead, p);
strcat (skinhead, ".skin");
//advance to third
p = strchr(p2, '|');
assert(p);
if (!p)
{
return false;
}
*p=0;
p++;
strcat (skintorso,p2);
strcat (skintorso, ".skin");
strcat (skinlower,p);
strcat (skinlower, ".skin");
return true;
}
return false;
}
// given a name, go get the skin we want and return
qhandle_t RE_RegisterIndividualSkin( const char *name , qhandle_t hSkin)
{
skin_t *skin;
skinSurface_t *surf;
char *text, *text_p;
char *token;
char surfName[MAX_QPATH];
// load and parse the skin file
ri.FS_ReadFile( name, (void **)&text );
if ( !text ) {
#ifndef FINAL_BUILD
Com_Printf( "WARNING: RE_RegisterSkin( '%s' ) failed to load!\n", name );
#endif
return 0;
}
assert (tr.skins[hSkin]); //should already be setup, but might be an 3part append
skin = tr.skins[hSkin];
text_p = text;
while ( text_p && *text_p ) {
// get surface name
token = CommaParse( &text_p );
Q_strncpyz( surfName, token, sizeof( surfName ) );
if ( !token[0] ) {
break;
}
// lowercase the surface name so skin compares are faster
Q_strlwr( surfName );
if ( *text_p == ',' ) {
text_p++;
}
if ( !strncmp( token, "tag_", 4 ) ) { //these aren't in there, but just in case you load an id style one...
continue;
}
// parse the shader name
token = CommaParse( &text_p );
if ( !strcmp( &surfName[strlen(surfName)-4], "_off") )
{
if ( !strcmp( token ,"*off" ) )
{
continue; //don't need these double offs
}
surfName[strlen(surfName)-4] = 0; //remove the "_off"
}
if ((int)(sizeof( skin->surfaces) / sizeof( skin->surfaces[0] )) <= skin->numSurfaces)
{
assert( (int)(sizeof( skin->surfaces) / sizeof( skin->surfaces[0] )) > skin->numSurfaces );
Com_Printf( "WARNING: RE_RegisterSkin( '%s' ) more than %u surfaces!\n", name, (unsigned int)ARRAY_LEN(skin->surfaces) );
break;
}
surf = (skinSurface_t *) Hunk_Alloc( sizeof( *skin->surfaces[0] ), h_low );
skin->surfaces[skin->numSurfaces] = (_skinSurface_t *)surf;
Q_strncpyz( surf->name, surfName, sizeof( surf->name ) );
if (gServerSkinHack) surf->shader = R_FindServerShader( token, lightmapsNone, stylesDefault, qtrue );
else surf->shader = R_FindShader( token, lightmapsNone, stylesDefault, qtrue );
skin->numSurfaces++;
}
ri.FS_FreeFile( text );
// never let a skin have 0 shaders
if ( skin->numSurfaces == 0 ) {
return 0; // use default skin
}
return hSkin;
}
qhandle_t RE_RegisterSkin( const char *name ) {
qhandle_t hSkin;
skin_t *skin;
if ( !name || !name[0] ) {
Com_Printf( "Empty name passed to RE_RegisterSkin\n" );
return 0;
}
if ( strlen( name ) >= MAX_QPATH ) {
Com_Printf( "Skin name exceeds MAX_QPATH\n" );
return 0;
}
// see if the skin is already loaded
for ( hSkin = 1; hSkin < tr.numSkins ; hSkin++ ) {
skin = tr.skins[hSkin];
if ( !Q_stricmp( skin->name, name ) ) {
if( skin->numSurfaces == 0 ) {
return 0; // default skin
}
return hSkin;
}
}
// allocate a new skin
if ( tr.numSkins == MAX_SKINS ) {
Com_Printf( "WARNING: RE_RegisterSkin( '%s' ) MAX_SKINS hit\n", name );
return 0;
}
tr.numSkins++;
skin = (struct skin_s *)Hunk_Alloc( sizeof( skin_t ), h_low );
tr.skins[hSkin] = skin;
Q_strncpyz( skin->name, name, sizeof( skin->name ) );
skin->numSurfaces = 0;
// make sure the render thread is stopped
R_IssuePendingRenderCommands();
// If not a .skin file, load as a single shader
if ( strcmp( name + strlen( name ) - 5, ".skin" ) ) {
/* skin->numSurfaces = 1;
skin->surfaces[0] = (skinSurface_t *)Hunk_Alloc( sizeof(skin->surfaces[0]), h_low );
skin->surfaces[0]->shader = R_FindShader( name, lightmapsNone, stylesDefault, qtrue );
return hSkin;
*/
}
char skinhead[MAX_QPATH]={0};
char skintorso[MAX_QPATH]={0};
char skinlower[MAX_QPATH]={0};
if ( RE_SplitSkins(name, (char*)&skinhead, (char*)&skintorso, (char*)&skinlower ) )
{//three part
hSkin = RE_RegisterIndividualSkin(skinhead, hSkin);
if (hSkin)
{
hSkin = RE_RegisterIndividualSkin(skintorso, hSkin);
if (hSkin)
{
hSkin = RE_RegisterIndividualSkin(skinlower, hSkin);
}
}
}
else
{//single skin
hSkin = RE_RegisterIndividualSkin(name, hSkin);
}
return(hSkin);
}
/*
==================
CommaParse
This is unfortunate, but the skin files aren't
compatible with our normal parsing rules.
==================
*/
static char *CommaParse( char **data_p ) {
int c = 0, len;
char *data;
static char com_token[MAX_TOKEN_CHARS];
data = *data_p;
len = 0;
com_token[0] = 0;
// make sure incoming data is valid
if ( !data ) {
*data_p = NULL;
return com_token;
}
while ( 1 ) {
// skip whitespace
while( (c = *(const unsigned char* /*eurofix*/)data) <= ' ') {
if( !c ) {
break;
}
data++;
}
c = *data;
// skip double slash comments
if ( c == '/' && data[1] == '/' )
{
while (*data && *data != '\n')
data++;
}
// skip /* */ comments
else if ( c=='/' && data[1] == '*' )
{
while ( *data && ( *data != '*' || data[1] != '/' ) )
{
data++;
}
if ( *data )
{
data += 2;
}
}
else
{
break;
}
}
if ( c == 0 ) {
return "";
}
// handle quoted strings
if (c == '\"')
{
data++;
while (1)
{
c = *data++;
if (c=='\"' || !c)
{
com_token[len] = 0;
*data_p = ( char * ) data;
return com_token;
}
if (len < MAX_TOKEN_CHARS - 1)
{
com_token[len] = c;
len++;
}
}
}
// parse a regular word
do
{
if (len < MAX_TOKEN_CHARS - 1)
{
com_token[len] = c;
len++;
}
data++;
c = *data;
} while (c>32 && c != ',' );
com_token[len] = 0;
*data_p = ( char * ) data;
return com_token;
}
/*
===============
RE_RegisterServerSkin
Mangled version of the above function to load .skin files on the server.
===============
*/
qhandle_t RE_RegisterServerSkin( const char *name ) {
qhandle_t r;
if (ri.Cvar_VariableIntegerValue( "cl_running" ) &&
ri.Com_TheHunkMarkHasBeenMade() &&
ShaderHashTableExists())
{ //If the client is running then we can go straight into the normal registerskin func
return RE_RegisterSkin(name);
}
gServerSkinHack = true;
r = RE_RegisterSkin(name);
gServerSkinHack = false;
return r;
}
/*
===============
R_InitSkins
===============
*/
void R_InitSkins( void ) {
skin_t *skin;
tr.numSkins = 1;
// make the default skin have all default shaders
skin = tr.skins[0] = (struct skin_s *)ri.Hunk_Alloc( sizeof( skin_t ), h_low );
Q_strncpyz( skin->name, "<default skin>", sizeof( skin->name ) );
skin->numSurfaces = 1;
skin->surfaces[0] = (_skinSurface_t *)ri.Hunk_Alloc( sizeof( skinSurface_t ), h_low );
skin->surfaces[0]->shader = tr.defaultShader;
}
/*
===============
R_GetSkinByHandle
===============
*/
skin_t *R_GetSkinByHandle( qhandle_t hSkin ) {
if ( hSkin < 1 || hSkin >= tr.numSkins ) {
return tr.skins[0];
}
return tr.skins[ hSkin ];
}
| gpl-2.0 |
atmark-techno/atmark-dist | user/pppd/ppp-2.4.4/include/linux/ppp-comp.h | 9529 | /*
* ppp-comp.h - Definitions for doing PPP packet compression.
*
* Copyright (c) 1984 Paul Mackerras. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* 3. The name(s) of the authors of this software must not be used to
* endorse or promote products derived from this software without
* prior written permission.
*
* 4. Redistributions of any form whatsoever must retain the following
* acknowledgment:
* "This product includes software developed by Paul Mackerras
* <[email protected]>".
*
* THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO
* THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
* AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY
* SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
* AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
* OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
* $Id: ppp-comp.h,v 1.10 2002/12/06 09:49:15 paulus Exp $
*/
/*
* ==FILEVERSION 20020319==
*
* NOTE TO MAINTAINERS:
* If you modify this file at all, please set the above date.
* ppp-comp.h is shipped with a PPP distribution as well as with the kernel;
* if everyone increases the FILEVERSION number above, then scripts
* can do the right thing when deciding whether to install a new ppp-comp.h
* file. Don't change the format of that line otherwise, so the
* installation script can recognize it.
*/
#ifndef _NET_PPP_COMP_H
#define _NET_PPP_COMP_H
/*
* The following symbols control whether we include code for
* various compression methods.
*/
#ifndef DO_BSD_COMPRESS
#define DO_BSD_COMPRESS 1 /* by default, include BSD-Compress */
#endif
#ifndef DO_DEFLATE
#define DO_DEFLATE 1 /* by default, include Deflate */
#endif
#define DO_PREDICTOR_1 0
#define DO_PREDICTOR_2 0
/*
* Structure giving methods for compression/decompression.
*/
struct compressor {
int compress_proto; /* CCP compression protocol number */
/* Allocate space for a compressor (transmit side) */
void *(*comp_alloc) (unsigned char *options, int opt_len);
/* Free space used by a compressor */
void (*comp_free) (void *state);
/* Initialize a compressor */
int (*comp_init) (void *state, unsigned char *options,
int opt_len, int unit, int opthdr, int debug);
/* Reset a compressor */
void (*comp_reset) (void *state);
/* Compress a packet */
int (*compress) (void *state, unsigned char *rptr,
unsigned char *obuf, int isize, int osize);
/* Return compression statistics */
void (*comp_stat) (void *state, struct compstat *stats);
/* Allocate space for a decompressor (receive side) */
void *(*decomp_alloc) (unsigned char *options, int opt_len);
/* Free space used by a decompressor */
void (*decomp_free) (void *state);
/* Initialize a decompressor */
int (*decomp_init) (void *state, unsigned char *options,
int opt_len, int unit, int opthdr, int mru,
int debug);
/* Reset a decompressor */
void (*decomp_reset) (void *state);
/* Decompress a packet. */
int (*decompress) (void *state, unsigned char *ibuf, int isize,
unsigned char *obuf, int osize);
/* Update state for an incompressible packet received */
void (*incomp) (void *state, unsigned char *ibuf, int icnt);
/* Return decompression statistics */
void (*decomp_stat) (void *state, struct compstat *stats);
};
/*
* The return value from decompress routine is the length of the
* decompressed packet if successful, otherwise DECOMP_ERROR
* or DECOMP_FATALERROR if an error occurred.
*
* We need to make this distinction so that we can disable certain
* useful functionality, namely sending a CCP reset-request as a result
* of an error detected after decompression. This is to avoid infringing
* a patent held by Motorola.
* Don't you just lurve software patents.
*/
#define DECOMP_ERROR -1 /* error detected before decomp. */
#define DECOMP_FATALERROR -2 /* error detected after decomp. */
/*
* CCP codes.
*/
#define CCP_CONFREQ 1
#define CCP_CONFACK 2
#define CCP_TERMREQ 5
#define CCP_TERMACK 6
#define CCP_RESETREQ 14
#define CCP_RESETACK 15
/*
* Max # bytes for a CCP option
*/
#define CCP_MAX_OPTION_LENGTH 32
/*
* Parts of a CCP packet.
*/
#define CCP_CODE(dp) ((dp)[0])
#define CCP_ID(dp) ((dp)[1])
#define CCP_LENGTH(dp) (((dp)[2] << 8) + (dp)[3])
#define CCP_HDRLEN 4
#define CCP_OPT_CODE(dp) ((dp)[0])
#define CCP_OPT_LENGTH(dp) ((dp)[1])
#define CCP_OPT_MINLEN 2
/*
* Definitions for BSD-Compress.
*/
#define CI_BSD_COMPRESS 21 /* config. option for BSD-Compress */
#define CILEN_BSD_COMPRESS 3 /* length of config. option */
/* Macros for handling the 3rd byte of the BSD-Compress config option. */
#define BSD_NBITS(x) ((x) & 0x1F) /* number of bits requested */
#define BSD_VERSION(x) ((x) >> 5) /* version of option format */
#define BSD_CURRENT_VERSION 1 /* current version number */
#define BSD_MAKE_OPT(v, n) (((v) << 5) | (n))
#define BSD_MIN_BITS 9 /* smallest code size supported */
#define BSD_MAX_BITS 15 /* largest code size supported */
/*
* Definitions for Deflate.
*/
#define CI_DEFLATE 26 /* config option for Deflate */
#define CI_DEFLATE_DRAFT 24 /* value used in original draft RFC */
#define CILEN_DEFLATE 4 /* length of its config option */
#define DEFLATE_MIN_SIZE 8
#define DEFLATE_MAX_SIZE 15
#define DEFLATE_METHOD_VAL 8
#define DEFLATE_SIZE(x) (((x) >> 4) + DEFLATE_MIN_SIZE)
#define DEFLATE_METHOD(x) ((x) & 0x0F)
#define DEFLATE_MAKE_OPT(w) ((((w) - DEFLATE_MIN_SIZE) << 4) \
+ DEFLATE_METHOD_VAL)
#define DEFLATE_CHK_SEQUENCE 0
/*
* Definitions for MPPE.
*/
#define CI_MPPE 18 /* config option for MPPE */
#define CILEN_MPPE 6 /* length of config option */
#define MPPE_PAD 4 /* MPPE growth per frame */
#define MPPE_MAX_KEY_LEN 16 /* largest key length (128-bit) */
/* option bits for ccp_options.mppe */
#define MPPE_OPT_40 0x01 /* 40 bit */
#define MPPE_OPT_128 0x02 /* 128 bit */
#define MPPE_OPT_STATEFUL 0x04 /* stateful mode */
/* unsupported opts */
#define MPPE_OPT_56 0x08 /* 56 bit */
#define MPPE_OPT_MPPC 0x10 /* MPPC compression */
#define MPPE_OPT_D 0x20 /* Unknown */
#define MPPE_OPT_UNSUPPORTED (MPPE_OPT_56|MPPE_OPT_MPPC|MPPE_OPT_D)
#define MPPE_OPT_UNKNOWN 0x40 /* Bits !defined in RFC 3078 were set */
/*
* This is not nice ... the alternative is a bitfield struct though.
* And unfortunately, we cannot share the same bits for the option
* names above since C and H are the same bit. We could do a u_int32
* but then we have to do a htonl() all the time and/or we still need
* to know which octet is which.
*/
#define MPPE_C_BIT 0x01 /* MPPC */
#define MPPE_D_BIT 0x10 /* Obsolete, usage unknown */
#define MPPE_L_BIT 0x20 /* 40-bit */
#define MPPE_S_BIT 0x40 /* 128-bit */
#define MPPE_M_BIT 0x80 /* 56-bit, not supported */
#define MPPE_H_BIT 0x01 /* Stateless (in a different byte) */
/* Does not include H bit; used for least significant octet only. */
#define MPPE_ALL_BITS (MPPE_D_BIT|MPPE_L_BIT|MPPE_S_BIT|MPPE_M_BIT|MPPE_H_BIT)
/* Build a CI from mppe opts (see RFC 3078) */
#define MPPE_OPTS_TO_CI(opts, ci) \
do { \
u_char *ptr = ci; /* u_char[4] */ \
\
/* H bit */ \
if (opts & MPPE_OPT_STATEFUL) \
*ptr++ = 0x0; \
else \
*ptr++ = MPPE_H_BIT; \
*ptr++ = 0; \
*ptr++ = 0; \
\
/* S,L bits */ \
*ptr = 0; \
if (opts & MPPE_OPT_128) \
*ptr |= MPPE_S_BIT; \
if (opts & MPPE_OPT_40) \
*ptr |= MPPE_L_BIT; \
/* M,D,C bits not supported */ \
} while (/* CONSTCOND */ 0)
/* The reverse of the above */
#define MPPE_CI_TO_OPTS(ci, opts) \
do { \
u_char *ptr = ci; /* u_char[4] */ \
\
opts = 0; \
\
/* H bit */ \
if (!(ptr[0] & MPPE_H_BIT)) \
opts |= MPPE_OPT_STATEFUL; \
\
/* S,L bits */ \
if (ptr[3] & MPPE_S_BIT) \
opts |= MPPE_OPT_128; \
if (ptr[3] & MPPE_L_BIT) \
opts |= MPPE_OPT_40; \
\
/* M,D,C bits */ \
if (ptr[3] & MPPE_M_BIT) \
opts |= MPPE_OPT_56; \
if (ptr[3] & MPPE_D_BIT) \
opts |= MPPE_OPT_D; \
if (ptr[3] & MPPE_C_BIT) \
opts |= MPPE_OPT_MPPC; \
\
/* Other bits */ \
if (ptr[0] & ~MPPE_H_BIT) \
opts |= MPPE_OPT_UNKNOWN; \
if (ptr[1] || ptr[2]) \
opts |= MPPE_OPT_UNKNOWN; \
if (ptr[3] & ~MPPE_ALL_BITS) \
opts |= MPPE_OPT_UNKNOWN; \
} while (/* CONSTCOND */ 0)
/*
* Definitions for other, as yet unsupported, compression methods.
*/
#define CI_PREDICTOR_1 1 /* config option for Predictor-1 */
#define CILEN_PREDICTOR_1 2 /* length of its config option */
#define CI_PREDICTOR_2 2 /* config option for Predictor-2 */
#define CILEN_PREDICTOR_2 2 /* length of its config option */
#ifdef __KERNEL__
extern int ppp_register_compressor(struct compressor *);
extern void ppp_unregister_compressor(struct compressor *);
#endif /* __KERNEL__ */
#endif /* _NET_PPP_COMP_H */
| gpl-2.0 |
xkollar/spacewalk | java/code/src/com/redhat/rhn/frontend/action/systems/sdc/SystemPendingEventsAction.java | 4067 | /**
* Copyright (c) 2012--2014 Red Hat, Inc.
*
* This software is licensed to you under the GNU General Public License,
* version 2 (GPLv2). There is NO WARRANTY for this software, express or
* implied, including the implied warranties of MERCHANTABILITY or FITNESS
* FOR A PARTICULAR PURPOSE. You should have received a copy of GPLv2
* along with this software; if not, see
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
*
* Red Hat trademarks are not licensed under GPLv2. No permission is
* granted to use or replicate Red Hat trademarks that are incorporated
* in this software or its documentation.
*/
package com.redhat.rhn.frontend.action.systems.sdc;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;
import com.redhat.rhn.common.db.datasource.DataResult;
import com.redhat.rhn.domain.rhnset.RhnSet;
import com.redhat.rhn.domain.server.Server;
import com.redhat.rhn.domain.user.User;
import com.redhat.rhn.frontend.dto.SystemPendingEventDto;
import com.redhat.rhn.frontend.struts.RequestContext;
import com.redhat.rhn.frontend.struts.RhnAction;
import com.redhat.rhn.frontend.struts.RhnHelper;
import com.redhat.rhn.frontend.struts.RhnListSetHelper;
import com.redhat.rhn.frontend.struts.StrutsDelegate;
import com.redhat.rhn.frontend.taglibs.list.ListTagHelper;
import com.redhat.rhn.frontend.taglibs.list.TagHelper;
import com.redhat.rhn.manager.rhnset.RhnSetDecl;
import com.redhat.rhn.manager.rhnset.RhnSetManager;
import com.redhat.rhn.manager.system.SystemManager;
/**
* SystemPendingEventsAction
* @version $Rev$
*/
public class SystemPendingEventsAction extends RhnAction {
/**
* {@inheritDoc}
*/
public ActionForward execute(ActionMapping mapping, ActionForm formIn,
HttpServletRequest request,
HttpServletResponse response) {
RequestContext context = new RequestContext(request);
Long sid = context.getRequiredParam("sid");
Server server = context.lookupAndBindServer();
User user = context.getCurrentUser();
Map<String, Object> params = makeParamMap(request);
params.put("sid", server.getId());
request.setAttribute(ListTagHelper.PARENT_URL, request.getRequestURI() +
"?sid=" + server.getId());
request.setAttribute("sid", sid);
RhnSet set = RhnSetDecl.PENDING_ACTIONS_TO_DELETE.get(user);
RhnListSetHelper helper = new RhnListSetHelper(request);
if (context.wasDispatched("system.event.pending.cancel")) {
helper.updateSet(set, RhnSetDecl.PENDING_ACTIONS_TO_DELETE.getLabel());
if (!set.isEmpty()) {
return getStrutsDelegate().forwardParams(
mapping.findForward("continue"), params);
}
RhnHelper.handleEmptySelection(request);
}
set.clear();
RhnSetManager.store(set);
DataResult<SystemPendingEventDto> result =
SystemManager.systemPendingEvents(sid, null);
if (ListTagHelper.getListAction(RequestContext.PAGE_LIST, request) != null) {
helper.execute(set, RequestContext.PAGE_LIST, result);
}
if (!set.isEmpty()) {
helper.syncSelections(set, result);
ListTagHelper.setSelectedAmount(RequestContext.PAGE_LIST,
set.size(), request);
}
ListTagHelper.bindSetDeclTo(RequestContext.PAGE_LIST,
RhnSetDecl.PENDING_ACTIONS_TO_DELETE, request);
TagHelper.bindElaboratorTo(RequestContext.PAGE_LIST,
result.getElaborator(), request);
params.put("isLocked", server.getLock() == null ? false : true);
request.setAttribute(RequestContext.PAGE_LIST, result);
return StrutsDelegate.getInstance().forwardParams(
mapping.findForward("default"), params);
}
}
| gpl-2.0 |
BPI-SINOVOIP/BPI-Mainline-kernel | linux-4.14/arch/x86/kernel/machine_kexec_32.c | 6942 | /*
* handle transition of Linux booting another kernel
* Copyright (C) 2002-2005 Eric Biederman <[email protected]>
*
* This source code is licensed under the GNU General Public License,
* Version 2. See the file COPYING for more details.
*/
#include <linux/mm.h>
#include <linux/kexec.h>
#include <linux/delay.h>
#include <linux/numa.h>
#include <linux/ftrace.h>
#include <linux/suspend.h>
#include <linux/gfp.h>
#include <linux/io.h>
#include <asm/pgtable.h>
#include <asm/pgalloc.h>
#include <asm/tlbflush.h>
#include <asm/mmu_context.h>
#include <asm/apic.h>
#include <asm/io_apic.h>
#include <asm/cpufeature.h>
#include <asm/desc.h>
#include <asm/set_memory.h>
#include <asm/debugreg.h>
static void set_gdt(void *newgdt, __u16 limit)
{
struct desc_ptr curgdt;
/* ia32 supports unaligned loads & stores */
curgdt.size = limit;
curgdt.address = (unsigned long)newgdt;
load_gdt(&curgdt);
}
static void load_segments(void)
{
#define __STR(X) #X
#define STR(X) __STR(X)
__asm__ __volatile__ (
"\tljmp $"STR(__KERNEL_CS)",$1f\n"
"\t1:\n"
"\tmovl $"STR(__KERNEL_DS)",%%eax\n"
"\tmovl %%eax,%%ds\n"
"\tmovl %%eax,%%es\n"
"\tmovl %%eax,%%ss\n"
: : : "eax", "memory");
#undef STR
#undef __STR
}
static void machine_kexec_free_page_tables(struct kimage *image)
{
free_page((unsigned long)image->arch.pgd);
image->arch.pgd = NULL;
#ifdef CONFIG_X86_PAE
free_page((unsigned long)image->arch.pmd0);
image->arch.pmd0 = NULL;
free_page((unsigned long)image->arch.pmd1);
image->arch.pmd1 = NULL;
#endif
free_page((unsigned long)image->arch.pte0);
image->arch.pte0 = NULL;
free_page((unsigned long)image->arch.pte1);
image->arch.pte1 = NULL;
}
static int machine_kexec_alloc_page_tables(struct kimage *image)
{
image->arch.pgd = (pgd_t *)get_zeroed_page(GFP_KERNEL);
#ifdef CONFIG_X86_PAE
image->arch.pmd0 = (pmd_t *)get_zeroed_page(GFP_KERNEL);
image->arch.pmd1 = (pmd_t *)get_zeroed_page(GFP_KERNEL);
#endif
image->arch.pte0 = (pte_t *)get_zeroed_page(GFP_KERNEL);
image->arch.pte1 = (pte_t *)get_zeroed_page(GFP_KERNEL);
if (!image->arch.pgd ||
#ifdef CONFIG_X86_PAE
!image->arch.pmd0 || !image->arch.pmd1 ||
#endif
!image->arch.pte0 || !image->arch.pte1) {
return -ENOMEM;
}
return 0;
}
static void machine_kexec_page_table_set_one(
pgd_t *pgd, pmd_t *pmd, pte_t *pte,
unsigned long vaddr, unsigned long paddr)
{
p4d_t *p4d;
pud_t *pud;
pgd += pgd_index(vaddr);
#ifdef CONFIG_X86_PAE
if (!(pgd_val(*pgd) & _PAGE_PRESENT))
set_pgd(pgd, __pgd(__pa(pmd) | _PAGE_PRESENT));
#endif
p4d = p4d_offset(pgd, vaddr);
pud = pud_offset(p4d, vaddr);
pmd = pmd_offset(pud, vaddr);
if (!(pmd_val(*pmd) & _PAGE_PRESENT))
set_pmd(pmd, __pmd(__pa(pte) | _PAGE_TABLE));
pte = pte_offset_kernel(pmd, vaddr);
set_pte(pte, pfn_pte(paddr >> PAGE_SHIFT, PAGE_KERNEL_EXEC));
}
static void machine_kexec_prepare_page_tables(struct kimage *image)
{
void *control_page;
pmd_t *pmd = NULL;
control_page = page_address(image->control_code_page);
#ifdef CONFIG_X86_PAE
pmd = image->arch.pmd0;
#endif
machine_kexec_page_table_set_one(
image->arch.pgd, pmd, image->arch.pte0,
(unsigned long)control_page, __pa(control_page));
#ifdef CONFIG_X86_PAE
pmd = image->arch.pmd1;
#endif
machine_kexec_page_table_set_one(
image->arch.pgd, pmd, image->arch.pte1,
__pa(control_page), __pa(control_page));
}
/*
* A architecture hook called to validate the
* proposed image and prepare the control pages
* as needed. The pages for KEXEC_CONTROL_PAGE_SIZE
* have been allocated, but the segments have yet
* been copied into the kernel.
*
* Do what every setup is needed on image and the
* reboot code buffer to allow us to avoid allocations
* later.
*
* - Make control page executable.
* - Allocate page tables
* - Setup page tables
*/
int machine_kexec_prepare(struct kimage *image)
{
int error;
set_pages_x(image->control_code_page, 1);
error = machine_kexec_alloc_page_tables(image);
if (error)
return error;
machine_kexec_prepare_page_tables(image);
return 0;
}
/*
* Undo anything leftover by machine_kexec_prepare
* when an image is freed.
*/
void machine_kexec_cleanup(struct kimage *image)
{
set_pages_nx(image->control_code_page, 1);
machine_kexec_free_page_tables(image);
}
/*
* Do not allocate memory (or fail in any way) in machine_kexec().
* We are past the point of no return, committed to rebooting now.
*/
void machine_kexec(struct kimage *image)
{
unsigned long page_list[PAGES_NR];
void *control_page;
int save_ftrace_enabled;
asmlinkage unsigned long
(*relocate_kernel_ptr)(unsigned long indirection_page,
unsigned long control_page,
unsigned long start_address,
unsigned int has_pae,
unsigned int preserve_context);
#ifdef CONFIG_KEXEC_JUMP
if (image->preserve_context)
save_processor_state();
#endif
save_ftrace_enabled = __ftrace_enabled_save();
/* Interrupts aren't acceptable while we reboot */
local_irq_disable();
hw_breakpoint_disable();
if (image->preserve_context) {
#ifdef CONFIG_X86_IO_APIC
/*
* We need to put APICs in legacy mode so that we can
* get timer interrupts in second kernel. kexec/kdump
* paths already have calls to disable_IO_APIC() in
* one form or other. kexec jump path also need
* one.
*/
disable_IO_APIC();
#endif
}
control_page = page_address(image->control_code_page);
memcpy(control_page, relocate_kernel, KEXEC_CONTROL_CODE_MAX_SIZE);
relocate_kernel_ptr = control_page;
page_list[PA_CONTROL_PAGE] = __pa(control_page);
page_list[VA_CONTROL_PAGE] = (unsigned long)control_page;
page_list[PA_PGD] = __pa(image->arch.pgd);
if (image->type == KEXEC_TYPE_DEFAULT)
page_list[PA_SWAP_PAGE] = (page_to_pfn(image->swap_page)
<< PAGE_SHIFT);
/*
* The segment registers are funny things, they have both a
* visible and an invisible part. Whenever the visible part is
* set to a specific selector, the invisible part is loaded
* with from a table in memory. At no other time is the
* descriptor table in memory accessed.
*
* I take advantage of this here by force loading the
* segments, before I zap the gdt with an invalid value.
*/
load_segments();
/*
* The gdt & idt are now invalid.
* If you want to load them you must set up your own idt & gdt.
*/
idt_invalidate(phys_to_virt(0));
set_gdt(phys_to_virt(0), 0);
/* now call it */
image->start = relocate_kernel_ptr((unsigned long)image->head,
(unsigned long)page_list,
image->start,
boot_cpu_has(X86_FEATURE_PAE),
image->preserve_context);
#ifdef CONFIG_KEXEC_JUMP
if (image->preserve_context)
restore_processor_state();
#endif
__ftrace_enabled_restore(save_ftrace_enabled);
}
void arch_crash_save_vmcoreinfo(void)
{
#ifdef CONFIG_NUMA
VMCOREINFO_SYMBOL(node_data);
VMCOREINFO_LENGTH(node_data, MAX_NUMNODES);
#endif
#ifdef CONFIG_X86_PAE
VMCOREINFO_CONFIG(X86_PAE);
#endif
}
| gpl-2.0 |
md-5/jdk10 | test/hotspot/jtreg/vmTestbase/nsk/jvmti/GetThreadCpuTimerInfo/thrtimerinfo001.java | 3506 | /*
* Copyright (c) 2003, 2018, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package nsk.jvmti.GetThreadCpuTimerInfo;
import java.io.PrintStream;
import nsk.share.*;
import nsk.share.jvmti.*;
/** Debuggee class for this test. */
public class thrtimerinfo001 extends DebugeeClass {
/** Load native library if required. */
static {
loadLibrary("thrtimerinfo001");
}
/** Run test from command line. */
public static void main(String argv[]) {
argv = nsk.share.jvmti.JVMTITest.commonInit(argv);
// JCK-compatible exit
System.exit(run(argv, System.out) + Consts.JCK_STATUS_BASE);
}
/** Run test from JCK-compatible environment. */
public static int run(String argv[], PrintStream out) {
return new thrtimerinfo001().runIt(argv, out);
}
/* =================================================================== */
// scaffold objects
ArgumentHandler argHandler = null;
Log log = null;
long timeout = 0;
int status = Consts.TEST_PASSED;
/** Run debuggee. */
public int runIt(String argv[], PrintStream out) {
argHandler = new ArgumentHandler(argv);
log = new Log(out, argHandler);
timeout = argHandler.getWaitTime() * 60 * 1000; // milliseconds
thrtimerinfo001Thread thread = new thrtimerinfo001Thread("TestedThread");
// sync before thread started
log.display("Sync: tested thread created");
status = checkStatus(status);
// start and finish tested thread
try {
thread.start();
thread.join();
} catch (InterruptedException e) {
throw new Failure("Main thread interrupted while waiting for tested thread:\n\t"
+ e);
}
// sync after thread finished
log.display("Sync: tested thread started and finished");
status = checkStatus(status);
return status;
}
}
/* =================================================================== */
/** Class for tested thread. */
class thrtimerinfo001Thread extends Thread {
/** Make thread with specific name. */
public thrtimerinfo001Thread(String name) {
super(name);
}
/** Run some code. */
public void run() {
// do something
int n = 1000;
int s = 0;
for (int i = 0; i < n; i++) {
if (i % 2 == 0) {
s += i * 10;
} else {
s -= i * 10;
}
}
}
}
| gpl-2.0 |
dylex/android_external_busybox | runit/sv.c | 15818 | /*
Copyright (c) 2001-2006, Gerrit Pape
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. The name of the author may not be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/* Taken from http://smarden.sunsite.dk/runit/sv.8.html:
sv - control and manage services monitored by runsv
sv [-v] [-w sec] command services
/etc/init.d/service [-w sec] command
The sv program reports the current status and controls the state of services
monitored by the runsv(8) supervisor.
services consists of one or more arguments, each argument naming a directory
service used by runsv(8). If service doesn't start with a dot or slash,
it is searched in the default services directory /var/service/, otherwise
relative to the current directory.
command is one of up, down, status, once, pause, cont, hup, alarm, interrupt,
1, 2, term, kill, or exit, or start, stop, restart, shutdown, force-stop,
force-reload, force-restart, force-shutdown.
The sv program can be sym-linked to /etc/init.d/ to provide an LSB init
script interface. The service to be controlled then is specified by the
base name of the "init script".
status
Report the current status of the service, and the appendant log service
if available, to standard output.
up
If the service is not running, start it. If the service stops, restart it.
down
If the service is running, send it the TERM signal, and the CONT signal.
If ./run exits, start ./finish if it exists. After it stops, do not
restart service.
once
If the service is not running, start it. Do not restart it if it stops.
pause cont hup alarm interrupt quit 1 2 term kill
If the service is running, send it the STOP, CONT, HUP, ALRM, INT, QUIT,
USR1, USR2, TERM, or KILL signal respectively.
exit
If the service is running, send it the TERM signal, and the CONT signal.
Do not restart the service. If the service is down, and no log service
exists, runsv(8) exits. If the service is down and a log service exists,
send the TERM signal to the log service. If the log service is down,
runsv(8) exits. This command is ignored if it is given to an appendant
log service.
sv actually looks only at the first character of above commands.
Commands compatible to LSB init script actions:
status
Same as status.
start
Same as up, but wait up to 7 seconds for the command to take effect.
Then report the status or timeout. If the script ./check exists in
the service directory, sv runs this script to check whether the service
is up and available; it's considered to be available if ./check exits
with 0.
stop
Same as down, but wait up to 7 seconds for the service to become down.
Then report the status or timeout.
restart
Send the commands term, cont, and up to the service, and wait up to
7 seconds for the service to restart. Then report the status or timeout.
If the script ./check exists in the service directory, sv runs this script
to check whether the service is up and available again; it's considered
to be available if ./check exits with 0.
shutdown
Same as exit, but wait up to 7 seconds for the runsv(8) process
to terminate. Then report the status or timeout.
force-stop
Same as down, but wait up to 7 seconds for the service to become down.
Then report the status, and on timeout send the service the kill command.
force-reload
Send the service the term and cont commands, and wait up to
7 seconds for the service to restart. Then report the status,
and on timeout send the service the kill command.
force-restart
Send the service the term, cont and up commands, and wait up to
7 seconds for the service to restart. Then report the status, and
on timeout send the service the kill command. If the script ./check
exists in the service directory, sv runs this script to check whether
the service is up and available again; it's considered to be available
if ./check exits with 0.
force-shutdown
Same as exit, but wait up to 7 seconds for the runsv(8) process to
terminate. Then report the status, and on timeout send the service
the kill command.
Additional Commands
check
Check for the service to be in the state that's been requested. Wait up to
7 seconds for the service to reach the requested state, then report
the status or timeout. If the requested state of the service is up,
and the script ./check exists in the service directory, sv runs
this script to check whether the service is up and running;
it's considered to be up if ./check exits with 0.
Options
-v
wait up to 7 seconds for the command to take effect.
Then report the status or timeout.
-w sec
Override the default timeout of 7 seconds with sec seconds. Implies -v.
Environment
SVDIR
The environment variable $SVDIR overrides the default services directory
/var/service.
SVWAIT
The environment variable $SVWAIT overrides the default 7 seconds to wait
for a command to take effect. It is overridden by the -w option.
Exit Codes
sv exits 0, if the command was successfully sent to all services, and,
if it was told to wait, the command has taken effect to all services.
For each service that caused an error (e.g. the directory is not
controlled by a runsv(8) process, or sv timed out while waiting),
sv increases the exit code by one and exits non zero. The maximum
is 99. sv exits 100 on error.
*/
/* Busyboxed by Denys Vlasenko <[email protected]> */
/* TODO: depends on runit_lib.c - review and reduce/eliminate */
#include <sys/poll.h>
#include <sys/file.h>
#include "libbb.h"
#include "runit_lib.h"
struct globals {
const char *acts;
char **service;
unsigned rc;
/* "Bernstein" time format: unix + 0x400000000000000aULL */
uint64_t tstart, tnow;
svstatus_t svstatus;
};
#define G (*(struct globals*)&bb_common_bufsiz1)
#define acts (G.acts )
#define service (G.service )
#define rc (G.rc )
#define tstart (G.tstart )
#define tnow (G.tnow )
#define svstatus (G.svstatus )
#define INIT_G() do { } while (0)
static void fatal_cannot(const char *m1) NORETURN;
static void fatal_cannot(const char *m1)
{
bb_perror_msg("fatal: can't %s", m1);
_exit(151);
}
static void out(const char *p, const char *m1)
{
printf("%s%s: %s", p, *service, m1);
if (errno) {
printf(": %s", strerror(errno));
}
bb_putchar('\n'); /* will also flush the output */
}
#define WARN "warning: "
#define OK "ok: "
static void fail(const char *m1)
{
++rc;
out("fail: ", m1);
}
static void failx(const char *m1)
{
errno = 0;
fail(m1);
}
static void warn(const char *m1)
{
++rc;
/* "warning: <service>: <m1>\n" */
out("warning: ", m1);
}
static void ok(const char *m1)
{
errno = 0;
out(OK, m1);
}
static int svstatus_get(void)
{
int fd, r;
fd = open_write("supervise/ok");
if (fd == -1) {
if (errno == ENODEV) {
*acts == 'x' ? ok("runsv not running")
: failx("runsv not running");
return 0;
}
warn("can't open supervise/ok");
return -1;
}
close(fd);
fd = open_read("supervise/status");
if (fd == -1) {
warn("can't open supervise/status");
return -1;
}
r = read(fd, &svstatus, 20);
close(fd);
switch (r) {
case 20:
break;
case -1:
warn("can't read supervise/status");
return -1;
default:
errno = 0;
warn("can't read supervise/status: bad format");
return -1;
}
return 1;
}
static unsigned svstatus_print(const char *m)
{
int diff;
int pid;
int normallyup = 0;
struct stat s;
uint64_t timestamp;
if (stat("down", &s) == -1) {
if (errno != ENOENT) {
bb_perror_msg(WARN"can't stat %s/down", *service);
return 0;
}
normallyup = 1;
}
pid = SWAP_LE32(svstatus.pid_le32);
timestamp = SWAP_BE64(svstatus.time_be64);
if (pid) {
switch (svstatus.run_or_finish) {
case 1: printf("run: "); break;
case 2: printf("finish: "); break;
}
printf("%s: (pid %d) ", m, pid);
} else {
printf("down: %s: ", m);
}
diff = tnow - timestamp;
printf("%us", (diff < 0 ? 0 : diff));
if (pid) {
if (!normallyup) printf(", normally down");
if (svstatus.paused) printf(", paused");
if (svstatus.want == 'd') printf(", want down");
if (svstatus.got_term) printf(", got TERM");
} else {
if (normallyup) printf(", normally up");
if (svstatus.want == 'u') printf(", want up");
}
return pid ? 1 : 2;
}
static int status(const char *unused UNUSED_PARAM)
{
int r;
if (svstatus_get() <= 0)
return 0;
r = svstatus_print(*service);
if (chdir("log") == -1) {
if (errno != ENOENT) {
printf("; log: "WARN"can't change to log service directory: %s",
strerror(errno));
}
} else if (svstatus_get()) {
printf("; ");
svstatus_print("log");
}
bb_putchar('\n'); /* will also flush the output */
return r;
}
static int checkscript(void)
{
char *prog[2];
struct stat s;
int pid, w;
if (stat("check", &s) == -1) {
if (errno == ENOENT) return 1;
bb_perror_msg(WARN"can't stat %s/check", *service);
return 0;
}
/* if (!(s.st_mode & S_IXUSR)) return 1; */
prog[0] = (char*)"./check";
prog[1] = NULL;
pid = spawn(prog);
if (pid <= 0) {
bb_perror_msg(WARN"can't %s child %s/check", "run", *service);
return 0;
}
while (safe_waitpid(pid, &w, 0) == -1) {
bb_perror_msg(WARN"can't %s child %s/check", "wait for", *service);
return 0;
}
return WEXITSTATUS(w) == 0;
}
static int check(const char *a)
{
int r;
unsigned pid_le32;
uint64_t timestamp;
r = svstatus_get();
if (r == -1)
return -1;
if (r == 0) {
if (*a == 'x')
return 1;
return -1;
}
pid_le32 = svstatus.pid_le32;
switch (*a) {
case 'x':
return 0;
case 'u':
if (!pid_le32 || svstatus.run_or_finish != 1) return 0;
if (!checkscript()) return 0;
break;
case 'd':
if (pid_le32) return 0;
break;
case 'c':
if (pid_le32 && !checkscript()) return 0;
break;
case 't':
if (!pid_le32 && svstatus.want == 'd') break;
timestamp = SWAP_BE64(svstatus.time_be64);
if ((tstart > timestamp) || !pid_le32 || svstatus.got_term || !checkscript())
return 0;
break;
case 'o':
timestamp = SWAP_BE64(svstatus.time_be64);
if ((!pid_le32 && tstart > timestamp) || (pid_le32 && svstatus.want != 'd'))
return 0;
}
printf(OK);
svstatus_print(*service);
bb_putchar('\n'); /* will also flush the output */
return 1;
}
static int control(const char *a)
{
int fd, r, l;
/* Is it an optimization?
It causes problems with "sv o SRV; ...; sv d SRV"
('d' is not passed to SRV because its .want == 'd'):
if (svstatus_get() <= 0)
return -1;
if (svstatus.want == *a)
return 0;
*/
fd = open_write("supervise/control");
if (fd == -1) {
if (errno != ENODEV)
warn("can't open supervise/control");
else
*a == 'x' ? ok("runsv not running") : failx("runsv not running");
return -1;
}
l = strlen(a);
r = write(fd, a, l);
close(fd);
if (r != l) {
warn("can't write to supervise/control");
return -1;
}
return 1;
}
int sv_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
int sv_main(int argc UNUSED_PARAM, char **argv)
{
unsigned opt;
char *x;
char *action;
const char *varservice = CONFIG_SV_DEFAULT_SERVICE_DIR;
unsigned waitsec = 7;
smallint kll = 0;
int verbose = 0;
int (*act)(const char*);
int (*cbk)(const char*);
int curdir;
INIT_G();
xfunc_error_retval = 100;
x = getenv("SVDIR");
if (x) varservice = x;
x = getenv("SVWAIT");
if (x) waitsec = xatou(x);
opt_complementary = "w+:vv"; /* -w N, -v is a counter */
opt = getopt32(argv, "w:v", &waitsec, &verbose);
argv += optind;
action = *argv++;
if (!action || !*argv) bb_show_usage();
tnow = time(NULL) + 0x400000000000000aULL;
tstart = tnow;
curdir = open_read(".");
if (curdir == -1)
fatal_cannot("open current directory");
act = &control;
acts = "s";
cbk = ✓
switch (*action) {
case 'x':
case 'e':
acts = "x";
if (!verbose) cbk = NULL;
break;
case 'X':
case 'E':
acts = "x";
kll = 1;
break;
case 'D':
acts = "d";
kll = 1;
break;
case 'T':
acts = "tc";
kll = 1;
break;
case 'c':
if (str_equal(action, "check")) {
act = NULL;
acts = "c";
break;
}
case 'u': case 'd': case 'o': case 't': case 'p': case 'h':
case 'a': case 'i': case 'k': case 'q': case '1': case '2':
action[1] = '\0';
acts = action;
if (!verbose) cbk = NULL;
break;
case 's':
if (str_equal(action, "shutdown")) {
acts = "x";
break;
}
if (str_equal(action, "start")) {
acts = "u";
break;
}
if (str_equal(action, "stop")) {
acts = "d";
break;
}
/* "status" */
act = &status;
cbk = NULL;
break;
case 'r':
if (str_equal(action, "restart")) {
acts = "tcu";
break;
}
bb_show_usage();
case 'f':
if (str_equal(action, "force-reload")) {
acts = "tc";
kll = 1;
break;
}
if (str_equal(action, "force-restart")) {
acts = "tcu";
kll = 1;
break;
}
if (str_equal(action, "force-shutdown")) {
acts = "x";
kll = 1;
break;
}
if (str_equal(action, "force-stop")) {
acts = "d";
kll = 1;
break;
}
default:
bb_show_usage();
}
service = argv;
while ((x = *service) != NULL) {
if (x[0] != '/' && x[0] != '.') {
if (chdir(varservice) == -1)
goto chdir_failed_0;
}
if (chdir(x) == -1) {
chdir_failed_0:
fail("can't change to service directory");
goto nullify_service_0;
}
if (act && (act(acts) == -1)) {
nullify_service_0:
*service = (char*) -1L; /* "dead" */
}
if (fchdir(curdir) == -1)
fatal_cannot("change to original directory");
service++;
}
if (cbk) while (1) {
int want_exit;
int diff;
diff = tnow - tstart;
service = argv;
want_exit = 1;
while ((x = *service) != NULL) {
if (x == (char*) -1L) /* "dead" */
goto next;
if (x[0] != '/' && x[0] != '.') {
if (chdir(varservice) == -1)
goto chdir_failed;
}
if (chdir(x) == -1) {
chdir_failed:
fail("can't change to service directory");
goto nullify_service;
}
if (cbk(acts) != 0)
goto nullify_service;
want_exit = 0;
if (diff >= waitsec) {
printf(kll ? "kill: " : "timeout: ");
if (svstatus_get() > 0) {
svstatus_print(x);
++rc;
}
bb_putchar('\n'); /* will also flush the output */
if (kll)
control("k");
nullify_service:
*service = (char*) -1L; /* "dead" */
}
if (fchdir(curdir) == -1)
fatal_cannot("change to original directory");
next:
service++;
}
if (want_exit) break;
usleep(420000);
tnow = time(NULL) + 0x400000000000000aULL;
}
return rc > 99 ? 99 : rc;
}
| gpl-2.0 |
dvh11er/mage-cheatcode | magento/app/code/core/Mage/Checkout/controllers/MultishippingController.php | 20321 | <?php
/**
* Magento
*
* NOTICE OF LICENSE
*
* This source file is subject to the Open Software License (OSL 3.0)
* that is bundled with this package in the file LICENSE.txt.
* It is also available through the world-wide-web at this URL:
* http://opensource.org/licenses/osl-3.0.php
* If you did not receive a copy of the license and are unable to
* obtain it through the world-wide-web, please send an email
* to [email protected] so we can send you a copy immediately.
*
* DISCLAIMER
*
* Do not edit or add to this file if you wish to upgrade Magento to newer
* versions in the future. If you wish to customize Magento for your
* needs please refer to http://www.magento.com for more information.
*
* @category Mage
* @package Mage_Checkout
* @copyright Copyright (c) 2006-2015 X.commerce, Inc. (http://www.magento.com)
* @license http://opensource.org/licenses/osl-3.0.php Open Software License (OSL 3.0)
*/
/**
* Multishipping checkout controller
*
* @author Magento Core Team <[email protected]>
*/
class Mage_Checkout_MultishippingController extends Mage_Checkout_Controller_Action
{
/**
* Retrieve checkout model
*
* @return Mage_Checkout_Model_Type_Multishipping
*/
protected function _getCheckout()
{
return Mage::getSingleton('checkout/type_multishipping');
}
/**
* Retrieve checkout state model
*
* @return Mage_Checkout_Model_Type_Multishipping_State
*/
protected function _getState()
{
return Mage::getSingleton('checkout/type_multishipping_state');
}
/**
* Retrieve checkout url heler
*
* @return Mage_Checkout_Helper_Url
*/
protected function _getHelper()
{
return Mage::helper('checkout/url');
}
/**
* Retrieve checkout session
*
* @return Mage_Checkout_Model_Session
*/
protected function _getCheckoutSession()
{
return Mage::getSingleton('checkout/session');
}
/**
* Action predispatch
*
* Check customer authentication for some actions
*
* @return Mage_Checkout_MultishippingController
*/
public function preDispatch()
{
parent::preDispatch();
if ($this->getFlag('', 'redirectLogin')) {
return $this;
}
$action = strtolower($this->getRequest()->getActionName());
$checkoutSessionQuote = $this->_getCheckoutSession()->getQuote();
/**
* Catch index action call to set some flags before checkout/type_multishipping model initialization
*/
if ($action == 'index') {
$checkoutSessionQuote->setIsMultiShipping(true);
$this->_getCheckoutSession()->setCheckoutState(
Mage_Checkout_Model_Session::CHECKOUT_STATE_BEGIN
);
} elseif (!$checkoutSessionQuote->getIsMultiShipping() &&
!in_array($action, array('login', 'register', 'success'))
) {
$this->_redirect('*/*/index');
$this->setFlag('', self::FLAG_NO_DISPATCH, true);
return $this;
}
if (!in_array($action, array('login', 'register'))) {
if (!Mage::getSingleton('customer/session')->authenticate($this, $this->_getHelper()->getMSLoginUrl())) {
$this->setFlag('', self::FLAG_NO_DISPATCH, true);
}
if (!Mage::helper('checkout')->isMultishippingCheckoutAvailable()) {
$error = $this->_getCheckout()->getMinimumAmountError();
$this->_getCheckoutSession()->addError($error);
$this->_redirectUrl($this->_getHelper()->getCartUrl());
$this->setFlag('', self::FLAG_NO_DISPATCH, true);
return $this;
}
}
if (!$this->_preDispatchValidateCustomer()) {
return $this;
}
if ($this->_getCheckoutSession()->getCartWasUpdated(true) &&
!in_array($action, array('index', 'login', 'register', 'addresses', 'success'))
) {
$this->_redirectUrl($this->_getHelper()->getCartUrl());
$this->setFlag('', self::FLAG_NO_DISPATCH, true);
}
if ($action == 'success' && $this->_getCheckout()->getCheckoutSession()->getDisplaySuccess(true)) {
return $this;
}
$quote = $this->_getCheckout()->getQuote();
if (!$quote->hasItems() || $quote->getHasError() || $quote->isVirtual()) {
$this->_redirectUrl($this->_getHelper()->getCartUrl());
$this->setFlag('', self::FLAG_NO_DISPATCH, true);
return;
}
return $this;
}
/**
* Index action of Multishipping checkout
*/
public function indexAction()
{
$this->_getCheckoutSession()->setCartWasUpdated(false);
$this->_redirect('*/*/addresses');
}
/**
* Multishipping checkout login page
*/
public function loginAction()
{
if (Mage::getSingleton('customer/session')->isLoggedIn()) {
$this->_redirect('*/*/');
return;
}
$this->loadLayout();
$this->_initLayoutMessages('customer/session');
// set account create url
if ($loginForm = $this->getLayout()->getBlock('customer_form_login')) {
$loginForm->setCreateAccountUrl($this->_getHelper()->getMSRegisterUrl());
}
$this->renderLayout();
}
/**
* Multishipping checkout login page
*/
public function registerAction()
{
if (Mage::getSingleton('customer/session')->isLoggedIn()) {
$this->_redirectUrl($this->_getHelper()->getMSCheckoutUrl());
return;
}
$this->loadLayout();
$this->_initLayoutMessages('customer/session');
if ($registerForm = $this->getLayout()->getBlock('customer_form_register')) {
$registerForm->setShowAddressFields(true)
->setBackUrl($this->_getHelper()->getMSLoginUrl())
->setSuccessUrl($this->_getHelper()->getMSShippingAddressSavedUrl())
->setErrorUrl($this->_getHelper()->getCurrentUrl());
}
$this->renderLayout();
}
/**
* Multishipping checkout select address page
*/
public function addressesAction()
{
// If customer do not have addresses
if (!$this->_getCheckout()->getCustomerDefaultShippingAddress()) {
$this->_redirect('*/multishipping_address/newShipping');
return;
}
$this->_getState()->unsCompleteStep(
Mage_Checkout_Model_Type_Multishipping_State::STEP_SHIPPING
);
$this->_getState()->setActiveStep(
Mage_Checkout_Model_Type_Multishipping_State::STEP_SELECT_ADDRESSES
);
if (!$this->_getCheckout()->validateMinimumAmount()) {
$message = $this->_getCheckout()->getMinimumAmountDescription();
$this->_getCheckout()->getCheckoutSession()->addNotice($message);
}
$this->loadLayout();
$this->_initLayoutMessages('customer/session');
$this->_initLayoutMessages('checkout/session');
$this->renderLayout();
}
/**
* Multishipping checkout process posted addresses
*/
public function addressesPostAction()
{
if (!$this->_getCheckout()->getCustomerDefaultShippingAddress()) {
$this->_redirect('*/multishipping_address/newShipping');
return;
}
try {
if ($this->getRequest()->getParam('continue', false)) {
$this->_getCheckout()->setCollectRatesFlag(true);
$this->_getState()->setActiveStep(
Mage_Checkout_Model_Type_Multishipping_State::STEP_SHIPPING
);
$this->_getState()->setCompleteStep(
Mage_Checkout_Model_Type_Multishipping_State::STEP_SELECT_ADDRESSES
);
$this->_redirect('*/*/shipping');
}
elseif ($this->getRequest()->getParam('new_address')) {
$this->_redirect('*/multishipping_address/newShipping');
}
else {
$this->_redirect('*/*/addresses');
}
if ($shipToInfo = $this->getRequest()->getPost('ship')) {
$this->_getCheckout()->setShippingItemsInformation($shipToInfo);
}
}
catch (Mage_Core_Exception $e) {
$this->_getCheckoutSession()->addError($e->getMessage());
$this->_redirect('*/*/addresses');
}
catch (Exception $e) {
$this->_getCheckoutSession()->addException(
$e,
Mage::helper('checkout')->__('Data saving problem')
);
$this->_redirect('*/*/addresses');
}
}
/**
* Multishipping checkout action to go back to addresses page
*/
public function backToAddressesAction()
{
$this->_getState()->setActiveStep(
Mage_Checkout_Model_Type_Multishipping_State::STEP_SELECT_ADDRESSES
);
$this->_getState()->unsCompleteStep(
Mage_Checkout_Model_Type_Multishipping_State::STEP_SHIPPING
);
$this->_redirect('*/*/addresses');
}
/**
* Multishipping checkout remove item action
*/
public function removeItemAction()
{
$itemId = $this->getRequest()->getParam('id');
$addressId = $this->getRequest()->getParam('address');
if ($addressId && $itemId) {
$this->_getCheckout()->setCollectRatesFlag(true);
$this->_getCheckout()->removeAddressItem($addressId, $itemId);
}
$this->_redirect('*/*/addresses');
}
/**
* Returns whether the minimum amount has been reached
*
* @return bool
*/
protected function _validateMinimumAmount()
{
if (!$this->_getCheckout()->validateMinimumAmount()) {
$error = $this->_getCheckout()->getMinimumAmountError();
$this->_getCheckout()->getCheckoutSession()->addError($error);
$this->_forward('backToAddresses');
return false;
}
return true;
}
/**
* Multishipping checkout shipping information page
*/
public function shippingAction()
{
if (!$this->_validateMinimumAmount()) {
return;
}
if (!$this->_getState()->getCompleteStep(Mage_Checkout_Model_Type_Multishipping_State::STEP_SELECT_ADDRESSES)) {
$this->_redirect('*/*/addresses');
return $this;
}
$this->_getState()->setActiveStep(
Mage_Checkout_Model_Type_Multishipping_State::STEP_SHIPPING
);
$this->loadLayout();
$this->_initLayoutMessages('customer/session');
$this->_initLayoutMessages('checkout/session');
$this->renderLayout();
}
/**
* Multishipping checkout action to go back to shipping
*/
public function backToShippingAction()
{
$this->_getState()->setActiveStep(
Mage_Checkout_Model_Type_Multishipping_State::STEP_SHIPPING
);
$this->_getState()->unsCompleteStep(
Mage_Checkout_Model_Type_Multishipping_State::STEP_BILLING
);
$this->_redirect('*/*/shipping');
}
/**
* Multishipping checkout after the shipping page
*/
public function shippingPostAction()
{
$shippingMethods = $this->getRequest()->getPost('shipping_method');
try {
Mage::dispatchEvent(
'checkout_controller_multishipping_shipping_post',
array('request'=>$this->getRequest(), 'quote'=>$this->_getCheckout()->getQuote())
);
$this->_getCheckout()->setShippingMethods($shippingMethods);
$this->_getState()->setActiveStep(
Mage_Checkout_Model_Type_Multishipping_State::STEP_BILLING
);
$this->_getState()->setCompleteStep(
Mage_Checkout_Model_Type_Multishipping_State::STEP_SHIPPING
);
$this->_redirect('*/*/billing');
}
catch (Exception $e) {
$this->_getCheckoutSession()->addError($e->getMessage());
$this->_redirect('*/*/shipping');
}
}
/**
* Multishipping checkout billing information page
*/
public function billingAction()
{
$collectTotals = false;
$quote = $this->_getCheckoutSession()->getQuote();
/**
* Reset customer balance
*/
if ($quote->getUseCustomerBalance()) {
$quote->setUseCustomerBalance(false);
$collectTotals = true;
}
/**
* Reset reward points
*/
if ($quote->getUseRewardPoints()) {
$quote->setUseRewardPoints(false);
$collectTotals = true;
}
if ($collectTotals) {
$quote->collectTotals()->save();
}
if (!$this->_validateBilling()) {
return;
}
if (!$this->_validateMinimumAmount()) {
return;
}
if (!$this->_getState()->getCompleteStep(Mage_Checkout_Model_Type_Multishipping_State::STEP_SHIPPING)) {
$this->_redirect('*/*/shipping');
return $this;
}
$this->_getState()->setActiveStep(
Mage_Checkout_Model_Type_Multishipping_State::STEP_BILLING
);
$this->loadLayout();
$this->_initLayoutMessages('customer/session');
$this->_initLayoutMessages('checkout/session');
$this->renderLayout();
}
/**
* Validation of selecting of billing address
*
* @return boolean
*/
protected function _validateBilling()
{
if(!$this->_getCheckout()->getQuote()->getBillingAddress()->getFirstname()) {
$this->_redirect('*/multishipping_address/selectBilling');
return false;
}
return true;
}
/**
* Multishipping checkout action to go back to billing
*/
public function backToBillingAction()
{
$this->_getState()->setActiveStep(
Mage_Checkout_Model_Type_Multishipping_State::STEP_BILLING
);
$this->_getState()->unsCompleteStep(
Mage_Checkout_Model_Type_Multishipping_State::STEP_OVERVIEW
);
$this->_redirect('*/*/billing');
}
/**
* Multishipping checkout place order page
*/
public function overviewAction()
{
if (!$this->_validateMinimumAmount()) {
return $this;
}
$this->_getState()->setActiveStep(Mage_Checkout_Model_Type_Multishipping_State::STEP_OVERVIEW);
try {
$payment = $this->getRequest()->getPost('payment', array());
$payment['checks'] = Mage_Payment_Model_Method_Abstract::CHECK_USE_FOR_MULTISHIPPING
| Mage_Payment_Model_Method_Abstract::CHECK_USE_FOR_COUNTRY
| Mage_Payment_Model_Method_Abstract::CHECK_USE_FOR_CURRENCY
| Mage_Payment_Model_Method_Abstract::CHECK_ORDER_TOTAL_MIN_MAX
| Mage_Payment_Model_Method_Abstract::CHECK_ZERO_TOTAL;
$this->_getCheckout()->setPaymentMethod($payment);
$this->_getState()->setCompleteStep(
Mage_Checkout_Model_Type_Multishipping_State::STEP_BILLING
);
$this->loadLayout();
$this->_initLayoutMessages('checkout/session');
$this->_initLayoutMessages('customer/session');
$this->renderLayout();
}
catch (Mage_Core_Exception $e) {
$this->_getCheckoutSession()->addError($e->getMessage());
$this->_redirect('*/*/billing');
}
catch (Exception $e) {
Mage::logException($e);
$this->_getCheckoutSession()->addException($e, $this->__('Cannot open the overview page'));
$this->_redirect('*/*/billing');
}
}
/**
* Multishipping checkout after the overview page
*/
public function overviewPostAction()
{
if (!$this->_validateFormKey()) {
$this->_forward('backToAddresses');
return;
}
if (!$this->_validateMinimumAmount()) {
return;
}
try {
if ($requiredAgreements = Mage::helper('checkout')->getRequiredAgreementIds()) {
$postedAgreements = array_keys($this->getRequest()->getPost('agreement', array()));
if ($diff = array_diff($requiredAgreements, $postedAgreements)) {
$this->_getCheckoutSession()->addError($this->__('Please agree to all Terms and Conditions before placing the order.'));
$this->_redirect('*/*/billing');
return;
}
}
$payment = $this->getRequest()->getPost('payment');
$paymentInstance = $this->_getCheckout()->getQuote()->getPayment();
if (isset($payment['cc_number'])) {
$paymentInstance->setCcNumber($payment['cc_number']);
}
if (isset($payment['cc_cid'])) {
$paymentInstance->setCcCid($payment['cc_cid']);
}
$this->_getCheckout()->createOrders();
$this->_getState()->setActiveStep(
Mage_Checkout_Model_Type_Multishipping_State::STEP_SUCCESS
);
$this->_getState()->setCompleteStep(
Mage_Checkout_Model_Type_Multishipping_State::STEP_OVERVIEW
);
$this->_getCheckout()->getCheckoutSession()->clear();
$this->_getCheckout()->getCheckoutSession()->setDisplaySuccess(true);
$this->_redirect('*/*/success');
} catch (Mage_Payment_Model_Info_Exception $e) {
$message = $e->getMessage();
if ( !empty($message) ) {
$this->_getCheckoutSession()->addError($message);
}
$this->_redirect('*/*/billing');
} catch (Mage_Checkout_Exception $e) {
Mage::helper('checkout')
->sendPaymentFailedEmail($this->_getCheckout()->getQuote(), $e->getMessage(), 'multi-shipping');
$this->_getCheckout()->getCheckoutSession()->clear();
$this->_getCheckoutSession()->addError($e->getMessage());
$this->_redirect('*/cart');
}
catch (Mage_Core_Exception $e) {
Mage::helper('checkout')
->sendPaymentFailedEmail($this->_getCheckout()->getQuote(), $e->getMessage(), 'multi-shipping');
$this->_getCheckoutSession()->addError($e->getMessage());
$this->_redirect('*/*/billing');
} catch (Exception $e) {
Mage::logException($e);
Mage::helper('checkout')
->sendPaymentFailedEmail($this->_getCheckout()->getQuote(), $e->getMessage(), 'multi-shipping');
$this->_getCheckoutSession()->addError($this->__('Order place error.'));
$this->_redirect('*/*/billing');
}
}
/**
* Multishipping checkout success page
*/
public function successAction()
{
if (!$this->_getState()->getCompleteStep(Mage_Checkout_Model_Type_Multishipping_State::STEP_OVERVIEW)) {
$this->_redirect('*/*/addresses');
return $this;
}
$this->loadLayout();
$this->_initLayoutMessages('checkout/session');
$ids = $this->_getCheckout()->getOrderIds();
Mage::dispatchEvent('checkout_multishipping_controller_success_action', array('order_ids' => $ids));
$this->renderLayout();
}
/**
* Redirect to login page
*/
public function redirectLogin()
{
$this->setFlag('', 'no-dispatch', true);
Mage::getSingleton('customer/session')->setBeforeAuthUrl(Mage::getUrl('*/*', array('_secure'=>true)));
$this->getResponse()->setRedirect(
Mage::helper('core/url')->addRequestParam(
$this->_getHelper()->getMSLoginUrl(),
array('context' => 'checkout')
)
);
$this->setFlag('', 'redirectLogin', true);
}
}
| gpl-2.0 |
eGovCologne/od-cologne | sites/all/libraries/Leaflet/debug/map/image-overlay.html | 1330 | <!DOCTYPE html>
<html>
<head>
<title>Leaflet debug page</title>
<link rel="stylesheet" href="../../dist/leaflet.css" />
<!--[if lte IE 8]><link rel="stylesheet" href="../../dist/leaflet.ie.css" /><![endif]-->
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<link rel="stylesheet" href="../css/screen.css" />
<script type="text/javascript" src="../../build/deps.js"></script>
<script src="../leaflet-include.js"></script>
</head>
<body>
<div id="map"></div>
<button id="populate">Populate with 10 markers</button>
<script type="text/javascript">
var cloudmadeUrl = 'http://{s}.tile.cloudmade.com/BC9A493B41014CAABB98F0471D759707/997/256/{z}/{x}/{y}.png',
cloudmadeAttribution = 'Map data © 2011 OpenStreetMap contributors, Imagery © 2011 CloudMade',
cloudmade = new L.TileLayer(cloudmadeUrl, {maxZoom: 18, attribution: cloudmadeAttribution}),
latlng = new L.LatLng(50.5, 30.51);
var map = new L.Map('map');
map.addLayer(cloudmade);
var bounds = new L.LatLngBounds(
new L.LatLng(40.71222,-74.22655),
new L.LatLng(40.77394,-74.12544));
map.fitBounds(bounds);
var overlay = new L.ImageOverlay("https://www.lib.utexas.edu/maps/historical/newark_nj_1922.jpg", bounds, {
opacity: 0.5
});
map.addLayer(overlay);
</script>
</body>
</html>
| gpl-2.0 |
cory-ko/KBWS | gsoap/Symbian/interop2test.cpp | 11395 | //===================================================================================
//
// (C) COPYRIGHT International Business Machines Corp., 2002 All Rights Reserved
// Licensed Materials - Property of IBM
// US Government Users Restricted Rights - Use, duplication or
// disclosure restricted by GSA ADP Schedule Contract with IBM Corp.
//
// IBM DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
// ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE. IN NO EVENT SHALL IBM BE LIABLE FOR ANY SPECIAL, INDIRECT OR
// CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF
// USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
// OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE
// OR PERFORMANCE OF THIS SOFTWARE.
//
// The program may be used, executed, copied, modified, and distributed
// without royalty for the purpose of developing, using, marketing, or distributing.
//
//=======================================================================================
// gSOAP v2 Interop test round 2 base
//#include "interoptA.h"
#include "soapH.h"
extern "C" void displayText(char *text);
extern "C" int interopA(const char *url);
struct Namespace namespacesA[] =
{ {"SOAP-ENV", "http://schemas.xmlsoap.org/soap/envelope/"},
{"SOAP-ENC", "http://schemas.xmlsoap.org/soap/encoding/"},
{"xsi", "http://www.w3.org/2001/XMLSchema-instance", "http://www.w3.org/*/XMLSchema-instance"},
{"xsd", "http://www.w3.org/2001/XMLSchema", "http://www.w3.org/*/XMLSchema"},
{"ns", "http://soapinterop.org/"},
{"s", "http://soapinterop.org/xsd"},
{"a", "http://xml.apache.org/xml-soap"},
{"h", "http://soapinterop.org/echoheader/"},
{NULL, NULL}
};
int interopA(const char *url)
{
struct soap *soap;
int i, g;
xsd__string so, si = "Hello World! <>&";
struct ArrayOfstring Asi, Aso;
xsd__int no, ni = 1234567890;
xsd__int n = 2147483647;
struct ArrayOfint Ani, Ano;
// xsd__float f1 = 3.40282e+38;
xsd__float f1 = 123.5678;
xsd__float f2 = 3.14;
xsd__float fo, fi = 123.456;
// xsd__float fo, fi = 3e2;
//#ifdef SYMBIAN
// const struct soap_double_nan { unsigned int n1, n2; } soap_double_nan;
//#endif
xsd__float nan = FLT_NAN, inf = FLT_PINFTY, ninf = FLT_NINFTY;
struct ArrayOffloat Afi, Afo;
struct s__SOAPStruct sti, *p;
struct ns__echoStructResponse sto;
struct ArrayOfSOAPStruct Asti, Asto;
struct ns__echoVoidResponse Rv;
struct xsd__base64Binary b64i, b64o;
xsd__dateTime dto, dti = "1967-12-29T01:02:03";
struct xsd__hexBinary hbi, hbo;
xsd__decimal Do, Di = "1234567890.123456789";
xsd__boolean bo, bi = true;
//struct a__Map mi, mo;
//struct ArrayOfMap Ami, Amo;
// char buff[100];
displayText("running test A on");
displayText((char*)url);
soap = soap_new();
soap->namespaces = (struct Namespace *)namespacesA;
// soap.send_timeout = 30;
// soap.recv_timeout = 30;
Asi.__size = 8;
Asi.__offset = 0;
Asi.__ptr = (xsd__string*)malloc(Asi.__size*sizeof(xsd__string));
Asi.__ptr[0] = NULL;
Asi.__ptr[1] = " Hello\tWorld";
Asi.__ptr[2] = NULL;
Asi.__ptr[3] = "! ";
Asi.__ptr[4] = NULL;
Asi.__ptr[5] = si;
Asi.__ptr[6] = NULL;
Asi.__ptr[7] = si;
Ani.__size = 0;
Ani.__offset = 0;
Ani.__ptr = NULL; // (xsd__int*)malloc(Ani.__size*sizeof(xsd__int));
Afi.__size = 5;
Afi.__offset = 0;
Afi.__ptr = (xsd__float**)malloc(Afi.__size*sizeof(xsd__float*));
Afi.__ptr[0] = &f1;
Afi.__ptr[1] = &nan; // FLT_NAN;
Afi.__ptr[2] = &inf; // FLT_PINFTY;
Afi.__ptr[3] = &ninf; // FLT_NINFTY;
Afi.__ptr[4] = &f2;
sti.varString = "Hello";
sti.varInt = &n;
sti.varFloat = &f1;
Asti.__size = 3;
Asti.__offset = 2;
Asti.__ptr = (struct s__SOAPStruct**)malloc((Asti.__size+1)*sizeof(struct s__SOAPStruct*));
p = (struct s__SOAPStruct*)malloc(Asti.__size*sizeof(struct s__SOAPStruct));
Asti.__ptr[0] = p;
Asti.__ptr[1] = p+1;
Asti.__ptr[2] = p+2;
Asti.__ptr[3] = p;
Asti.__ptr[0]->varString = "Hello";
Asti.__ptr[0]->varInt = &n;
Asti.__ptr[0]->varFloat = &f1;
Asti.__ptr[1]->varString = "World";
Asti.__ptr[1]->varInt = &n;
Asti.__ptr[1]->varFloat = &f2;
Asti.__ptr[2]->varString = "!";
Asti.__ptr[2]->varInt = &n;
Asti.__ptr[2]->varFloat = &f2;
// b64i.__ptr = (unsigned char*)"This is an example Base64 encoded string";
// b64i.__size = strlen((char*)b64i.__ptr)+1;
unsigned char b64data[4]={0x80, 0x81, 0x82, 0x83};
b64i.__ptr = b64data;
b64i.__size = 4;
hbi.__ptr = (unsigned char*)"This is an example HexBinary encoded string";
hbi.__size = strlen((char*)hbi.__ptr)+1;
/*
mi.__size = 2;
mi.__ptr = (struct _item*)malloc(mi.__size*sizeof(struct _item));
mi.__ptr[0].key = new xsd__string_("hello");
mi.__ptr[0].value = new xsd__string_("world");
mi.__ptr[1].key = new xsd__int_(2);
mi.__ptr[1].value = new xsd__boolean_(true);
Ami.__size = 2;
Ami.__ptr = (struct a__Map**)malloc(Ami.__size*sizeof(struct a__Map*));
Ami.__ptr[0] = &mi;
Ami.__ptr[1] = &mi; */
char *site=(char*)url;
// char* site ="http://websrv.cs.fsu.edu/~engelen/interop2.cgi";
// char* site = "http://nagoya.apache.org:5049/axis/services/echo ";
char* action = "http://soapinterop.org/";
bool ok=true;
if (soap_call_ns__echoString(soap, site, action, si, so))
{
displayText("echoString fail");
ok=false;
}
else if (!so || strcmp(si, so))
{
ok=false;
displayText("echoString mismatched");
}
else
displayText("echoString pass");
if (soap_call_ns__echoInteger(soap, site, "http://soapinterop.org/", ni, no))
{
ok=false;
displayText("echoInteger fail");
}
else if (ni != no)
{
ok=false;
displayText("echoInteger mismatched");
}
else
displayText("echoInteger pass");
if (soap_call_ns__echoFloat(soap, site, "http://soapinterop.org/", fi, fo))
{
ok=false;
displayText("echoFloat fail");
}
else if (fi != fo)
{
ok=false;
displayText("echoFloat mismatched");
}
else
displayText("echoFloat pass");
if (soap_call_ns__echoStruct(soap, site, "http://soapinterop.org/", sti, sto))
{
ok=false;
displayText("echoStruct fail");
}
else if (!sto._return.varString || strcmp(sti.varString, sto._return.varString)
|| !sto._return.varInt || *sti.varInt != *sto._return.varInt
|| !sto._return.varFloat || *sti.varFloat != *sto._return.varFloat)
{
ok=false;
displayText("echoStruct mismatch");
}
else
displayText("echoStruct pass");
if (soap_call_ns__echoStringArray(soap, site, "http://soapinterop.org/", Asi, Aso))
{
soap_set_fault(soap);
soap_faultdetail(soap);
ok=false;
displayText("echoStringArray fail");
}
else
{ g = 0;
if (Asi.__size != Aso.__size)
g = 1;
else
for (i = 0; i < Asi.__size; i++)
if (Asi.__ptr[i] && Aso.__ptr[i] && strcmp(Asi.__ptr[i], Aso.__ptr[i]))
g = 1;
else if (!Asi.__ptr[i])
;
else if (Asi.__ptr[i] && !Aso.__ptr[i])
g = 1;
if (g)
{
ok=false;
displayText("echoStringArray mismatch");
}
else
displayText("echoStringArray pass");
}
if (soap_call_ns__echoIntegerArray(soap, site, "http://soapinterop.org/", Ani, Ano))
{ displayText("echoIntegerArray fail");
ok=false;
}
else
{ g = 0;
if (Ani.__size != Ano.__size)
g = 1;
else
for (i = 0; i < Ani.__size; i++)
if (Ani.__ptr[i] && (!Ano.__ptr[i] || *Ani.__ptr[i] != *Ano.__ptr[i]))
g = 1;
if (g)
{ displayText("echoIntegerArray mismatch");
ok=false;
}
else
displayText("echoIntegerArray pass");
}
if (soap_call_ns__echoFloatArray(soap, site, "http://soapinterop.org/", Afi, Afo))
{ displayText("echoFloatArray fail");
ok=false;
}
else
{ g = 0;
if (Afi.__size != Afo.__size)
g = 1;
else
for (i = 0; i < Afi.__size; i++)
if (Afi.__ptr[i] && Afo.__ptr[i] && soap_isnan(*Afi.__ptr[i]) && soap_isnan(*Afo.__ptr[i]))
;
else if (Afi.__ptr[i] && (!Afo.__ptr[i] || *Afi.__ptr[i] != *Afo.__ptr[i]))
g = 1;
if (g)
{ displayText("echoFloatArray mismatch");
ok=false;
}
else
displayText("echoFloatArray pass");
}
if (soap_call_ns__echoStructArray(soap, site, "http://soapinterop.org/", Asti, Asto))
{ displayText("echoStructArray fail");
ok=false;
}
else
{ g = 0;
if (Asti.__size+Asti.__offset != Asto.__size+Asto.__offset)
g = 1;
else
for (i = Asti.__offset; i < Asti.__size+Asti.__offset; i++)
if (!Asto.__ptr[i-Asto.__offset] ||
!Asto.__ptr[i-Asto.__offset]->varString ||
strcmp(Asti.__ptr[i-Asti.__offset]->varString, Asto.__ptr[i-Asto.__offset]->varString) ||
!Asto.__ptr[i-Asto.__offset]->varInt ||
*Asti.__ptr[i-Asti.__offset]->varInt != *Asto.__ptr[i-Asto.__offset]->varInt ||
!Asto.__ptr[i-Asto.__offset]->varFloat ||
*Asti.__ptr[i-Asti.__offset]->varFloat != *Asto.__ptr[i-Asto.__offset]->varFloat)
g = 1;
if (g)
{ displayText("echoStructArray mismatch");
ok=false;
}
else
displayText("echoStructArray pass");
}
if (soap_call_ns__echoVoid(soap, site, "http://soapinterop.org/", Rv))
{ displayText("echoVoid fail");
ok=false;
}
else
displayText("echoVoid pass");
if (soap_call_ns__echoBase64(soap, site, "http://soapinterop.org/", b64i, b64o))
{ displayText("echoBase64 fail");
ok=false;
}
else if ((b64i.__size+2)/3 != (b64o.__size+2)/3 || strncmp((char*)b64i.__ptr, (char*)b64o.__ptr,b64i.__size))
{
displayText("echoBase64 mismatch");
ok=false;
}
else
displayText("echoBase64 pass");
if (soap_call_ns__echoDate(soap, site, "http://soapinterop.org/", dti, dto))
{
displayText("echoDate fail");
ok=false;
}
else if (!dto || strncmp(dti, dto, 19))
{
displayText("echoDate mismatch");
ok=false;
}
else
displayText("echoDate pass");
if (soap_call_ns__echoHexBinary(soap, site, "http://soapinterop.org/", hbi, hbo))
{
ok=false;
displayText("echoHexBinary fail");
}
else if (hbi.__size != hbo.__size || strcmp((char*)hbi.__ptr, (char*)hbo.__ptr))
{
ok=false;
displayText("echoHexBinary mismatch");
}
else
displayText("echoHexBinary pass");
if (soap_call_ns__echoDecimal(soap, site, "http://soapinterop.org/", Di, Do))
{
ok=false;
displayText("echoDecimal pass");
}
else if (strcmp(Di, Do))
{
ok=false;
displayText("echoDecimal mismatch");
}
else
displayText("echoDecimal pass");
if (soap_call_ns__echoBoolean(soap, site, "http://soapinterop.org/", bi, bo))
{
ok=false;
displayText("echoBoolean fail");
}
else if (bi != bo)
{
ok=false;
displayText("echoBoolean mismatch");
}
else
displayText("echoBoolean pass");
if (ok)
displayText("ALL PASS");
else
displayText("FAILURES");
return 0;
end:
return 1;
}
| gpl-2.0 |
perryjrandall/arsenalsuite | cpp/lib/classes/base/shotgroupbase.cpp | 1325 | /*
*
* Copyright 2003, 2004 Blur Studio Inc.
*
* This file is part of the Resin software package.
*
* Resin is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* Resin is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Resin; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
#ifndef COMMIT_CODE
#include <qdir.h>
#include <stdlib.h>
#include "shotgroup.h"
int ShotGroup::frameStart() const
{
return shots()[shots().count()-1].frameStart();
}
int ShotGroup::frameEnd() const
{
return shots()[0].frameEnd();
}
int ShotGroup::frameStartEDL() const
{
return shots()[shots().count()-1].frameStartEDL();
}
int ShotGroup::frameEndEDL() const
{
return shots()[0].frameEndEDL();
}
ShotList ShotGroup::shots() const
{
ShotList shots = children( Shot::type(), true );
return shots;
}
#endif
| gpl-2.0 |
Gurgel100/gcc | gcc/testsuite/gcc.dg/vect/pr88598-3.c | 948 | /* { dg-additional-options "-ffast-math -fdump-tree-optimized" } */
#include "tree-vect.h"
#define N 4
float a[N];
float __attribute__ ((noipa))
f1 (void)
{
float b[N] = { 1, 0, 0, 0 }, res = 0;
for (int i = 0; i < N; ++i)
res += a[i] * b[i];
return res;
}
float __attribute__ ((noipa))
f2 (void)
{
float b[N] = { 0, 1, 0, 0 }, res = 0;
for (int i = 0; i < N; ++i)
res += a[i] * b[i];
return res;
}
float __attribute__ ((noipa))
f3 (void)
{
float b[N] = { 0, 0, 0, 1 }, res = 0;
for (int i = 0; i < N; ++i)
res += a[i] * b[i];
return res;
}
int
main ()
{
check_vect ();
for (int i = 0; i < N; ++i)
a[i] = 0xe0 + i;
if (f1 () != a[0]
|| f2 () != a[1]
|| f3 () != a[N - 1])
__builtin_abort ();
return 0;
}
/* ??? We need more constant folding for this to work with fully-masked
loops. */
/* { dg-final { scan-tree-dump-not {REDUC_PLUS} "optimized" { xfail aarch64_sve } } } */
| gpl-2.0 |
kronat/linux | mm/mempolicy.c | 73162 | /*
* Simple NUMA memory policy for the Linux kernel.
*
* Copyright 2003,2004 Andi Kleen, SuSE Labs.
* (C) Copyright 2005 Christoph Lameter, Silicon Graphics, Inc.
* Subject to the GNU Public License, version 2.
*
* NUMA policy allows the user to give hints in which node(s) memory should
* be allocated.
*
* Support four policies per VMA and per process:
*
* The VMA policy has priority over the process policy for a page fault.
*
* interleave Allocate memory interleaved over a set of nodes,
* with normal fallback if it fails.
* For VMA based allocations this interleaves based on the
* offset into the backing object or offset into the mapping
* for anonymous memory. For process policy an process counter
* is used.
*
* bind Only allocate memory on a specific set of nodes,
* no fallback.
* FIXME: memory is allocated starting with the first node
* to the last. It would be better if bind would truly restrict
* the allocation to memory nodes instead
*
* preferred Try a specific node first before normal fallback.
* As a special case NUMA_NO_NODE here means do the allocation
* on the local CPU. This is normally identical to default,
* but useful to set in a VMA when you have a non default
* process policy.
*
* default Allocate on the local node first, or when on a VMA
* use the process policy. This is what Linux always did
* in a NUMA aware kernel and still does by, ahem, default.
*
* The process policy is applied for most non interrupt memory allocations
* in that process' context. Interrupts ignore the policies and always
* try to allocate on the local CPU. The VMA policy is only applied for memory
* allocations for a VMA in the VM.
*
* Currently there are a few corner cases in swapping where the policy
* is not applied, but the majority should be handled. When process policy
* is used it is not remembered over swap outs/swap ins.
*
* Only the highest zone in the zone hierarchy gets policied. Allocations
* requesting a lower zone just use default policy. This implies that
* on systems with highmem kernel lowmem allocation don't get policied.
* Same with GFP_DMA allocations.
*
* For shmfs/tmpfs/hugetlbfs shared memory the policy is shared between
* all users and remembered even when nobody has memory mapped.
*/
/* Notebook:
fix mmap readahead to honour policy and enable policy for any page cache
object
statistics for bigpages
global policy for page cache? currently it uses process policy. Requires
first item above.
handle mremap for shared memory (currently ignored for the policy)
grows down?
make bind policy root only? It can trigger oom much faster and the
kernel is not always grateful with that.
*/
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
#include <linux/mempolicy.h>
#include <linux/mm.h>
#include <linux/highmem.h>
#include <linux/hugetlb.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/sched/mm.h>
#include <linux/sched/numa_balancing.h>
#include <linux/sched/task.h>
#include <linux/nodemask.h>
#include <linux/cpuset.h>
#include <linux/slab.h>
#include <linux/string.h>
#include <linux/export.h>
#include <linux/nsproxy.h>
#include <linux/interrupt.h>
#include <linux/init.h>
#include <linux/compat.h>
#include <linux/ptrace.h>
#include <linux/swap.h>
#include <linux/seq_file.h>
#include <linux/proc_fs.h>
#include <linux/migrate.h>
#include <linux/ksm.h>
#include <linux/rmap.h>
#include <linux/security.h>
#include <linux/syscalls.h>
#include <linux/ctype.h>
#include <linux/mm_inline.h>
#include <linux/mmu_notifier.h>
#include <linux/printk.h>
#include <linux/swapops.h>
#include <asm/tlbflush.h>
#include <linux/uaccess.h>
#include "internal.h"
/* Internal flags */
#define MPOL_MF_DISCONTIG_OK (MPOL_MF_INTERNAL << 0) /* Skip checks for continuous vmas */
#define MPOL_MF_INVERT (MPOL_MF_INTERNAL << 1) /* Invert check for nodemask */
static struct kmem_cache *policy_cache;
static struct kmem_cache *sn_cache;
/* Highest zone. An specific allocation for a zone below that is not
policied. */
enum zone_type policy_zone = 0;
/*
* run-time system-wide default policy => local allocation
*/
static struct mempolicy default_policy = {
.refcnt = ATOMIC_INIT(1), /* never free it */
.mode = MPOL_PREFERRED,
.flags = MPOL_F_LOCAL,
};
static struct mempolicy preferred_node_policy[MAX_NUMNODES];
struct mempolicy *get_task_policy(struct task_struct *p)
{
struct mempolicy *pol = p->mempolicy;
int node;
if (pol)
return pol;
node = numa_node_id();
if (node != NUMA_NO_NODE) {
pol = &preferred_node_policy[node];
/* preferred_node_policy is not initialised early in boot */
if (pol->mode)
return pol;
}
return &default_policy;
}
static const struct mempolicy_operations {
int (*create)(struct mempolicy *pol, const nodemask_t *nodes);
void (*rebind)(struct mempolicy *pol, const nodemask_t *nodes);
} mpol_ops[MPOL_MAX];
static inline int mpol_store_user_nodemask(const struct mempolicy *pol)
{
return pol->flags & MPOL_MODE_FLAGS;
}
static void mpol_relative_nodemask(nodemask_t *ret, const nodemask_t *orig,
const nodemask_t *rel)
{
nodemask_t tmp;
nodes_fold(tmp, *orig, nodes_weight(*rel));
nodes_onto(*ret, tmp, *rel);
}
static int mpol_new_interleave(struct mempolicy *pol, const nodemask_t *nodes)
{
if (nodes_empty(*nodes))
return -EINVAL;
pol->v.nodes = *nodes;
return 0;
}
static int mpol_new_preferred(struct mempolicy *pol, const nodemask_t *nodes)
{
if (!nodes)
pol->flags |= MPOL_F_LOCAL; /* local allocation */
else if (nodes_empty(*nodes))
return -EINVAL; /* no allowed nodes */
else
pol->v.preferred_node = first_node(*nodes);
return 0;
}
static int mpol_new_bind(struct mempolicy *pol, const nodemask_t *nodes)
{
if (nodes_empty(*nodes))
return -EINVAL;
pol->v.nodes = *nodes;
return 0;
}
/*
* mpol_set_nodemask is called after mpol_new() to set up the nodemask, if
* any, for the new policy. mpol_new() has already validated the nodes
* parameter with respect to the policy mode and flags. But, we need to
* handle an empty nodemask with MPOL_PREFERRED here.
*
* Must be called holding task's alloc_lock to protect task's mems_allowed
* and mempolicy. May also be called holding the mmap_semaphore for write.
*/
static int mpol_set_nodemask(struct mempolicy *pol,
const nodemask_t *nodes, struct nodemask_scratch *nsc)
{
int ret;
/* if mode is MPOL_DEFAULT, pol is NULL. This is right. */
if (pol == NULL)
return 0;
/* Check N_MEMORY */
nodes_and(nsc->mask1,
cpuset_current_mems_allowed, node_states[N_MEMORY]);
VM_BUG_ON(!nodes);
if (pol->mode == MPOL_PREFERRED && nodes_empty(*nodes))
nodes = NULL; /* explicit local allocation */
else {
if (pol->flags & MPOL_F_RELATIVE_NODES)
mpol_relative_nodemask(&nsc->mask2, nodes, &nsc->mask1);
else
nodes_and(nsc->mask2, *nodes, nsc->mask1);
if (mpol_store_user_nodemask(pol))
pol->w.user_nodemask = *nodes;
else
pol->w.cpuset_mems_allowed =
cpuset_current_mems_allowed;
}
if (nodes)
ret = mpol_ops[pol->mode].create(pol, &nsc->mask2);
else
ret = mpol_ops[pol->mode].create(pol, NULL);
return ret;
}
/*
* This function just creates a new policy, does some check and simple
* initialization. You must invoke mpol_set_nodemask() to set nodes.
*/
static struct mempolicy *mpol_new(unsigned short mode, unsigned short flags,
nodemask_t *nodes)
{
struct mempolicy *policy;
pr_debug("setting mode %d flags %d nodes[0] %lx\n",
mode, flags, nodes ? nodes_addr(*nodes)[0] : NUMA_NO_NODE);
if (mode == MPOL_DEFAULT) {
if (nodes && !nodes_empty(*nodes))
return ERR_PTR(-EINVAL);
return NULL;
}
VM_BUG_ON(!nodes);
/*
* MPOL_PREFERRED cannot be used with MPOL_F_STATIC_NODES or
* MPOL_F_RELATIVE_NODES if the nodemask is empty (local allocation).
* All other modes require a valid pointer to a non-empty nodemask.
*/
if (mode == MPOL_PREFERRED) {
if (nodes_empty(*nodes)) {
if (((flags & MPOL_F_STATIC_NODES) ||
(flags & MPOL_F_RELATIVE_NODES)))
return ERR_PTR(-EINVAL);
}
} else if (mode == MPOL_LOCAL) {
if (!nodes_empty(*nodes) ||
(flags & MPOL_F_STATIC_NODES) ||
(flags & MPOL_F_RELATIVE_NODES))
return ERR_PTR(-EINVAL);
mode = MPOL_PREFERRED;
} else if (nodes_empty(*nodes))
return ERR_PTR(-EINVAL);
policy = kmem_cache_alloc(policy_cache, GFP_KERNEL);
if (!policy)
return ERR_PTR(-ENOMEM);
atomic_set(&policy->refcnt, 1);
policy->mode = mode;
policy->flags = flags;
return policy;
}
/* Slow path of a mpol destructor. */
void __mpol_put(struct mempolicy *p)
{
if (!atomic_dec_and_test(&p->refcnt))
return;
kmem_cache_free(policy_cache, p);
}
static void mpol_rebind_default(struct mempolicy *pol, const nodemask_t *nodes)
{
}
static void mpol_rebind_nodemask(struct mempolicy *pol, const nodemask_t *nodes)
{
nodemask_t tmp;
if (pol->flags & MPOL_F_STATIC_NODES)
nodes_and(tmp, pol->w.user_nodemask, *nodes);
else if (pol->flags & MPOL_F_RELATIVE_NODES)
mpol_relative_nodemask(&tmp, &pol->w.user_nodemask, nodes);
else {
nodes_remap(tmp, pol->v.nodes,pol->w.cpuset_mems_allowed,
*nodes);
pol->w.cpuset_mems_allowed = tmp;
}
if (nodes_empty(tmp))
tmp = *nodes;
pol->v.nodes = tmp;
}
static void mpol_rebind_preferred(struct mempolicy *pol,
const nodemask_t *nodes)
{
nodemask_t tmp;
if (pol->flags & MPOL_F_STATIC_NODES) {
int node = first_node(pol->w.user_nodemask);
if (node_isset(node, *nodes)) {
pol->v.preferred_node = node;
pol->flags &= ~MPOL_F_LOCAL;
} else
pol->flags |= MPOL_F_LOCAL;
} else if (pol->flags & MPOL_F_RELATIVE_NODES) {
mpol_relative_nodemask(&tmp, &pol->w.user_nodemask, nodes);
pol->v.preferred_node = first_node(tmp);
} else if (!(pol->flags & MPOL_F_LOCAL)) {
pol->v.preferred_node = node_remap(pol->v.preferred_node,
pol->w.cpuset_mems_allowed,
*nodes);
pol->w.cpuset_mems_allowed = *nodes;
}
}
/*
* mpol_rebind_policy - Migrate a policy to a different set of nodes
*
* Per-vma policies are protected by mmap_sem. Allocations using per-task
* policies are protected by task->mems_allowed_seq to prevent a premature
* OOM/allocation failure due to parallel nodemask modification.
*/
static void mpol_rebind_policy(struct mempolicy *pol, const nodemask_t *newmask)
{
if (!pol)
return;
if (!mpol_store_user_nodemask(pol) &&
nodes_equal(pol->w.cpuset_mems_allowed, *newmask))
return;
mpol_ops[pol->mode].rebind(pol, newmask);
}
/*
* Wrapper for mpol_rebind_policy() that just requires task
* pointer, and updates task mempolicy.
*
* Called with task's alloc_lock held.
*/
void mpol_rebind_task(struct task_struct *tsk, const nodemask_t *new)
{
mpol_rebind_policy(tsk->mempolicy, new);
}
/*
* Rebind each vma in mm to new nodemask.
*
* Call holding a reference to mm. Takes mm->mmap_sem during call.
*/
void mpol_rebind_mm(struct mm_struct *mm, nodemask_t *new)
{
struct vm_area_struct *vma;
down_write(&mm->mmap_sem);
for (vma = mm->mmap; vma; vma = vma->vm_next)
mpol_rebind_policy(vma->vm_policy, new);
up_write(&mm->mmap_sem);
}
static const struct mempolicy_operations mpol_ops[MPOL_MAX] = {
[MPOL_DEFAULT] = {
.rebind = mpol_rebind_default,
},
[MPOL_INTERLEAVE] = {
.create = mpol_new_interleave,
.rebind = mpol_rebind_nodemask,
},
[MPOL_PREFERRED] = {
.create = mpol_new_preferred,
.rebind = mpol_rebind_preferred,
},
[MPOL_BIND] = {
.create = mpol_new_bind,
.rebind = mpol_rebind_nodemask,
},
};
static void migrate_page_add(struct page *page, struct list_head *pagelist,
unsigned long flags);
struct queue_pages {
struct list_head *pagelist;
unsigned long flags;
nodemask_t *nmask;
struct vm_area_struct *prev;
};
/*
* Check if the page's nid is in qp->nmask.
*
* If MPOL_MF_INVERT is set in qp->flags, check if the nid is
* in the invert of qp->nmask.
*/
static inline bool queue_pages_required(struct page *page,
struct queue_pages *qp)
{
int nid = page_to_nid(page);
unsigned long flags = qp->flags;
return node_isset(nid, *qp->nmask) == !(flags & MPOL_MF_INVERT);
}
static int queue_pages_pmd(pmd_t *pmd, spinlock_t *ptl, unsigned long addr,
unsigned long end, struct mm_walk *walk)
{
int ret = 0;
struct page *page;
struct queue_pages *qp = walk->private;
unsigned long flags;
if (unlikely(is_pmd_migration_entry(*pmd))) {
ret = 1;
goto unlock;
}
page = pmd_page(*pmd);
if (is_huge_zero_page(page)) {
spin_unlock(ptl);
__split_huge_pmd(walk->vma, pmd, addr, false, NULL);
goto out;
}
if (!queue_pages_required(page, qp)) {
ret = 1;
goto unlock;
}
ret = 1;
flags = qp->flags;
/* go to thp migration */
if (flags & (MPOL_MF_MOVE | MPOL_MF_MOVE_ALL))
migrate_page_add(page, qp->pagelist, flags);
unlock:
spin_unlock(ptl);
out:
return ret;
}
/*
* Scan through pages checking if pages follow certain conditions,
* and move them to the pagelist if they do.
*/
static int queue_pages_pte_range(pmd_t *pmd, unsigned long addr,
unsigned long end, struct mm_walk *walk)
{
struct vm_area_struct *vma = walk->vma;
struct page *page;
struct queue_pages *qp = walk->private;
unsigned long flags = qp->flags;
int ret;
pte_t *pte;
spinlock_t *ptl;
ptl = pmd_trans_huge_lock(pmd, vma);
if (ptl) {
ret = queue_pages_pmd(pmd, ptl, addr, end, walk);
if (ret)
return 0;
}
if (pmd_trans_unstable(pmd))
return 0;
pte = pte_offset_map_lock(walk->mm, pmd, addr, &ptl);
for (; addr != end; pte++, addr += PAGE_SIZE) {
if (!pte_present(*pte))
continue;
page = vm_normal_page(vma, addr, *pte);
if (!page)
continue;
/*
* vm_normal_page() filters out zero pages, but there might
* still be PageReserved pages to skip, perhaps in a VDSO.
*/
if (PageReserved(page))
continue;
if (!queue_pages_required(page, qp))
continue;
migrate_page_add(page, qp->pagelist, flags);
}
pte_unmap_unlock(pte - 1, ptl);
cond_resched();
return 0;
}
static int queue_pages_hugetlb(pte_t *pte, unsigned long hmask,
unsigned long addr, unsigned long end,
struct mm_walk *walk)
{
#ifdef CONFIG_HUGETLB_PAGE
struct queue_pages *qp = walk->private;
unsigned long flags = qp->flags;
struct page *page;
spinlock_t *ptl;
pte_t entry;
ptl = huge_pte_lock(hstate_vma(walk->vma), walk->mm, pte);
entry = huge_ptep_get(pte);
if (!pte_present(entry))
goto unlock;
page = pte_page(entry);
if (!queue_pages_required(page, qp))
goto unlock;
/* With MPOL_MF_MOVE, we migrate only unshared hugepage. */
if (flags & (MPOL_MF_MOVE_ALL) ||
(flags & MPOL_MF_MOVE && page_mapcount(page) == 1))
isolate_huge_page(page, qp->pagelist);
unlock:
spin_unlock(ptl);
#else
BUG();
#endif
return 0;
}
#ifdef CONFIG_NUMA_BALANCING
/*
* This is used to mark a range of virtual addresses to be inaccessible.
* These are later cleared by a NUMA hinting fault. Depending on these
* faults, pages may be migrated for better NUMA placement.
*
* This is assuming that NUMA faults are handled using PROT_NONE. If
* an architecture makes a different choice, it will need further
* changes to the core.
*/
unsigned long change_prot_numa(struct vm_area_struct *vma,
unsigned long addr, unsigned long end)
{
int nr_updated;
nr_updated = change_protection(vma, addr, end, PAGE_NONE, 0, 1);
if (nr_updated)
count_vm_numa_events(NUMA_PTE_UPDATES, nr_updated);
return nr_updated;
}
#else
static unsigned long change_prot_numa(struct vm_area_struct *vma,
unsigned long addr, unsigned long end)
{
return 0;
}
#endif /* CONFIG_NUMA_BALANCING */
static int queue_pages_test_walk(unsigned long start, unsigned long end,
struct mm_walk *walk)
{
struct vm_area_struct *vma = walk->vma;
struct queue_pages *qp = walk->private;
unsigned long endvma = vma->vm_end;
unsigned long flags = qp->flags;
if (!vma_migratable(vma))
return 1;
if (endvma > end)
endvma = end;
if (vma->vm_start > start)
start = vma->vm_start;
if (!(flags & MPOL_MF_DISCONTIG_OK)) {
if (!vma->vm_next && vma->vm_end < end)
return -EFAULT;
if (qp->prev && qp->prev->vm_end < vma->vm_start)
return -EFAULT;
}
qp->prev = vma;
if (flags & MPOL_MF_LAZY) {
/* Similar to task_numa_work, skip inaccessible VMAs */
if (!is_vm_hugetlb_page(vma) &&
(vma->vm_flags & (VM_READ | VM_EXEC | VM_WRITE)) &&
!(vma->vm_flags & VM_MIXEDMAP))
change_prot_numa(vma, start, endvma);
return 1;
}
/* queue pages from current vma */
if (flags & (MPOL_MF_MOVE | MPOL_MF_MOVE_ALL))
return 0;
return 1;
}
/*
* Walk through page tables and collect pages to be migrated.
*
* If pages found in a given range are on a set of nodes (determined by
* @nodes and @flags,) it's isolated and queued to the pagelist which is
* passed via @private.)
*/
static int
queue_pages_range(struct mm_struct *mm, unsigned long start, unsigned long end,
nodemask_t *nodes, unsigned long flags,
struct list_head *pagelist)
{
struct queue_pages qp = {
.pagelist = pagelist,
.flags = flags,
.nmask = nodes,
.prev = NULL,
};
struct mm_walk queue_pages_walk = {
.hugetlb_entry = queue_pages_hugetlb,
.pmd_entry = queue_pages_pte_range,
.test_walk = queue_pages_test_walk,
.mm = mm,
.private = &qp,
};
return walk_page_range(start, end, &queue_pages_walk);
}
/*
* Apply policy to a single VMA
* This must be called with the mmap_sem held for writing.
*/
static int vma_replace_policy(struct vm_area_struct *vma,
struct mempolicy *pol)
{
int err;
struct mempolicy *old;
struct mempolicy *new;
pr_debug("vma %lx-%lx/%lx vm_ops %p vm_file %p set_policy %p\n",
vma->vm_start, vma->vm_end, vma->vm_pgoff,
vma->vm_ops, vma->vm_file,
vma->vm_ops ? vma->vm_ops->set_policy : NULL);
new = mpol_dup(pol);
if (IS_ERR(new))
return PTR_ERR(new);
if (vma->vm_ops && vma->vm_ops->set_policy) {
err = vma->vm_ops->set_policy(vma, new);
if (err)
goto err_out;
}
old = vma->vm_policy;
vma->vm_policy = new; /* protected by mmap_sem */
mpol_put(old);
return 0;
err_out:
mpol_put(new);
return err;
}
/* Step 2: apply policy to a range and do splits. */
static int mbind_range(struct mm_struct *mm, unsigned long start,
unsigned long end, struct mempolicy *new_pol)
{
struct vm_area_struct *next;
struct vm_area_struct *prev;
struct vm_area_struct *vma;
int err = 0;
pgoff_t pgoff;
unsigned long vmstart;
unsigned long vmend;
vma = find_vma(mm, start);
if (!vma || vma->vm_start > start)
return -EFAULT;
prev = vma->vm_prev;
if (start > vma->vm_start)
prev = vma;
for (; vma && vma->vm_start < end; prev = vma, vma = next) {
next = vma->vm_next;
vmstart = max(start, vma->vm_start);
vmend = min(end, vma->vm_end);
if (mpol_equal(vma_policy(vma), new_pol))
continue;
pgoff = vma->vm_pgoff +
((vmstart - vma->vm_start) >> PAGE_SHIFT);
prev = vma_merge(mm, prev, vmstart, vmend, vma->vm_flags,
vma->anon_vma, vma->vm_file, pgoff,
new_pol, vma->vm_userfaultfd_ctx);
if (prev) {
vma = prev;
next = vma->vm_next;
if (mpol_equal(vma_policy(vma), new_pol))
continue;
/* vma_merge() joined vma && vma->next, case 8 */
goto replace;
}
if (vma->vm_start != vmstart) {
err = split_vma(vma->vm_mm, vma, vmstart, 1);
if (err)
goto out;
}
if (vma->vm_end != vmend) {
err = split_vma(vma->vm_mm, vma, vmend, 0);
if (err)
goto out;
}
replace:
err = vma_replace_policy(vma, new_pol);
if (err)
goto out;
}
out:
return err;
}
/* Set the process memory policy */
static long do_set_mempolicy(unsigned short mode, unsigned short flags,
nodemask_t *nodes)
{
struct mempolicy *new, *old;
NODEMASK_SCRATCH(scratch);
int ret;
if (!scratch)
return -ENOMEM;
new = mpol_new(mode, flags, nodes);
if (IS_ERR(new)) {
ret = PTR_ERR(new);
goto out;
}
task_lock(current);
ret = mpol_set_nodemask(new, nodes, scratch);
if (ret) {
task_unlock(current);
mpol_put(new);
goto out;
}
old = current->mempolicy;
current->mempolicy = new;
if (new && new->mode == MPOL_INTERLEAVE)
current->il_prev = MAX_NUMNODES-1;
task_unlock(current);
mpol_put(old);
ret = 0;
out:
NODEMASK_SCRATCH_FREE(scratch);
return ret;
}
/*
* Return nodemask for policy for get_mempolicy() query
*
* Called with task's alloc_lock held
*/
static void get_policy_nodemask(struct mempolicy *p, nodemask_t *nodes)
{
nodes_clear(*nodes);
if (p == &default_policy)
return;
switch (p->mode) {
case MPOL_BIND:
/* Fall through */
case MPOL_INTERLEAVE:
*nodes = p->v.nodes;
break;
case MPOL_PREFERRED:
if (!(p->flags & MPOL_F_LOCAL))
node_set(p->v.preferred_node, *nodes);
/* else return empty node mask for local allocation */
break;
default:
BUG();
}
}
static int lookup_node(unsigned long addr)
{
struct page *p;
int err;
err = get_user_pages(addr & PAGE_MASK, 1, 0, &p, NULL);
if (err >= 0) {
err = page_to_nid(p);
put_page(p);
}
return err;
}
/* Retrieve NUMA policy */
static long do_get_mempolicy(int *policy, nodemask_t *nmask,
unsigned long addr, unsigned long flags)
{
int err;
struct mm_struct *mm = current->mm;
struct vm_area_struct *vma = NULL;
struct mempolicy *pol = current->mempolicy;
if (flags &
~(unsigned long)(MPOL_F_NODE|MPOL_F_ADDR|MPOL_F_MEMS_ALLOWED))
return -EINVAL;
if (flags & MPOL_F_MEMS_ALLOWED) {
if (flags & (MPOL_F_NODE|MPOL_F_ADDR))
return -EINVAL;
*policy = 0; /* just so it's initialized */
task_lock(current);
*nmask = cpuset_current_mems_allowed;
task_unlock(current);
return 0;
}
if (flags & MPOL_F_ADDR) {
/*
* Do NOT fall back to task policy if the
* vma/shared policy at addr is NULL. We
* want to return MPOL_DEFAULT in this case.
*/
down_read(&mm->mmap_sem);
vma = find_vma_intersection(mm, addr, addr+1);
if (!vma) {
up_read(&mm->mmap_sem);
return -EFAULT;
}
if (vma->vm_ops && vma->vm_ops->get_policy)
pol = vma->vm_ops->get_policy(vma, addr);
else
pol = vma->vm_policy;
} else if (addr)
return -EINVAL;
if (!pol)
pol = &default_policy; /* indicates default behavior */
if (flags & MPOL_F_NODE) {
if (flags & MPOL_F_ADDR) {
err = lookup_node(addr);
if (err < 0)
goto out;
*policy = err;
} else if (pol == current->mempolicy &&
pol->mode == MPOL_INTERLEAVE) {
*policy = next_node_in(current->il_prev, pol->v.nodes);
} else {
err = -EINVAL;
goto out;
}
} else {
*policy = pol == &default_policy ? MPOL_DEFAULT :
pol->mode;
/*
* Internal mempolicy flags must be masked off before exposing
* the policy to userspace.
*/
*policy |= (pol->flags & MPOL_MODE_FLAGS);
}
err = 0;
if (nmask) {
if (mpol_store_user_nodemask(pol)) {
*nmask = pol->w.user_nodemask;
} else {
task_lock(current);
get_policy_nodemask(pol, nmask);
task_unlock(current);
}
}
out:
mpol_cond_put(pol);
if (vma)
up_read(¤t->mm->mmap_sem);
return err;
}
#ifdef CONFIG_MIGRATION
/*
* page migration, thp tail pages can be passed.
*/
static void migrate_page_add(struct page *page, struct list_head *pagelist,
unsigned long flags)
{
struct page *head = compound_head(page);
/*
* Avoid migrating a page that is shared with others.
*/
if ((flags & MPOL_MF_MOVE_ALL) || page_mapcount(head) == 1) {
if (!isolate_lru_page(head)) {
list_add_tail(&head->lru, pagelist);
mod_node_page_state(page_pgdat(head),
NR_ISOLATED_ANON + page_is_file_cache(head),
hpage_nr_pages(head));
}
}
}
/* page allocation callback for NUMA node migration */
struct page *alloc_new_node_page(struct page *page, unsigned long node)
{
if (PageHuge(page))
return alloc_huge_page_node(page_hstate(compound_head(page)),
node);
else if (PageTransHuge(page)) {
struct page *thp;
thp = alloc_pages_node(node,
(GFP_TRANSHUGE | __GFP_THISNODE),
HPAGE_PMD_ORDER);
if (!thp)
return NULL;
prep_transhuge_page(thp);
return thp;
} else
return __alloc_pages_node(node, GFP_HIGHUSER_MOVABLE |
__GFP_THISNODE, 0);
}
/*
* Migrate pages from one node to a target node.
* Returns error or the number of pages not migrated.
*/
static int migrate_to_node(struct mm_struct *mm, int source, int dest,
int flags)
{
nodemask_t nmask;
LIST_HEAD(pagelist);
int err = 0;
nodes_clear(nmask);
node_set(source, nmask);
/*
* This does not "check" the range but isolates all pages that
* need migration. Between passing in the full user address
* space range and MPOL_MF_DISCONTIG_OK, this call can not fail.
*/
VM_BUG_ON(!(flags & (MPOL_MF_MOVE | MPOL_MF_MOVE_ALL)));
queue_pages_range(mm, mm->mmap->vm_start, mm->task_size, &nmask,
flags | MPOL_MF_DISCONTIG_OK, &pagelist);
if (!list_empty(&pagelist)) {
err = migrate_pages(&pagelist, alloc_new_node_page, NULL, dest,
MIGRATE_SYNC, MR_SYSCALL);
if (err)
putback_movable_pages(&pagelist);
}
return err;
}
/*
* Move pages between the two nodesets so as to preserve the physical
* layout as much as possible.
*
* Returns the number of page that could not be moved.
*/
int do_migrate_pages(struct mm_struct *mm, const nodemask_t *from,
const nodemask_t *to, int flags)
{
int busy = 0;
int err;
nodemask_t tmp;
err = migrate_prep();
if (err)
return err;
down_read(&mm->mmap_sem);
/*
* Find a 'source' bit set in 'tmp' whose corresponding 'dest'
* bit in 'to' is not also set in 'tmp'. Clear the found 'source'
* bit in 'tmp', and return that <source, dest> pair for migration.
* The pair of nodemasks 'to' and 'from' define the map.
*
* If no pair of bits is found that way, fallback to picking some
* pair of 'source' and 'dest' bits that are not the same. If the
* 'source' and 'dest' bits are the same, this represents a node
* that will be migrating to itself, so no pages need move.
*
* If no bits are left in 'tmp', or if all remaining bits left
* in 'tmp' correspond to the same bit in 'to', return false
* (nothing left to migrate).
*
* This lets us pick a pair of nodes to migrate between, such that
* if possible the dest node is not already occupied by some other
* source node, minimizing the risk of overloading the memory on a
* node that would happen if we migrated incoming memory to a node
* before migrating outgoing memory source that same node.
*
* A single scan of tmp is sufficient. As we go, we remember the
* most recent <s, d> pair that moved (s != d). If we find a pair
* that not only moved, but what's better, moved to an empty slot
* (d is not set in tmp), then we break out then, with that pair.
* Otherwise when we finish scanning from_tmp, we at least have the
* most recent <s, d> pair that moved. If we get all the way through
* the scan of tmp without finding any node that moved, much less
* moved to an empty node, then there is nothing left worth migrating.
*/
tmp = *from;
while (!nodes_empty(tmp)) {
int s,d;
int source = NUMA_NO_NODE;
int dest = 0;
for_each_node_mask(s, tmp) {
/*
* do_migrate_pages() tries to maintain the relative
* node relationship of the pages established between
* threads and memory areas.
*
* However if the number of source nodes is not equal to
* the number of destination nodes we can not preserve
* this node relative relationship. In that case, skip
* copying memory from a node that is in the destination
* mask.
*
* Example: [2,3,4] -> [3,4,5] moves everything.
* [0-7] - > [3,4,5] moves only 0,1,2,6,7.
*/
if ((nodes_weight(*from) != nodes_weight(*to)) &&
(node_isset(s, *to)))
continue;
d = node_remap(s, *from, *to);
if (s == d)
continue;
source = s; /* Node moved. Memorize */
dest = d;
/* dest not in remaining from nodes? */
if (!node_isset(dest, tmp))
break;
}
if (source == NUMA_NO_NODE)
break;
node_clear(source, tmp);
err = migrate_to_node(mm, source, dest, flags);
if (err > 0)
busy += err;
if (err < 0)
break;
}
up_read(&mm->mmap_sem);
if (err < 0)
return err;
return busy;
}
/*
* Allocate a new page for page migration based on vma policy.
* Start by assuming the page is mapped by the same vma as contains @start.
* Search forward from there, if not. N.B., this assumes that the
* list of pages handed to migrate_pages()--which is how we get here--
* is in virtual address order.
*/
static struct page *new_page(struct page *page, unsigned long start)
{
struct vm_area_struct *vma;
unsigned long uninitialized_var(address);
vma = find_vma(current->mm, start);
while (vma) {
address = page_address_in_vma(page, vma);
if (address != -EFAULT)
break;
vma = vma->vm_next;
}
if (PageHuge(page)) {
return alloc_huge_page_vma(page_hstate(compound_head(page)),
vma, address);
} else if (PageTransHuge(page)) {
struct page *thp;
thp = alloc_hugepage_vma(GFP_TRANSHUGE, vma, address,
HPAGE_PMD_ORDER);
if (!thp)
return NULL;
prep_transhuge_page(thp);
return thp;
}
/*
* if !vma, alloc_page_vma() will use task or system default policy
*/
return alloc_page_vma(GFP_HIGHUSER_MOVABLE | __GFP_RETRY_MAYFAIL,
vma, address);
}
#else
static void migrate_page_add(struct page *page, struct list_head *pagelist,
unsigned long flags)
{
}
int do_migrate_pages(struct mm_struct *mm, const nodemask_t *from,
const nodemask_t *to, int flags)
{
return -ENOSYS;
}
static struct page *new_page(struct page *page, unsigned long start)
{
return NULL;
}
#endif
static long do_mbind(unsigned long start, unsigned long len,
unsigned short mode, unsigned short mode_flags,
nodemask_t *nmask, unsigned long flags)
{
struct mm_struct *mm = current->mm;
struct mempolicy *new;
unsigned long end;
int err;
LIST_HEAD(pagelist);
if (flags & ~(unsigned long)MPOL_MF_VALID)
return -EINVAL;
if ((flags & MPOL_MF_MOVE_ALL) && !capable(CAP_SYS_NICE))
return -EPERM;
if (start & ~PAGE_MASK)
return -EINVAL;
if (mode == MPOL_DEFAULT)
flags &= ~MPOL_MF_STRICT;
len = (len + PAGE_SIZE - 1) & PAGE_MASK;
end = start + len;
if (end < start)
return -EINVAL;
if (end == start)
return 0;
new = mpol_new(mode, mode_flags, nmask);
if (IS_ERR(new))
return PTR_ERR(new);
if (flags & MPOL_MF_LAZY)
new->flags |= MPOL_F_MOF;
/*
* If we are using the default policy then operation
* on discontinuous address spaces is okay after all
*/
if (!new)
flags |= MPOL_MF_DISCONTIG_OK;
pr_debug("mbind %lx-%lx mode:%d flags:%d nodes:%lx\n",
start, start + len, mode, mode_flags,
nmask ? nodes_addr(*nmask)[0] : NUMA_NO_NODE);
if (flags & (MPOL_MF_MOVE | MPOL_MF_MOVE_ALL)) {
err = migrate_prep();
if (err)
goto mpol_out;
}
{
NODEMASK_SCRATCH(scratch);
if (scratch) {
down_write(&mm->mmap_sem);
task_lock(current);
err = mpol_set_nodemask(new, nmask, scratch);
task_unlock(current);
if (err)
up_write(&mm->mmap_sem);
} else
err = -ENOMEM;
NODEMASK_SCRATCH_FREE(scratch);
}
if (err)
goto mpol_out;
err = queue_pages_range(mm, start, end, nmask,
flags | MPOL_MF_INVERT, &pagelist);
if (!err)
err = mbind_range(mm, start, end, new);
if (!err) {
int nr_failed = 0;
if (!list_empty(&pagelist)) {
WARN_ON_ONCE(flags & MPOL_MF_LAZY);
nr_failed = migrate_pages(&pagelist, new_page, NULL,
start, MIGRATE_SYNC, MR_MEMPOLICY_MBIND);
if (nr_failed)
putback_movable_pages(&pagelist);
}
if (nr_failed && (flags & MPOL_MF_STRICT))
err = -EIO;
} else
putback_movable_pages(&pagelist);
up_write(&mm->mmap_sem);
mpol_out:
mpol_put(new);
return err;
}
/*
* User space interface with variable sized bitmaps for nodelists.
*/
/* Copy a node mask from user space. */
static int get_nodes(nodemask_t *nodes, const unsigned long __user *nmask,
unsigned long maxnode)
{
unsigned long k;
unsigned long t;
unsigned long nlongs;
unsigned long endmask;
--maxnode;
nodes_clear(*nodes);
if (maxnode == 0 || !nmask)
return 0;
if (maxnode > PAGE_SIZE*BITS_PER_BYTE)
return -EINVAL;
nlongs = BITS_TO_LONGS(maxnode);
if ((maxnode % BITS_PER_LONG) == 0)
endmask = ~0UL;
else
endmask = (1UL << (maxnode % BITS_PER_LONG)) - 1;
/*
* When the user specified more nodes than supported just check
* if the non supported part is all zero.
*
* If maxnode have more longs than MAX_NUMNODES, check
* the bits in that area first. And then go through to
* check the rest bits which equal or bigger than MAX_NUMNODES.
* Otherwise, just check bits [MAX_NUMNODES, maxnode).
*/
if (nlongs > BITS_TO_LONGS(MAX_NUMNODES)) {
for (k = BITS_TO_LONGS(MAX_NUMNODES); k < nlongs; k++) {
if (get_user(t, nmask + k))
return -EFAULT;
if (k == nlongs - 1) {
if (t & endmask)
return -EINVAL;
} else if (t)
return -EINVAL;
}
nlongs = BITS_TO_LONGS(MAX_NUMNODES);
endmask = ~0UL;
}
if (maxnode > MAX_NUMNODES && MAX_NUMNODES % BITS_PER_LONG != 0) {
unsigned long valid_mask = endmask;
valid_mask &= ~((1UL << (MAX_NUMNODES % BITS_PER_LONG)) - 1);
if (get_user(t, nmask + nlongs - 1))
return -EFAULT;
if (t & valid_mask)
return -EINVAL;
}
if (copy_from_user(nodes_addr(*nodes), nmask, nlongs*sizeof(unsigned long)))
return -EFAULT;
nodes_addr(*nodes)[nlongs-1] &= endmask;
return 0;
}
/* Copy a kernel node mask to user space */
static int copy_nodes_to_user(unsigned long __user *mask, unsigned long maxnode,
nodemask_t *nodes)
{
unsigned long copy = ALIGN(maxnode-1, 64) / 8;
const int nbytes = BITS_TO_LONGS(MAX_NUMNODES) * sizeof(long);
if (copy > nbytes) {
if (copy > PAGE_SIZE)
return -EINVAL;
if (clear_user((char __user *)mask + nbytes, copy - nbytes))
return -EFAULT;
copy = nbytes;
}
return copy_to_user(mask, nodes_addr(*nodes), copy) ? -EFAULT : 0;
}
static long kernel_mbind(unsigned long start, unsigned long len,
unsigned long mode, const unsigned long __user *nmask,
unsigned long maxnode, unsigned int flags)
{
nodemask_t nodes;
int err;
unsigned short mode_flags;
mode_flags = mode & MPOL_MODE_FLAGS;
mode &= ~MPOL_MODE_FLAGS;
if (mode >= MPOL_MAX)
return -EINVAL;
if ((mode_flags & MPOL_F_STATIC_NODES) &&
(mode_flags & MPOL_F_RELATIVE_NODES))
return -EINVAL;
err = get_nodes(&nodes, nmask, maxnode);
if (err)
return err;
return do_mbind(start, len, mode, mode_flags, &nodes, flags);
}
SYSCALL_DEFINE6(mbind, unsigned long, start, unsigned long, len,
unsigned long, mode, const unsigned long __user *, nmask,
unsigned long, maxnode, unsigned int, flags)
{
return kernel_mbind(start, len, mode, nmask, maxnode, flags);
}
/* Set the process memory policy */
static long kernel_set_mempolicy(int mode, const unsigned long __user *nmask,
unsigned long maxnode)
{
int err;
nodemask_t nodes;
unsigned short flags;
flags = mode & MPOL_MODE_FLAGS;
mode &= ~MPOL_MODE_FLAGS;
if ((unsigned int)mode >= MPOL_MAX)
return -EINVAL;
if ((flags & MPOL_F_STATIC_NODES) && (flags & MPOL_F_RELATIVE_NODES))
return -EINVAL;
err = get_nodes(&nodes, nmask, maxnode);
if (err)
return err;
return do_set_mempolicy(mode, flags, &nodes);
}
SYSCALL_DEFINE3(set_mempolicy, int, mode, const unsigned long __user *, nmask,
unsigned long, maxnode)
{
return kernel_set_mempolicy(mode, nmask, maxnode);
}
static int kernel_migrate_pages(pid_t pid, unsigned long maxnode,
const unsigned long __user *old_nodes,
const unsigned long __user *new_nodes)
{
struct mm_struct *mm = NULL;
struct task_struct *task;
nodemask_t task_nodes;
int err;
nodemask_t *old;
nodemask_t *new;
NODEMASK_SCRATCH(scratch);
if (!scratch)
return -ENOMEM;
old = &scratch->mask1;
new = &scratch->mask2;
err = get_nodes(old, old_nodes, maxnode);
if (err)
goto out;
err = get_nodes(new, new_nodes, maxnode);
if (err)
goto out;
/* Find the mm_struct */
rcu_read_lock();
task = pid ? find_task_by_vpid(pid) : current;
if (!task) {
rcu_read_unlock();
err = -ESRCH;
goto out;
}
get_task_struct(task);
err = -EINVAL;
/*
* Check if this process has the right to modify the specified process.
* Use the regular "ptrace_may_access()" checks.
*/
if (!ptrace_may_access(task, PTRACE_MODE_READ_REALCREDS)) {
rcu_read_unlock();
err = -EPERM;
goto out_put;
}
rcu_read_unlock();
task_nodes = cpuset_mems_allowed(task);
/* Is the user allowed to access the target nodes? */
if (!nodes_subset(*new, task_nodes) && !capable(CAP_SYS_NICE)) {
err = -EPERM;
goto out_put;
}
task_nodes = cpuset_mems_allowed(current);
nodes_and(*new, *new, task_nodes);
if (nodes_empty(*new))
goto out_put;
nodes_and(*new, *new, node_states[N_MEMORY]);
if (nodes_empty(*new))
goto out_put;
err = security_task_movememory(task);
if (err)
goto out_put;
mm = get_task_mm(task);
put_task_struct(task);
if (!mm) {
err = -EINVAL;
goto out;
}
err = do_migrate_pages(mm, old, new,
capable(CAP_SYS_NICE) ? MPOL_MF_MOVE_ALL : MPOL_MF_MOVE);
mmput(mm);
out:
NODEMASK_SCRATCH_FREE(scratch);
return err;
out_put:
put_task_struct(task);
goto out;
}
SYSCALL_DEFINE4(migrate_pages, pid_t, pid, unsigned long, maxnode,
const unsigned long __user *, old_nodes,
const unsigned long __user *, new_nodes)
{
return kernel_migrate_pages(pid, maxnode, old_nodes, new_nodes);
}
/* Retrieve NUMA policy */
static int kernel_get_mempolicy(int __user *policy,
unsigned long __user *nmask,
unsigned long maxnode,
unsigned long addr,
unsigned long flags)
{
int err;
int uninitialized_var(pval);
nodemask_t nodes;
if (nmask != NULL && maxnode < MAX_NUMNODES)
return -EINVAL;
err = do_get_mempolicy(&pval, &nodes, addr, flags);
if (err)
return err;
if (policy && put_user(pval, policy))
return -EFAULT;
if (nmask)
err = copy_nodes_to_user(nmask, maxnode, &nodes);
return err;
}
SYSCALL_DEFINE5(get_mempolicy, int __user *, policy,
unsigned long __user *, nmask, unsigned long, maxnode,
unsigned long, addr, unsigned long, flags)
{
return kernel_get_mempolicy(policy, nmask, maxnode, addr, flags);
}
#ifdef CONFIG_COMPAT
COMPAT_SYSCALL_DEFINE5(get_mempolicy, int __user *, policy,
compat_ulong_t __user *, nmask,
compat_ulong_t, maxnode,
compat_ulong_t, addr, compat_ulong_t, flags)
{
long err;
unsigned long __user *nm = NULL;
unsigned long nr_bits, alloc_size;
DECLARE_BITMAP(bm, MAX_NUMNODES);
nr_bits = min_t(unsigned long, maxnode-1, MAX_NUMNODES);
alloc_size = ALIGN(nr_bits, BITS_PER_LONG) / 8;
if (nmask)
nm = compat_alloc_user_space(alloc_size);
err = kernel_get_mempolicy(policy, nm, nr_bits+1, addr, flags);
if (!err && nmask) {
unsigned long copy_size;
copy_size = min_t(unsigned long, sizeof(bm), alloc_size);
err = copy_from_user(bm, nm, copy_size);
/* ensure entire bitmap is zeroed */
err |= clear_user(nmask, ALIGN(maxnode-1, 8) / 8);
err |= compat_put_bitmap(nmask, bm, nr_bits);
}
return err;
}
COMPAT_SYSCALL_DEFINE3(set_mempolicy, int, mode, compat_ulong_t __user *, nmask,
compat_ulong_t, maxnode)
{
unsigned long __user *nm = NULL;
unsigned long nr_bits, alloc_size;
DECLARE_BITMAP(bm, MAX_NUMNODES);
nr_bits = min_t(unsigned long, maxnode-1, MAX_NUMNODES);
alloc_size = ALIGN(nr_bits, BITS_PER_LONG) / 8;
if (nmask) {
if (compat_get_bitmap(bm, nmask, nr_bits))
return -EFAULT;
nm = compat_alloc_user_space(alloc_size);
if (copy_to_user(nm, bm, alloc_size))
return -EFAULT;
}
return kernel_set_mempolicy(mode, nm, nr_bits+1);
}
COMPAT_SYSCALL_DEFINE6(mbind, compat_ulong_t, start, compat_ulong_t, len,
compat_ulong_t, mode, compat_ulong_t __user *, nmask,
compat_ulong_t, maxnode, compat_ulong_t, flags)
{
unsigned long __user *nm = NULL;
unsigned long nr_bits, alloc_size;
nodemask_t bm;
nr_bits = min_t(unsigned long, maxnode-1, MAX_NUMNODES);
alloc_size = ALIGN(nr_bits, BITS_PER_LONG) / 8;
if (nmask) {
if (compat_get_bitmap(nodes_addr(bm), nmask, nr_bits))
return -EFAULT;
nm = compat_alloc_user_space(alloc_size);
if (copy_to_user(nm, nodes_addr(bm), alloc_size))
return -EFAULT;
}
return kernel_mbind(start, len, mode, nm, nr_bits+1, flags);
}
COMPAT_SYSCALL_DEFINE4(migrate_pages, compat_pid_t, pid,
compat_ulong_t, maxnode,
const compat_ulong_t __user *, old_nodes,
const compat_ulong_t __user *, new_nodes)
{
unsigned long __user *old = NULL;
unsigned long __user *new = NULL;
nodemask_t tmp_mask;
unsigned long nr_bits;
unsigned long size;
nr_bits = min_t(unsigned long, maxnode - 1, MAX_NUMNODES);
size = ALIGN(nr_bits, BITS_PER_LONG) / 8;
if (old_nodes) {
if (compat_get_bitmap(nodes_addr(tmp_mask), old_nodes, nr_bits))
return -EFAULT;
old = compat_alloc_user_space(new_nodes ? size * 2 : size);
if (new_nodes)
new = old + size / sizeof(unsigned long);
if (copy_to_user(old, nodes_addr(tmp_mask), size))
return -EFAULT;
}
if (new_nodes) {
if (compat_get_bitmap(nodes_addr(tmp_mask), new_nodes, nr_bits))
return -EFAULT;
if (new == NULL)
new = compat_alloc_user_space(size);
if (copy_to_user(new, nodes_addr(tmp_mask), size))
return -EFAULT;
}
return kernel_migrate_pages(pid, nr_bits + 1, old, new);
}
#endif /* CONFIG_COMPAT */
struct mempolicy *__get_vma_policy(struct vm_area_struct *vma,
unsigned long addr)
{
struct mempolicy *pol = NULL;
if (vma) {
if (vma->vm_ops && vma->vm_ops->get_policy) {
pol = vma->vm_ops->get_policy(vma, addr);
} else if (vma->vm_policy) {
pol = vma->vm_policy;
/*
* shmem_alloc_page() passes MPOL_F_SHARED policy with
* a pseudo vma whose vma->vm_ops=NULL. Take a reference
* count on these policies which will be dropped by
* mpol_cond_put() later
*/
if (mpol_needs_cond_ref(pol))
mpol_get(pol);
}
}
return pol;
}
/*
* get_vma_policy(@vma, @addr)
* @vma: virtual memory area whose policy is sought
* @addr: address in @vma for shared policy lookup
*
* Returns effective policy for a VMA at specified address.
* Falls back to current->mempolicy or system default policy, as necessary.
* Shared policies [those marked as MPOL_F_SHARED] require an extra reference
* count--added by the get_policy() vm_op, as appropriate--to protect against
* freeing by another task. It is the caller's responsibility to free the
* extra reference for shared policies.
*/
static struct mempolicy *get_vma_policy(struct vm_area_struct *vma,
unsigned long addr)
{
struct mempolicy *pol = __get_vma_policy(vma, addr);
if (!pol)
pol = get_task_policy(current);
return pol;
}
bool vma_policy_mof(struct vm_area_struct *vma)
{
struct mempolicy *pol;
if (vma->vm_ops && vma->vm_ops->get_policy) {
bool ret = false;
pol = vma->vm_ops->get_policy(vma, vma->vm_start);
if (pol && (pol->flags & MPOL_F_MOF))
ret = true;
mpol_cond_put(pol);
return ret;
}
pol = vma->vm_policy;
if (!pol)
pol = get_task_policy(current);
return pol->flags & MPOL_F_MOF;
}
static int apply_policy_zone(struct mempolicy *policy, enum zone_type zone)
{
enum zone_type dynamic_policy_zone = policy_zone;
BUG_ON(dynamic_policy_zone == ZONE_MOVABLE);
/*
* if policy->v.nodes has movable memory only,
* we apply policy when gfp_zone(gfp) = ZONE_MOVABLE only.
*
* policy->v.nodes is intersect with node_states[N_MEMORY].
* so if the following test faile, it implies
* policy->v.nodes has movable memory only.
*/
if (!nodes_intersects(policy->v.nodes, node_states[N_HIGH_MEMORY]))
dynamic_policy_zone = ZONE_MOVABLE;
return zone >= dynamic_policy_zone;
}
/*
* Return a nodemask representing a mempolicy for filtering nodes for
* page allocation
*/
static nodemask_t *policy_nodemask(gfp_t gfp, struct mempolicy *policy)
{
/* Lower zones don't get a nodemask applied for MPOL_BIND */
if (unlikely(policy->mode == MPOL_BIND) &&
apply_policy_zone(policy, gfp_zone(gfp)) &&
cpuset_nodemask_valid_mems_allowed(&policy->v.nodes))
return &policy->v.nodes;
return NULL;
}
/* Return the node id preferred by the given mempolicy, or the given id */
static int policy_node(gfp_t gfp, struct mempolicy *policy,
int nd)
{
if (policy->mode == MPOL_PREFERRED && !(policy->flags & MPOL_F_LOCAL))
nd = policy->v.preferred_node;
else {
/*
* __GFP_THISNODE shouldn't even be used with the bind policy
* because we might easily break the expectation to stay on the
* requested node and not break the policy.
*/
WARN_ON_ONCE(policy->mode == MPOL_BIND && (gfp & __GFP_THISNODE));
}
return nd;
}
/* Do dynamic interleaving for a process */
static unsigned interleave_nodes(struct mempolicy *policy)
{
unsigned next;
struct task_struct *me = current;
next = next_node_in(me->il_prev, policy->v.nodes);
if (next < MAX_NUMNODES)
me->il_prev = next;
return next;
}
/*
* Depending on the memory policy provide a node from which to allocate the
* next slab entry.
*/
unsigned int mempolicy_slab_node(void)
{
struct mempolicy *policy;
int node = numa_mem_id();
if (in_interrupt())
return node;
policy = current->mempolicy;
if (!policy || policy->flags & MPOL_F_LOCAL)
return node;
switch (policy->mode) {
case MPOL_PREFERRED:
/*
* handled MPOL_F_LOCAL above
*/
return policy->v.preferred_node;
case MPOL_INTERLEAVE:
return interleave_nodes(policy);
case MPOL_BIND: {
struct zoneref *z;
/*
* Follow bind policy behavior and start allocation at the
* first node.
*/
struct zonelist *zonelist;
enum zone_type highest_zoneidx = gfp_zone(GFP_KERNEL);
zonelist = &NODE_DATA(node)->node_zonelists[ZONELIST_FALLBACK];
z = first_zones_zonelist(zonelist, highest_zoneidx,
&policy->v.nodes);
return z->zone ? z->zone->node : node;
}
default:
BUG();
}
}
/*
* Do static interleaving for a VMA with known offset @n. Returns the n'th
* node in pol->v.nodes (starting from n=0), wrapping around if n exceeds the
* number of present nodes.
*/
static unsigned offset_il_node(struct mempolicy *pol, unsigned long n)
{
unsigned nnodes = nodes_weight(pol->v.nodes);
unsigned target;
int i;
int nid;
if (!nnodes)
return numa_node_id();
target = (unsigned int)n % nnodes;
nid = first_node(pol->v.nodes);
for (i = 0; i < target; i++)
nid = next_node(nid, pol->v.nodes);
return nid;
}
/* Determine a node number for interleave */
static inline unsigned interleave_nid(struct mempolicy *pol,
struct vm_area_struct *vma, unsigned long addr, int shift)
{
if (vma) {
unsigned long off;
/*
* for small pages, there is no difference between
* shift and PAGE_SHIFT, so the bit-shift is safe.
* for huge pages, since vm_pgoff is in units of small
* pages, we need to shift off the always 0 bits to get
* a useful offset.
*/
BUG_ON(shift < PAGE_SHIFT);
off = vma->vm_pgoff >> (shift - PAGE_SHIFT);
off += (addr - vma->vm_start) >> shift;
return offset_il_node(pol, off);
} else
return interleave_nodes(pol);
}
#ifdef CONFIG_HUGETLBFS
/*
* huge_node(@vma, @addr, @gfp_flags, @mpol)
* @vma: virtual memory area whose policy is sought
* @addr: address in @vma for shared policy lookup and interleave policy
* @gfp_flags: for requested zone
* @mpol: pointer to mempolicy pointer for reference counted mempolicy
* @nodemask: pointer to nodemask pointer for MPOL_BIND nodemask
*
* Returns a nid suitable for a huge page allocation and a pointer
* to the struct mempolicy for conditional unref after allocation.
* If the effective policy is 'BIND, returns a pointer to the mempolicy's
* @nodemask for filtering the zonelist.
*
* Must be protected by read_mems_allowed_begin()
*/
int huge_node(struct vm_area_struct *vma, unsigned long addr, gfp_t gfp_flags,
struct mempolicy **mpol, nodemask_t **nodemask)
{
int nid;
*mpol = get_vma_policy(vma, addr);
*nodemask = NULL; /* assume !MPOL_BIND */
if (unlikely((*mpol)->mode == MPOL_INTERLEAVE)) {
nid = interleave_nid(*mpol, vma, addr,
huge_page_shift(hstate_vma(vma)));
} else {
nid = policy_node(gfp_flags, *mpol, numa_node_id());
if ((*mpol)->mode == MPOL_BIND)
*nodemask = &(*mpol)->v.nodes;
}
return nid;
}
/*
* init_nodemask_of_mempolicy
*
* If the current task's mempolicy is "default" [NULL], return 'false'
* to indicate default policy. Otherwise, extract the policy nodemask
* for 'bind' or 'interleave' policy into the argument nodemask, or
* initialize the argument nodemask to contain the single node for
* 'preferred' or 'local' policy and return 'true' to indicate presence
* of non-default mempolicy.
*
* We don't bother with reference counting the mempolicy [mpol_get/put]
* because the current task is examining it's own mempolicy and a task's
* mempolicy is only ever changed by the task itself.
*
* N.B., it is the caller's responsibility to free a returned nodemask.
*/
bool init_nodemask_of_mempolicy(nodemask_t *mask)
{
struct mempolicy *mempolicy;
int nid;
if (!(mask && current->mempolicy))
return false;
task_lock(current);
mempolicy = current->mempolicy;
switch (mempolicy->mode) {
case MPOL_PREFERRED:
if (mempolicy->flags & MPOL_F_LOCAL)
nid = numa_node_id();
else
nid = mempolicy->v.preferred_node;
init_nodemask_of_node(mask, nid);
break;
case MPOL_BIND:
/* Fall through */
case MPOL_INTERLEAVE:
*mask = mempolicy->v.nodes;
break;
default:
BUG();
}
task_unlock(current);
return true;
}
#endif
/*
* mempolicy_nodemask_intersects
*
* If tsk's mempolicy is "default" [NULL], return 'true' to indicate default
* policy. Otherwise, check for intersection between mask and the policy
* nodemask for 'bind' or 'interleave' policy. For 'perferred' or 'local'
* policy, always return true since it may allocate elsewhere on fallback.
*
* Takes task_lock(tsk) to prevent freeing of its mempolicy.
*/
bool mempolicy_nodemask_intersects(struct task_struct *tsk,
const nodemask_t *mask)
{
struct mempolicy *mempolicy;
bool ret = true;
if (!mask)
return ret;
task_lock(tsk);
mempolicy = tsk->mempolicy;
if (!mempolicy)
goto out;
switch (mempolicy->mode) {
case MPOL_PREFERRED:
/*
* MPOL_PREFERRED and MPOL_F_LOCAL are only preferred nodes to
* allocate from, they may fallback to other nodes when oom.
* Thus, it's possible for tsk to have allocated memory from
* nodes in mask.
*/
break;
case MPOL_BIND:
case MPOL_INTERLEAVE:
ret = nodes_intersects(mempolicy->v.nodes, *mask);
break;
default:
BUG();
}
out:
task_unlock(tsk);
return ret;
}
/* Allocate a page in interleaved policy.
Own path because it needs to do special accounting. */
static struct page *alloc_page_interleave(gfp_t gfp, unsigned order,
unsigned nid)
{
struct page *page;
page = __alloc_pages(gfp, order, nid);
/* skip NUMA_INTERLEAVE_HIT counter update if numa stats is disabled */
if (!static_branch_likely(&vm_numa_stat_key))
return page;
if (page && page_to_nid(page) == nid) {
preempt_disable();
__inc_numa_state(page_zone(page), NUMA_INTERLEAVE_HIT);
preempt_enable();
}
return page;
}
/**
* alloc_pages_vma - Allocate a page for a VMA.
*
* @gfp:
* %GFP_USER user allocation.
* %GFP_KERNEL kernel allocations,
* %GFP_HIGHMEM highmem/user allocations,
* %GFP_FS allocation should not call back into a file system.
* %GFP_ATOMIC don't sleep.
*
* @order:Order of the GFP allocation.
* @vma: Pointer to VMA or NULL if not available.
* @addr: Virtual Address of the allocation. Must be inside the VMA.
* @node: Which node to prefer for allocation (modulo policy).
* @hugepage: for hugepages try only the preferred node if possible
*
* This function allocates a page from the kernel page pool and applies
* a NUMA policy associated with the VMA or the current process.
* When VMA is not NULL caller must hold down_read on the mmap_sem of the
* mm_struct of the VMA to prevent it from going away. Should be used for
* all allocations for pages that will be mapped into user space. Returns
* NULL when no page can be allocated.
*/
struct page *
alloc_pages_vma(gfp_t gfp, int order, struct vm_area_struct *vma,
unsigned long addr, int node, bool hugepage)
{
struct mempolicy *pol;
struct page *page;
int preferred_nid;
nodemask_t *nmask;
pol = get_vma_policy(vma, addr);
if (pol->mode == MPOL_INTERLEAVE) {
unsigned nid;
nid = interleave_nid(pol, vma, addr, PAGE_SHIFT + order);
mpol_cond_put(pol);
page = alloc_page_interleave(gfp, order, nid);
goto out;
}
if (unlikely(IS_ENABLED(CONFIG_TRANSPARENT_HUGEPAGE) && hugepage)) {
int hpage_node = node;
/*
* For hugepage allocation and non-interleave policy which
* allows the current node (or other explicitly preferred
* node) we only try to allocate from the current/preferred
* node and don't fall back to other nodes, as the cost of
* remote accesses would likely offset THP benefits.
*
* If the policy is interleave, or does not allow the current
* node in its nodemask, we allocate the standard way.
*/
if (pol->mode == MPOL_PREFERRED &&
!(pol->flags & MPOL_F_LOCAL))
hpage_node = pol->v.preferred_node;
nmask = policy_nodemask(gfp, pol);
if (!nmask || node_isset(hpage_node, *nmask)) {
mpol_cond_put(pol);
page = __alloc_pages_node(hpage_node,
gfp | __GFP_THISNODE, order);
goto out;
}
}
nmask = policy_nodemask(gfp, pol);
preferred_nid = policy_node(gfp, pol, node);
page = __alloc_pages_nodemask(gfp, order, preferred_nid, nmask);
mpol_cond_put(pol);
out:
return page;
}
/**
* alloc_pages_current - Allocate pages.
*
* @gfp:
* %GFP_USER user allocation,
* %GFP_KERNEL kernel allocation,
* %GFP_HIGHMEM highmem allocation,
* %GFP_FS don't call back into a file system.
* %GFP_ATOMIC don't sleep.
* @order: Power of two of allocation size in pages. 0 is a single page.
*
* Allocate a page from the kernel page pool. When not in
* interrupt context and apply the current process NUMA policy.
* Returns NULL when no page can be allocated.
*/
struct page *alloc_pages_current(gfp_t gfp, unsigned order)
{
struct mempolicy *pol = &default_policy;
struct page *page;
if (!in_interrupt() && !(gfp & __GFP_THISNODE))
pol = get_task_policy(current);
/*
* No reference counting needed for current->mempolicy
* nor system default_policy
*/
if (pol->mode == MPOL_INTERLEAVE)
page = alloc_page_interleave(gfp, order, interleave_nodes(pol));
else
page = __alloc_pages_nodemask(gfp, order,
policy_node(gfp, pol, numa_node_id()),
policy_nodemask(gfp, pol));
return page;
}
EXPORT_SYMBOL(alloc_pages_current);
int vma_dup_policy(struct vm_area_struct *src, struct vm_area_struct *dst)
{
struct mempolicy *pol = mpol_dup(vma_policy(src));
if (IS_ERR(pol))
return PTR_ERR(pol);
dst->vm_policy = pol;
return 0;
}
/*
* If mpol_dup() sees current->cpuset == cpuset_being_rebound, then it
* rebinds the mempolicy its copying by calling mpol_rebind_policy()
* with the mems_allowed returned by cpuset_mems_allowed(). This
* keeps mempolicies cpuset relative after its cpuset moves. See
* further kernel/cpuset.c update_nodemask().
*
* current's mempolicy may be rebinded by the other task(the task that changes
* cpuset's mems), so we needn't do rebind work for current task.
*/
/* Slow path of a mempolicy duplicate */
struct mempolicy *__mpol_dup(struct mempolicy *old)
{
struct mempolicy *new = kmem_cache_alloc(policy_cache, GFP_KERNEL);
if (!new)
return ERR_PTR(-ENOMEM);
/* task's mempolicy is protected by alloc_lock */
if (old == current->mempolicy) {
task_lock(current);
*new = *old;
task_unlock(current);
} else
*new = *old;
if (current_cpuset_is_being_rebound()) {
nodemask_t mems = cpuset_mems_allowed(current);
mpol_rebind_policy(new, &mems);
}
atomic_set(&new->refcnt, 1);
return new;
}
/* Slow path of a mempolicy comparison */
bool __mpol_equal(struct mempolicy *a, struct mempolicy *b)
{
if (!a || !b)
return false;
if (a->mode != b->mode)
return false;
if (a->flags != b->flags)
return false;
if (mpol_store_user_nodemask(a))
if (!nodes_equal(a->w.user_nodemask, b->w.user_nodemask))
return false;
switch (a->mode) {
case MPOL_BIND:
/* Fall through */
case MPOL_INTERLEAVE:
return !!nodes_equal(a->v.nodes, b->v.nodes);
case MPOL_PREFERRED:
/* a's ->flags is the same as b's */
if (a->flags & MPOL_F_LOCAL)
return true;
return a->v.preferred_node == b->v.preferred_node;
default:
BUG();
return false;
}
}
/*
* Shared memory backing store policy support.
*
* Remember policies even when nobody has shared memory mapped.
* The policies are kept in Red-Black tree linked from the inode.
* They are protected by the sp->lock rwlock, which should be held
* for any accesses to the tree.
*/
/*
* lookup first element intersecting start-end. Caller holds sp->lock for
* reading or for writing
*/
static struct sp_node *
sp_lookup(struct shared_policy *sp, unsigned long start, unsigned long end)
{
struct rb_node *n = sp->root.rb_node;
while (n) {
struct sp_node *p = rb_entry(n, struct sp_node, nd);
if (start >= p->end)
n = n->rb_right;
else if (end <= p->start)
n = n->rb_left;
else
break;
}
if (!n)
return NULL;
for (;;) {
struct sp_node *w = NULL;
struct rb_node *prev = rb_prev(n);
if (!prev)
break;
w = rb_entry(prev, struct sp_node, nd);
if (w->end <= start)
break;
n = prev;
}
return rb_entry(n, struct sp_node, nd);
}
/*
* Insert a new shared policy into the list. Caller holds sp->lock for
* writing.
*/
static void sp_insert(struct shared_policy *sp, struct sp_node *new)
{
struct rb_node **p = &sp->root.rb_node;
struct rb_node *parent = NULL;
struct sp_node *nd;
while (*p) {
parent = *p;
nd = rb_entry(parent, struct sp_node, nd);
if (new->start < nd->start)
p = &(*p)->rb_left;
else if (new->end > nd->end)
p = &(*p)->rb_right;
else
BUG();
}
rb_link_node(&new->nd, parent, p);
rb_insert_color(&new->nd, &sp->root);
pr_debug("inserting %lx-%lx: %d\n", new->start, new->end,
new->policy ? new->policy->mode : 0);
}
/* Find shared policy intersecting idx */
struct mempolicy *
mpol_shared_policy_lookup(struct shared_policy *sp, unsigned long idx)
{
struct mempolicy *pol = NULL;
struct sp_node *sn;
if (!sp->root.rb_node)
return NULL;
read_lock(&sp->lock);
sn = sp_lookup(sp, idx, idx+1);
if (sn) {
mpol_get(sn->policy);
pol = sn->policy;
}
read_unlock(&sp->lock);
return pol;
}
static void sp_free(struct sp_node *n)
{
mpol_put(n->policy);
kmem_cache_free(sn_cache, n);
}
/**
* mpol_misplaced - check whether current page node is valid in policy
*
* @page: page to be checked
* @vma: vm area where page mapped
* @addr: virtual address where page mapped
*
* Lookup current policy node id for vma,addr and "compare to" page's
* node id.
*
* Returns:
* -1 - not misplaced, page is in the right node
* node - node id where the page should be
*
* Policy determination "mimics" alloc_page_vma().
* Called from fault path where we know the vma and faulting address.
*/
int mpol_misplaced(struct page *page, struct vm_area_struct *vma, unsigned long addr)
{
struct mempolicy *pol;
struct zoneref *z;
int curnid = page_to_nid(page);
unsigned long pgoff;
int thiscpu = raw_smp_processor_id();
int thisnid = cpu_to_node(thiscpu);
int polnid = -1;
int ret = -1;
pol = get_vma_policy(vma, addr);
if (!(pol->flags & MPOL_F_MOF))
goto out;
switch (pol->mode) {
case MPOL_INTERLEAVE:
pgoff = vma->vm_pgoff;
pgoff += (addr - vma->vm_start) >> PAGE_SHIFT;
polnid = offset_il_node(pol, pgoff);
break;
case MPOL_PREFERRED:
if (pol->flags & MPOL_F_LOCAL)
polnid = numa_node_id();
else
polnid = pol->v.preferred_node;
break;
case MPOL_BIND:
/*
* allows binding to multiple nodes.
* use current page if in policy nodemask,
* else select nearest allowed node, if any.
* If no allowed nodes, use current [!misplaced].
*/
if (node_isset(curnid, pol->v.nodes))
goto out;
z = first_zones_zonelist(
node_zonelist(numa_node_id(), GFP_HIGHUSER),
gfp_zone(GFP_HIGHUSER),
&pol->v.nodes);
polnid = z->zone->node;
break;
default:
BUG();
}
/* Migrate the page towards the node whose CPU is referencing it */
if (pol->flags & MPOL_F_MORON) {
polnid = thisnid;
if (!should_numa_migrate_memory(current, page, curnid, thiscpu))
goto out;
}
if (curnid != polnid)
ret = polnid;
out:
mpol_cond_put(pol);
return ret;
}
/*
* Drop the (possibly final) reference to task->mempolicy. It needs to be
* dropped after task->mempolicy is set to NULL so that any allocation done as
* part of its kmem_cache_free(), such as by KASAN, doesn't reference a freed
* policy.
*/
void mpol_put_task_policy(struct task_struct *task)
{
struct mempolicy *pol;
task_lock(task);
pol = task->mempolicy;
task->mempolicy = NULL;
task_unlock(task);
mpol_put(pol);
}
static void sp_delete(struct shared_policy *sp, struct sp_node *n)
{
pr_debug("deleting %lx-l%lx\n", n->start, n->end);
rb_erase(&n->nd, &sp->root);
sp_free(n);
}
static void sp_node_init(struct sp_node *node, unsigned long start,
unsigned long end, struct mempolicy *pol)
{
node->start = start;
node->end = end;
node->policy = pol;
}
static struct sp_node *sp_alloc(unsigned long start, unsigned long end,
struct mempolicy *pol)
{
struct sp_node *n;
struct mempolicy *newpol;
n = kmem_cache_alloc(sn_cache, GFP_KERNEL);
if (!n)
return NULL;
newpol = mpol_dup(pol);
if (IS_ERR(newpol)) {
kmem_cache_free(sn_cache, n);
return NULL;
}
newpol->flags |= MPOL_F_SHARED;
sp_node_init(n, start, end, newpol);
return n;
}
/* Replace a policy range. */
static int shared_policy_replace(struct shared_policy *sp, unsigned long start,
unsigned long end, struct sp_node *new)
{
struct sp_node *n;
struct sp_node *n_new = NULL;
struct mempolicy *mpol_new = NULL;
int ret = 0;
restart:
write_lock(&sp->lock);
n = sp_lookup(sp, start, end);
/* Take care of old policies in the same range. */
while (n && n->start < end) {
struct rb_node *next = rb_next(&n->nd);
if (n->start >= start) {
if (n->end <= end)
sp_delete(sp, n);
else
n->start = end;
} else {
/* Old policy spanning whole new range. */
if (n->end > end) {
if (!n_new)
goto alloc_new;
*mpol_new = *n->policy;
atomic_set(&mpol_new->refcnt, 1);
sp_node_init(n_new, end, n->end, mpol_new);
n->end = start;
sp_insert(sp, n_new);
n_new = NULL;
mpol_new = NULL;
break;
} else
n->end = start;
}
if (!next)
break;
n = rb_entry(next, struct sp_node, nd);
}
if (new)
sp_insert(sp, new);
write_unlock(&sp->lock);
ret = 0;
err_out:
if (mpol_new)
mpol_put(mpol_new);
if (n_new)
kmem_cache_free(sn_cache, n_new);
return ret;
alloc_new:
write_unlock(&sp->lock);
ret = -ENOMEM;
n_new = kmem_cache_alloc(sn_cache, GFP_KERNEL);
if (!n_new)
goto err_out;
mpol_new = kmem_cache_alloc(policy_cache, GFP_KERNEL);
if (!mpol_new)
goto err_out;
goto restart;
}
/**
* mpol_shared_policy_init - initialize shared policy for inode
* @sp: pointer to inode shared policy
* @mpol: struct mempolicy to install
*
* Install non-NULL @mpol in inode's shared policy rb-tree.
* On entry, the current task has a reference on a non-NULL @mpol.
* This must be released on exit.
* This is called at get_inode() calls and we can use GFP_KERNEL.
*/
void mpol_shared_policy_init(struct shared_policy *sp, struct mempolicy *mpol)
{
int ret;
sp->root = RB_ROOT; /* empty tree == default mempolicy */
rwlock_init(&sp->lock);
if (mpol) {
struct vm_area_struct pvma;
struct mempolicy *new;
NODEMASK_SCRATCH(scratch);
if (!scratch)
goto put_mpol;
/* contextualize the tmpfs mount point mempolicy */
new = mpol_new(mpol->mode, mpol->flags, &mpol->w.user_nodemask);
if (IS_ERR(new))
goto free_scratch; /* no valid nodemask intersection */
task_lock(current);
ret = mpol_set_nodemask(new, &mpol->w.user_nodemask, scratch);
task_unlock(current);
if (ret)
goto put_new;
/* Create pseudo-vma that contains just the policy */
memset(&pvma, 0, sizeof(struct vm_area_struct));
vma_init(&pvma, NULL);
pvma.vm_end = TASK_SIZE; /* policy covers entire file */
mpol_set_shared_policy(sp, &pvma, new); /* adds ref */
put_new:
mpol_put(new); /* drop initial ref */
free_scratch:
NODEMASK_SCRATCH_FREE(scratch);
put_mpol:
mpol_put(mpol); /* drop our incoming ref on sb mpol */
}
}
int mpol_set_shared_policy(struct shared_policy *info,
struct vm_area_struct *vma, struct mempolicy *npol)
{
int err;
struct sp_node *new = NULL;
unsigned long sz = vma_pages(vma);
pr_debug("set_shared_policy %lx sz %lu %d %d %lx\n",
vma->vm_pgoff,
sz, npol ? npol->mode : -1,
npol ? npol->flags : -1,
npol ? nodes_addr(npol->v.nodes)[0] : NUMA_NO_NODE);
if (npol) {
new = sp_alloc(vma->vm_pgoff, vma->vm_pgoff + sz, npol);
if (!new)
return -ENOMEM;
}
err = shared_policy_replace(info, vma->vm_pgoff, vma->vm_pgoff+sz, new);
if (err && new)
sp_free(new);
return err;
}
/* Free a backing policy store on inode delete. */
void mpol_free_shared_policy(struct shared_policy *p)
{
struct sp_node *n;
struct rb_node *next;
if (!p->root.rb_node)
return;
write_lock(&p->lock);
next = rb_first(&p->root);
while (next) {
n = rb_entry(next, struct sp_node, nd);
next = rb_next(&n->nd);
sp_delete(p, n);
}
write_unlock(&p->lock);
}
#ifdef CONFIG_NUMA_BALANCING
static int __initdata numabalancing_override;
static void __init check_numabalancing_enable(void)
{
bool numabalancing_default = false;
if (IS_ENABLED(CONFIG_NUMA_BALANCING_DEFAULT_ENABLED))
numabalancing_default = true;
/* Parsed by setup_numabalancing. override == 1 enables, -1 disables */
if (numabalancing_override)
set_numabalancing_state(numabalancing_override == 1);
if (num_online_nodes() > 1 && !numabalancing_override) {
pr_info("%s automatic NUMA balancing. Configure with numa_balancing= or the kernel.numa_balancing sysctl\n",
numabalancing_default ? "Enabling" : "Disabling");
set_numabalancing_state(numabalancing_default);
}
}
static int __init setup_numabalancing(char *str)
{
int ret = 0;
if (!str)
goto out;
if (!strcmp(str, "enable")) {
numabalancing_override = 1;
ret = 1;
} else if (!strcmp(str, "disable")) {
numabalancing_override = -1;
ret = 1;
}
out:
if (!ret)
pr_warn("Unable to parse numa_balancing=\n");
return ret;
}
__setup("numa_balancing=", setup_numabalancing);
#else
static inline void __init check_numabalancing_enable(void)
{
}
#endif /* CONFIG_NUMA_BALANCING */
/* assumes fs == KERNEL_DS */
void __init numa_policy_init(void)
{
nodemask_t interleave_nodes;
unsigned long largest = 0;
int nid, prefer = 0;
policy_cache = kmem_cache_create("numa_policy",
sizeof(struct mempolicy),
0, SLAB_PANIC, NULL);
sn_cache = kmem_cache_create("shared_policy_node",
sizeof(struct sp_node),
0, SLAB_PANIC, NULL);
for_each_node(nid) {
preferred_node_policy[nid] = (struct mempolicy) {
.refcnt = ATOMIC_INIT(1),
.mode = MPOL_PREFERRED,
.flags = MPOL_F_MOF | MPOL_F_MORON,
.v = { .preferred_node = nid, },
};
}
/*
* Set interleaving policy for system init. Interleaving is only
* enabled across suitably sized nodes (default is >= 16MB), or
* fall back to the largest node if they're all smaller.
*/
nodes_clear(interleave_nodes);
for_each_node_state(nid, N_MEMORY) {
unsigned long total_pages = node_present_pages(nid);
/* Preserve the largest node */
if (largest < total_pages) {
largest = total_pages;
prefer = nid;
}
/* Interleave this node? */
if ((total_pages << PAGE_SHIFT) >= (16 << 20))
node_set(nid, interleave_nodes);
}
/* All too small, use the largest */
if (unlikely(nodes_empty(interleave_nodes)))
node_set(prefer, interleave_nodes);
if (do_set_mempolicy(MPOL_INTERLEAVE, 0, &interleave_nodes))
pr_err("%s: interleaving failed\n", __func__);
check_numabalancing_enable();
}
/* Reset policy of current process to default */
void numa_default_policy(void)
{
do_set_mempolicy(MPOL_DEFAULT, 0, NULL);
}
/*
* Parse and format mempolicy from/to strings
*/
/*
* "local" is implemented internally by MPOL_PREFERRED with MPOL_F_LOCAL flag.
*/
static const char * const policy_modes[] =
{
[MPOL_DEFAULT] = "default",
[MPOL_PREFERRED] = "prefer",
[MPOL_BIND] = "bind",
[MPOL_INTERLEAVE] = "interleave",
[MPOL_LOCAL] = "local",
};
#ifdef CONFIG_TMPFS
/**
* mpol_parse_str - parse string to mempolicy, for tmpfs mpol mount option.
* @str: string containing mempolicy to parse
* @mpol: pointer to struct mempolicy pointer, returned on success.
*
* Format of input:
* <mode>[=<flags>][:<nodelist>]
*
* On success, returns 0, else 1
*/
int mpol_parse_str(char *str, struct mempolicy **mpol)
{
struct mempolicy *new = NULL;
unsigned short mode;
unsigned short mode_flags;
nodemask_t nodes;
char *nodelist = strchr(str, ':');
char *flags = strchr(str, '=');
int err = 1;
if (nodelist) {
/* NUL-terminate mode or flags string */
*nodelist++ = '\0';
if (nodelist_parse(nodelist, nodes))
goto out;
if (!nodes_subset(nodes, node_states[N_MEMORY]))
goto out;
} else
nodes_clear(nodes);
if (flags)
*flags++ = '\0'; /* terminate mode string */
for (mode = 0; mode < MPOL_MAX; mode++) {
if (!strcmp(str, policy_modes[mode])) {
break;
}
}
if (mode >= MPOL_MAX)
goto out;
switch (mode) {
case MPOL_PREFERRED:
/*
* Insist on a nodelist of one node only
*/
if (nodelist) {
char *rest = nodelist;
while (isdigit(*rest))
rest++;
if (*rest)
goto out;
}
break;
case MPOL_INTERLEAVE:
/*
* Default to online nodes with memory if no nodelist
*/
if (!nodelist)
nodes = node_states[N_MEMORY];
break;
case MPOL_LOCAL:
/*
* Don't allow a nodelist; mpol_new() checks flags
*/
if (nodelist)
goto out;
mode = MPOL_PREFERRED;
break;
case MPOL_DEFAULT:
/*
* Insist on a empty nodelist
*/
if (!nodelist)
err = 0;
goto out;
case MPOL_BIND:
/*
* Insist on a nodelist
*/
if (!nodelist)
goto out;
}
mode_flags = 0;
if (flags) {
/*
* Currently, we only support two mutually exclusive
* mode flags.
*/
if (!strcmp(flags, "static"))
mode_flags |= MPOL_F_STATIC_NODES;
else if (!strcmp(flags, "relative"))
mode_flags |= MPOL_F_RELATIVE_NODES;
else
goto out;
}
new = mpol_new(mode, mode_flags, &nodes);
if (IS_ERR(new))
goto out;
/*
* Save nodes for mpol_to_str() to show the tmpfs mount options
* for /proc/mounts, /proc/pid/mounts and /proc/pid/mountinfo.
*/
if (mode != MPOL_PREFERRED)
new->v.nodes = nodes;
else if (nodelist)
new->v.preferred_node = first_node(nodes);
else
new->flags |= MPOL_F_LOCAL;
/*
* Save nodes for contextualization: this will be used to "clone"
* the mempolicy in a specific context [cpuset] at a later time.
*/
new->w.user_nodemask = nodes;
err = 0;
out:
/* Restore string for error message */
if (nodelist)
*--nodelist = ':';
if (flags)
*--flags = '=';
if (!err)
*mpol = new;
return err;
}
#endif /* CONFIG_TMPFS */
/**
* mpol_to_str - format a mempolicy structure for printing
* @buffer: to contain formatted mempolicy string
* @maxlen: length of @buffer
* @pol: pointer to mempolicy to be formatted
*
* Convert @pol into a string. If @buffer is too short, truncate the string.
* Recommend a @maxlen of at least 32 for the longest mode, "interleave", the
* longest flag, "relative", and to display at least a few node ids.
*/
void mpol_to_str(char *buffer, int maxlen, struct mempolicy *pol)
{
char *p = buffer;
nodemask_t nodes = NODE_MASK_NONE;
unsigned short mode = MPOL_DEFAULT;
unsigned short flags = 0;
if (pol && pol != &default_policy && !(pol->flags & MPOL_F_MORON)) {
mode = pol->mode;
flags = pol->flags;
}
switch (mode) {
case MPOL_DEFAULT:
break;
case MPOL_PREFERRED:
if (flags & MPOL_F_LOCAL)
mode = MPOL_LOCAL;
else
node_set(pol->v.preferred_node, nodes);
break;
case MPOL_BIND:
case MPOL_INTERLEAVE:
nodes = pol->v.nodes;
break;
default:
WARN_ON_ONCE(1);
snprintf(p, maxlen, "unknown");
return;
}
p += snprintf(p, maxlen, "%s", policy_modes[mode]);
if (flags & MPOL_MODE_FLAGS) {
p += snprintf(p, buffer + maxlen - p, "=");
/*
* Currently, the only defined flags are mutually exclusive
*/
if (flags & MPOL_F_STATIC_NODES)
p += snprintf(p, buffer + maxlen - p, "static");
else if (flags & MPOL_F_RELATIVE_NODES)
p += snprintf(p, buffer + maxlen - p, "relative");
}
if (!nodes_empty(nodes))
p += scnprintf(p, buffer + maxlen - p, ":%*pbl",
nodemask_pr_args(&nodes));
}
| gpl-2.0 |
koct9i/linux | drivers/staging/erofs/internal.h | 15962 | /* SPDX-License-Identifier: GPL-2.0
*
* linux/drivers/staging/erofs/internal.h
*
* Copyright (C) 2017-2018 HUAWEI, Inc.
* http://www.huawei.com/
* Created by Gao Xiang <[email protected]>
*
* This file is subject to the terms and conditions of the GNU General Public
* License. See the file COPYING in the main directory of the Linux
* distribution for more details.
*/
#ifndef __INTERNAL_H
#define __INTERNAL_H
#include <linux/fs.h>
#include <linux/dcache.h>
#include <linux/mm.h>
#include <linux/pagemap.h>
#include <linux/bio.h>
#include <linux/buffer_head.h>
#include <linux/cleancache.h>
#include <linux/slab.h>
#include <linux/vmalloc.h>
#include "erofs_fs.h"
/* redefine pr_fmt "erofs: " */
#undef pr_fmt
#define pr_fmt(fmt) "erofs: " fmt
#define errln(x, ...) pr_err(x "\n", ##__VA_ARGS__)
#define infoln(x, ...) pr_info(x "\n", ##__VA_ARGS__)
#ifdef CONFIG_EROFS_FS_DEBUG
#define debugln(x, ...) pr_debug(x "\n", ##__VA_ARGS__)
#define dbg_might_sleep might_sleep
#define DBG_BUGON BUG_ON
#else
#define debugln(x, ...) ((void)0)
#define dbg_might_sleep() ((void)0)
#define DBG_BUGON(x) ((void)(x))
#endif
enum {
FAULT_KMALLOC,
FAULT_READ_IO,
FAULT_MAX,
};
#ifdef CONFIG_EROFS_FAULT_INJECTION
extern const char *erofs_fault_name[FAULT_MAX];
#define IS_FAULT_SET(fi, type) ((fi)->inject_type & (1 << (type)))
struct erofs_fault_info {
atomic_t inject_ops;
unsigned int inject_rate;
unsigned int inject_type;
};
#endif
#ifdef CONFIG_EROFS_FS_ZIP_CACHE_BIPOLAR
#define EROFS_FS_ZIP_CACHE_LVL (2)
#elif defined(EROFS_FS_ZIP_CACHE_UNIPOLAR)
#define EROFS_FS_ZIP_CACHE_LVL (1)
#else
#define EROFS_FS_ZIP_CACHE_LVL (0)
#endif
#if (!defined(EROFS_FS_HAS_MANAGED_CACHE) && (EROFS_FS_ZIP_CACHE_LVL > 0))
#define EROFS_FS_HAS_MANAGED_CACHE
#endif
/* EROFS_SUPER_MAGIC_V1 to represent the whole file system */
#define EROFS_SUPER_MAGIC EROFS_SUPER_MAGIC_V1
typedef u64 erofs_nid_t;
struct erofs_sb_info {
/* list for all registered superblocks, mainly for shrinker */
struct list_head list;
struct mutex umount_mutex;
u32 blocks;
u32 meta_blkaddr;
#ifdef CONFIG_EROFS_FS_XATTR
u32 xattr_blkaddr;
#endif
/* inode slot unit size in bit shift */
unsigned char islotbits;
#ifdef CONFIG_EROFS_FS_ZIP
/* cluster size in bit shift */
unsigned char clusterbits;
/* the dedicated workstation for compression */
struct radix_tree_root workstn_tree;
/* threshold for decompression synchronously */
unsigned int max_sync_decompress_pages;
#ifdef EROFS_FS_HAS_MANAGED_CACHE
struct inode *managed_cache;
#endif
#endif
u32 build_time_nsec;
u64 build_time;
/* what we really care is nid, rather than ino.. */
erofs_nid_t root_nid;
/* used for statfs, f_files - f_favail */
u64 inos;
u8 uuid[16]; /* 128-bit uuid for volume */
u8 volume_name[16]; /* volume name */
u32 requirements;
char *dev_name;
unsigned int mount_opt;
unsigned int shrinker_run_no;
#ifdef CONFIG_EROFS_FAULT_INJECTION
struct erofs_fault_info fault_info; /* For fault injection */
#endif
};
#ifdef CONFIG_EROFS_FAULT_INJECTION
#define erofs_show_injection_info(type) \
infoln("inject %s in %s of %pS", erofs_fault_name[type], \
__func__, __builtin_return_address(0))
static inline bool time_to_inject(struct erofs_sb_info *sbi, int type)
{
struct erofs_fault_info *ffi = &sbi->fault_info;
if (!ffi->inject_rate)
return false;
if (!IS_FAULT_SET(ffi, type))
return false;
atomic_inc(&ffi->inject_ops);
if (atomic_read(&ffi->inject_ops) >= ffi->inject_rate) {
atomic_set(&ffi->inject_ops, 0);
return true;
}
return false;
}
#else
static inline bool time_to_inject(struct erofs_sb_info *sbi, int type)
{
return false;
}
static inline void erofs_show_injection_info(int type)
{
}
#endif
static inline void *erofs_kmalloc(struct erofs_sb_info *sbi,
size_t size, gfp_t flags)
{
if (time_to_inject(sbi, FAULT_KMALLOC)) {
erofs_show_injection_info(FAULT_KMALLOC);
return NULL;
}
return kmalloc(size, flags);
}
#define EROFS_SB(sb) ((struct erofs_sb_info *)(sb)->s_fs_info)
#define EROFS_I_SB(inode) ((struct erofs_sb_info *)(inode)->i_sb->s_fs_info)
/* Mount flags set via mount options or defaults */
#define EROFS_MOUNT_XATTR_USER 0x00000010
#define EROFS_MOUNT_POSIX_ACL 0x00000020
#define EROFS_MOUNT_FAULT_INJECTION 0x00000040
#define clear_opt(sbi, option) ((sbi)->mount_opt &= ~EROFS_MOUNT_##option)
#define set_opt(sbi, option) ((sbi)->mount_opt |= EROFS_MOUNT_##option)
#define test_opt(sbi, option) ((sbi)->mount_opt & EROFS_MOUNT_##option)
#ifdef CONFIG_EROFS_FS_ZIP
#define erofs_workstn_lock(sbi) xa_lock(&(sbi)->workstn_tree)
#define erofs_workstn_unlock(sbi) xa_unlock(&(sbi)->workstn_tree)
/* basic unit of the workstation of a super_block */
struct erofs_workgroup {
/* the workgroup index in the workstation */
pgoff_t index;
/* overall workgroup reference count */
atomic_t refcount;
};
#define EROFS_LOCKED_MAGIC (INT_MIN | 0xE0F510CCL)
#if defined(CONFIG_SMP)
static inline bool erofs_workgroup_try_to_freeze(struct erofs_workgroup *grp,
int val)
{
preempt_disable();
if (val != atomic_cmpxchg(&grp->refcount, val, EROFS_LOCKED_MAGIC)) {
preempt_enable();
return false;
}
return true;
}
static inline void erofs_workgroup_unfreeze(struct erofs_workgroup *grp,
int orig_val)
{
/*
* other observers should notice all modifications
* in the freezing period.
*/
smp_mb();
atomic_set(&grp->refcount, orig_val);
preempt_enable();
}
static inline int erofs_wait_on_workgroup_freezed(struct erofs_workgroup *grp)
{
return atomic_cond_read_relaxed(&grp->refcount,
VAL != EROFS_LOCKED_MAGIC);
}
#else
static inline bool erofs_workgroup_try_to_freeze(struct erofs_workgroup *grp,
int val)
{
preempt_disable();
/* no need to spin on UP platforms, let's just disable preemption. */
if (val != atomic_read(&grp->refcount)) {
preempt_enable();
return false;
}
return true;
}
static inline void erofs_workgroup_unfreeze(struct erofs_workgroup *grp,
int orig_val)
{
preempt_enable();
}
static inline int erofs_wait_on_workgroup_freezed(struct erofs_workgroup *grp)
{
int v = atomic_read(&grp->refcount);
/* workgroup is never freezed on uniprocessor systems */
DBG_BUGON(v == EROFS_LOCKED_MAGIC);
return v;
}
#endif
int erofs_workgroup_put(struct erofs_workgroup *grp);
struct erofs_workgroup *erofs_find_workgroup(struct super_block *sb,
pgoff_t index, bool *tag);
int erofs_register_workgroup(struct super_block *sb,
struct erofs_workgroup *grp, bool tag);
unsigned long erofs_shrink_workstation(struct erofs_sb_info *sbi,
unsigned long nr_shrink, bool cleanup);
void erofs_workgroup_free_rcu(struct erofs_workgroup *grp);
#ifdef EROFS_FS_HAS_MANAGED_CACHE
int erofs_try_to_free_all_cached_pages(struct erofs_sb_info *sbi,
struct erofs_workgroup *egrp);
int erofs_try_to_free_cached_page(struct address_space *mapping,
struct page *page);
#define MNGD_MAPPING(sbi) ((sbi)->managed_cache->i_mapping)
static inline bool erofs_page_is_managed(const struct erofs_sb_info *sbi,
struct page *page)
{
return page->mapping == MNGD_MAPPING(sbi);
}
#else
#define MNGD_MAPPING(sbi) (NULL)
static inline bool erofs_page_is_managed(const struct erofs_sb_info *sbi,
struct page *page) { return false; }
#endif
#define DEFAULT_MAX_SYNC_DECOMPRESS_PAGES 3
static inline bool __should_decompress_synchronously(struct erofs_sb_info *sbi,
unsigned int nr)
{
return nr <= sbi->max_sync_decompress_pages;
}
int __init z_erofs_init_zip_subsystem(void);
void z_erofs_exit_zip_subsystem(void);
#else
/* dummy initializer/finalizer for the decompression subsystem */
static inline int z_erofs_init_zip_subsystem(void) { return 0; }
static inline void z_erofs_exit_zip_subsystem(void) {}
#endif
/* we strictly follow PAGE_SIZE and no buffer head yet */
#define LOG_BLOCK_SIZE PAGE_SHIFT
#undef LOG_SECTORS_PER_BLOCK
#define LOG_SECTORS_PER_BLOCK (PAGE_SHIFT - 9)
#undef SECTORS_PER_BLOCK
#define SECTORS_PER_BLOCK (1 << SECTORS_PER_BLOCK)
#define EROFS_BLKSIZ (1 << LOG_BLOCK_SIZE)
#if (EROFS_BLKSIZ % 4096 || !EROFS_BLKSIZ)
#error erofs cannot be used in this platform
#endif
#define ROOT_NID(sb) ((sb)->root_nid)
#ifdef CONFIG_EROFS_FS_ZIP
/* hard limit of pages per compressed cluster */
#define Z_EROFS_CLUSTER_MAX_PAGES (CONFIG_EROFS_FS_CLUSTER_PAGE_LIMIT)
/* page count of a compressed cluster */
#define erofs_clusterpages(sbi) ((1 << (sbi)->clusterbits) / PAGE_SIZE)
#endif
typedef u64 erofs_off_t;
/* data type for filesystem-wide blocks number */
typedef u32 erofs_blk_t;
#define erofs_blknr(addr) ((addr) / EROFS_BLKSIZ)
#define erofs_blkoff(addr) ((addr) % EROFS_BLKSIZ)
#define blknr_to_addr(nr) ((erofs_off_t)(nr) * EROFS_BLKSIZ)
static inline erofs_off_t iloc(struct erofs_sb_info *sbi, erofs_nid_t nid)
{
return blknr_to_addr(sbi->meta_blkaddr) + (nid << sbi->islotbits);
}
/* atomic flag definitions */
#define EROFS_V_EA_INITED_BIT 0
/* bitlock definitions (arranged in reverse order) */
#define EROFS_V_BL_XATTR_BIT (BITS_PER_LONG - 1)
struct erofs_vnode {
erofs_nid_t nid;
/* atomic flags (including bitlocks) */
unsigned long flags;
unsigned char data_mapping_mode;
/* inline size in bytes */
unsigned char inode_isize;
unsigned short xattr_isize;
unsigned xattr_shared_count;
unsigned *xattr_shared_xattrs;
erofs_blk_t raw_blkaddr;
/* the corresponding vfs inode */
struct inode vfs_inode;
};
#define EROFS_V(ptr) \
container_of(ptr, struct erofs_vnode, vfs_inode)
#define __inode_advise(x, bit, bits) \
(((x) >> (bit)) & ((1 << (bits)) - 1))
#define __inode_version(advise) \
__inode_advise(advise, EROFS_I_VERSION_BIT, \
EROFS_I_VERSION_BITS)
#define __inode_data_mapping(advise) \
__inode_advise(advise, EROFS_I_DATA_MAPPING_BIT,\
EROFS_I_DATA_MAPPING_BITS)
static inline unsigned long inode_datablocks(struct inode *inode)
{
/* since i_size cannot be changed */
return DIV_ROUND_UP(inode->i_size, EROFS_BLKSIZ);
}
static inline bool is_inode_layout_plain(struct inode *inode)
{
return EROFS_V(inode)->data_mapping_mode == EROFS_INODE_LAYOUT_PLAIN;
}
static inline bool is_inode_layout_compression(struct inode *inode)
{
return EROFS_V(inode)->data_mapping_mode ==
EROFS_INODE_LAYOUT_COMPRESSION;
}
static inline bool is_inode_layout_inline(struct inode *inode)
{
return EROFS_V(inode)->data_mapping_mode == EROFS_INODE_LAYOUT_INLINE;
}
extern const struct super_operations erofs_sops;
extern const struct address_space_operations erofs_raw_access_aops;
#ifdef CONFIG_EROFS_FS_ZIP
extern const struct address_space_operations z_erofs_vle_normalaccess_aops;
#endif
/*
* Logical to physical block mapping, used by erofs_map_blocks()
*
* Different with other file systems, it is used for 2 access modes:
*
* 1) RAW access mode:
*
* Users pass a valid (m_lblk, m_lofs -- usually 0) pair,
* and get the valid m_pblk, m_pofs and the longest m_len(in bytes).
*
* Note that m_lblk in the RAW access mode refers to the number of
* the compressed ondisk block rather than the uncompressed
* in-memory block for the compressed file.
*
* m_pofs equals to m_lofs except for the inline data page.
*
* 2) Normal access mode:
*
* If the inode is not compressed, it has no difference with
* the RAW access mode. However, if the inode is compressed,
* users should pass a valid (m_lblk, m_lofs) pair, and get
* the needed m_pblk, m_pofs, m_len to get the compressed data
* and the updated m_lblk, m_lofs which indicates the start
* of the corresponding uncompressed data in the file.
*/
enum {
BH_Zipped = BH_PrivateStart,
};
/* Has a disk mapping */
#define EROFS_MAP_MAPPED (1 << BH_Mapped)
/* Located in metadata (could be copied from bd_inode) */
#define EROFS_MAP_META (1 << BH_Meta)
/* The extent has been compressed */
#define EROFS_MAP_ZIPPED (1 << BH_Zipped)
struct erofs_map_blocks {
erofs_off_t m_pa, m_la;
u64 m_plen, m_llen;
unsigned int m_flags;
struct page *mpage;
};
/* Flags used by erofs_map_blocks() */
#define EROFS_GET_BLOCKS_RAW 0x0001
#ifdef CONFIG_EROFS_FS_ZIP
int z_erofs_map_blocks_iter(struct inode *inode,
struct erofs_map_blocks *map,
int flags);
#else
static inline int z_erofs_map_blocks_iter(struct inode *inode,
struct erofs_map_blocks *map,
int flags)
{
return -ENOTSUPP;
}
#endif
/* data.c */
static inline struct bio *
erofs_grab_bio(struct super_block *sb,
erofs_blk_t blkaddr, unsigned int nr_pages, void *bi_private,
bio_end_io_t endio, bool nofail)
{
const gfp_t gfp = GFP_NOIO;
struct bio *bio;
do {
if (nr_pages == 1) {
bio = bio_alloc(gfp | (nofail ? __GFP_NOFAIL : 0), 1);
if (unlikely(!bio)) {
DBG_BUGON(nofail);
return ERR_PTR(-ENOMEM);
}
break;
}
bio = bio_alloc(gfp, nr_pages);
nr_pages /= 2;
} while (unlikely(!bio));
bio->bi_end_io = endio;
bio_set_dev(bio, sb->s_bdev);
bio->bi_iter.bi_sector = (sector_t)blkaddr << LOG_SECTORS_PER_BLOCK;
bio->bi_private = bi_private;
return bio;
}
static inline void __submit_bio(struct bio *bio, unsigned op, unsigned op_flags)
{
bio_set_op_attrs(bio, op, op_flags);
submit_bio(bio);
}
#ifndef CONFIG_EROFS_FS_IO_MAX_RETRIES
#define EROFS_IO_MAX_RETRIES_NOFAIL 0
#else
#define EROFS_IO_MAX_RETRIES_NOFAIL CONFIG_EROFS_FS_IO_MAX_RETRIES
#endif
struct page *__erofs_get_meta_page(struct super_block *sb, erofs_blk_t blkaddr,
bool prio, bool nofail);
static inline struct page *erofs_get_meta_page(struct super_block *sb,
erofs_blk_t blkaddr, bool prio)
{
return __erofs_get_meta_page(sb, blkaddr, prio, false);
}
static inline struct page *erofs_get_meta_page_nofail(struct super_block *sb,
erofs_blk_t blkaddr, bool prio)
{
return __erofs_get_meta_page(sb, blkaddr, prio, true);
}
int erofs_map_blocks(struct inode *, struct erofs_map_blocks *, int);
static inline struct page *
erofs_get_inline_page(struct inode *inode,
erofs_blk_t blkaddr)
{
return erofs_get_meta_page(inode->i_sb,
blkaddr, S_ISDIR(inode->i_mode));
}
/* inode.c */
static inline unsigned long erofs_inode_hash(erofs_nid_t nid)
{
#if BITS_PER_LONG == 32
return (nid >> 32) ^ (nid & 0xffffffff);
#else
return nid;
#endif
}
extern const struct inode_operations erofs_generic_iops;
extern const struct inode_operations erofs_symlink_iops;
extern const struct inode_operations erofs_fast_symlink_iops;
static inline void set_inode_fast_symlink(struct inode *inode)
{
inode->i_op = &erofs_fast_symlink_iops;
}
static inline bool is_inode_fast_symlink(struct inode *inode)
{
return inode->i_op == &erofs_fast_symlink_iops;
}
struct inode *erofs_iget(struct super_block *sb, erofs_nid_t nid, bool dir);
/* namei.c */
extern const struct inode_operations erofs_dir_iops;
int erofs_namei(struct inode *dir, struct qstr *name,
erofs_nid_t *nid, unsigned int *d_type);
/* dir.c */
extern const struct file_operations erofs_dir_fops;
static inline void *erofs_vmap(struct page **pages, unsigned int count)
{
#ifdef CONFIG_EROFS_FS_USE_VM_MAP_RAM
int i = 0;
while (1) {
void *addr = vm_map_ram(pages, count, -1, PAGE_KERNEL);
/* retry two more times (totally 3 times) */
if (addr || ++i >= 3)
return addr;
vm_unmap_aliases();
}
return NULL;
#else
return vmap(pages, count, VM_MAP, PAGE_KERNEL);
#endif
}
static inline void erofs_vunmap(const void *mem, unsigned int count)
{
#ifdef CONFIG_EROFS_FS_USE_VM_MAP_RAM
vm_unmap_ram(mem, count);
#else
vunmap(mem);
#endif
}
/* utils.c */
extern struct shrinker erofs_shrinker_info;
struct page *erofs_allocpage(struct list_head *pool, gfp_t gfp);
void erofs_register_super(struct super_block *sb);
void erofs_unregister_super(struct super_block *sb);
#ifndef lru_to_page
#define lru_to_page(head) (list_entry((head)->prev, struct page, lru))
#endif
#endif
| gpl-2.0 |
janlindstrom/percona-xtrabackup | storage/innobase/xtrabackup/test/t/xb_stats_datadir.sh | 864 | ################################################################################
# Bug #1174314
# Test xtrabackup --stats with server dir
################################################################################
. inc/common.sh
logdir=${TEST_VAR_ROOT}/logs
mkdir $logdir
MYSQLD_EXTRA_MY_CNF_OPTS="
innodb_log_group_home_dir=$logdir
"
start_server
run_cmd $MYSQL $MYSQL_ARGS test <<EOF
CREATE TABLE t1(a INT) ENGINE=InnoDB;
INSERT INTO t1 VALUES (1), (2), (3);
EOF
shutdown_server
# there is inconsistency between shutdown_server and stop_server
# stop_server sets XB_ARGS="--no-defaults", while shutdown_server
# doesn't.
# we pass all necessary options as an arguments, so if someday this
# will be changed, test still will work
xtrabackup --stats --datadir=${MYSQLD_DATADIR} \
--innodb_log_group_home_dir=$logdir
vlog "stats did not fail"
| gpl-2.0 |
md-5/jdk10 | test/hotspot/jtreg/vmTestbase/nsk/jdi/VirtualMachine/redefineClasses/redefineclasses012/newclass01/redefineclasses012b.java | 1616 | /*
* Copyright (c) 2002, 2018, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package nsk.jdi.VirtualMachine.redefineClasses;
import nsk.share.*;
import nsk.share.jpda.*;
import nsk.share.jdi.*;
/**
* <code>redefineclasses012b</code> is deugee's part of the redefineclasses012.
* adding new field
*/
public interface redefineclasses012b {
//new fields
static public final Object newField001 = null;
//preexisting fields
static public final Object field001 = null;
public final Object field002 = null;
final Object field003 = null;
Object field004 = null;
}
| gpl-2.0 |
Taeung/tip | drivers/gpu/drm/i915/i915_active.c | 7177 | /*
* SPDX-License-Identifier: MIT
*
* Copyright © 2019 Intel Corporation
*/
#include "i915_drv.h"
#include "i915_active.h"
#define BKL(ref) (&(ref)->i915->drm.struct_mutex)
/*
* Active refs memory management
*
* To be more economical with memory, we reap all the i915_active trees as
* they idle (when we know the active requests are inactive) and allocate the
* nodes from a local slab cache to hopefully reduce the fragmentation.
*/
static struct i915_global_active {
struct kmem_cache *slab_cache;
} global;
struct active_node {
struct i915_active_request base;
struct i915_active *ref;
struct rb_node node;
u64 timeline;
};
static void
__active_park(struct i915_active *ref)
{
struct active_node *it, *n;
rbtree_postorder_for_each_entry_safe(it, n, &ref->tree, node) {
GEM_BUG_ON(i915_active_request_isset(&it->base));
kmem_cache_free(global.slab_cache, it);
}
ref->tree = RB_ROOT;
}
static void
__active_retire(struct i915_active *ref)
{
GEM_BUG_ON(!ref->count);
if (--ref->count)
return;
/* return the unused nodes to our slabcache */
__active_park(ref);
ref->retire(ref);
}
static void
node_retire(struct i915_active_request *base, struct i915_request *rq)
{
__active_retire(container_of(base, struct active_node, base)->ref);
}
static void
last_retire(struct i915_active_request *base, struct i915_request *rq)
{
__active_retire(container_of(base, struct i915_active, last));
}
static struct i915_active_request *
active_instance(struct i915_active *ref, u64 idx)
{
struct active_node *node;
struct rb_node **p, *parent;
struct i915_request *old;
/*
* We track the most recently used timeline to skip a rbtree search
* for the common case, under typical loads we never need the rbtree
* at all. We can reuse the last slot if it is empty, that is
* after the previous activity has been retired, or if it matches the
* current timeline.
*
* Note that we allow the timeline to be active simultaneously in
* the rbtree and the last cache. We do this to avoid having
* to search and replace the rbtree element for a new timeline, with
* the cost being that we must be aware that the ref may be retired
* twice for the same timeline (as the older rbtree element will be
* retired before the new request added to last).
*/
old = i915_active_request_raw(&ref->last, BKL(ref));
if (!old || old->fence.context == idx)
goto out;
/* Move the currently active fence into the rbtree */
idx = old->fence.context;
parent = NULL;
p = &ref->tree.rb_node;
while (*p) {
parent = *p;
node = rb_entry(parent, struct active_node, node);
if (node->timeline == idx)
goto replace;
if (node->timeline < idx)
p = &parent->rb_right;
else
p = &parent->rb_left;
}
node = kmem_cache_alloc(global.slab_cache, GFP_KERNEL);
/* kmalloc may retire the ref->last (thanks shrinker)! */
if (unlikely(!i915_active_request_raw(&ref->last, BKL(ref)))) {
kmem_cache_free(global.slab_cache, node);
goto out;
}
if (unlikely(!node))
return ERR_PTR(-ENOMEM);
i915_active_request_init(&node->base, NULL, node_retire);
node->ref = ref;
node->timeline = idx;
rb_link_node(&node->node, parent, p);
rb_insert_color(&node->node, &ref->tree);
replace:
/*
* Overwrite the previous active slot in the rbtree with last,
* leaving last zeroed. If the previous slot is still active,
* we must be careful as we now only expect to receive one retire
* callback not two, and so much undo the active counting for the
* overwritten slot.
*/
if (i915_active_request_isset(&node->base)) {
/* Retire ourselves from the old rq->active_list */
__list_del_entry(&node->base.link);
ref->count--;
GEM_BUG_ON(!ref->count);
}
GEM_BUG_ON(list_empty(&ref->last.link));
list_replace_init(&ref->last.link, &node->base.link);
node->base.request = fetch_and_zero(&ref->last.request);
out:
return &ref->last;
}
void i915_active_init(struct drm_i915_private *i915,
struct i915_active *ref,
void (*retire)(struct i915_active *ref))
{
ref->i915 = i915;
ref->retire = retire;
ref->tree = RB_ROOT;
i915_active_request_init(&ref->last, NULL, last_retire);
ref->count = 0;
}
int i915_active_ref(struct i915_active *ref,
u64 timeline,
struct i915_request *rq)
{
struct i915_active_request *active;
int err = 0;
/* Prevent reaping in case we malloc/wait while building the tree */
i915_active_acquire(ref);
active = active_instance(ref, timeline);
if (IS_ERR(active)) {
err = PTR_ERR(active);
goto out;
}
if (!i915_active_request_isset(active))
ref->count++;
__i915_active_request_set(active, rq);
GEM_BUG_ON(!ref->count);
out:
i915_active_release(ref);
return err;
}
bool i915_active_acquire(struct i915_active *ref)
{
lockdep_assert_held(BKL(ref));
return !ref->count++;
}
void i915_active_release(struct i915_active *ref)
{
lockdep_assert_held(BKL(ref));
__active_retire(ref);
}
int i915_active_wait(struct i915_active *ref)
{
struct active_node *it, *n;
int ret = 0;
if (i915_active_acquire(ref))
goto out_release;
ret = i915_active_request_retire(&ref->last, BKL(ref));
if (ret)
goto out_release;
rbtree_postorder_for_each_entry_safe(it, n, &ref->tree, node) {
ret = i915_active_request_retire(&it->base, BKL(ref));
if (ret)
break;
}
out_release:
i915_active_release(ref);
return ret;
}
int i915_request_await_active_request(struct i915_request *rq,
struct i915_active_request *active)
{
struct i915_request *barrier =
i915_active_request_raw(active, &rq->i915->drm.struct_mutex);
return barrier ? i915_request_await_dma_fence(rq, &barrier->fence) : 0;
}
int i915_request_await_active(struct i915_request *rq, struct i915_active *ref)
{
struct active_node *it, *n;
int err = 0;
/* await allocates and so we need to avoid hitting the shrinker */
if (i915_active_acquire(ref))
goto out; /* was idle */
err = i915_request_await_active_request(rq, &ref->last);
if (err)
goto out;
rbtree_postorder_for_each_entry_safe(it, n, &ref->tree, node) {
err = i915_request_await_active_request(rq, &it->base);
if (err)
goto out;
}
out:
i915_active_release(ref);
return err;
}
#if IS_ENABLED(CONFIG_DRM_I915_DEBUG_GEM)
void i915_active_fini(struct i915_active *ref)
{
GEM_BUG_ON(i915_active_request_isset(&ref->last));
GEM_BUG_ON(!RB_EMPTY_ROOT(&ref->tree));
GEM_BUG_ON(ref->count);
}
#endif
int i915_active_request_set(struct i915_active_request *active,
struct i915_request *rq)
{
int err;
/* Must maintain ordering wrt previous active requests */
err = i915_request_await_active_request(rq, active);
if (err)
return err;
__i915_active_request_set(active, rq);
return 0;
}
void i915_active_retire_noop(struct i915_active_request *active,
struct i915_request *request)
{
/* Space left intentionally blank */
}
#if IS_ENABLED(CONFIG_DRM_I915_SELFTEST)
#include "selftests/i915_active.c"
#endif
int __init i915_global_active_init(void)
{
global.slab_cache = KMEM_CACHE(active_node, SLAB_HWCACHE_ALIGN);
if (!global.slab_cache)
return -ENOMEM;
return 0;
}
void __exit i915_global_active_exit(void)
{
kmem_cache_destroy(global.slab_cache);
}
| gpl-2.0 |
byeonggonlee/lynx-ns-gb | toolchain/share/doc/arm-arm-none-eabi/html/gcc/Structures-unions-enumerations-and-bit_002dfields-implementation.html | 5754 | <html lang="en">
<head>
<title>Structures unions enumerations and bit-fields implementation - Using the GNU Compiler Collection (GCC)</title>
<meta http-equiv="Content-Type" content="text/html">
<meta name="description" content="Using the GNU Compiler Collection (GCC)">
<meta name="generator" content="makeinfo 4.13">
<link title="Top" rel="start" href="index.html#Top">
<link rel="up" href="C-Implementation.html#C-Implementation" title="C Implementation">
<link rel="prev" href="Hints-implementation.html#Hints-implementation" title="Hints implementation">
<link rel="next" href="Qualifiers-implementation.html#Qualifiers-implementation" title="Qualifiers implementation">
<link href="http://www.gnu.org/software/texinfo/" rel="generator-home" title="Texinfo Homepage">
<!--
Copyright (C) 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997,
1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
2010 Free Software Foundation, Inc.
Permission is granted to copy, distribute and/or modify this document
under the terms of the GNU Free Documentation License, Version 1.3 or
any later version published by the Free Software Foundation; with the
Invariant Sections being ``Funding Free Software'', the Front-Cover
Texts being (a) (see below), and with the Back-Cover Texts being (b)
(see below). A copy of the license is included in the section entitled
``GNU Free Documentation License''.
(a) The FSF's Front-Cover Text is:
A GNU Manual
(b) The FSF's Back-Cover Text is:
You have freedom to copy and modify this GNU Manual, like GNU
software. Copies published by the Free Software Foundation raise
funds for GNU development.-->
<meta http-equiv="Content-Style-Type" content="text/css">
<style type="text/css"><!--
pre.display { font-family:inherit }
pre.format { font-family:inherit }
pre.smalldisplay { font-family:inherit; font-size:smaller }
pre.smallformat { font-family:inherit; font-size:smaller }
pre.smallexample { font-size:smaller }
pre.smalllisp { font-size:smaller }
span.sc { font-variant:small-caps }
span.roman { font-family:serif; font-weight:normal; }
span.sansserif { font-family:sans-serif; font-weight:normal; }
--></style>
<link rel="stylesheet" type="text/css" href="../cs.css">
</head>
<body>
<div class="node">
<a name="Structures-unions-enumerations-and-bit-fields-implementation"></a>
<a name="Structures-unions-enumerations-and-bit_002dfields-implementation"></a>
<p>
Next: <a rel="next" accesskey="n" href="Qualifiers-implementation.html#Qualifiers-implementation">Qualifiers implementation</a>,
Previous: <a rel="previous" accesskey="p" href="Hints-implementation.html#Hints-implementation">Hints implementation</a>,
Up: <a rel="up" accesskey="u" href="C-Implementation.html#C-Implementation">C Implementation</a>
<hr>
</div>
<h3 class="section">4.9 Structures, unions, enumerations, and bit-fields</h3>
<ul>
<li><cite>A member of a union object is accessed using a member of a
different type (C90 6.3.2.3).</cite>
<p>The relevant bytes of the representation of the object are treated as
an object of the type used for the access. See <a href="Type_002dpunning.html#Type_002dpunning">Type-punning</a>. This
may be a trap representation.
<li><cite>Whether a “plain” </cite><code>int</code><cite> bit-field is treated as a
</cite><code>signed int</code><cite> bit-field or as an </cite><code>unsigned int</code><cite> bit-field
(C90 6.5.2, C90 6.5.2.1, C99 6.7.2, C99 6.7.2.1).</cite>
<p><a name="index-funsigned_002dbitfields-2233"></a>By default it is treated as <code>signed int</code> but this may be changed
by the <samp><span class="option">-funsigned-bitfields</span></samp> option.
<li><cite>Allowable bit-field types other than </cite><code>_Bool</code><cite>, </cite><code>signed int</code><cite>,
and </cite><code>unsigned int</code><cite> (C99 6.7.2.1).</cite>
<p>No other types are permitted in strictly conforming mode.
<!-- Would it be better to restrict the pedwarn for other types to C90 -->
<!-- mode and document the other types for C99 mode? -->
<li><cite>Whether a bit-field can straddle a storage-unit boundary (C90
6.5.2.1, C99 6.7.2.1).</cite>
<p>Determined by ABI.
<li><cite>The order of allocation of bit-fields within a unit (C90
6.5.2.1, C99 6.7.2.1).</cite>
<p>Determined by ABI.
<li><cite>The alignment of non-bit-field members of structures (C90
6.5.2.1, C99 6.7.2.1).</cite>
<p>Determined by ABI.
<li><cite>The integer type compatible with each enumerated type (C90
6.5.2.2, C99 6.7.2.2).</cite>
<p><a name="index-fshort_002denums-2234"></a>Normally, the type is <code>unsigned int</code> if there are no negative
values in the enumeration, otherwise <code>int</code>. If
<samp><span class="option">-fshort-enums</span></samp> is specified, then if there are negative values
it is the first of <code>signed char</code>, <code>short</code> and <code>int</code>
that can represent all the values, otherwise it is the first of
<code>unsigned char</code>, <code>unsigned short</code> and <code>unsigned int</code>
that can represent all the values.
<!-- On a few unusual targets with 64-bit int, this doesn't agree with -->
<!-- the code and one of the types accessed via mode attributes (which -->
<!-- are not currently considered extended integer types) may be used. -->
<!-- If these types are made extended integer types, it would still be -->
<!-- the case that -fshort-enums stops the implementation from -->
<!-- conforming to C90 on those targets. -->
<p>On some targets, <samp><span class="option">-fshort-enums</span></samp> is the default; this is
determined by the ABI.
</ul>
</body></html>
| gpl-2.0 |
Gurgel100/gcc | libgomp/testsuite/libgomp.fortran/simd7.f90 | 9253 | ! { dg-do run }
! { dg-additional-options "-msse2" { target sse2_runtime } }
! { dg-additional-options "-mavx" { target avx_runtime } }
subroutine foo (d, e, f, g, m, n)
integer :: i, j, b(2:9), c(3:n), d(:), e(2:n), f(2:,3:), n
integer, allocatable :: g(:), h(:), k, m
logical :: l
l = .false.
allocate (h(2:7))
i = 4; j = 4; b = 7; c = 8; d = 9; e = 10; f = 11; g = 12; h = 13; k = 14; m = 15
!$omp simd linear(b)linear(c:2)linear(d:3)linear(e:4)linear(f:5)linear(g:6) &
!$omp & linear(h:7)linear(k:8)linear(m:9) reduction(.or.:l)
do i = 0, 63
l = l .or. .not.allocated (g) .or. .not.allocated (h)
l = l .or. .not.allocated (k) .or. .not.allocated (m)
l = l .or. any (b /= 7 + i) .or. any (c /= 8 + 2 * i)
l = l .or. any (d /= 9 + 3 * i) .or. any (e /= 10 + 4 * i)
l = l .or. any (f /= 11 + 5 * i) .or. any (g /= 12 + 6 * i)
l = l .or. any (h /= 13 + 7 * i) .or. (k /= 14 + 8 * i)
l = l .or. (m /= 15 + 9 * i)
l = l .or. (lbound (b, 1) /= 2) .or. (ubound (b, 1) /= 9)
l = l .or. (lbound (c, 1) /= 3) .or. (ubound (c, 1) /= n)
l = l .or. (lbound (d, 1) /= 1) .or. (ubound (d, 1) /= 17)
l = l .or. (lbound (e, 1) /= 2) .or. (ubound (e, 1) /= n)
l = l .or. (lbound (f, 1) /= 2) .or. (ubound (f, 1) /= 3)
l = l .or. (lbound (f, 2) /= 3) .or. (ubound (f, 2) /= 5)
l = l .or. (lbound (g, 1) /= 7) .or. (ubound (g, 1) /= 10)
l = l .or. (lbound (h, 1) /= 2) .or. (ubound (h, 1) /= 7)
b = b + 1; c = c + 2; d = d + 3; e = e + 4; f = f + 5; g = g + 6
h = h + 7; k = k + 8; m = m + 9
end do
if (l .or. i /= 64) stop 1
if (any (b /= 7 + 64) .or. any (c /= 8 + 2 * 64)) stop 2
if (any (d /= 9 + 3 * 64) .or. any (e /= 10 + 4 * 64)) stop 3
if (any (f /= 11 + 5 * 64) .or. any (g /= 12 + 6 * 64)) stop 4
if (any (h /= 13 + 7 * 64) .or. (k /= 14 + 8 * 64)) stop 5
if (m /= 15 + 9 * 64) stop 6
if ((lbound (b, 1) /= 2) .or. (ubound (b, 1) /= 9)) stop 7
if ((lbound (c, 1) /= 3) .or. (ubound (c, 1) /= n)) stop 8
if ((lbound (d, 1) /= 1) .or. (ubound (d, 1) /= 17)) stop 9
if ((lbound (e, 1) /= 2) .or. (ubound (e, 1) /= n)) stop 10
if ((lbound (f, 1) /= 2) .or. (ubound (f, 1) /= 3)) stop 11
if ((lbound (f, 2) /= 3) .or. (ubound (f, 2) /= 5)) stop 12
if ((lbound (g, 1) /= 7) .or. (ubound (g, 1) /= 10)) stop 13
if ((lbound (h, 1) /= 2) .or. (ubound (h, 1) /= 7)) stop 14
i = 4; j = 4; b = 7; c = 8; d = 9; e = 10; f = 11; g = 12; h = 13; k = 14; m = 15
!$omp simd linear(b)linear(c:2)linear(d:3)linear(e:4)linear(f:5)linear(g:6) &
!$omp & linear(h:7)linear(k:8)linear(m:9) reduction(.or.:l) collapse(2)
do i = 0, 7
do j = 0, 7
l = l .or. .not.allocated (g) .or. .not.allocated (h)
l = l .or. .not.allocated (k) .or. .not.allocated (m)
l = l .or. any (b /= 7 + (8 * i + j)) .or. any (c /= 8 + 2 * (8 * i + j))
l = l .or. any (d /= 9 + 3 * (8 * i + j)) .or. any (e /= 10 + 4 * (8 * i + j))
l = l .or. any (f /= 11 + 5 * (8 * i + j)) .or. any (g /= 12 + 6 * (8 * i + j))
l = l .or. any (h /= 13 + 7 * (8 * i + j)) .or. (k /= 14 + 8 * (8 * i + j))
l = l .or. (m /= 15 + 9 * (8 * i + j))
l = l .or. (lbound (b, 1) /= 2) .or. (ubound (b, 1) /= 9)
l = l .or. (lbound (c, 1) /= 3) .or. (ubound (c, 1) /= n)
l = l .or. (lbound (d, 1) /= 1) .or. (ubound (d, 1) /= 17)
l = l .or. (lbound (e, 1) /= 2) .or. (ubound (e, 1) /= n)
l = l .or. (lbound (f, 1) /= 2) .or. (ubound (f, 1) /= 3)
l = l .or. (lbound (f, 2) /= 3) .or. (ubound (f, 2) /= 5)
l = l .or. (lbound (g, 1) /= 7) .or. (ubound (g, 1) /= 10)
l = l .or. (lbound (h, 1) /= 2) .or. (ubound (h, 1) /= 7)
b = b + 1; c = c + 2; d = d + 3; e = e + 4; f = f + 5; g = g + 6
h = h + 7; k = k + 8; m = m + 9
end do
end do
if (l .or. i /= 8 .or. j /= 8) stop 15
if (any (b /= 7 + 64) .or. any (c /= 8 + 2 * 64)) stop 16
if (any (d /= 9 + 3 * 64) .or. any (e /= 10 + 4 * 64)) stop 17
if (any (f /= 11 + 5 * 64) .or. any (g /= 12 + 6 * 64)) stop 18
if (any (h /= 13 + 7 * 64) .or. (k /= 14 + 8 * 64)) stop 19
if (m /= 15 + 9 * 64) stop 20
if ((lbound (b, 1) /= 2) .or. (ubound (b, 1) /= 9)) stop 21
if ((lbound (c, 1) /= 3) .or. (ubound (c, 1) /= n)) stop 22
if ((lbound (d, 1) /= 1) .or. (ubound (d, 1) /= 17)) stop 23
if ((lbound (e, 1) /= 2) .or. (ubound (e, 1) /= n)) stop 24
if ((lbound (f, 1) /= 2) .or. (ubound (f, 1) /= 3)) stop 25
if ((lbound (f, 2) /= 3) .or. (ubound (f, 2) /= 5)) stop 26
if ((lbound (g, 1) /= 7) .or. (ubound (g, 1) /= 10)) stop 27
if ((lbound (h, 1) /= 2) .or. (ubound (h, 1) /= 7)) stop 28
i = 4; j = 4; b = 7; c = 8; d = 9; e = 10; f = 11; g = 12; h = 13; k = 14; m = 15
!$omp parallel do simd linear(b)linear(c:2)linear(d:3)linear(e:4)linear(f:5) &
!$omp & linear(g:6)linear(h:7)linear(k:8)linear(m:9) reduction(.or.:l)
do i = 0, 63
l = l .or. .not.allocated (g) .or. .not.allocated (h)
l = l .or. .not.allocated (k) .or. .not.allocated (m)
l = l .or. any (b /= 7 + i) .or. any (c /= 8 + 2 * i)
l = l .or. any (d /= 9 + 3 * i) .or. any (e /= 10 + 4 * i)
l = l .or. any (f /= 11 + 5 * i) .or. any (g /= 12 + 6 * i)
l = l .or. any (h /= 13 + 7 * i) .or. (k /= 14 + 8 * i)
l = l .or. (m /= 15 + 9 * i)
l = l .or. (lbound (b, 1) /= 2) .or. (ubound (b, 1) /= 9)
l = l .or. (lbound (c, 1) /= 3) .or. (ubound (c, 1) /= n)
l = l .or. (lbound (d, 1) /= 1) .or. (ubound (d, 1) /= 17)
l = l .or. (lbound (e, 1) /= 2) .or. (ubound (e, 1) /= n)
l = l .or. (lbound (f, 1) /= 2) .or. (ubound (f, 1) /= 3)
l = l .or. (lbound (f, 2) /= 3) .or. (ubound (f, 2) /= 5)
l = l .or. (lbound (g, 1) /= 7) .or. (ubound (g, 1) /= 10)
l = l .or. (lbound (h, 1) /= 2) .or. (ubound (h, 1) /= 7)
b = b + 1; c = c + 2; d = d + 3; e = e + 4; f = f + 5; g = g + 6
h = h + 7; k = k + 8; m = m + 9
end do
if (l .or. i /= 64) stop 29
if (any (b /= 7 + 64) .or. any (c /= 8 + 2 * 64)) stop 30
if (any (d /= 9 + 3 * 64) .or. any (e /= 10 + 4 * 64)) stop 31
if (any (f /= 11 + 5 * 64) .or. any (g /= 12 + 6 * 64)) stop 32
if (any (h /= 13 + 7 * 64) .or. (k /= 14 + 8 * 64)) stop 33
if (m /= 15 + 9 * 64) stop 34
if ((lbound (b, 1) /= 2) .or. (ubound (b, 1) /= 9)) stop 35
if ((lbound (c, 1) /= 3) .or. (ubound (c, 1) /= n)) stop 36
if ((lbound (d, 1) /= 1) .or. (ubound (d, 1) /= 17)) stop 37
if ((lbound (e, 1) /= 2) .or. (ubound (e, 1) /= n)) stop 38
if ((lbound (f, 1) /= 2) .or. (ubound (f, 1) /= 3)) stop 39
if ((lbound (f, 2) /= 3) .or. (ubound (f, 2) /= 5)) stop 40
if ((lbound (g, 1) /= 7) .or. (ubound (g, 1) /= 10)) stop 41
if ((lbound (h, 1) /= 2) .or. (ubound (h, 1) /= 7)) stop 42
i = 4; j = 4; b = 7; c = 8; d = 9; e = 10; f = 11; g = 12; h = 13; k = 14; m = 15
!$omp parallel do simd linear(b)linear(c:2)linear(d:3)linear(e:4)linear(f:5) &
!$omp & linear(g:6)linear(h:7)linear(k:8)linear(m:9) reduction(.or.:l) collapse(2)
do i = 0, 7
do j = 0, 7
l = l .or. .not.allocated (g) .or. .not.allocated (h)
l = l .or. .not.allocated (k) .or. .not.allocated (m)
l = l .or. any (b /= 7 + (8 * i + j)) .or. any (c /= 8 + 2 * (8 * i + j))
l = l .or. any (d /= 9 + 3 * (8 * i + j)) .or. any (e /= 10 + 4 * (8 * i + j))
l = l .or. any (f /= 11 + 5 * (8 * i + j)) .or. any (g /= 12 + 6 * (8 * i + j))
l = l .or. any (h /= 13 + 7 * (8 * i + j)) .or. (k /= 14 + 8 * (8 * i + j))
l = l .or. (m /= 15 + 9 * (8 * i + j))
l = l .or. (lbound (b, 1) /= 2) .or. (ubound (b, 1) /= 9)
l = l .or. (lbound (c, 1) /= 3) .or. (ubound (c, 1) /= n)
l = l .or. (lbound (d, 1) /= 1) .or. (ubound (d, 1) /= 17)
l = l .or. (lbound (e, 1) /= 2) .or. (ubound (e, 1) /= n)
l = l .or. (lbound (f, 1) /= 2) .or. (ubound (f, 1) /= 3)
l = l .or. (lbound (f, 2) /= 3) .or. (ubound (f, 2) /= 5)
l = l .or. (lbound (g, 1) /= 7) .or. (ubound (g, 1) /= 10)
l = l .or. (lbound (h, 1) /= 2) .or. (ubound (h, 1) /= 7)
b = b + 1; c = c + 2; d = d + 3; e = e + 4; f = f + 5; g = g + 6
h = h + 7; k = k + 8; m = m + 9
end do
end do
if (l .or. i /= 8 .or. j /= 8) stop 43
if (any (b /= 7 + 64) .or. any (c /= 8 + 2 * 64)) stop 44
if (any (d /= 9 + 3 * 64) .or. any (e /= 10 + 4 * 64)) stop 45
if (any (f /= 11 + 5 * 64) .or. any (g /= 12 + 6 * 64)) stop 46
if (any (h /= 13 + 7 * 64) .or. (k /= 14 + 8 * 64)) stop 47
if (m /= 15 + 9 * 64) stop 48
if ((lbound (b, 1) /= 2) .or. (ubound (b, 1) /= 9)) stop 49
if ((lbound (c, 1) /= 3) .or. (ubound (c, 1) /= n)) stop 50
if ((lbound (d, 1) /= 1) .or. (ubound (d, 1) /= 17)) stop 51
if ((lbound (e, 1) /= 2) .or. (ubound (e, 1) /= n)) stop 52
if ((lbound (f, 1) /= 2) .or. (ubound (f, 1) /= 3)) stop 53
if ((lbound (f, 2) /= 3) .or. (ubound (f, 2) /= 5)) stop 54
if ((lbound (g, 1) /= 7) .or. (ubound (g, 1) /= 10)) stop 55
if ((lbound (h, 1) /= 2) .or. (ubound (h, 1) /= 7)) stop 56
end subroutine
interface
subroutine foo (d, e, f, g, m, n)
integer :: d(:), e(2:n), f(2:,3:), n
integer, allocatable :: g(:), m
end subroutine
end interface
integer, parameter :: n = 8
integer :: d(2:18), e(3:n+1), f(5:6,7:9)
integer, allocatable :: g(:), m
allocate (g(7:10))
call foo (d, e, f, g, m, n)
end
| gpl-2.0 |
co-alliance/adr | sites/all/modules/islandora_contrib/islandora_scholar/modules/citeproc/lib/citeproc-php/doc/html/classcsl__sort.html | 5865 | <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
<title>CiteProc - PHP: csl_sort Class Reference</title>
<link href="tabs.css" rel="stylesheet" type="text/css"/>
<link href="search/search.css" rel="stylesheet" type="text/css"/>
<script type="text/javascript" src="search/search.js"></script>
<link href="navtree.css" rel="stylesheet" type="text/css"/>
<script type="text/javascript" src="jquery.js"></script>
<script type="text/javascript" src="navtree.js"></script>
<script type="text/javascript" src="resize.js"></script>
<script type="text/javascript">
$(document).ready(initResizable);
</script>
<link href="doxygen.css" rel="stylesheet" type="text/css"/>
</head>
<body onload='searchBox.OnSelectItem(0);'>
<!-- Generated by Doxygen 1.7.3 -->
<script type="text/javascript"><!--
var searchBox = new SearchBox("searchBox", "search",false,'Search');
--></script>
<div id="top">
<div id="titlearea">
<table cellspacing="0" cellpadding="0">
<tbody>
<tr style="height: 56px;">
<td style="padding-left: 0.5em;">
<div id="projectname">CiteProc - PHP</div>
<div id="projectbrief">A PHP implementation of the CSL citation processor "CiteProc"</div>
</td>
</tr>
</tbody>
</table>
</div>
<div id="navrow1" class="tabs">
<ul class="tablist">
<li><a href="index.html"><span>Main Page</span></a></li>
<li class="current"><a href="annotated.html"><span>Data Structures</span></a></li>
<li><a href="files.html"><span>Files</span></a></li>
<li id="searchli">
<div id="MSearchBox" class="MSearchBoxInactive">
<span class="left">
<img id="MSearchSelect" src="search/mag_sel.png"
onmouseover="return searchBox.OnSearchSelectShow()"
onmouseout="return searchBox.OnSearchSelectHide()"
alt=""/>
<input type="text" id="MSearchField" value="Search" accesskey="S"
onfocus="searchBox.OnSearchFieldFocus(true)"
onblur="searchBox.OnSearchFieldFocus(false)"
onkeyup="searchBox.OnSearchFieldChange(event)"/>
</span><span class="right">
<a id="MSearchClose" href="javascript:searchBox.CloseResultsWindow()"><img id="MSearchCloseImg" border="0" src="search/close.png" alt=""/></a>
</span>
</div>
</li>
</ul>
</div>
<div id="navrow2" class="tabs2">
<ul class="tablist">
<li><a href="annotated.html"><span>Data Structures</span></a></li>
<li><a href="classes.html"><span>Data Structure Index</span></a></li>
<li><a href="hierarchy.html"><span>Class Hierarchy</span></a></li>
<li><a href="functions.html"><span>Data Fields</span></a></li>
</ul>
</div>
</div>
<div id="side-nav" class="ui-resizable side-nav-resizable">
<div id="nav-tree">
<div id="nav-tree-contents">
</div>
</div>
<div id="splitbar" style="-moz-user-select:none;"
class="ui-resizable-handle">
</div>
</div>
<script type="text/javascript">
initNavTree('classcsl__sort.html','');
</script>
<div id="doc-content">
<div class="header">
<div class="headertitle">
<h1>csl_sort Class Reference</h1> </div>
</div>
<div class="contents">
<!-- doxytag: class="csl_sort" --><!-- doxytag: inherits="csl_element" --><div class="dynheader">
Inheritance diagram for csl_sort:</div>
<div class="dyncontent">
<div class="center">
<img src="classcsl__sort.png" usemap="#csl_sort_map" alt=""/>
<map id="csl_sort_map" name="csl_sort_map">
<area href="classcsl__element.html" alt="csl_element" shape="rect" coords="0,56,89,80"/>
<area href="classcsl__collection.html" alt="csl_collection" shape="rect" coords="0,0,89,24"/>
</map>
</div></div>
<table class="memberdecls">
</table>
<hr/><a name="_details"></a><h2>Detailed Description</h2>
<div class="textblock">
<p>Definition at line <a class="el" href="_cite_proc_8php_source.html#l01169">1169</a> of file <a class="el" href="_cite_proc_8php_source.html">CiteProc.php</a>.</p>
</div><hr/>The documentation for this class was generated from the following file:<ul>
<li><a class="el" href="_cite_proc_8php_source.html">CiteProc.php</a></li>
</ul>
</div>
</div>
<div id="nav-path" class="navpath">
<ul>
<li class="navelem"><a class="el" href="classcsl__sort.html">csl_sort</a> </li>
<li class="footer">Generated on Thu Feb 10 2011 10:45:56 for CiteProc - PHP by 
<a href="http://www.doxygen.org/index.html">
<img class="footer" src="doxygen.png" alt="doxygen"/></a> 1.7.3 </li>
</ul>
</div>
<!--- window showing the filter options -->
<div id="MSearchSelectWindow"
onmouseover="return searchBox.OnSearchSelectShow()"
onmouseout="return searchBox.OnSearchSelectHide()"
onkeydown="return searchBox.OnSearchSelectKey(event)">
<a class="SelectItem" href="javascript:void(0)" onclick="searchBox.OnSelectItem(0)"><span class="SelectionMark"> </span>All</a><a class="SelectItem" href="javascript:void(0)" onclick="searchBox.OnSelectItem(1)"><span class="SelectionMark"> </span>Data Structures</a><a class="SelectItem" href="javascript:void(0)" onclick="searchBox.OnSelectItem(2)"><span class="SelectionMark"> </span>Files</a><a class="SelectItem" href="javascript:void(0)" onclick="searchBox.OnSelectItem(3)"><span class="SelectionMark"> </span>Functions</a><a class="SelectItem" href="javascript:void(0)" onclick="searchBox.OnSelectItem(4)"><span class="SelectionMark"> </span>Variables</a></div>
<!-- iframe showing the search results (closed by default) -->
<div id="MSearchResultsWindow">
<iframe src="" frameborder="0"
name="MSearchResults" id="MSearchResults">
</iframe>
</div>
</body>
</html>
| gpl-2.0 |
sgrichards/BrightonDrupal | vendor/drupal/console/src/Command/Generate/PluginFieldWidgetCommand.php | 5154 | <?php
/**
* @file
* Contains \Drupal\Console\Command\Generate\PluginFieldWidgetCommand.
*/
namespace Drupal\Console\Command\Generate;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Output\OutputInterface;
use Drupal\Console\Generator\PluginFieldWidgetGenerator;
use Drupal\Console\Command\ModuleTrait;
use Drupal\Console\Command\ConfirmationTrait;
use Drupal\Console\Command\GeneratorCommand;
use Drupal\Console\Style\DrupalStyle;
class PluginFieldWidgetCommand extends GeneratorCommand
{
use ModuleTrait;
use ConfirmationTrait;
protected function configure()
{
$this
->setName('generate:plugin:fieldwidget')
->setDescription($this->trans('commands.generate.plugin.fieldwidget.description'))
->setHelp($this->trans('commands.generate.plugin.fieldwidget.help'))
->addOption('module', '', InputOption::VALUE_REQUIRED, $this->trans('commands.common.options.module'))
->addOption(
'class',
'',
InputOption::VALUE_REQUIRED,
$this->trans('commands.generate.plugin.fieldwidget.options.class')
)
->addOption(
'label',
'',
InputOption::VALUE_OPTIONAL,
$this->trans('commands.generate.plugin.fieldwidget.options.label')
)
->addOption(
'plugin-id',
'',
InputOption::VALUE_OPTIONAL,
$this->trans('commands.generate.plugin.fieldwidget.options.plugin-id')
)
->addOption(
'field-type',
'',
InputOption::VALUE_OPTIONAL,
$this->trans('commands.generate.plugin.fieldwidget.options.field-type')
);
}
/**
* {@inheritdoc}
*/
protected function execute(InputInterface $input, OutputInterface $output)
{
$io = new DrupalStyle($input, $output);
// @see use Drupal\Console\Command\ConfirmationTrait::confirmGeneration
if (!$this->confirmGeneration($io)) {
return;
}
$module = $input->getOption('module');
$class_name = $input->getOption('class');
$label = $input->getOption('label');
$plugin_id = $input->getOption('plugin-id');
$field_type = $input->getOption('field-type');
$this
->getGenerator()
->generate($module, $class_name, $label, $plugin_id, $field_type);
$this->getChain()->addCommand('cache:rebuild', ['cache' => 'discovery']);
}
protected function interact(InputInterface $input, OutputInterface $output)
{
$io = new DrupalStyle($input, $output);
$fieldTypePluginManager = $this->getService('plugin.manager.field.field_type');
// --module option
$module = $input->getOption('module');
if (!$module) {
// @see Drupal\Console\Command\ModuleTrait::moduleQuestion
$module = $this->moduleQuestion($output);
$input->setOption('module', $module);
}
// --class option
$class_name = $input->getOption('class');
if (!$class_name) {
$class_name = $io->ask(
$this->trans('commands.generate.plugin.fieldwidget.questions.class'),
'ExampleFieldWidget'
);
$input->setOption('class', $class_name);
}
// --plugin label option
$label = $input->getOption('label');
if (!$label) {
$label = $io->ask(
$this->trans('commands.generate.plugin.fieldwidget.questions.label'),
$this->getStringHelper()->camelCaseToHuman($class_name)
);
$input->setOption('label', $label);
}
// --plugin-id option
$plugin_id = $input->getOption('plugin-id');
if (!$plugin_id) {
$plugin_id = $io->ask(
$this->trans('commands.generate.plugin.fieldwidget.questions.plugin-id'),
$this->getStringHelper()->camelCaseToUnderscore($class_name)
);
$input->setOption('plugin-id', $plugin_id);
}
// --field-type option
$field_type = $input->getOption('field-type');
if (!$field_type) {
// Gather valid field types.
$field_type_options = array();
foreach ($fieldTypePluginManager->getGroupedDefinitions($fieldTypePluginManager->getUiDefinitions()) as $category => $field_types) {
foreach ($field_types as $name => $field_type) {
$field_type_options[] = $name;
}
}
$field_type = $io->choice(
$this->trans('commands.generate.plugin.fieldwidget.questions.field-type'),
$field_type_options
);
$input->setOption('field-type', $field_type);
}
}
protected function createGenerator()
{
return new PluginFieldWidgetGenerator();
}
}
| gpl-2.0 |
JohnsonYuan/MuseScore | effects/effectgui.h | 1051 | //=============================================================================
// MuseSynth
// Music Software Synthesizer
//
// Copyright (C) 2013 Werner Schweer
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2
// as published by the Free Software Foundation and appearing in
// the file LICENCE.GPL
//=============================================================================
#ifndef __EFFECTGUI_H__
#define __EFFECTGUI_H__
namespace Ms {
class Effect;
//---------------------------------------------------------
// EffectGui
//---------------------------------------------------------
class EffectGui : public QWidget {
Q_OBJECT
Effect* _effect;
signals:
void valueChanged();
public slots:
void valueChanged(const QString& name, qreal);
public:
EffectGui(Effect*, QWidget* parent = 0);
Effect* effect() const { return _effect; }
virtual void updateValues() = 0;
};
}
#endif
| gpl-2.0 |
greghaskins/openjdk-jdk7u-jdk | src/macosx/classes/java/net/DefaultInterface.java | 3499 | /*
* Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package java.net;
/**
* Choose a network inteface to be the default for
* outgoing IPv6 traffic that does not specify a scope_id (and which needs one).
* We choose the first interface that is up and is (in order of preference):
* 1. neither loopback nor point to point
* 2. point to point
* 3. loopback
* 4. none.
* Platforms that do not require a default interface implement a dummy
* that returns null.
*/
import java.util.Enumeration;
import java.io.IOException;
class DefaultInterface {
private final static NetworkInterface defaultInterface =
chooseDefaultInterface();
static NetworkInterface getDefault() {
return defaultInterface;
}
/**
* Choose a default interface. This method returns an interface that is
* both "up" and supports multicast. This method choses an interface in
* order of preference:
* 1. neither loopback nor point to point
* 2. point to point
* 3. loopback
*
* @return the chosen interface or {@code null} if there isn't a suitable
* default
*/
private static NetworkInterface chooseDefaultInterface() {
Enumeration<NetworkInterface> nifs;
try {
nifs = NetworkInterface.getNetworkInterfaces();
} catch (IOException ignore) {
// unable to enumate network interfaces
return null;
}
NetworkInterface ppp = null;
NetworkInterface loopback = null;
while (nifs.hasMoreElements()) {
NetworkInterface ni = nifs.nextElement();
try {
if (ni.isUp() && ni.supportsMulticast()) {
boolean isLoopback = ni.isLoopback();
boolean isPPP = ni.isPointToPoint();
if (!isLoopback && !isPPP) {
// found an interface that is not the loopback or a
// point-to-point interface
return ni;
}
if (ppp == null && isPPP)
ppp = ni;
if (loopback == null && isLoopback)
loopback = ni;
}
} catch (IOException skip) { }
}
return (ppp != null) ? ppp : loopback;
}
}
| gpl-2.0 |
cleemesser/pyo | include/streammodule.h | 3845 | /**************************************************************************
* Copyright 2009-2015 Olivier Belanger *
* *
* This file is part of pyo, a python module to help digital signal *
* processing script creation. *
* *
* pyo is free software: you can redistribute it and/or modify *
* it under the terms of the GNU Lesser General Public License as *
* published by the Free Software Foundation, either version 3 of the *
* License, or (at your option) any later version. *
* *
* pyo is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU Lesser General Public License for more details. *
* *
* You should have received a copy of the GNU Lesser General Public *
* License along with pyo. If not, see <http://www.gnu.org/licenses/>. *
*************************************************************************/
#include <Python.h>
#include "pyomodule.h"
typedef struct {
PyObject_HEAD
PyObject *streamobject;
void (*funcptr)();
int sid;
int chnl;
int bufsize;
int active;
int todac;
int duration;
int bufferCountWait;
int bufferCount;
MYFLT *data;
} Stream;
extern int Stream_getNewStreamId();
extern PyObject * Stream_getStreamObject(Stream *self);
extern int Stream_getStreamId(Stream *self);
extern int Stream_getStreamActive(Stream *self);
extern int Stream_getBufferCountWait(Stream *self);
extern int Stream_getDuration(Stream *self);
extern int Stream_getStreamChnl(Stream *self);
extern int Stream_getStreamToDac(Stream *self);
extern MYFLT * Stream_getData(Stream *self);
extern void Stream_setData(Stream * self, MYFLT *data);
extern void Stream_setFunctionPtr(Stream *self, void *ptr);
extern void Stream_callFunction(Stream *self);
extern void Stream_IncrementBufferCount(Stream *self);
extern void Stream_IncrementDurationCount(Stream *self);
extern PyTypeObject StreamType;
#define MAKE_NEW_STREAM(self, type, rt_error) \
(self) = (Stream *)(type)->tp_alloc((type), 0); \
if ((self) == rt_error) { return rt_error; } \
\
(self)->sid = (self)->chnl = (self)->todac = (self)->bufferCountWait = (self)->bufferCount = (self)->bufsize = (self)->duration = 0; \
(self)->active = 1;
typedef struct {
PyObject_HEAD
MYFLT *data;
} TriggerStream;
extern MYFLT * TriggerStream_getData(TriggerStream *self);
extern void TriggerStream_setData(TriggerStream * self, MYFLT *data);
extern PyTypeObject TriggerStreamType;
#define MAKE_NEW_TRIGGER_STREAM(self, type, rt_error) \
(self) = (TriggerStream *)(type)->tp_alloc((type), 0); \
#ifdef __STREAM_MODULE
/* include from stream.c */
#else
/* include from other modules to use API */
#define Stream_setStreamObject(op, v) (((Stream *)(op))->streamobject = (v))
#define Stream_setStreamId(op, v) (((Stream *)(op))->sid = (v))
#define Stream_setStreamChnl(op, v) (((Stream *)(op))->chnl = (v))
#define Stream_setStreamActive(op, v) (((Stream *)(op))->active = (v))
#define Stream_setStreamToDac(op, v) (((Stream *)(op))->todac = (v))
#define Stream_setBufferCountWait(op, v) (((Stream *)(op))->bufferCountWait = (v))
#define Stream_setDuration(op, v) (((Stream *)(op))->duration = (v))
#define Stream_setBufferSize(op, v) (((Stream *)(op))->bufsize = (v))
#endif
/* __STREAMMODULE */ | gpl-3.0 |
together-web-pj/together-web-pj | node_modules/npm/html/doc/cli/npm-version.html | 7099 | <!doctype html>
<html>
<title>npm-version</title>
<meta charset="utf-8">
<link rel="stylesheet" type="text/css" href="../../static/style.css">
<link rel="canonical" href="https://www.npmjs.org/doc/cli/npm-version.html">
<script async=true src="../../static/toc.js"></script>
<body>
<div id="wrapper">
<h1><a href="../cli/npm-version.html">npm-version</a></h1> <p>Bump a package version</p>
<h2 id="synopsis">SYNOPSIS</h2>
<pre><code>npm version [<newversion> | major | minor | patch | premajor | preminor | prepatch | prerelease]
</code></pre><h2 id="description">DESCRIPTION</h2>
<p>Run this in a package directory to bump the version and write the new
data back to <code>package.json</code> and, if present, <code>npm-shrinkwrap.json</code>.</p>
<p>The <code>newversion</code> argument should be a valid semver string, <em>or</em> a
valid second argument to semver.inc (one of <code>patch</code>, <code>minor</code>, <code>major</code>,
<code>prepatch</code>, <code>preminor</code>, <code>premajor</code>, <code>prerelease</code>). In the second case,
the existing version will be incremented by 1 in the specified field.</p>
<p>If run in a git repo, it will also create a version commit and tag.
This behavior is controlled by <code>git-tag-version</code> (see below), and can
be disabled on the command line by running <code>npm --no-git-tag-version version</code>.
It will fail if the working directory is not clean, unless the <code>--force</code>
flag is set.</p>
<p>If supplied with <code>--message</code> (shorthand: <code>-m</code>) config option, npm will
use it as a commit message when creating a version commit. If the
<code>message</code> config contains <code>%s</code> then that will be replaced with the
resulting version number. For example:</p>
<pre><code>npm version patch -m "Upgrade to %s for reasons"
</code></pre><p>If the <code>sign-git-tag</code> config is set, then the tag will be signed using
the <code>-s</code> flag to git. Note that you must have a default GPG key set up
in your git config for this to work properly. For example:</p>
<pre><code>$ npm config set sign-git-tag true
$ npm version patch
You need a passphrase to unlock the secret key for
user: "isaacs (http://blog.izs.me/) <[email protected]>"
2048-bit RSA key, ID 6C481CF6, created 2010-08-31
Enter passphrase:
</code></pre><p>If <code>preversion</code>, <code>version</code>, or <code>postversion</code> are in the <code>scripts</code> property of
the package.json, they will be executed as part of running <code>npm version</code>.</p>
<p>The exact order of execution is as follows:</p>
<ol>
<li>Check to make sure the git working directory is clean before we get started.
Your scripts may add files to the commit in future steps.
This step is skipped if the <code>--force</code> flag is set.</li>
<li>Run the <code>preversion</code> script. These scripts have access to the old <code>version</code> in package.json.
A typical use would be running your full test suite before deploying.
Any files you want added to the commit should be explicitly added using <code>git add</code>.</li>
<li>Bump <code>version</code> in <code>package.json</code> as requested (<code>patch</code>, <code>minor</code>, <code>major</code>, etc). </li>
<li>Run the <code>version</code> script. These scripts have access to the new <code>version</code> in package.json
(so they can incorporate it into file headers in generated files for example).
Again, scripts should explicitly add generated files to the commit using <code>git add</code>.</li>
<li>Commit and tag.</li>
<li>Run the <code>postversion</code> script. Use it to clean up the file system or automatically push
the commit and/or tag.</li>
</ol>
<p>Take the following example:</p>
<pre><code>"scripts": {
"preversion": "npm test",
"version": "npm run build && git add -A dist",
"postversion": "git push && git push --tags && rm -rf build/temp"
}
</code></pre><p>This runs all your tests, and proceeds only if they pass. Then runs your <code>build</code> script, and
adds everything in the <code>dist</code> directory to the commit. After the commit, it pushes the new commit
and tag up to the server, and deletes the <code>build/temp</code> directory.</p>
<h2 id="configuration">CONFIGURATION</h2>
<h3 id="git-tag-version">git-tag-version</h3>
<ul>
<li>Default: true</li>
<li>Type: Boolean</li>
</ul>
<p>Commit and tag the version change.</p>
<h2 id="see-also">SEE ALSO</h2>
<ul>
<li><a href="../cli/npm-init.html">npm-init(1)</a></li>
<li><a href="../cli/npm-run-script.html">npm-run-script(1)</a></li>
<li><a href="../misc/npm-scripts.html">npm-scripts(7)</a></li>
<li><a href="../files/package.json.html">package.json(5)</a></li>
<li><a href="../misc/semver.html">semver(7)</a></li>
<li><a href="../misc/config.html">config(7)</a></li>
</ul>
</div>
<table border=0 cellspacing=0 cellpadding=0 id=npmlogo>
<tr><td style="width:180px;height:10px;background:rgb(237,127,127)" colspan=18> </td></tr>
<tr><td rowspan=4 style="width:10px;height:10px;background:rgb(237,127,127)"> </td><td style="width:40px;height:10px;background:#fff" colspan=4> </td><td style="width:10px;height:10px;background:rgb(237,127,127)" rowspan=4> </td><td style="width:40px;height:10px;background:#fff" colspan=4> </td><td rowspan=4 style="width:10px;height:10px;background:rgb(237,127,127)"> </td><td colspan=6 style="width:60px;height:10px;background:#fff"> </td><td style="width:10px;height:10px;background:rgb(237,127,127)" rowspan=4> </td></tr>
<tr><td colspan=2 style="width:20px;height:30px;background:#fff" rowspan=3> </td><td style="width:10px;height:10px;background:rgb(237,127,127)" rowspan=3> </td><td style="width:10px;height:10px;background:#fff" rowspan=3> </td><td style="width:20px;height:10px;background:#fff" rowspan=4 colspan=2> </td><td style="width:10px;height:20px;background:rgb(237,127,127)" rowspan=2> </td><td style="width:10px;height:10px;background:#fff" rowspan=3> </td><td style="width:20px;height:10px;background:#fff" rowspan=3 colspan=2> </td><td style="width:10px;height:10px;background:rgb(237,127,127)" rowspan=3> </td><td style="width:10px;height:10px;background:#fff" rowspan=3> </td><td style="width:10px;height:10px;background:rgb(237,127,127)" rowspan=3> </td></tr>
<tr><td style="width:10px;height:10px;background:#fff" rowspan=2> </td></tr>
<tr><td style="width:10px;height:10px;background:#fff"> </td></tr>
<tr><td style="width:60px;height:10px;background:rgb(237,127,127)" colspan=6> </td><td colspan=10 style="width:10px;height:10px;background:rgb(237,127,127)"> </td></tr>
<tr><td colspan=5 style="width:50px;height:10px;background:#fff"> </td><td style="width:40px;height:10px;background:rgb(237,127,127)" colspan=4> </td><td style="width:90px;height:10px;background:#fff" colspan=9> </td></tr>
</table>
<p id="footer">npm-version — [email protected]</p>
| gpl-3.0 |
hjlfmy/de4dot | de4dot.code/deobfuscators/MaxtoCode/DecrypterInfo.cs | 1256 | /*
Copyright (C) 2011-2012 [email protected]
This file is part of de4dot.
de4dot is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
de4dot is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with de4dot. If not, see <http://www.gnu.org/licenses/>.
*/
using de4dot.PE;
namespace de4dot.code.deobfuscators.MaxtoCode {
class DecrypterInfo {
public readonly MainType mainType;
public readonly PeImage peImage;
public readonly PeHeader peHeader;
public readonly McKey mcKey;
public readonly byte[] fileData;
public DecrypterInfo(MainType mainType, byte[] fileData) {
this.mainType = mainType;
this.peImage = new PeImage(fileData);
this.peHeader = new PeHeader(mainType, peImage);
this.mcKey = new McKey(peImage, peHeader);
this.fileData = fileData;
}
}
}
| gpl-3.0 |
OpenBankProject/OBP-Kafka-Python | lib/kafka/metrics/kafka_metric.py | 933 | from __future__ import absolute_import
import time
class KafkaMetric(object):
# NOTE java constructor takes a lock instance
def __init__(self, metric_name, measurable, config):
if not metric_name:
raise ValueError('metric_name must be non-empty')
if not measurable:
raise ValueError('measurable must be non-empty')
self._metric_name = metric_name
self._measurable = measurable
self._config = config
@property
def metric_name(self):
return self._metric_name
@property
def measurable(self):
return self._measurable
@property
def config(self):
return self._config
@config.setter
def config(self, config):
self._config = config
def value(self, time_ms=None):
if time_ms is None:
time_ms = time.time() * 1000
return self.measurable.measure(self.config, time_ms)
| agpl-3.0 |
nophead/Skeinforge50plus | skeinforge_application/skeinforge_utilities/skeinforge_help.py | 3508 | """
Help has buttons and menu items to open help, blog and forum pages in your primary browser.
"""
from __future__ import absolute_import
#Init has to be imported first because it has code to workaround the python bug where relative imports don't work if the module is imported as a main module.
import __init__
from fabmetheus_utilities import archive
from fabmetheus_utilities import settings
from skeinforge_application.skeinforge_utilities import skeinforge_profile
__author__ = 'Enrique Perez ([email protected])'
__date__ = '$Date: 2008/21/04 $'
__license__ = 'GNU Affero General Public License http://www.gnu.org/licenses/agpl.html'
def getNewRepository():
'Get new repository.'
return HelpRepository()
class HelpRepository:
"A class to handle the help settings."
def __init__(self):
"Set the default settings, execute title & settings fileName."
skeinforge_profile.addListsToCraftTypeRepository('skeinforge_application.skeinforge_utilities.skeinforge_help.html', self)
announcementsText = '- Announcements - '
announcementsLabel = settings.LabelDisplay().getFromName(announcementsText, self )
announcementsLabel.columnspan = 6
settings.LabelDisplay().getFromName('Fabmetheus Blog, Announcements & Questions:', self )
settings.HelpPage().getFromNameAfterHTTP('fabmetheus.blogspot.com/', 'Fabmetheus Blog', self )
settings.LabelSeparator().getFromRepository(self)
settings.LabelDisplay().getFromName('- Documentation -', self )
settings.LabelDisplay().getFromName('Local Documentation Table of Contents: ', self )
settings.HelpPage().getFromNameSubName('Contents', self, 'contents.html')
settings.LabelDisplay().getFromName('Wiki Manual with Pictures & Charts: ', self )
settings.HelpPage().getFromNameAfterHTTP('fabmetheus.crsndoo.com/wiki/index.php/Skeinforge', 'Wiki Manual', self )
settings.LabelDisplay().getFromName('Skeinforge Overview: ', self )
settings.HelpPage().getFromNameSubName('Skeinforge Overview', self, 'skeinforge_application.skeinforge.html')
settings.LabelSeparator().getFromRepository(self)
settings.LabelDisplay().getFromName('- Search -', self )
settings.LabelDisplay().getFromName('Reprap Search:', self )
settings.HelpPage().getFromNameAfterHTTP('members.axion.net/~enrique/search_reprap.html', 'Reprap Search', self )
settings.LabelDisplay().getFromName('Skeinforge Search:', self )
settings.HelpPage().getFromNameAfterHTTP('members.axion.net/~enrique/search_skeinforge.html', 'Skeinforge Search', self )
settings.LabelDisplay().getFromName('Web Search:', self )
settings.HelpPage().getFromNameAfterHTTP('members.axion.net/~enrique/search_web.html', 'Web Search', self )
settings.LabelSeparator().getFromRepository(self)
settings.LabelDisplay().getFromName('- Troubleshooting -', self )
settings.LabelDisplay().getFromName('Skeinforge Forum:', self)
settings.HelpPage().getFromNameAfterHTTP('forums.reprap.org/list.php?154', ' Skeinforge Forum ', self )
settings.LabelSeparator().getFromRepository(self)
self.version = settings.LabelDisplay().getFromName('Version: ' + archive.getFileText(archive.getVersionFileName()), self)
self.wikiManualPrimary = settings.BooleanSetting().getFromValue('Wiki Manual Primary', self, True )
self.wikiManualPrimary.setUpdateFunction( self.save )
def save(self):
"Write the entities."
settings.writeSettingsPrintMessage(self)
| agpl-3.0 |
kinoc/opencog | opencog/embodiment/AvatarComboVocabulary/avatar_operator.h | 4357 | /*
* opencog/embodiment/AvatarComboVocabulary/avatar_operator.h
*
* Copyright (C) 2002-2009 Novamente LLC
* All Rights Reserved
* Author(s): Nil Geisweiller
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License v3 as
* published by the Free Software Foundation and including the exceptions
* at http://opencog.org/wiki/Licenses
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program; if not, write to:
* Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#ifndef _AVATAR_OPERATOR_H
#define _AVATAR_OPERATOR_H
#include <moses/comboreduct/combo/operator_base.h>
#include <moses/comboreduct/type_checker/type_tree.h>
namespace opencog { namespace combo {
using namespace std;
//this class implement operator_base in a generic way using
//an enum
//enum_count corresponds to the last enum element of OPERATOR_ENUM
//supposely denoting the number of elements
template<typename OPERATOR_ENUM, OPERATOR_ENUM enum_count>
class avatar_operator : public operator_base
{
public:
//struct for description of name and type
struct basic_description {
OPERATOR_ENUM operator_enum;
string name;
string type;
};
protected:
//enum, i.e. set of operators
OPERATOR_ENUM _enum;
//name and type
std::string _name;
type_tree _type_tree;
arity_t _arity;
type_tree _output_type;
type_tree_seq _arg_type_tree;
//ctor
avatar_operator();
//these 2 methods must be implemented to simply contain the address of
//the start of an array containing all basic descriptions
//and the number of entries
virtual const basic_description* get_basic_description_array() const = 0;
virtual unsigned int get_basic_description_array_count() const = 0;
//this is called to fill name and type using the basic_description
//array returned by get_basic_description_array
void set_basic_description(OPERATOR_ENUM oe);
public:
OPERATOR_ENUM get_enum() const;
};
template<typename OPERATOR_ENUM, OPERATOR_ENUM enum_count>
avatar_operator<OPERATOR_ENUM, enum_count>::avatar_operator()
{
_enum = enum_count;
_name = "UNDEFINED_OPERATOR";
_arity = 0;
_output_type = type_tree(id::ill_formed_type);
}
template<typename OPERATOR_ENUM, OPERATOR_ENUM enum_count>
void avatar_operator<OPERATOR_ENUM, enum_count>::set_basic_description(OPERATOR_ENUM oe)
{
const basic_description* bd = get_basic_description_array();
unsigned int bd_count = get_basic_description_array_count();
OC_ASSERT(bd_count == (unsigned int)enum_count,
"there must be entries for all perceptions.");
bool found = false;
for (unsigned int i = 0; i < bd_count && !found; ++i) {
if (bd[i].operator_enum == oe) {
found = true;
//setting perception name
_name = bd[i].name;
//setting perception type tree
std::istringstream is(bd[i].type);
try {
is >> _type_tree;
} catch (opencog::InconsistenceException& ie) {
std::cout << "WARNING : there must be a problem with the type description of " << _name << ", as the interpretation of the type string : " << "\"" << is.str() << "\"" << " has raised the following exception : " << ie.getMessage() << std::endl;
}
//setting arity
_arity = type_tree_arity(_type_tree);
//setting output type
_output_type = get_signature_output(_type_tree);
//setting input argument type trees
_arg_type_tree = get_signature_inputs(_type_tree);
}
}
OC_ASSERT(found,
"avatar_perception with enum %d has not been found in pbd",
oe);
}
template<typename OPERATOR_ENUM, OPERATOR_ENUM enum_count>
OPERATOR_ENUM avatar_operator<OPERATOR_ENUM, enum_count>::get_enum() const
{
return _enum;
}
}} // ~namespaces combo opencog
#endif
| agpl-3.0 |
aabadie/RIOT | cpu/sam0_common/include/vendor/samd20/include/instance/dsu.h | 6504 | /**
* \file
*
* \brief Instance description for DSU
*
* Copyright (c) 2018 Microchip Technology Inc.
*
* \asf_license_start
*
* \page License
*
* SPDX-License-Identifier: Apache-2.0
*
* 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 Licence 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.
*
* \asf_license_stop
*
*/
#ifndef _SAMD20_DSU_INSTANCE_
#define _SAMD20_DSU_INSTANCE_
/* ========== Register definition for DSU peripheral ========== */
#if (defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__))
#define REG_DSU_CTRL (0x41002000) /**< \brief (DSU) Control */
#define REG_DSU_STATUSA (0x41002001) /**< \brief (DSU) Status A */
#define REG_DSU_STATUSB (0x41002002) /**< \brief (DSU) Status B */
#define REG_DSU_ADDR (0x41002004) /**< \brief (DSU) Address */
#define REG_DSU_LENGTH (0x41002008) /**< \brief (DSU) Length */
#define REG_DSU_DATA (0x4100200C) /**< \brief (DSU) Data */
#define REG_DSU_DCC0 (0x41002010) /**< \brief (DSU) Debug Communication Channel 0 */
#define REG_DSU_DCC1 (0x41002014) /**< \brief (DSU) Debug Communication Channel 1 */
#define REG_DSU_DID (0x41002018) /**< \brief (DSU) Device Identification */
#define REG_DSU_DCFG0 (0x410020F0) /**< \brief (DSU) Device Configuration 0 */
#define REG_DSU_DCFG1 (0x410020F4) /**< \brief (DSU) Device Configuration 1 */
#define REG_DSU_ENTRY0 (0x41003000) /**< \brief (DSU) CoreSight ROM Table Entry 0 */
#define REG_DSU_ENTRY1 (0x41003004) /**< \brief (DSU) CoreSight ROM Table Entry 1 */
#define REG_DSU_END (0x41003008) /**< \brief (DSU) CoreSight ROM Table End */
#define REG_DSU_MEMTYPE (0x41003FCC) /**< \brief (DSU) CoreSight ROM Table Memory Type */
#define REG_DSU_PID4 (0x41003FD0) /**< \brief (DSU) Peripheral Identification 4 */
#define REG_DSU_PID5 (0x41003FD4) /**< \brief (DSU) Peripheral Identification 5 */
#define REG_DSU_PID6 (0x41003FD8) /**< \brief (DSU) Peripheral Identification 6 */
#define REG_DSU_PID7 (0x41003FDC) /**< \brief (DSU) Peripheral Identification 7 */
#define REG_DSU_PID0 (0x41003FE0) /**< \brief (DSU) Peripheral Identification 0 */
#define REG_DSU_PID1 (0x41003FE4) /**< \brief (DSU) Peripheral Identification 1 */
#define REG_DSU_PID2 (0x41003FE8) /**< \brief (DSU) Peripheral Identification 2 */
#define REG_DSU_PID3 (0x41003FEC) /**< \brief (DSU) Peripheral Identification 3 */
#define REG_DSU_CID0 (0x41003FF0) /**< \brief (DSU) Component Identification 0 */
#define REG_DSU_CID1 (0x41003FF4) /**< \brief (DSU) Component Identification 1 */
#define REG_DSU_CID2 (0x41003FF8) /**< \brief (DSU) Component Identification 2 */
#define REG_DSU_CID3 (0x41003FFC) /**< \brief (DSU) Component Identification 3 */
#else
#define REG_DSU_CTRL (*(WoReg8 *)0x41002000UL) /**< \brief (DSU) Control */
#define REG_DSU_STATUSA (*(RwReg8 *)0x41002001UL) /**< \brief (DSU) Status A */
#define REG_DSU_STATUSB (*(RoReg8 *)0x41002002UL) /**< \brief (DSU) Status B */
#define REG_DSU_ADDR (*(RwReg *)0x41002004UL) /**< \brief (DSU) Address */
#define REG_DSU_LENGTH (*(RwReg *)0x41002008UL) /**< \brief (DSU) Length */
#define REG_DSU_DATA (*(RwReg *)0x4100200CUL) /**< \brief (DSU) Data */
#define REG_DSU_DCC0 (*(RwReg *)0x41002010UL) /**< \brief (DSU) Debug Communication Channel 0 */
#define REG_DSU_DCC1 (*(RwReg *)0x41002014UL) /**< \brief (DSU) Debug Communication Channel 1 */
#define REG_DSU_DID (*(RoReg *)0x41002018UL) /**< \brief (DSU) Device Identification */
#define REG_DSU_DCFG0 (*(RwReg *)0x410020F0UL) /**< \brief (DSU) Device Configuration 0 */
#define REG_DSU_DCFG1 (*(RwReg *)0x410020F4UL) /**< \brief (DSU) Device Configuration 1 */
#define REG_DSU_ENTRY0 (*(RoReg *)0x41003000UL) /**< \brief (DSU) CoreSight ROM Table Entry 0 */
#define REG_DSU_ENTRY1 (*(RoReg *)0x41003004UL) /**< \brief (DSU) CoreSight ROM Table Entry 1 */
#define REG_DSU_END (*(RoReg *)0x41003008UL) /**< \brief (DSU) CoreSight ROM Table End */
#define REG_DSU_MEMTYPE (*(RoReg *)0x41003FCCUL) /**< \brief (DSU) CoreSight ROM Table Memory Type */
#define REG_DSU_PID4 (*(RoReg *)0x41003FD0UL) /**< \brief (DSU) Peripheral Identification 4 */
#define REG_DSU_PID5 (*(RoReg *)0x41003FD4UL) /**< \brief (DSU) Peripheral Identification 5 */
#define REG_DSU_PID6 (*(RoReg *)0x41003FD8UL) /**< \brief (DSU) Peripheral Identification 6 */
#define REG_DSU_PID7 (*(RoReg *)0x41003FDCUL) /**< \brief (DSU) Peripheral Identification 7 */
#define REG_DSU_PID0 (*(RoReg *)0x41003FE0UL) /**< \brief (DSU) Peripheral Identification 0 */
#define REG_DSU_PID1 (*(RoReg *)0x41003FE4UL) /**< \brief (DSU) Peripheral Identification 1 */
#define REG_DSU_PID2 (*(RoReg *)0x41003FE8UL) /**< \brief (DSU) Peripheral Identification 2 */
#define REG_DSU_PID3 (*(RoReg *)0x41003FECUL) /**< \brief (DSU) Peripheral Identification 3 */
#define REG_DSU_CID0 (*(RoReg *)0x41003FF0UL) /**< \brief (DSU) Component Identification 0 */
#define REG_DSU_CID1 (*(RoReg *)0x41003FF4UL) /**< \brief (DSU) Component Identification 1 */
#define REG_DSU_CID2 (*(RoReg *)0x41003FF8UL) /**< \brief (DSU) Component Identification 2 */
#define REG_DSU_CID3 (*(RoReg *)0x41003FFCUL) /**< \brief (DSU) Component Identification 3 */
#endif /* (defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */
/* ========== Instance parameters for DSU peripheral ========== */
#define DSU_CLK_HSB_ID 3
#endif /* _SAMD20_DSU_INSTANCE_ */
| lgpl-2.1 |
anoobs/xen-api | scripts/examples/python/vm_start_async.py | 2335 | #!/usr/bin/env python
# Copyright (c) 2006-2007 XenSource, Inc.
#
# Permission to use, copy, modify, and distribute this software for any
# purpose with or without fee is hereby granted, provided that the above
# copyright notice and this permission notice appear in all copies.
#
# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
# OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
# Simple example using the asynchronous version of the VM start method
# Assumes the presence of a VM called 'new'
import pprint, time, sys
import XenAPI
def main(session):
print "Listing all VM references:"
vms = session.xenapi.VM.get_all()
pprint.pprint(vms)
print "Dumping all VM records:"
for vm in vms:
pprint.pprint(session.xenapi.VM.get_record(vm))
print "Attempting to start a VM called 'new' (if it doesn't exist this will throw an exception)"
vm = session.xenapi.VM.get_by_name_label('new')[0]
session.xenapi.VM.start(vm, False, True)
print "Attempting to start the VM asynchronously"
task = session.xenapi.Async.VM.start(vm, False, True)
task_record = session.xenapi.task.get_record(task)
print "The initial contents of the task record:"
pprint.pprint(task_record)
print "Waiting for the task to complete"
while session.xenapi.task.get_status(task) == "pending": time.sleep(1)
task_record = session.xenapi.task.get_record(task)
print "The final contents of the task record:"
pprint.pprint(task_record)
if __name__ == "__main__":
if len(sys.argv) <> 4:
print "Usage:"
print sys.argv[0], " <url> <username> <password>"
sys.exit(1)
url = sys.argv[1]
username = sys.argv[2]
password = sys.argv[3]
# First acquire a valid session by logging in:
session = XenAPI.Session(url)
session.xenapi.login_with_password(username, password, "1.0", "xen-api-scripts-vm-start-async.py")
main(session)
| lgpl-2.1 |
perovic/root | tutorials/graphics/ellipse.C | 765 | //Draw ellipses
//Author: Rene Brun
TCanvas *ellipse(){
TCanvas *c1 = new TCanvas("c1");
c1->Range(0,0,1,1);
TPaveLabel *pel = new TPaveLabel(0.1,0.8,0.9,0.95,"Examples of Ellipses");
pel->SetFillColor(42);
pel->Draw();
TEllipse *el1 = new TEllipse(0.25,0.25,.1,.2);
el1->Draw();
TEllipse *el2 = new TEllipse(0.25,0.6,.2,.1);
el2->SetFillColor(6);
el2->SetFillStyle(3008);
el2->Draw();
TEllipse *el3 = new TEllipse(0.75,0.6,.2,.1,45,315);
el3->SetFillColor(2);
el3->SetFillStyle(1001);
el3->SetLineColor(4);
el3->Draw();
TEllipse *el4 = new TEllipse(0.75,0.25,.2,.15,45,315,62);
el4->SetFillColor(5);
el4->SetFillStyle(1001);
el4->SetLineColor(4);
el4->SetLineWidth(6);
el4->Draw();
return c1;
}
| lgpl-2.1 |
rbazaud/lxqt-panel | plugin-desktopswitch/translations/desktopswitch_es_VE.ts | 1622 | <?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE TS>
<TS version="2.1" language="es_VE">
<context>
<name>DesktopSwitch</name>
<message>
<location filename="../desktopswitch.cpp" line="83"/>
<source>Switch to desktop %1</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../desktopswitch.cpp" line="123"/>
<location filename="../desktopswitch.cpp" line="133"/>
<source>Desktop %1</source>
<translation>Escritorio %1</translation>
</message>
</context>
<context>
<name>DesktopSwitchConfiguration</name>
<message>
<location filename="../desktopswitchconfiguration.ui" line="14"/>
<source>DesktopSwitch settings</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../desktopswitchconfiguration.ui" line="20"/>
<source>Number of rows:</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../desktopswitchconfiguration.ui" line="40"/>
<source>Desktop labels:</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../desktopswitchconfiguration.ui" line="58"/>
<source>Numbers</source>
<translation type="unfinished"></translation>
</message>
<message>
<location filename="../desktopswitchconfiguration.ui" line="63"/>
<source>Names</source>
<translation type="unfinished"></translation>
</message>
</context>
</TS>
| lgpl-2.1 |
jessevdk/gtk | testsuite/css/parser/test-css-parser.c | 14278 | /*
* Copyright (C) 2011 Red Hat Inc.
*
* Author:
* Benjamin Otte <[email protected]>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
#include "config.h"
#undef GTK_DISABLE_DEPRECATED
#include <string.h>
#include <glib/gstdio.h>
#include <gtk/gtk.h>
static char *
test_get_reference_file (const char *css_file)
{
GString *file = g_string_new (NULL);
if (g_str_has_suffix (css_file, ".css"))
g_string_append_len (file, css_file, strlen (css_file) - 4);
else
g_string_append (file, css_file);
g_string_append (file, ".ref.css");
if (!g_file_test (file->str, G_FILE_TEST_EXISTS))
{
g_string_free (file, TRUE);
return g_strdup (css_file);
}
return g_string_free (file, FALSE);
}
static char *
test_get_errors_file (const char *css_file)
{
GString *file = g_string_new (NULL);
if (g_str_has_suffix (css_file, ".css"))
g_string_append_len (file, css_file, strlen (css_file) - 4);
else
g_string_append (file, css_file);
g_string_append (file, ".errors");
if (!g_file_test (file->str, G_FILE_TEST_EXISTS))
{
g_string_free (file, TRUE);
return NULL;
}
return g_string_free (file, FALSE);
}
static char *
diff_with_file (const char *file1,
char *text,
gssize len,
GError **error)
{
const char *command[] = { "diff", "-u", file1, NULL, NULL };
char *diff, *tmpfile;
int fd;
diff = NULL;
if (len < 0)
len = strlen (text);
/* write the text buffer to a temporary file */
fd = g_file_open_tmp (NULL, &tmpfile, error);
if (fd < 0)
return NULL;
if (write (fd, text, len) != (int) len)
{
close (fd);
g_set_error (error,
G_FILE_ERROR, G_FILE_ERROR_FAILED,
"Could not write data to temporary file '%s'", tmpfile);
goto done;
}
close (fd);
command[3] = tmpfile;
/* run diff command */
g_spawn_sync (NULL,
(char **) command,
NULL,
G_SPAWN_SEARCH_PATH,
NULL, NULL,
&diff,
NULL, NULL,
error);
done:
g_unlink (tmpfile);
g_free (tmpfile);
return diff;
}
static void
append_error_value (GString *string,
GType enum_type,
guint value)
{
GEnumClass *enum_class;
GEnumValue *enum_value;
enum_class = g_type_class_ref (enum_type);
enum_value = g_enum_get_value (enum_class, value);
g_string_append (string, enum_value->value_name);
g_type_class_unref (enum_class);
}
static void
parsing_error_cb (GtkCssProvider *provider,
GtkCssSection *section,
const GError *error,
GString *errors)
{
char *basename;
basename = g_file_get_basename (gtk_css_section_get_file (section));
g_string_append_printf (errors,
"%s:%u: error: ",
basename, gtk_css_section_get_end_line (section) + 1);
g_free (basename);
if (error->domain == GTK_CSS_PROVIDER_ERROR)
append_error_value (errors, GTK_TYPE_CSS_PROVIDER_ERROR, error->code);
else
g_string_append_printf (errors,
"%s %u\n",
g_quark_to_string (error->domain),
error->code);
g_string_append_c (errors, '\n');
}
static void
test_css_file (GFile *file)
{
GtkCssProvider *provider;
char *css, *diff;
char *css_file, *reference_file, *errors_file;
GString *errors;
GError *error = NULL;
css_file = g_file_get_path (file);
errors = g_string_new ("");
provider = gtk_css_provider_new ();
g_signal_connect (provider,
"parsing-error",
G_CALLBACK (parsing_error_cb),
errors);
gtk_css_provider_load_from_path (provider,
css_file,
NULL);
css = gtk_css_provider_to_string (provider);
reference_file = test_get_reference_file (css_file);
diff = diff_with_file (reference_file, css, -1, &error);
g_assert_no_error (error);
if (diff && diff[0])
{
g_test_message ("Resulting CSS doesn't match reference:\n%s", diff);
g_test_fail ();
}
g_free (css);
g_free (reference_file);
errors_file = test_get_errors_file (css_file);
if (errors_file)
{
diff = diff_with_file (errors_file, errors->str, errors->len, &error);
g_assert_no_error (error);
if (diff && diff[0])
{
g_test_message ("Errors don't match expected errors:\n%s", diff);
g_test_fail ();
}
}
else if (errors->str[0])
{
g_test_message ("Unexpected errors:\n%s", errors->str);
g_test_fail ();
}
g_free (errors_file);
g_string_free (errors, TRUE);
g_free (diff);
g_free (css_file);
}
static void
add_test_for_file (GFile *file)
{
char *path;
path = g_file_get_path (file);
g_test_add_vtable (path,
0,
g_object_ref (file),
NULL,
(GTestFixtureFunc) test_css_file,
(GTestFixtureFunc) g_object_unref);
g_free (path);
}
static int
compare_files (gconstpointer a, gconstpointer b)
{
GFile *file1 = G_FILE (a);
GFile *file2 = G_FILE (b);
char *path1, *path2;
int result;
path1 = g_file_get_path (file1);
path2 = g_file_get_path (file2);
result = strcmp (path1, path2);
g_free (path1);
g_free (path2);
return result;
}
static void
add_tests_for_files_in_directory (GFile *dir)
{
GFileEnumerator *enumerator;
GFileInfo *info;
GList *files;
GError *error = NULL;
enumerator = g_file_enumerate_children (dir, G_FILE_ATTRIBUTE_STANDARD_NAME, 0, NULL, &error);
g_assert_no_error (error);
files = NULL;
while ((info = g_file_enumerator_next_file (enumerator, NULL, &error)))
{
const char *filename;
filename = g_file_info_get_name (info);
if (!g_str_has_suffix (filename, ".css") ||
g_str_has_suffix (filename, ".out.css") ||
g_str_has_suffix (filename, ".ref.css"))
{
g_object_unref (info);
continue;
}
files = g_list_prepend (files, g_file_get_child (dir, filename));
g_object_unref (info);
}
g_assert_no_error (error);
g_object_unref (enumerator);
files = g_list_sort (files, compare_files);
g_list_foreach (files, (GFunc) add_test_for_file, NULL);
g_list_free_full (files, g_object_unref);
}
static gboolean
parse_uint8 (const char *string,
GValue *value,
GError **error)
{
g_value_set_uchar (value, 42);
return TRUE;
}
int
main (int argc, char **argv)
{
gtk_test_init (&argc, &argv);
G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
/* Add a bunch of properties so we can test that we parse them properly */
gtk_style_properties_register_property (NULL,
g_param_spec_boolean ("boolean-property",
"boolean property",
"test boolean properties",
TRUE,
G_PARAM_READABLE));
gtk_style_properties_register_property (NULL,
g_param_spec_int ("int-property",
"int property",
"test int properties",
G_MININT, G_MAXINT, 0,
G_PARAM_READABLE));
gtk_style_properties_register_property (NULL,
g_param_spec_uint ("uint-property",
"uint property",
"test uint properties",
0, G_MAXUINT, 0,
G_PARAM_READABLE));
gtk_style_properties_register_property (NULL,
g_param_spec_string ("string-property",
"string property",
"test string properties",
NULL,
G_PARAM_READABLE));
gtk_style_properties_register_property (NULL,
g_param_spec_boxed ("rgba-property",
"rgba property",
"test rgba properties",
GDK_TYPE_RGBA,
G_PARAM_READABLE));
gtk_style_properties_register_property (NULL,
g_param_spec_boxed ("color-property",
"color property",
"test color properties",
GDK_TYPE_COLOR,
G_PARAM_READABLE));
gtk_style_properties_register_property (NULL,
g_param_spec_boxed ("border-property",
"border property",
"test border properties",
GTK_TYPE_BORDER,
G_PARAM_READABLE));
gtk_style_properties_register_property (NULL,
g_param_spec_boxed ("font-property",
"font property",
"test font properties",
PANGO_TYPE_FONT_DESCRIPTION,
G_PARAM_READABLE));
#if 0
/* not public API, use transition instead */
gtk_style_properties_register_property (NULL,
g_param_spec_boxed ("animation-property",
"animation property",
"test animation properties",
GTK_TYPE_ANIMATION_DESCRIPTION,
G_PARAM_READABLE));
#endif
gtk_style_properties_register_property (NULL,
g_param_spec_object ("engine-property",
"engine property",
"test theming engine properties",
GTK_TYPE_THEMING_ENGINE,
G_PARAM_READABLE));
gtk_style_properties_register_property (NULL,
g_param_spec_enum ("enum-property",
"enum property",
"test enum properties",
GTK_TYPE_SHADOW_TYPE,
0,
G_PARAM_READABLE));
gtk_style_properties_register_property (NULL,
g_param_spec_flags ("flags-property",
"flags property",
"test flags properties",
GTK_TYPE_STATE_FLAGS,
GTK_STATE_FLAG_NORMAL,
G_PARAM_READABLE));
gtk_style_properties_register_property (parse_uint8,
g_param_spec_uchar ("uint8-property",
"uint8 property",
"test uint8 properties",
0, G_MAXUINT8, 0,
G_PARAM_READABLE));
G_GNUC_END_IGNORE_DEPRECATIONS;
if (argc < 2)
{
const char *basedir;
GFile *dir;
basedir = g_test_get_dir (G_TEST_DIST);
dir = g_file_new_for_path (basedir);
add_tests_for_files_in_directory (dir);
g_object_unref (dir);
}
else
{
guint i;
for (i = 1; i < argc; i++)
{
GFile *file = g_file_new_for_commandline_arg (argv[i]);
add_test_for_file (file);
g_object_unref (file);
}
}
return g_test_run ();
}
| lgpl-2.1 |
ganquan0910/pac4j | pac4j-oauth/src/test/java/org/pac4j/oauth/profile/facebook/TestFacebookRelationshipStatusConverter.java | 5452 | /*
Copyright 2012 - 2015 pac4j organization
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.pac4j.oauth.profile.facebook;
import junit.framework.TestCase;
import org.pac4j.oauth.profile.facebook.FacebookRelationshipStatus;
import org.pac4j.oauth.profile.facebook.converter.FacebookRelationshipStatusConverter;
/**
* This class test the {@link org.pac4j.oauth.profile.facebook.converter.FacebookRelationshipStatusConverter} class.
*
* @author Jerome Leleu
* @since 1.0.0
*/
public final class TestFacebookRelationshipStatusConverter extends TestCase {
private final FacebookRelationshipStatusConverter converter = new FacebookRelationshipStatusConverter();
public void testNull() {
assertNull(this.converter.convert(null));
}
public void testNotAString() {
assertNull(this.converter.convert(Boolean.TRUE));
}
public void testSingle() {
assertEquals(FacebookRelationshipStatus.SINGLE, this.converter.convert("Single"));
}
public void testInARelationship() {
assertEquals(FacebookRelationshipStatus.IN_A_RELATIONSHIP, this.converter.convert("In a relationship"));
}
public void testEngaged() {
assertEquals(FacebookRelationshipStatus.ENGAGED, this.converter.convert("Engaged"));
}
public void testMarried() {
assertEquals(FacebookRelationshipStatus.MARRIED, this.converter.convert("Married"));
}
public void testItsComplicated() {
assertEquals(FacebookRelationshipStatus.ITS_COMPLICATED, this.converter.convert("It's complicated"));
}
public void testInAnOpenRelationship() {
assertEquals(FacebookRelationshipStatus.IN_AN_OPEN_RELATIONSHIP,
this.converter.convert("In an open relationship"));
}
public void testWidowed() {
assertEquals(FacebookRelationshipStatus.WIDOWED, this.converter.convert("Widowed"));
}
public void testSeparated() {
assertEquals(FacebookRelationshipStatus.SEPARATED, this.converter.convert("Separated"));
}
public void testDivorced() {
assertEquals(FacebookRelationshipStatus.DIVORCED, this.converter.convert("Divorced"));
}
public void testInACivilUnion() {
assertEquals(FacebookRelationshipStatus.IN_A_CIVIL_UNION, this.converter.convert("In a civil union"));
}
public void testInADomesticPartnership() {
assertEquals(FacebookRelationshipStatus.IN_A_DOMESTIC_PARTNERSHIP,
this.converter.convert("In a domestic partnership"));
}
public void testSingleEnum() {
assertEquals(FacebookRelationshipStatus.SINGLE,
this.converter.convert(FacebookRelationshipStatus.SINGLE.toString()));
}
public void testInARelationshipEnum() {
assertEquals(FacebookRelationshipStatus.IN_A_RELATIONSHIP,
this.converter.convert(FacebookRelationshipStatus.IN_A_RELATIONSHIP.toString()));
}
public void testEngagedEnum() {
assertEquals(FacebookRelationshipStatus.ENGAGED,
this.converter.convert(FacebookRelationshipStatus.ENGAGED.toString()));
}
public void testMarriedEnum() {
assertEquals(FacebookRelationshipStatus.MARRIED,
this.converter.convert(FacebookRelationshipStatus.MARRIED.toString()));
}
public void testItsComplicatedEnum() {
assertEquals(FacebookRelationshipStatus.ITS_COMPLICATED,
this.converter.convert(FacebookRelationshipStatus.ITS_COMPLICATED.toString()));
}
public void testInAnOpenRelationshipEnum() {
assertEquals(FacebookRelationshipStatus.IN_AN_OPEN_RELATIONSHIP,
this.converter.convert(FacebookRelationshipStatus.IN_AN_OPEN_RELATIONSHIP.toString()));
}
public void testWidowedEnum() {
assertEquals(FacebookRelationshipStatus.WIDOWED,
this.converter.convert(FacebookRelationshipStatus.WIDOWED.toString()));
}
public void testSeparatedEnum() {
assertEquals(FacebookRelationshipStatus.SEPARATED,
this.converter.convert(FacebookRelationshipStatus.SEPARATED.toString()));
}
public void testDivorcedEnum() {
assertEquals(FacebookRelationshipStatus.DIVORCED,
this.converter.convert(FacebookRelationshipStatus.DIVORCED.toString()));
}
public void testInACivilUnionEnum() {
assertEquals(FacebookRelationshipStatus.IN_A_CIVIL_UNION,
this.converter.convert(FacebookRelationshipStatus.IN_A_CIVIL_UNION.toString()));
}
public void testInADomesticPartnershipEnum() {
assertEquals(FacebookRelationshipStatus.IN_A_DOMESTIC_PARTNERSHIP,
this.converter.convert(FacebookRelationshipStatus.IN_A_DOMESTIC_PARTNERSHIP.toString()));
}
}
| apache-2.0 |
bruthe/hadoop-2.6.0r | src/common/org/apache/hadoop/crypto/key/kms/ValueQueue.java | 12143 | /**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.apache.hadoop.crypto.key.kms;
import java.io.IOException;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import com.google.common.base.Preconditions;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import org.apache.hadoop.classification.InterfaceAudience;
/**
* A Utility class that maintains a Queue of entries for a given key. It tries
* to ensure that there is are always at-least <code>numValues</code> entries
* available for the client to consume for a particular key.
* It also uses an underlying Cache to evict queues for keys that have not been
* accessed for a configurable period of time.
* Implementing classes are required to implement the
* <code>QueueRefiller</code> interface that exposes a method to refill the
* queue, when empty
*/
@InterfaceAudience.Private
public class ValueQueue <E> {
/**
* QueueRefiller interface a client must implement to use this class
*/
public interface QueueRefiller <E> {
/**
* Method that has to be implemented by implementing classes to fill the
* Queue.
* @param keyName Key name
* @param keyQueue Queue that needs to be filled
* @param numValues number of Values to be added to the queue.
* @throws IOException
*/
public void fillQueueForKey(String keyName,
Queue<E> keyQueue, int numValues) throws IOException;
}
private static final String REFILL_THREAD =
ValueQueue.class.getName() + "_thread";
private final LoadingCache<String, LinkedBlockingQueue<E>> keyQueues;
private final ThreadPoolExecutor executor;
private final UniqueKeyBlockingQueue queue = new UniqueKeyBlockingQueue();
private final QueueRefiller<E> refiller;
private final SyncGenerationPolicy policy;
private final int numValues;
private final float lowWatermark;
private volatile boolean executorThreadsStarted = false;
/**
* A <code>Runnable</code> which takes a string name.
*/
private abstract static class NamedRunnable implements Runnable {
final String name;
private NamedRunnable(String keyName) {
this.name = keyName;
}
}
/**
* This backing blocking queue used in conjunction with the
* <code>ThreadPoolExecutor</code> used by the <code>ValueQueue</code>. This
* Queue accepts a task only if the task is not currently in the process
* of being run by a thread which is implied by the presence of the key
* in the <code>keysInProgress</code> set.
*
* NOTE: Only methods that ware explicitly called by the
* <code>ThreadPoolExecutor</code> need to be over-ridden.
*/
private static class UniqueKeyBlockingQueue extends
LinkedBlockingQueue<Runnable> {
private static final long serialVersionUID = -2152747693695890371L;
private HashSet<String> keysInProgress = new HashSet<String>();
@Override
public synchronized void put(Runnable e) throws InterruptedException {
if (keysInProgress.add(((NamedRunnable)e).name)) {
super.put(e);
}
}
@Override
public Runnable take() throws InterruptedException {
Runnable k = super.take();
if (k != null) {
keysInProgress.remove(((NamedRunnable)k).name);
}
return k;
}
@Override
public Runnable poll(long timeout, TimeUnit unit)
throws InterruptedException {
Runnable k = super.poll(timeout, unit);
if (k != null) {
keysInProgress.remove(((NamedRunnable)k).name);
}
return k;
}
}
/**
* Policy to decide how many values to return to client when client asks for
* "n" values and Queue is empty.
* This decides how many values to return when client calls "getAtMost"
*/
public static enum SyncGenerationPolicy {
ATLEAST_ONE, // Return atleast 1 value
LOW_WATERMARK, // Return min(n, lowWatermark * numValues) values
ALL // Return n values
}
/**
* Constructor takes the following tunable configuration parameters
* @param numValues The number of values cached in the Queue for a
* particular key.
* @param lowWatermark The ratio of (number of current entries/numValues)
* below which the <code>fillQueueForKey()</code> funciton will be
* invoked to fill the Queue.
* @param expiry Expiry time after which the Key and associated Queue are
* evicted from the cache.
* @param numFillerThreads Number of threads to use for the filler thread
* @param policy The SyncGenerationPolicy to use when client
* calls "getAtMost"
* @param refiller implementation of the QueueRefiller
*/
public ValueQueue(final int numValues, final float lowWatermark,
long expiry, int numFillerThreads, SyncGenerationPolicy policy,
final QueueRefiller<E> refiller) {
Preconditions.checkArgument(numValues > 0, "\"numValues\" must be > 0");
Preconditions.checkArgument(((lowWatermark > 0)&&(lowWatermark <= 1)),
"\"lowWatermark\" must be > 0 and <= 1");
Preconditions.checkArgument(expiry > 0, "\"expiry\" must be > 0");
Preconditions.checkArgument(numFillerThreads > 0,
"\"numFillerThreads\" must be > 0");
Preconditions.checkNotNull(policy, "\"policy\" must not be null");
this.refiller = refiller;
this.policy = policy;
this.numValues = numValues;
this.lowWatermark = lowWatermark;
keyQueues = CacheBuilder.newBuilder()
.expireAfterAccess(expiry, TimeUnit.MILLISECONDS)
.build(new CacheLoader<String, LinkedBlockingQueue<E>>() {
@Override
public LinkedBlockingQueue<E> load(String keyName)
throws Exception {
LinkedBlockingQueue<E> keyQueue =
new LinkedBlockingQueue<E>();
refiller.fillQueueForKey(keyName, keyQueue,
(int)(lowWatermark * numValues));
return keyQueue;
}
});
executor =
new ThreadPoolExecutor(numFillerThreads, numFillerThreads, 0L,
TimeUnit.MILLISECONDS, queue, new ThreadFactoryBuilder()
.setDaemon(true)
.setNameFormat(REFILL_THREAD).build());
}
public ValueQueue(final int numValues, final float lowWaterMark, long expiry,
int numFillerThreads, QueueRefiller<E> fetcher) {
this(numValues, lowWaterMark, expiry, numFillerThreads,
SyncGenerationPolicy.ALL, fetcher);
}
/**
* Initializes the Value Queues for the provided keys by calling the
* fill Method with "numInitValues" values
* @param keyNames Array of key Names
* @throws ExecutionException
*/
public void initializeQueuesForKeys(String... keyNames)
throws ExecutionException {
for (String keyName : keyNames) {
keyQueues.get(keyName);
}
}
/**
* This removes the value currently at the head of the Queue for the
* provided key. Will immediately fire the Queue filler function if key
* does not exist.
* If Queue exists but all values are drained, It will ask the generator
* function to add 1 value to Queue and then drain it.
* @param keyName String key name
* @return E the next value in the Queue
* @throws IOException
* @throws ExecutionException
*/
public E getNext(String keyName)
throws IOException, ExecutionException {
return getAtMost(keyName, 1).get(0);
}
/**
* Drains the Queue for the provided key.
*
* @param keyName the key to drain the Queue for
*/
public void drain(String keyName ) {
try {
keyQueues.get(keyName).clear();
} catch (ExecutionException ex) {
//NOP
}
}
/**
* This removes the "num" values currently at the head of the Queue for the
* provided key. Will immediately fire the Queue filler function if key
* does not exist
* How many values are actually returned is governed by the
* <code>SyncGenerationPolicy</code> specified by the user.
* @param keyName String key name
* @param num Minimum number of values to return.
* @return List<E> values returned
* @throws IOException
* @throws ExecutionException
*/
public List<E> getAtMost(String keyName, int num) throws IOException,
ExecutionException {
LinkedBlockingQueue<E> keyQueue = keyQueues.get(keyName);
// Using poll to avoid race condition..
LinkedList<E> ekvs = new LinkedList<E>();
try {
for (int i = 0; i < num; i++) {
E val = keyQueue.poll();
// If queue is empty now, Based on the provided SyncGenerationPolicy,
// figure out how many new values need to be generated synchronously
if (val == null) {
// Synchronous call to get remaining values
int numToFill = 0;
switch (policy) {
case ATLEAST_ONE:
numToFill = (ekvs.size() < 1) ? 1 : 0;
break;
case LOW_WATERMARK:
numToFill =
Math.min(num, (int) (lowWatermark * numValues)) - ekvs.size();
break;
case ALL:
numToFill = num - ekvs.size();
break;
}
// Synchronous fill if not enough values found
if (numToFill > 0) {
refiller.fillQueueForKey(keyName, ekvs, numToFill);
}
// Asynch task to fill > lowWatermark
if (i <= (int) (lowWatermark * numValues)) {
submitRefillTask(keyName, keyQueue);
}
return ekvs;
}
ekvs.add(val);
}
} catch (Exception e) {
throw new IOException("Exeption while contacting value generator ", e);
}
return ekvs;
}
private void submitRefillTask(final String keyName,
final Queue<E> keyQueue) throws InterruptedException {
if (!executorThreadsStarted) {
synchronized (this) {
// To ensure all requests are first queued, make coreThreads =
// maxThreads
// and pre-start all the Core Threads.
executor.prestartAllCoreThreads();
executorThreadsStarted = true;
}
}
// The submit/execute method of the ThreadPoolExecutor is bypassed and
// the Runnable is directly put in the backing BlockingQueue so that we
// can control exactly how the runnable is inserted into the queue.
queue.put(
new NamedRunnable(keyName) {
@Override
public void run() {
int cacheSize = numValues;
int threshold = (int) (lowWatermark * (float) cacheSize);
// Need to ensure that only one refill task per key is executed
try {
if (keyQueue.size() < threshold) {
refiller.fillQueueForKey(name, keyQueue,
cacheSize - keyQueue.size());
}
} catch (final Exception e) {
throw new RuntimeException(e);
}
}
}
);
}
/**
* Cleanly shutdown
*/
public void shutdown() {
executor.shutdownNow();
}
}
| apache-2.0 |
sethpollack/kubernetes | vendor/github.com/Azure/azure-sdk-for-go/version/version.go | 865 | package version
// Copyright (c) Microsoft and contributors. All rights reserved.
//
// 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.
//
// Code generated by Microsoft (R) AutoRest Code Generator.
// Changes may cause incorrect behavior and will be lost if the code is regenerated.
// Number contains the semantic version of this SDK.
const Number = "v40.2.0"
| apache-2.0 |
github-co/kubernetes | pkg/client/clientset_generated/release_1_5/typed/rbac/v1alpha1/fake/fake_clusterrolebinding.go | 4098 | /*
Copyright 2016 The Kubernetes Authors.
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 fake
import (
api "k8s.io/kubernetes/pkg/api"
unversioned "k8s.io/kubernetes/pkg/api/unversioned"
v1 "k8s.io/kubernetes/pkg/api/v1"
v1alpha1 "k8s.io/kubernetes/pkg/apis/rbac/v1alpha1"
core "k8s.io/kubernetes/pkg/client/testing/core"
labels "k8s.io/kubernetes/pkg/labels"
watch "k8s.io/kubernetes/pkg/watch"
)
// FakeClusterRoleBindings implements ClusterRoleBindingInterface
type FakeClusterRoleBindings struct {
Fake *FakeRbacV1alpha1
}
var clusterrolebindingsResource = unversioned.GroupVersionResource{Group: "rbac.authorization.k8s.io", Version: "v1alpha1", Resource: "clusterrolebindings"}
func (c *FakeClusterRoleBindings) Create(clusterRoleBinding *v1alpha1.ClusterRoleBinding) (result *v1alpha1.ClusterRoleBinding, err error) {
obj, err := c.Fake.
Invokes(core.NewRootCreateAction(clusterrolebindingsResource, clusterRoleBinding), &v1alpha1.ClusterRoleBinding{})
if obj == nil {
return nil, err
}
return obj.(*v1alpha1.ClusterRoleBinding), err
}
func (c *FakeClusterRoleBindings) Update(clusterRoleBinding *v1alpha1.ClusterRoleBinding) (result *v1alpha1.ClusterRoleBinding, err error) {
obj, err := c.Fake.
Invokes(core.NewRootUpdateAction(clusterrolebindingsResource, clusterRoleBinding), &v1alpha1.ClusterRoleBinding{})
if obj == nil {
return nil, err
}
return obj.(*v1alpha1.ClusterRoleBinding), err
}
func (c *FakeClusterRoleBindings) Delete(name string, options *v1.DeleteOptions) error {
_, err := c.Fake.
Invokes(core.NewRootDeleteAction(clusterrolebindingsResource, name), &v1alpha1.ClusterRoleBinding{})
return err
}
func (c *FakeClusterRoleBindings) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error {
action := core.NewRootDeleteCollectionAction(clusterrolebindingsResource, listOptions)
_, err := c.Fake.Invokes(action, &v1alpha1.ClusterRoleBindingList{})
return err
}
func (c *FakeClusterRoleBindings) Get(name string) (result *v1alpha1.ClusterRoleBinding, err error) {
obj, err := c.Fake.
Invokes(core.NewRootGetAction(clusterrolebindingsResource, name), &v1alpha1.ClusterRoleBinding{})
if obj == nil {
return nil, err
}
return obj.(*v1alpha1.ClusterRoleBinding), err
}
func (c *FakeClusterRoleBindings) List(opts v1.ListOptions) (result *v1alpha1.ClusterRoleBindingList, err error) {
obj, err := c.Fake.
Invokes(core.NewRootListAction(clusterrolebindingsResource, opts), &v1alpha1.ClusterRoleBindingList{})
if obj == nil {
return nil, err
}
label, _, _ := core.ExtractFromListOptions(opts)
if label == nil {
label = labels.Everything()
}
list := &v1alpha1.ClusterRoleBindingList{}
for _, item := range obj.(*v1alpha1.ClusterRoleBindingList).Items {
if label.Matches(labels.Set(item.Labels)) {
list.Items = append(list.Items, item)
}
}
return list, err
}
// Watch returns a watch.Interface that watches the requested clusterRoleBindings.
func (c *FakeClusterRoleBindings) Watch(opts v1.ListOptions) (watch.Interface, error) {
return c.Fake.
InvokesWatch(core.NewRootWatchAction(clusterrolebindingsResource, opts))
}
// Patch applies the patch and returns the patched clusterRoleBinding.
func (c *FakeClusterRoleBindings) Patch(name string, pt api.PatchType, data []byte, subresources ...string) (result *v1alpha1.ClusterRoleBinding, err error) {
obj, err := c.Fake.
Invokes(core.NewRootPatchSubresourceAction(clusterrolebindingsResource, name, data, subresources...), &v1alpha1.ClusterRoleBinding{})
if obj == nil {
return nil, err
}
return obj.(*v1alpha1.ClusterRoleBinding), err
}
| apache-2.0 |
jthelin/docker | libnetwork/datastore/datastore.go | 16439 | package datastore
import (
"fmt"
"log"
"reflect"
"strings"
"sync"
"time"
"github.com/docker/docker/libnetwork/discoverapi"
"github.com/docker/docker/libnetwork/types"
"github.com/docker/libkv"
"github.com/docker/libkv/store"
)
//DataStore exported
type DataStore interface {
// GetObject gets data from datastore and unmarshals to the specified object
GetObject(key string, o KVObject) error
// PutObject adds a new Record based on an object into the datastore
PutObject(kvObject KVObject) error
// PutObjectAtomic provides an atomic add and update operation for a Record
PutObjectAtomic(kvObject KVObject) error
// DeleteObject deletes a record
DeleteObject(kvObject KVObject) error
// DeleteObjectAtomic performs an atomic delete operation
DeleteObjectAtomic(kvObject KVObject) error
// DeleteTree deletes a record
DeleteTree(kvObject KVObject) error
// Watchable returns whether the store is watchable or not
Watchable() bool
// Watch for changes on a KVObject
Watch(kvObject KVObject, stopCh <-chan struct{}) (<-chan KVObject, error)
// RestartWatch retriggers stopped Watches
RestartWatch()
// Active returns if the store is active
Active() bool
// List returns of a list of KVObjects belonging to the parent
// key. The caller must pass a KVObject of the same type as
// the objects that need to be listed
List(string, KVObject) ([]KVObject, error)
// Map returns a Map of KVObjects
Map(key string, kvObject KVObject) (map[string]KVObject, error)
// Scope returns the scope of the store
Scope() string
// KVStore returns access to the KV Store
KVStore() store.Store
// Close closes the data store
Close()
}
// ErrKeyModified is raised for an atomic update when the update is working on a stale state
var (
ErrKeyModified = store.ErrKeyModified
ErrKeyNotFound = store.ErrKeyNotFound
)
type datastore struct {
scope string
store store.Store
cache *cache
watchCh chan struct{}
active bool
sequential bool
sync.Mutex
}
// KVObject is Key/Value interface used by objects to be part of the DataStore
type KVObject interface {
// Key method lets an object provide the Key to be used in KV Store
Key() []string
// KeyPrefix method lets an object return immediate parent key that can be used for tree walk
KeyPrefix() []string
// Value method lets an object marshal its content to be stored in the KV store
Value() []byte
// SetValue is used by the datastore to set the object's value when loaded from the data store.
SetValue([]byte) error
// Index method returns the latest DB Index as seen by the object
Index() uint64
// SetIndex method allows the datastore to store the latest DB Index into the object
SetIndex(uint64)
// True if the object exists in the datastore, false if it hasn't been stored yet.
// When SetIndex() is called, the object has been stored.
Exists() bool
// DataScope indicates the storage scope of the KV object
DataScope() string
// Skip provides a way for a KV Object to avoid persisting it in the KV Store
Skip() bool
}
// KVConstructor interface defines methods which can construct a KVObject from another.
type KVConstructor interface {
// New returns a new object which is created based on the
// source object
New() KVObject
// CopyTo deep copies the contents of the implementing object
// to the passed destination object
CopyTo(KVObject) error
}
// ScopeCfg represents Datastore configuration.
type ScopeCfg struct {
Client ScopeClientCfg
}
// ScopeClientCfg represents Datastore Client-only mode configuration
type ScopeClientCfg struct {
Provider string
Address string
Config *store.Config
}
const (
// LocalScope indicates to store the KV object in local datastore such as boltdb
LocalScope = "local"
// GlobalScope indicates to store the KV object in global datastore such as consul/etcd/zookeeper
GlobalScope = "global"
// SwarmScope is not indicating a datastore location. It is defined here
// along with the other two scopes just for consistency.
SwarmScope = "swarm"
defaultPrefix = "/var/lib/docker/network/files"
)
const (
// NetworkKeyPrefix is the prefix for network key in the kv store
NetworkKeyPrefix = "network"
// EndpointKeyPrefix is the prefix for endpoint key in the kv store
EndpointKeyPrefix = "endpoint"
)
var (
defaultScopes = makeDefaultScopes()
)
func makeDefaultScopes() map[string]*ScopeCfg {
def := make(map[string]*ScopeCfg)
def[LocalScope] = &ScopeCfg{
Client: ScopeClientCfg{
Provider: string(store.BOLTDB),
Address: defaultPrefix + "/local-kv.db",
Config: &store.Config{
Bucket: "libnetwork",
ConnectionTimeout: time.Minute,
},
},
}
return def
}
var defaultRootChain = []string{"docker", "network", "v1.0"}
var rootChain = defaultRootChain
// DefaultScopes returns a map of default scopes and its config for clients to use.
func DefaultScopes(dataDir string) map[string]*ScopeCfg {
if dataDir != "" {
defaultScopes[LocalScope].Client.Address = dataDir + "/network/files/local-kv.db"
return defaultScopes
}
defaultScopes[LocalScope].Client.Address = defaultPrefix + "/local-kv.db"
return defaultScopes
}
// IsValid checks if the scope config has valid configuration.
func (cfg *ScopeCfg) IsValid() bool {
if cfg == nil ||
strings.TrimSpace(cfg.Client.Provider) == "" ||
strings.TrimSpace(cfg.Client.Address) == "" {
return false
}
return true
}
//Key provides convenient method to create a Key
func Key(key ...string) string {
keychain := append(rootChain, key...)
str := strings.Join(keychain, "/")
return str + "/"
}
//ParseKey provides convenient method to unpack the key to complement the Key function
func ParseKey(key string) ([]string, error) {
chain := strings.Split(strings.Trim(key, "/"), "/")
// The key must at least be equal to the rootChain in order to be considered as valid
if len(chain) <= len(rootChain) || !reflect.DeepEqual(chain[0:len(rootChain)], rootChain) {
return nil, types.BadRequestErrorf("invalid Key : %s", key)
}
return chain[len(rootChain):], nil
}
// newClient used to connect to KV Store
func newClient(scope string, kv string, addr string, config *store.Config, cached bool) (DataStore, error) {
if cached && scope != LocalScope {
return nil, fmt.Errorf("caching supported only for scope %s", LocalScope)
}
sequential := false
if scope == LocalScope {
sequential = true
}
if config == nil {
config = &store.Config{}
}
var addrs []string
if kv == string(store.BOLTDB) {
// Parse file path
addrs = strings.Split(addr, ",")
} else {
// Parse URI
parts := strings.SplitN(addr, "/", 2)
addrs = strings.Split(parts[0], ",")
// Add the custom prefix to the root chain
if len(parts) == 2 {
rootChain = append([]string{parts[1]}, defaultRootChain...)
}
}
store, err := libkv.NewStore(store.Backend(kv), addrs, config)
if err != nil {
return nil, err
}
ds := &datastore{scope: scope, store: store, active: true, watchCh: make(chan struct{}), sequential: sequential}
if cached {
ds.cache = newCache(ds)
}
return ds, nil
}
// NewDataStore creates a new instance of LibKV data store
func NewDataStore(scope string, cfg *ScopeCfg) (DataStore, error) {
if cfg == nil || cfg.Client.Provider == "" || cfg.Client.Address == "" {
c, ok := defaultScopes[scope]
if !ok || c.Client.Provider == "" || c.Client.Address == "" {
return nil, fmt.Errorf("unexpected scope %s without configuration passed", scope)
}
cfg = c
}
var cached bool
if scope == LocalScope {
cached = true
}
return newClient(scope, cfg.Client.Provider, cfg.Client.Address, cfg.Client.Config, cached)
}
// NewDataStoreFromConfig creates a new instance of LibKV data store starting from the datastore config data
func NewDataStoreFromConfig(dsc discoverapi.DatastoreConfigData) (DataStore, error) {
var (
ok bool
sCfgP *store.Config
)
sCfgP, ok = dsc.Config.(*store.Config)
if !ok && dsc.Config != nil {
return nil, fmt.Errorf("cannot parse store configuration: %v", dsc.Config)
}
scopeCfg := &ScopeCfg{
Client: ScopeClientCfg{
Address: dsc.Address,
Provider: dsc.Provider,
Config: sCfgP,
},
}
ds, err := NewDataStore(dsc.Scope, scopeCfg)
if err != nil {
return nil, fmt.Errorf("failed to construct datastore client from datastore configuration %v: %v", dsc, err)
}
return ds, err
}
func (ds *datastore) Close() {
ds.store.Close()
}
func (ds *datastore) Scope() string {
return ds.scope
}
func (ds *datastore) Active() bool {
return ds.active
}
func (ds *datastore) Watchable() bool {
return ds.scope != LocalScope
}
func (ds *datastore) Watch(kvObject KVObject, stopCh <-chan struct{}) (<-chan KVObject, error) {
sCh := make(chan struct{})
ctor, ok := kvObject.(KVConstructor)
if !ok {
return nil, fmt.Errorf("error watching object type %T, object does not implement KVConstructor interface", kvObject)
}
kvpCh, err := ds.store.Watch(Key(kvObject.Key()...), sCh)
if err != nil {
return nil, err
}
kvoCh := make(chan KVObject)
go func() {
retry_watch:
var err error
// Make sure to get a new instance of watch channel
ds.Lock()
watchCh := ds.watchCh
ds.Unlock()
loop:
for {
select {
case <-stopCh:
close(sCh)
return
case kvPair := <-kvpCh:
// If the backend KV store gets reset libkv's go routine
// for the watch can exit resulting in a nil value in
// channel.
if kvPair == nil {
ds.Lock()
ds.active = false
ds.Unlock()
break loop
}
dstO := ctor.New()
if err = dstO.SetValue(kvPair.Value); err != nil {
log.Printf("Could not unmarshal kvpair value = %s", string(kvPair.Value))
break
}
dstO.SetIndex(kvPair.LastIndex)
kvoCh <- dstO
}
}
// Wait on watch channel for a re-trigger when datastore becomes active
<-watchCh
kvpCh, err = ds.store.Watch(Key(kvObject.Key()...), sCh)
if err != nil {
log.Printf("Could not watch the key %s in store: %v", Key(kvObject.Key()...), err)
}
goto retry_watch
}()
return kvoCh, nil
}
func (ds *datastore) RestartWatch() {
ds.Lock()
defer ds.Unlock()
ds.active = true
watchCh := ds.watchCh
ds.watchCh = make(chan struct{})
close(watchCh)
}
func (ds *datastore) KVStore() store.Store {
return ds.store
}
// PutObjectAtomic adds a new Record based on an object into the datastore
func (ds *datastore) PutObjectAtomic(kvObject KVObject) error {
var (
previous *store.KVPair
pair *store.KVPair
err error
)
if ds.sequential {
ds.Lock()
defer ds.Unlock()
}
if kvObject == nil {
return types.BadRequestErrorf("invalid KV Object : nil")
}
kvObjValue := kvObject.Value()
if kvObjValue == nil {
return types.BadRequestErrorf("invalid KV Object with a nil Value for key %s", Key(kvObject.Key()...))
}
if kvObject.Skip() {
goto add_cache
}
if kvObject.Exists() {
previous = &store.KVPair{Key: Key(kvObject.Key()...), LastIndex: kvObject.Index()}
} else {
previous = nil
}
_, pair, err = ds.store.AtomicPut(Key(kvObject.Key()...), kvObjValue, previous, nil)
if err != nil {
if err == store.ErrKeyExists {
return ErrKeyModified
}
return err
}
kvObject.SetIndex(pair.LastIndex)
add_cache:
if ds.cache != nil {
// If persistent store is skipped, sequencing needs to
// happen in cache.
return ds.cache.add(kvObject, kvObject.Skip())
}
return nil
}
// PutObject adds a new Record based on an object into the datastore
func (ds *datastore) PutObject(kvObject KVObject) error {
if ds.sequential {
ds.Lock()
defer ds.Unlock()
}
if kvObject == nil {
return types.BadRequestErrorf("invalid KV Object : nil")
}
if kvObject.Skip() {
goto add_cache
}
if err := ds.putObjectWithKey(kvObject, kvObject.Key()...); err != nil {
return err
}
add_cache:
if ds.cache != nil {
// If persistent store is skipped, sequencing needs to
// happen in cache.
return ds.cache.add(kvObject, kvObject.Skip())
}
return nil
}
func (ds *datastore) putObjectWithKey(kvObject KVObject, key ...string) error {
kvObjValue := kvObject.Value()
if kvObjValue == nil {
return types.BadRequestErrorf("invalid KV Object with a nil Value for key %s", Key(kvObject.Key()...))
}
return ds.store.Put(Key(key...), kvObjValue, nil)
}
// GetObject returns a record matching the key
func (ds *datastore) GetObject(key string, o KVObject) error {
if ds.sequential {
ds.Lock()
defer ds.Unlock()
}
if ds.cache != nil {
return ds.cache.get(key, o)
}
kvPair, err := ds.store.Get(key)
if err != nil {
return err
}
if err := o.SetValue(kvPair.Value); err != nil {
return err
}
// Make sure the object has a correct view of the DB index in
// case we need to modify it and update the DB.
o.SetIndex(kvPair.LastIndex)
return nil
}
func (ds *datastore) ensureParent(parent string) error {
exists, err := ds.store.Exists(parent)
if err != nil {
return err
}
if exists {
return nil
}
return ds.store.Put(parent, []byte{}, &store.WriteOptions{IsDir: true})
}
func (ds *datastore) List(key string, kvObject KVObject) ([]KVObject, error) {
if ds.sequential {
ds.Lock()
defer ds.Unlock()
}
if ds.cache != nil {
return ds.cache.list(kvObject)
}
var kvol []KVObject
cb := func(key string, val KVObject) {
kvol = append(kvol, val)
}
err := ds.iterateKVPairsFromStore(key, kvObject, cb)
if err != nil {
return nil, err
}
return kvol, nil
}
func (ds *datastore) iterateKVPairsFromStore(key string, kvObject KVObject, callback func(string, KVObject)) error {
// Bail out right away if the kvObject does not implement KVConstructor
ctor, ok := kvObject.(KVConstructor)
if !ok {
return fmt.Errorf("error listing objects, object does not implement KVConstructor interface")
}
// Make sure the parent key exists
if err := ds.ensureParent(key); err != nil {
return err
}
kvList, err := ds.store.List(key)
if err != nil {
return err
}
for _, kvPair := range kvList {
if len(kvPair.Value) == 0 {
continue
}
dstO := ctor.New()
if err := dstO.SetValue(kvPair.Value); err != nil {
return err
}
// Make sure the object has a correct view of the DB index in
// case we need to modify it and update the DB.
dstO.SetIndex(kvPair.LastIndex)
callback(kvPair.Key, dstO)
}
return nil
}
func (ds *datastore) Map(key string, kvObject KVObject) (map[string]KVObject, error) {
if ds.sequential {
ds.Lock()
defer ds.Unlock()
}
kvol := make(map[string]KVObject)
cb := func(key string, val KVObject) {
// Trim the leading & trailing "/" to make it consistent across all stores
kvol[strings.Trim(key, "/")] = val
}
err := ds.iterateKVPairsFromStore(key, kvObject, cb)
if err != nil {
return nil, err
}
return kvol, nil
}
// DeleteObject unconditionally deletes a record from the store
func (ds *datastore) DeleteObject(kvObject KVObject) error {
if ds.sequential {
ds.Lock()
defer ds.Unlock()
}
// cleanup the cache first
if ds.cache != nil {
// If persistent store is skipped, sequencing needs to
// happen in cache.
ds.cache.del(kvObject, kvObject.Skip())
}
if kvObject.Skip() {
return nil
}
return ds.store.Delete(Key(kvObject.Key()...))
}
// DeleteObjectAtomic performs atomic delete on a record
func (ds *datastore) DeleteObjectAtomic(kvObject KVObject) error {
if ds.sequential {
ds.Lock()
defer ds.Unlock()
}
if kvObject == nil {
return types.BadRequestErrorf("invalid KV Object : nil")
}
previous := &store.KVPair{Key: Key(kvObject.Key()...), LastIndex: kvObject.Index()}
if kvObject.Skip() {
goto del_cache
}
if _, err := ds.store.AtomicDelete(Key(kvObject.Key()...), previous); err != nil {
if err == store.ErrKeyExists {
return ErrKeyModified
}
return err
}
del_cache:
// cleanup the cache only if AtomicDelete went through successfully
if ds.cache != nil {
// If persistent store is skipped, sequencing needs to
// happen in cache.
return ds.cache.del(kvObject, kvObject.Skip())
}
return nil
}
// DeleteTree unconditionally deletes a record from the store
func (ds *datastore) DeleteTree(kvObject KVObject) error {
if ds.sequential {
ds.Lock()
defer ds.Unlock()
}
// cleanup the cache first
if ds.cache != nil {
// If persistent store is skipped, sequencing needs to
// happen in cache.
ds.cache.del(kvObject, kvObject.Skip())
}
if kvObject.Skip() {
return nil
}
return ds.store.DeleteTree(Key(kvObject.KeyPrefix()...))
}
| apache-2.0 |
heathseals/marionette-collective | spec/unit/mcollective/aggregate/summary_spec.rb | 1991 | #!/usr/bin/env rspec
require 'spec_helper'
require 'mcollective/aggregate/summary'
module MCollective
class Aggregate
describe Summary do
describe "#startup_hook" do
it "should set the correct result hash" do
result = Summary.new(:test, [], "%d", :test_action)
result.result.should == {:value => {}, :type => :collection, :output => :test}
result.aggregate_format.should == "%d"
end
it "should set a defauly aggregate_format if one isn't defined" do
result = Summary.new(:test, [], nil, :test_action)
result.aggregate_format.should == :calculate
end
end
describe "#process_result" do
it "should add the value to the result hash" do
sum = Summary.new(:test, [], "%d", :test_action)
sum.process_result(:foo, {:test => :foo})
sum.result[:value].should == {:foo => 1}
end
it "should add the reply values to the result hash if value is an array" do
sum = Summary.new(:test, [], "%d", :test_action)
sum.process_result([:foo, :foo, :bar], {:test => [:foo, :foo, :bar]})
sum.result[:value].should == {:foo => 2, :bar => 1}
end
end
describe "#summarize" do
it "should calculate an attractive format" do
sum = Summary.new(:test, [], nil, :test_action)
sum.result[:value] = {"shrt" => 1, "long key" => 1}
sum.summarize.aggregate_format.should == "%8s = %s"
end
it "should calculate an attractive format when result type is not a string" do
sum1 = Summary.new(:test, [], nil, :test_action)
sum1.result[:value] = {true => 4, false => 5}
sum1.summarize.aggregate_format.should == "%5s = %s"
sum2 = Summary.new(:test, [], nil, :test_action)
sum2.result[:value] = {1 => 1, 10 => 2}
sum2.summarize.aggregate_format.should == "%2s = %s"
end
end
end
end
end
| apache-2.0 |
ManishJayaswal/roslyn | src/ExpressionEvaluator/CSharp/Test/ResultProvider/Helpers/TestTypeExtensions.cs | 563 | // Copyright (c) Microsoft. All Rights Reserved. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System;
using Microsoft.CodeAnalysis.ExpressionEvaluator;
namespace Microsoft.CodeAnalysis.CSharp.ExpressionEvaluator
{
internal static class TestTypeExtensions
{
public static string GetTypeName(this Type type, bool escapeKeywordIdentifiers = false)
{
return CSharpFormatter.Instance.GetTypeName((TypeImpl)type, escapeKeywordIdentifiers);
}
}
}
| apache-2.0 |
christi3k/zulip | docs/dev-remote.md | 6988 | # Developing on a remote machine
The Zulip developer environment works well on remote virtual machines. This can
be a good alternative for those with poor network connectivity or who have
limited storage/memory on their local machines.
We recommend giving the Zulip development environment its own virtual
machine, running Ubuntu 14.04 or
16.04, with at least 2GB of memory. If the Zulip development
environment will be the only thing running on the remote virtual
machine, we recommend installing
[directly][install-direct]. Otherwise, we recommend the
[Vagrant][install-vagrant] method so you can easily uninstall if you
need to.
## Connecting to the remote environment
The best way to connect to your server is using the command line tool `ssh`.
* On macOS and Linux/UNIX, `ssh` is a part of Terminal.
* On Windows, `ssh` comes with [Bash for Git][git-bash].
Open *Terminal* or *Bash for Git*, and connect with the following:
```
$ ssh username@host
```
If you have poor internet connectivity, we recommend using
[Mosh](https://mosh.org/) as it is more reliable over slow or unreliable
networks.
## Setting up the development environment
After you have connected to your remote server, you need to install the
development environment.
If the Zulip development environment will be the only thing running on
the remote virtual machine, we recommend installing
[directly][install-direct]. Otherwise, we recommend the
[Vagrant][install-vagrant] method so you can easily uninstall if you
need to.
## Running the development server
Once you have set up the development environment, you can start up the
development instance of Zulip with the following command in the directory where
you cloned Zulip:
```
./tools/run-dev.py --interface=''
```
This will start up the Zulip server on port 9991. You can then
navigate to `http://<REMOTE_IP>:9991` and you should see something like
this screenshot of the Zulip development environment:
You can [port
forward](https://help.ubuntu.com/community/SSH/OpenSSH/PortForwarding) using
ssh instead of running the development environment on an exposed interface.
For more information, see [Using the development
environment][rtd-using-dev-env].
## Making changes to code on your remote development server
To see changes on your remote development server, you need to do one of the following:
* [Edit locally](#editing-locally): Clone Zulip code to your computer and
then use your favorite editor to make changes. When you want to see changes
on your remote Zulip development instance, sync with Git.
* [Edit remotely](#editing-remotely): Edit code directly on your remote
Zulip development instance using a [Web-based IDE](#web-based-ide) (recommended for
beginners) or a [command line editor](#command-line-editors).
#### Editing locally
If you want to edit code locally install your favorite text editor. If you
don't have a favorite, here are some suggestions:
* [atom](https://atom.io/)
* [emacs](https://www.gnu.org/software/emacs/)
* [vim](http://www.vim.org/)
* [spacemacs](https://github.com/syl20bnr/spacemacs)
* [sublime](https://www.sublimetext.com/)
Next, follow our [Git and GitHub Guide](git-guide.html) to clone and configure
your fork of zulip on your local computer.
Once you have cloned your code locally, you can get to work.
##### Syncing changes
The easiest way to see your changes on your remote development server
is to **push them to GitHub** and them **fetch and merge** them from
the remote server.
For more detailed instructions about how to do this, see our [Git & GitHub
Guide][rtd-git-guide]. In brief, the steps are as follows.
On your **local computer**:
1. Open *Terminal* (macOS/Linux) or *Git for BASH*.
2. Change directory to where you cloned Zulip (e.g. `cd zulip`).
3. Use `git add` and `git commit` to stage and commit your changes (if you
haven't already).
4. Push your commits to GitHub with `git push origin branchname`.
Be sure to replace `branchname` with the name of your actual feature branch.
Once `git push` has completed successfully, you are ready to fetch the commits
from your remote development instance:
1. In *Terminal* or *Git BASH*, connect to your remote development
instance with `ssh user@host`.
2. Change to the zulip directory (e.g., `cd zulip`).
3. Fetch new commits from GitHub with `git fetch origin`.
4. Change to the branch you want to work on with `git checkout branchname`.
5. Merge the new commits into your branch with `git merge origin/branchname`.
#### Editing remotely
##### Web-based IDE
If you are relatively new to working on the command line, or just want to get
started working quickly, we recommend web-based IDE
[Codeanywhere][codeanywhere].
To setup Codeanywhere for Zulip:
1. Create a [Codeanywhere][codeanywhere] account and log in.
2. Create a new **SFTP-SSH** project. Use *Public key* for authentication.
3. Click **GET YOUR PUBLIC KEY** to get the new public key that
Codeanywhere generates when you create a new project. Add this public key to
`~/.ssh/authorized_keys` on your remote development instance.
4. Once you've added the new public key to your remote development instance, click
*CONNECT*.
Now your workspace should look similar this:
![Codeanywhere workspace][img-ca-workspace]
##### Command line editors
Another way to edit directly on the remote development server is with
a command line text editor on the remote machine.
Two editors often available by default on Linux systems are:
* **Nano**: A very simple, beginner-friendly editor. However, it lacks a lot of
features useful for programming, such as syntax highlighting, so we only
recommended it for quick edits to things like configuration files. Launch by
running command `nano <filename>`. Exit by pressing *control-X*.
* **[Vim](http://www.vim.org/)**: A very powerful editor that can take a while
to learn. Launch by running `vim <filename>`. Quit Vim by pressing *escape*,
typing `:q`, and then pressing *return*. Vim comes with a program to learn it
called `vimtutor` (just run that command to start it).
Other options include:
* [emacs](https://www.gnu.org/software/emacs/)
* [spacemacs](https://github.com/syl20bnr/spacemacs)
#### Next steps
Next, read the following to learn more about developing for Zulip:
* [Git & GitHub Guide][rtd-git-guide]
* [Using the Development Environment][rtd-using-dev-env]
* [Testing][rtd-testing]
[install-direct]: dev-setup-non-vagrant.html#installing-directly-on-ubuntu
[install-generic]: dev-setup-non-vagrant.html#installing-manually-on-linux
[install-vagrant]: dev-env-first-time-contributors.html
[rtd-git-guide]: git-guide.html
[rtd-using-dev-env]: using-dev-environment.html
[rtd-testing]: testing.html
[git-bash]: https://git-for-windows.github.io/
[codeanywhere]: https://codeanywhere.com/
[img-ca-settings]: images/codeanywhere-settings.png
[img-ca-workspace]: images/codeanywhere-workspace.png
| apache-2.0 |
bzz/circuit | sys/tele/conn.go | 874 | // Copyright 2013 The Go Circuit Project
// Use of this source code is governed by the license for
// The Go Circuit Project, found in the LICENSE file.
//
// Authors:
// 2013 Petar Maymounkov <[email protected]>
package tele
import (
"github.com/gocircuit/circuit/kit/tele/blend"
"github.com/gocircuit/circuit/use/n"
)
type Conn struct {
addr *Addr
sub *blend.Conn
}
func NewConn(sub *blend.Conn, addr *Addr) *Conn {
return &Conn{addr: addr, sub: sub}
}
func (c *Conn) Read() (v interface{}, err error) {
if v, err = c.sub.Read(); err != nil {
return nil, err
}
return
}
func (c *Conn) Write(v interface{}) (err error) {
if err = c.sub.Write(v); err != nil {
return err
}
return nil
}
func (c *Conn) Close() error {
return c.sub.Close()
}
func (c *Conn) Abort(reason error) {
c.sub.Abort(reason)
}
func (c *Conn) Addr() n.Addr {
return c.addr
}
| apache-2.0 |
ghchinoy/tensorflow | tensorflow/core/kernels/fuzzing/example_proto_fast_parsing_fuzz.cc | 2435 | /* Copyright 2016 Google Inc. All Rights Reserved.
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.
==============================================================================*/
#include "tensorflow/cc/ops/standard_ops.h"
#include "tensorflow/core/kernels/fuzzing/fuzz_session.h"
namespace tensorflow {
namespace fuzzing {
// Fuzz inputs to the example proto decoder.
// TODO(dga): Make this more comprehensive.
// Right now, it's just a quick PoC to show how to attach the
// plumbing, but it needs some real protos to chew on as a
// corpus, and the sparse/dense parts should be made more rich
// to achieve higher code coverage.
class FuzzExampleProtoFastParsing : public FuzzSession {
void BuildGraph(const Scope& scope) final {
using namespace ::tensorflow::ops; // NOLINT(build/namespaces)
// The serialized proto.
auto input = Placeholder(scope.WithOpName("input"), DT_STRING);
auto in_expanded = ExpandDims(scope, input, Const<int>(scope, 0));
auto names = Const(scope, {"noname"});
std::vector<Output> dense_keys = {Const(scope, {"a"})};
std::vector<Output> sparse_keys; // Empty.
std::vector<Output> dense_defaults = {Const(scope, {1.0f})};
DataTypeSlice sparse_types = {};
std::vector<PartialTensorShape> dense_shapes;
dense_shapes.push_back(PartialTensorShape());
(void)ParseExample(scope.WithOpName("output"), in_expanded, names,
sparse_keys, dense_keys, dense_defaults, sparse_types,
dense_shapes);
}
void FuzzImpl(const uint8_t* data, size_t size) final {
// TODO(dga): Test the batch case also.
Tensor input_tensor(tensorflow::DT_STRING, TensorShape({}));
input_tensor.scalar<string>()() =
string(reinterpret_cast<const char*>(data), size);
RunInputs({{"input", input_tensor}});
}
};
STANDARD_TF_FUZZ_FUNCTION(FuzzExampleProtoFastParsing);
} // end namespace fuzzing
} // end namespace tensorflow
| apache-2.0 |
emartin-pentaho/pentaho-kettle | core/src/main/java/org/pentaho/di/core/database/map/DatabaseConnectionMap.java | 5471 | /*! ******************************************************************************
*
* Pentaho Data Integration
*
* Copyright (C) 2002-2017 by Hitachi Vantara : http://www.pentaho.com
*
*******************************************************************************
*
* 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.pentaho.di.core.database.map;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.atomic.AtomicInteger;
import org.pentaho.di.core.util.Utils;
import org.pentaho.di.core.database.Database;
import org.pentaho.di.core.database.DatabaseTransactionListener;
/**
* This class contains a map between on the one hand
* <p/>
* the transformation name/thread the partition ID the connection group
* <p/>
* And on the other hand
* <p/>
* The database connection The number of times it was opened
*
* @author Matt
*/
public class DatabaseConnectionMap {
private final ConcurrentMap<String, Database> map;
private final AtomicInteger transactionId;
private final Map<String, List<DatabaseTransactionListener>> transactionListenersMap;
private static final DatabaseConnectionMap connectionMap = new DatabaseConnectionMap();
public static synchronized DatabaseConnectionMap getInstance() {
return connectionMap;
}
private DatabaseConnectionMap() {
map = new ConcurrentHashMap<String, Database>();
transactionId = new AtomicInteger( 0 );
transactionListenersMap = new HashMap<String, List<DatabaseTransactionListener>>();
}
/**
* Tries to obtain an existing <tt>Database</tt> instance for specified parameters. If none is found, then maps the
* key's value to <tt>database</tt>. Similarly to {@linkplain ConcurrentHashMap#putIfAbsent(Object, Object)} returns
* <tt>null</tt> if there was no value for the specified key and they mapped value otherwise.
*
* @param connectionGroup connection group
* @param partitionID partition's id
* @param database database
* @return <tt>null</tt> or previous value
*/
public Database getOrStoreIfAbsent( String connectionGroup, String partitionID, Database database ) {
String key = createEntryKey( connectionGroup, partitionID, database );
return map.putIfAbsent( key, database );
}
public void removeConnection( String connectionGroup, String partitionID, Database database ) {
String key = createEntryKey( connectionGroup, partitionID, database );
map.remove( key );
}
/**
* @deprecated use {@linkplain #getOrStoreIfAbsent(String, String, Database)} instead
*/
@Deprecated
public synchronized void storeDatabase( String connectionGroup, String partitionID, Database database ) {
String key = createEntryKey( connectionGroup, partitionID, database );
map.put( key, database );
}
/**
* @deprecated use {@linkplain #getOrStoreIfAbsent(String, String, Database)} instead
*/
@Deprecated
public synchronized Database getDatabase( String connectionGroup, String partitionID, Database database ) {
String key = createEntryKey( connectionGroup, partitionID, database );
return map.get( key );
}
public static String createEntryKey( String connectionGroup, String partitionID, Database database ) {
StringBuilder key = new StringBuilder( connectionGroup );
key.append( ':' ).append( database.getDatabaseMeta().getName() );
if ( !Utils.isEmpty( partitionID ) ) {
key.append( ':' ).append( partitionID );
}
return key.toString();
}
public Map<String, Database> getMap() {
return map;
}
public String getNextTransactionId() {
return Integer.toString( transactionId.incrementAndGet() );
}
public void addTransactionListener( String transactionId, DatabaseTransactionListener listener ) {
List<DatabaseTransactionListener> transactionListeners = getTransactionListeners( transactionId );
transactionListeners.add( listener );
}
public void removeTransactionListener( String transactionId, DatabaseTransactionListener listener ) {
List<DatabaseTransactionListener> transactionListeners = getTransactionListeners( transactionId );
transactionListeners.remove( listener );
}
public List<DatabaseTransactionListener> getTransactionListeners( String transactionId ) {
List<DatabaseTransactionListener> transactionListeners = transactionListenersMap.get( transactionId );
if ( transactionListeners == null ) {
transactionListeners = new ArrayList<DatabaseTransactionListener>();
transactionListenersMap.put( transactionId, transactionListeners );
}
return transactionListeners;
}
public void removeTransactionListeners( String transactionId ) {
transactionListenersMap.remove( transactionId );
}
}
| apache-2.0 |
nemanja88/azure-sdk-for-net | src/ResourceManagement/HDInsight/HDInsight/Generated/Models/DirectoryType.cs | 1096 | //
// Copyright (c) Microsoft and contributors. All rights reserved.
//
// 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.
//
// Warning: This code was generated by a tool.
//
// Changes to this file may cause incorrect behavior and will be lost if the
// code is regenerated.
using System;
using System.Linq;
namespace Microsoft.Azure.Management.HDInsight.Models
{
/// <summary>
/// The directory type.
/// </summary>
public enum DirectoryType
{
/// <summary>
/// active directory type.
/// </summary>
ActiveDirectory = 1,
}
}
| apache-2.0 |
JSDemos/android-sdk-20 | src/com/android/internal/telephony/WapPushManagerParams.java | 1891 | /*
* Copyright (C) 2010 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.internal.telephony;
/**
* WapPushManager constant value definitions
*/
public class WapPushManagerParams {
/**
* Application type activity
*/
public static final int APP_TYPE_ACTIVITY = 0;
/**
* Application type service
*/
public static final int APP_TYPE_SERVICE = 1;
/**
* Process Message return value
* Message is handled
*/
public static final int MESSAGE_HANDLED = 0x1;
/**
* Process Message return value
* Application ID or content type was not found in the application ID table
*/
public static final int APP_QUERY_FAILED = 0x2;
/**
* Process Message return value
* Receiver application signature check failed
*/
public static final int SIGNATURE_NO_MATCH = 0x4;
/**
* Process Message return value
* Receiver application was not found
*/
public static final int INVALID_RECEIVER_NAME = 0x8;
/**
* Process Message return value
* Unknown exception
*/
public static final int EXCEPTION_CAUGHT = 0x10;
/**
* Process Message return value
* Need further processing after WapPushManager message processing
*/
public static final int FURTHER_PROCESSING = 0x8000;
}
| apache-2.0 |
rodzyn0688/zipkin | zipkin-web/test/unit/helpers/trace_summaries_helper_test.rb | 81 | require 'test_helper'
class TraceSummariesHelperTest < ActionView::TestCase
end
| apache-2.0 |
jahnaviancha/scouter | scouter.client/src/scouter/client/maria/views/DigestTableView.java | 21743 | /*
* Copyright 2015 LG CNS.
*
* 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 scouter.client.maria.views;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.action.IToolBarManager;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.layout.TreeColumnLayout;
import org.eclipse.jface.viewers.ColumnPixelData;
import org.eclipse.jface.viewers.DoubleClickEvent;
import org.eclipse.jface.viewers.IDoubleClickListener;
import org.eclipse.jface.viewers.ILabelProviderListener;
import org.eclipse.jface.viewers.ITableLabelProvider;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.jface.viewers.TreeViewerColumn;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Tree;
import org.eclipse.swt.widgets.TreeColumn;
import org.eclipse.ui.IViewSite;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.part.ViewPart;
import scouter.client.Images;
import scouter.client.model.AgentDailyListProxy;
import scouter.client.model.DigestModel;
import scouter.client.model.RefreshThread;
import scouter.client.model.RefreshThread.Refreshable;
import scouter.client.model.TextProxy;
import scouter.client.net.INetReader;
import scouter.client.net.TcpProxy;
import scouter.client.popup.DigestDetailDialog;
import scouter.client.sorter.TreeLabelSorter;
import scouter.client.util.ConsoleProxy;
import scouter.client.util.ExUtil;
import scouter.client.util.ImageUtil;
import scouter.client.util.TimeUtil;
import scouter.io.DataInputX;
import scouter.lang.DigestKey;
import scouter.lang.counters.CounterConstants;
import scouter.lang.pack.MapPack;
import scouter.lang.pack.Pack;
import scouter.lang.pack.PackEnum;
import scouter.lang.pack.StatusPack;
import scouter.lang.value.ListValue;
import scouter.lang.value.MapValue;
import scouter.net.RequestCmd;
import scouter.util.CastUtil;
import scouter.util.DateUtil;
import scouter.util.FormatUtil;
public class DigestTableView extends ViewPart implements Refreshable {
public final static String ID = DigestTableView.class.getName();
double PICO = Math.pow(10, -12);
int serverId;
Composite parent;
TreeViewer viewer;
TreeColumnLayout columnLayout;
AgentDailyListProxy agentProxy = new AgentDailyListProxy();
RefreshThread thread;
boolean isAutoRefresh = false;
String date;
long stime, etime;
HashMap<Integer, DigestModel> root = new HashMap<Integer, DigestModel>();
public void init(IViewSite site) throws PartInitException {
super.init(site);
String secId = site.getSecondaryId();
this.serverId = CastUtil.cint(secId);
}
public void createPartControl(Composite parent) {
this.parent = parent;
GridLayout gridlayout = new GridLayout(1, false);
gridlayout.marginHeight = 0;
gridlayout.horizontalSpacing = 0;
gridlayout.marginWidth = 0;
parent.setLayout(gridlayout);
columnLayout = new TreeColumnLayout();
Composite mainComp = new Composite(parent, SWT.NONE);
mainComp.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
mainComp.setLayout(columnLayout);
viewer = new TreeViewer(mainComp, SWT.FULL_SELECTION | SWT.BORDER | SWT.V_SCROLL | SWT.H_SCROLL);
createColumns();
final Tree tree = viewer.getTree();
tree.setHeaderVisible(true);
tree.setLinesVisible(true);
viewer.setLabelProvider(new TreeLabelProvider());
viewer.setContentProvider(new TreeContentProvider());
viewer.setComparator(new TreeLabelSorter(viewer));
viewer.addDoubleClickListener(new IDoubleClickListener() {
public void doubleClick(DoubleClickEvent event) {
StructuredSelection sel = (StructuredSelection) event.getSelection();
Object o = sel.getFirstElement();
if (o instanceof DigestModel) {
DigestModel model = (DigestModel) o;
new DigestDetailDialog().show(model, stime, etime, serverId);
}
}
});
viewer.setInput(root);
IToolBarManager man = getViewSite().getActionBars().getToolBarManager();
Action actAutoRefresh = new Action("Auto Refresh in 10 sec.", IAction.AS_CHECK_BOX){
public void run() {
isAutoRefresh = isChecked();
if (isAutoRefresh) {
thread.interrupt();
}
}
};
actAutoRefresh.setImageDescriptor(ImageUtil.getImageDescriptor(Images.refresh_auto));
man.add(actAutoRefresh);
long now = TimeUtil.getCurrentTime(serverId);
date = DateUtil.yyyymmdd(now);
stime = now - DateUtil.MILLIS_PER_FIVE_MINUTE;
etime = now;
loadQueryJob.schedule(2000);
thread = new RefreshThread(this, 10000);
thread.start();
}
public void refresh() {
if (isAutoRefresh) {
root.clear();
long now = TimeUtil.getCurrentTime(serverId);
date = DateUtil.yyyymmdd(now);
stime = now - DateUtil.MILLIS_PER_FIVE_MINUTE;
etime = now;
loadQueryJob.schedule();
}
}
public void setInput(long stime, long etime) {
if (loadQueryJob.getState() == Job.WAITING || loadQueryJob.getState() == Job.RUNNING) {
MessageDialog.openInformation(null, "STOP", "Previous loading is not yet finished");
return;
}
if (etime - stime < DateUtil.MILLIS_PER_MINUTE) {
stime = etime - DateUtil.MILLIS_PER_MINUTE;
}
root.clear();
this.stime = stime;
this.etime = etime;
this.date = DateUtil.yyyymmdd(stime);
loadQueryJob.schedule();
}
ArrayList<DigestSchema> columnList = new ArrayList<DigestSchema>();
private void createColumns() {
columnList.clear();
for (DigestSchema column : DigestSchema.values()) {
createTreeViewerColumn(column.getTitle(), column.getWidth(), column.getAlignment(), true, true, column.isNumber());
columnList.add(column);
}
}
private TreeViewerColumn createTreeViewerColumn(String title, int width, int alignment, boolean resizable, boolean moveable, final boolean isNumber) {
final TreeViewerColumn viewerColumn = new TreeViewerColumn(viewer, SWT.NONE);
final TreeColumn column = viewerColumn.getColumn();
column.setText(title);
column.setAlignment(alignment);
column.setMoveable(moveable);
columnLayout.setColumnData(column, new ColumnPixelData(width, resizable));
column.setData("isNumber", isNumber);
column.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(SelectionEvent e) {
TreeLabelSorter sorter = (TreeLabelSorter) viewer.getComparator();
TreeColumn selectedColumn = (TreeColumn) e.widget;
sorter.setColumn(selectedColumn);
}
});
return viewerColumn;
}
public void setFocus() {
}
Job loadQueryJob = new Job("Load Digest List...") {
HashMap<DigestKey, MapPack> summaryMap = new HashMap<DigestKey, MapPack>();
HashMap<Integer, StatusPack> firstStatusMap = new HashMap<Integer, StatusPack>();
HashMap<Integer, StatusPack> lastStatusMap = new HashMap<Integer, StatusPack>();
protected IStatus run(final IProgressMonitor monitor) {
summaryMap.clear();
firstStatusMap.clear();
lastStatusMap.clear();
monitor.beginTask(DateUtil.hhmmss(stime) + " ~ " + DateUtil.hhmmss(etime), 100);
TcpProxy tcp = TcpProxy.getTcpProxy(serverId);
try {
MapPack param = new MapPack();
ListValue objHashLv = agentProxy.getObjHashLv(date, serverId, CounterConstants.MARIA_PLUGIN);
if (objHashLv.size() > 0) {
param.put("objHash", objHashLv);
param.put("date", date);
param.put("time", stime);
List<Pack> firstList = tcp.process(RequestCmd.DB_LAST_DIGEST_TABLE, param);
for (Pack p : firstList) {
StatusPack s = (StatusPack) p;
firstStatusMap.put(s.objHash, s);
}
param.put("stime", stime);
param.put("etime", etime);
tcp.process(RequestCmd.DB_DIGEST_TABLE, param, new INetReader() {
public void process(DataInputX in) throws IOException {
Pack p = in.readPack();
switch (p.getPackType()) {
case PackEnum.MAP:
MapPack m = (MapPack) p;
if (m.containsKey("percent")) {
monitor.worked(m.getInt("percent"));
} else {
int objHash = m.getInt("objHash");
int digestHash = m.getInt("digestHash");
summaryMap.put(new DigestKey(objHash, digestHash), m);
}
break;
case PackEnum.PERF_STATUS:
StatusPack sp = (StatusPack) p;
lastStatusMap.put(sp.objHash, sp);
break;
}
}
});
}
} catch (Exception e) {
ConsoleProxy.errorSafe(e.toString());
} finally {
TcpProxy.putTcpProxy(tcp);
}
Iterator<Integer> itr = lastStatusMap.keySet().iterator();
while (itr.hasNext()) {
int objHash = itr.next();
StatusPack firstStatus = firstStatusMap.get(objHash);
StatusPack lastStatus = lastStatusMap.get(objHash);
HashMap<Integer, MapValue> firstMap = new HashMap<Integer, MapValue>();
if (firstStatus == null) {
// nothing
} else {
// index first values for delta
MapValue firstData = firstStatus.data;
ListValue firstDigestLv = firstData.getList("DIGEST_TEXT");
for (int i = 0; i < firstDigestLv.size(); i++) {
int digestHash = firstDigestLv.getInt(i);
MapValue valueMap = new MapValue();
Enumeration<String> keys = firstData.keys();
while (keys.hasMoreElements()) {
String key = keys.nextElement();
valueMap.put(key, firstData.getList(key).get(i));
}
firstMap.put(digestHash, valueMap);
}
}
MapValue data = lastStatus.data;
ListValue digestLv = data.getList("DIGEST_TEXT");
ListValue schemaNameLv = data.getList("SCHEMA_NAME");
ListValue executionLv = data.getList("COUNT_STAR");
ListValue timerWaitLv = data.getList("SUM_TIMER_WAIT");
ListValue lockTimeLv = data.getList("SUM_LOCK_TIME");
ListValue errorsLv = data.getList("SUM_ERRORS");
ListValue warnsLv = data.getList("SUM_WARNINGS");
ListValue rowsAffectedLv = data.getList("SUM_ROWS_AFFECTED");
ListValue rowsSentLv = data.getList("SUM_ROWS_SENT");
ListValue rowsExaminedLv = data.getList("SUM_ROWS_EXAMINED");
ListValue createdTmpDiskTablesLv = data.getList("SUM_CREATED_TMP_DISK_TABLES");
ListValue createdTmpTablesLv = data.getList("SUM_CREATED_TMP_TABLES");
ListValue selectFullJoin = data.getList("SUM_SELECT_FULL_JOIN");
ListValue selectFullRangeJoin = data.getList("SUM_SELECT_FULL_RANGE_JOIN");
ListValue selectRangeLv = data.getList("SUM_SELECT_RANGE");
ListValue selectRangeCheckLv = data.getList("SUM_SELECT_RANGE_CHECK");
ListValue selectScanLv = data.getList("SUM_SELECT_SCAN");
ListValue sortMergePassesLv = data.getList("SUM_SORT_MERGE_PASSES");
ListValue sortRangeLv = data.getList("SUM_SORT_RANGE");
ListValue sortRowsLv = data.getList("SUM_SORT_ROWS");
ListValue sortScanLv = data.getList("SUM_SORT_SCAN");
ListValue noIndexUsedLv = data.getList("SUM_NO_INDEX_USED");
ListValue noGoodIndexUsedLv = data.getList("SUM_NO_GOOD_INDEX_USED");
ListValue firstSeenLv = data.getList("FIRST_SEEN");
ListValue lastSeenLv = data.getList("LAST_SEEN");
for (int i = 0; i < digestLv.size(); i++) {
if (lastSeenLv.getLong(i) < stime || lastSeenLv.getLong(i) > etime) {
continue;
}
DigestModel model = new DigestModel();
int digestHash = digestLv.getInt(i);
MapPack m = summaryMap.get(new DigestKey(objHash, digestHash));
if (m == null) continue;
long maxTimerWait = m.getLong("MAX_TIMER_WAIT");
long minTimerWait = m.getLong("MIN_TIMER_WAIT");
long avgTimerWait = m.getLong("AVG_TIMER_WAIT");
int count = m.getInt("count");
model.objHash = objHash;
model.digestHash = digestHash;
model.name = TextProxy.object.getLoadText(date, objHash, serverId);
model.database = TextProxy.maria.getLoadText(date, schemaNameLv.getInt(i), serverId);
model.firstSeen = firstSeenLv.getLong(i);
model.lastSeen = lastSeenLv.getLong(i);
model.avgResponseTime = avgTimerWait / (double) count;
model.minResponseTime = minTimerWait;
model.maxResponseTime = maxTimerWait;
MapValue firstValue = firstMap.get(digestHash);
if (firstValue == null) {
firstValue = new MapValue();
}
model.execution = executionLv.getInt(i) - firstValue.getInt("COUNT_STAR");
if (model.execution < 1) {
System.out.println("first=>" + firstStatus);
System.out.println("last =>" + firstStatus);
}
model.errorCnt = errorsLv.getInt(i) - firstValue.getInt("SUM_ERRORS");
model.warnCnt = warnsLv.getInt(i) - firstValue.getInt("SUM_WARNINGS");
model.sumResponseTime = timerWaitLv.getLong(i) - firstValue.getLong("SUM_TIMER_WAIT");
model.lockTime = lockTimeLv.getLong(i) - firstValue.getLong("SUM_LOCK_TIME");
model.rowsAffected = rowsAffectedLv.getLong(i) - firstValue.getLong("SUM_ROWS_AFFECTED");
model.rowsSent = rowsSentLv.getLong(i) - firstValue.getLong("SUM_ROWS_SENT");
model.rowsExamined = rowsExaminedLv.getLong(i) - firstValue.getLong("SUM_ROWS_EXAMINED");
model.createdTmpDiskTables = createdTmpDiskTablesLv.getLong(i) - firstValue.getLong("SUM_CREATED_TMP_DISK_TABLES");
model.createdTmpTables = createdTmpTablesLv.getLong(i) - firstValue.getLong("SUM_CREATED_TMP_TABLES");
model.selectFullJoin = selectFullJoin.getLong(i) - firstValue.getLong("SUM_SELECT_FULL_JOIN");
model.selectFullRangeJoin = selectFullRangeJoin.getLong(i) - firstValue.getLong("SUM_SELECT_FULL_RANGE_JOIN");
model.selectRange = selectRangeLv.getLong(i) - firstValue.getLong("SUM_SELECT_RANGE");
model.selectRangeCheck = selectRangeCheckLv.getLong(i) - firstValue.getLong("SUM_SELECT_RANGE_CHECK");
model.selectScan = selectScanLv.getLong(i) - firstValue.getLong("SUM_SELECT_SCAN");
model.sortMergePasses = sortMergePassesLv.getLong(i) - firstValue.getLong("SUM_SORT_MERGE_PASSES");
model.sortRange =sortRangeLv.getLong(i) - firstValue.getLong("SUM_SORT_RANGE");
model.sortRows = sortRowsLv.getLong(i) - firstValue.getLong("SUM_SORT_ROWS");
model.sortScan = sortScanLv.getLong(i) - firstValue.getLong("SUM_SORT_SCAN");
model.noIndexUsed = noIndexUsedLv.getLong(i) - firstValue.getLong("SUM_NO_INDEX_USED");
model.noGoodIndexUsed = noGoodIndexUsedLv.getLong(i) - firstValue.getLong("SUM_NO_GOOD_INDEX_USED");
DigestModel parent = root.get(digestHash);
if (parent == null) {
parent = new DigestModel();
parent.digestHash = digestHash;
String digestTxt = TextProxy.maria.getLoadText(date, digestHash, serverId);
parent.name = digestTxt == null ? "unknown hash" : digestTxt;
root.put(digestHash, parent);
}
model.parent = parent;
parent.addChild(model);
}
}
Iterator<DigestModel> parents = root.values().iterator();
while (parents.hasNext()) {
DigestModel parent = parents.next();
DigestModel[] childs = parent.getChildArray();
if (childs != null) {
double sumAvg = 0.0d;
for (DigestModel child : childs) {
sumAvg += child.avgResponseTime;
}
parent.avgResponseTime = sumAvg / childs.length;
}
}
monitor.done();
ExUtil.exec(viewer.getTree(), new Runnable() {
public void run() {
DigestTableView.this.setContentDescription(DateUtil.format(stime, "MM-dd HH:mm:ss") + " ~ " + DateUtil.format(etime, "MM-dd HH:mm:ss") + " (" + root.size() + ")");
viewer.refresh();
}
});
return Status.OK_STATUS;
}
};
class TreeContentProvider implements ITreeContentProvider {
public void dispose() {
}
public void inputChanged(Viewer arg0, Object arg1, Object arg2) {
}
public Object[] getChildren(Object parentElement) {
if (parentElement instanceof DigestModel) {
DigestModel parent = (DigestModel) parentElement;
Object[] array = parent.getChildArray();
if(array != null) return array;
}
return new Object[0];
}
public Object[] getElements(Object inputElement) {
if (inputElement instanceof HashMap) {
HashMap map = (HashMap) inputElement;
Object[] objArray = new Object[map.size()];
Iterator itr = map.values().iterator();
int cnt = 0;
while (itr.hasNext()) {
objArray[cnt] = itr.next();
cnt++;
}
return objArray;
}
return new Object[0];
}
public Object getParent(Object element) {
if (element instanceof DigestModel) {
return ((DigestModel) element).parent;
}
return null;
}
public boolean hasChildren(Object element) {
if (element instanceof DigestModel) {
return ((DigestModel) element).getChildArray() != null;
}
return false;
}
}
class TreeLabelProvider implements ITableLabelProvider {
public void addListener(ILabelProviderListener listener) {
}
public void dispose() {
}
public boolean isLabelProperty(Object element, String property) {
return false;
}
public void removeListener(ILabelProviderListener listener) {
}
public Image getColumnImage(Object element, int columnIndex) {
return null;
}
public String getColumnText(Object element, int columnIndex) {
if (element instanceof DigestModel) {
DigestModel model = (DigestModel) element;
DigestSchema column = columnList.get(columnIndex);
switch (column) {
case DIGEST_TEXT:
return model.name;
case SCHEMA_NAME:
return model.database;
case COUNT_STAR:
return FormatUtil.print(model.execution, "#,##0");
case SUM_ERRORS:
return FormatUtil.print(model.errorCnt, "#,##0");
case SUM_WARNINGS:
return FormatUtil.print(model.warnCnt, "#,##0");
case SUM_TIMER_WAIT:
return FormatUtil.print(model.sumResponseTime * PICO, "#,##0.00#");
case AVG_TIMER_WAIT:
return FormatUtil.print(model.avgResponseTime * PICO, "#,##0.00#");
case MIN_TIMER_WAIT:
return FormatUtil.print(model.minResponseTime * PICO, "#,##0.00#");
case MAX_TIMER_WAIT:
return FormatUtil.print(model.maxResponseTime * PICO, "#,##0.00#");
case SUM_LOCK_TIME:
return FormatUtil.print(model.lockTime * PICO, "#,##0.00#");
case SUM_ROWS_AFFECTED:
return FormatUtil.print(model.rowsAffected, "#,##0");
case SUM_ROWS_SENT:
return FormatUtil.print(model.rowsSent, "#,##0");
case SUM_ROWS_EXAMINED:
return FormatUtil.print(model.rowsExamined, "#,##0");
case SUM_CREATED_TMP_DISK_TABLES:
return FormatUtil.print(model.createdTmpDiskTables, "#,##0");
case SUM_CREATED_TMP_TABLES:
return FormatUtil.print(model.createdTmpTables, "#,##0");
case SUM_SELECT_FULL_JOIN:
return FormatUtil.print(model.selectFullJoin, "#,##0");
case SUM_SELECT_FULL_RANGE_JOIN:
return FormatUtil.print(model.selectFullRangeJoin, "#,##0");
case SUM_SELECT_RANGE:
return FormatUtil.print(model.selectRange, "#,##0");
case SUM_SELECT_RANGE_CHECK:
return FormatUtil.print(model.selectRangeCheck, "#,##0");
case SUM_SELECT_SCAN:
return FormatUtil.print(model.selectScan, "#,##0");
case SUM_SORT_MERGE_PASSES:
return FormatUtil.print(model.sortMergePasses, "#,##0");
case SUM_SORT_RANGE:
return FormatUtil.print(model.sortRange, "#,##0");
case SUM_SORT_ROWS:
return FormatUtil.print(model.sortRows, "#,##0");
case SUM_SORT_SCAN:
return FormatUtil.print(model.sortScan, "#,##0");
case SUM_NO_INDEX_USED:
return FormatUtil.print(model.noIndexUsed, "#,##0");
case SUM_NO_GOOD_INDEX_USED:
return FormatUtil.print(model.noGoodIndexUsed, "#,##0");
case FIRST_SEEN:
return DateUtil.timestamp(model.firstSeen);
case LAST_SEEN:
return DateUtil.timestamp(model.lastSeen);
}
}
return null;
}
}
public void dispose() {
super.dispose();
if (loadQueryJob != null && (loadQueryJob.getState() == Job.WAITING || loadQueryJob.getState() == Job.RUNNING)) {
loadQueryJob.cancel();
}
}
public static void main(String[] args) {
System.out.println(139871834183L * Math.pow(10, -12));
}
}
| apache-2.0 |
Alvin-Lau/zstack | sdk/src/main/java/org/zstack/sdk/GetCandidateVmForAttachingIsoResult.java | 372 | package org.zstack.sdk;
public class GetCandidateVmForAttachingIsoResult {
public java.util.List<VmInstanceInventory> inventories;
public void setInventories(java.util.List<VmInstanceInventory> inventories) {
this.inventories = inventories;
}
public java.util.List<VmInstanceInventory> getInventories() {
return this.inventories;
}
}
| apache-2.0 |
ErikSchierboom/roslyn | src/Workspaces/Core/Portable/FindSymbols/SymbolFinder.FindReferencesServerCallback.cs | 4661 | // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
#nullable disable
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.CodeAnalysis.Remote;
namespace Microsoft.CodeAnalysis.FindSymbols
{
public static partial class SymbolFinder
{
/// <summary>
/// Callback object we pass to the OOP server to hear about the result
/// of the FindReferencesEngine as it executes there.
/// </summary>
internal sealed class FindReferencesServerCallback : IEqualityComparer<SerializableSymbolAndProjectId>
{
private readonly Solution _solution;
private readonly IStreamingFindReferencesProgress _progress;
private readonly CancellationToken _cancellationToken;
private readonly object _gate = new();
private readonly Dictionary<SerializableSymbolAndProjectId, ISymbol> _definitionMap;
public FindReferencesServerCallback(
Solution solution,
IStreamingFindReferencesProgress progress,
CancellationToken cancellationToken)
{
_solution = solution;
_progress = progress;
_cancellationToken = cancellationToken;
_definitionMap = new Dictionary<SerializableSymbolAndProjectId, ISymbol>(this);
}
public ValueTask AddItemsAsync(int count)
=> _progress.ProgressTracker.AddItemsAsync(count);
public ValueTask ItemCompletedAsync()
=> _progress.ProgressTracker.ItemCompletedAsync();
public ValueTask OnStartedAsync()
=> _progress.OnStartedAsync();
public ValueTask OnCompletedAsync()
=> _progress.OnCompletedAsync();
public ValueTask OnFindInDocumentStartedAsync(DocumentId documentId)
{
var document = _solution.GetDocument(documentId);
return _progress.OnFindInDocumentStartedAsync(document);
}
public ValueTask OnFindInDocumentCompletedAsync(DocumentId documentId)
{
var document = _solution.GetDocument(documentId);
return _progress.OnFindInDocumentCompletedAsync(document);
}
public async ValueTask OnDefinitionFoundAsync(SerializableSymbolAndProjectId definition)
{
var symbol = await definition.TryRehydrateAsync(
_solution, _cancellationToken).ConfigureAwait(false);
if (symbol == null)
return;
lock (_gate)
{
_definitionMap[definition] = symbol;
}
await _progress.OnDefinitionFoundAsync(symbol).ConfigureAwait(false);
}
public async ValueTask OnReferenceFoundAsync(
SerializableSymbolAndProjectId definition, SerializableReferenceLocation reference)
{
ISymbol symbol;
lock (_gate)
{
// The definition may not be in the map if we failed to map it over using TryRehydrateAsync in OnDefinitionFoundAsync.
// Just ignore this reference. Note: while this is a degraded experience:
//
// 1. TryRehydrateAsync logs an NFE so we can track down while we're failing to roundtrip the
// definition so we can track down that issue.
// 2. NFE'ing and failing to show a result, is much better than NFE'ing and then crashing
// immediately afterwards.
if (!_definitionMap.TryGetValue(definition, out symbol))
return;
}
var referenceLocation = await reference.RehydrateAsync(
_solution, _cancellationToken).ConfigureAwait(false);
await _progress.OnReferenceFoundAsync(symbol, referenceLocation).ConfigureAwait(false);
}
bool IEqualityComparer<SerializableSymbolAndProjectId>.Equals(SerializableSymbolAndProjectId x, SerializableSymbolAndProjectId y)
=> y.SymbolKeyData.Equals(x.SymbolKeyData);
int IEqualityComparer<SerializableSymbolAndProjectId>.GetHashCode(SerializableSymbolAndProjectId obj)
=> obj.SymbolKeyData.GetHashCode();
}
}
}
| apache-2.0 |
synaptek/TypeScript | tests/cases/fourslash/completionForStringLiteral2.ts | 456 | /// <reference path='fourslash.ts'/>
////var o = {
//// foo() { },
//// bar: 0,
//// "some other name": 1
////};
////
////o["/*1*/bar"];
////o["/*2*/
goTo.marker('1');
verify.completionListContains("foo");
verify.completionListAllowsNewIdentifier();
verify.completionListCount(3);
goTo.marker('2');
verify.completionListContains("some other name");
verify.completionListAllowsNewIdentifier();
verify.completionListCount(3);
| apache-2.0 |
mayurid/azure-powershell | src/ResourceManager/Sql/Commands.Sql/Elastic Pools/Cmdlet/AzureSqlElasticPoolActivityCmdletBase.cs | 2382 | // ----------------------------------------------------------------------------------
//
// Copyright Microsoft Corporation
// 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.
// ----------------------------------------------------------------------------------
using System.Collections.Generic;
using System.Management.Automation;
using Microsoft.Azure.Commands.Sql.Common;
using Microsoft.Azure.Commands.Sql.ElasticPool.Model;
using Microsoft.Azure.Commands.Sql.ElasticPool.Services;
namespace Microsoft.Azure.Commands.Sql.ElasticPool.Cmdlet
{
public abstract class AzureSqlElasticPoolActivityCmdletBase : AzureSqlCmdletBase<IEnumerable<AzureSqlElasticPoolActivityModel>, AzureSqlElasticPoolAdapter>
{
/// <summary>
/// Gets or sets the name of the database server to use.
/// </summary>
[Parameter(Mandatory = true,
ValueFromPipelineByPropertyName = true,
Position = 1,
HelpMessage = "The name of the Azure SQL Server the Elastic Pool is in.")]
[ValidateNotNullOrEmpty]
public string ServerName { get; set; }
/// <summary>
/// Gets or sets the name of the ElasticPool to use.
/// </summary>
[Parameter(Mandatory = true,
ValueFromPipelineByPropertyName = true,
Position = 2,
HelpMessage = "The name of the Azure SQL Elastic Pool.")]
[ValidateNotNullOrEmpty]
public string ElasticPoolName { get; set; }
/// <summary>
/// Initializes the adapter
/// </summary>
/// <param name="subscription"></param>
/// <returns></returns>
protected override AzureSqlElasticPoolAdapter InitModelAdapter(Azure.Common.Authentication.Models.AzureSubscription subscription)
{
return new AzureSqlElasticPoolAdapter(DefaultProfile.Context);
}
}
}
| apache-2.0 |
philmerrell/ionic-site | _site/docs/api/directive/ionNavTitle/index.html | 28108 | <!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta name="description" content="Ionic makes it incredibly easy to build beautiful and interactive mobile apps using HTML5 and AngularJS.">
<meta name="keywords" content="html5,javascript,mobile,drifty,ionic,hybrid,phonegap,cordova,native,ios,android,angularjs">
<meta name="author" content="Drifty">
<meta property="og:image" content="http://ionicframework.com/img/ionic-logo-blog.png"/>
<title>ion-nav-title - Directive in module ionic - Ionic Framework</title>
<link href="/css/site.css?17" rel="stylesheet">
<!--<script src="//cdn.optimizely.com/js/595530035.js"></script>-->
<script type="text/javascript">var _sf_startpt=(new Date()).getTime()</script>
<script>
(function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
})(window,document,'script','//www.google-analytics.com/analytics.js','ga');
ga('create', 'UA-44023830-1', 'ionicframework.com');
ga('send', 'pageview');
</script>
<script>!function(d,s,id){var js,fjs=d.getElementsByTagName(s)[0],p=/^http:/.test(d.location)?'http':'https';if(!d.getElementById(id)){js=d.createElement(s);js.id=id;js.src=p+'://platform.twitter.com/widgets.js';fjs.parentNode.insertBefore(js,fjs);}}(document, 'script', 'twitter-wjs');</script>
<script src="//ajax.googleapis.com/ajax/libs/jquery/1.10.2/jquery.min.js"></script>
</head>
<body class="docs docs-page docs-api">
<nav class="navbar navbar-default horizontal-gradient" role="navigation">
<div class="container">
<div class="navbar-header">
<button type="button" class="navbar-toggle button ionic" data-toggle="collapse" data-target=".navbar-ex1-collapse">
<i class="icon ion-navicon"></i>
</button>
<a class="navbar-brand" href="/">
<img src="/img/ionic-logo-white.svg" width="123" height="43" alt="Ionic Framework">
</a>
<a href="http://blog.ionic.io/announcing-ionic-1-0/" target="_blank">
<img src="/img/ionic1-tag.png" alt="Ionic 1.0 is out!" width="28" height="32" style="margin-left: 140px; margin-top:22px; display:block">
</a>
</div>
<div class="collapse navbar-collapse navbar-ex1-collapse">
<ul class="nav navbar-nav navbar-right">
<li><a class="getting-started-nav nav-link" href="/getting-started/">Getting Started</a></li>
<li><a class="docs-nav nav-link" href="/docs/">Docs</a></li>
<li><a class="nav-link" href="http://ionic.io/support">Support</a></li>
<li><a class="blog-nav nav-link" href="http://blog.ionic.io/">Blog <span id="blog-badge">1</span></a></li>
<li><a class="nav-link" href="http://forum.ionicframework.com/">Forum</a></li>
<li class="dropdown">
<a href="#" class="dropdown-toggle nav-link " data-toggle="dropdown" role="button" aria-expanded="false">More <span class="caret"></span></a>
<ul class="dropdown-menu" role="menu">
<div class="arrow-up"></div>
<li><a class="products-nav nav-link" href="http://ionic.io/">Ionic Platform</a></li>
<li><a class="examples-nav nav-link" href="http://showcase.ionicframework.com/">Showcase</a></li>
<li><a class="nav-link" href="http://jobs.ionic.io/">Job Board</a></li>
<li><a class="nav-link" href="http://market.ionic.io/">Market</a></li>
<li><a class="nav-link" href="http://ionicworldwide.herokuapp.com/">Ionic Worldwide</a></li>
<li><a class="nav-link" href="http://play.ionic.io/">Playground</a></li>
<li><a class="nav-link" href="http://creator.ionic.io/">Creator</a></li>
<li><a class="nav-link" href="http://shop.ionic.io/">Shop</a></li>
<!--<li><a class="nav-link" href="http://ngcordova.com/">ngCordova</a></li>-->
</ul>
</li>
</ul>
</div>
</div>
</nav>
<div class="header horizontal-gradient">
<div class="container">
<h3>ion-nav-title</h3>
<h4>Directive in module ionic</h4>
</div>
<div class="news">
<div class="container">
<div class="row">
<div class="col-sm-8 news-col">
<div class="picker">
<select name="version"
id="version-toggle"
onchange="window.location.href=this.options[this.selectedIndex].value">
<option
value="/docs/v2/nightly/api/directive/ionNavTitle/"
>
nightly
</option>
<option
value="/docs/v2/api/directive/ionNavTitle/"
>
2.0.0 (latest)
</option>
</select>
</div>
</div>
<div class="col-sm-4 search-col">
<div class="search-bar">
<span class="search-icon ionic"><i class="ion-ios7-search-strong"></i></span>
<input type="search" id="search-input" value="Search">
</div>
</div>
</div>
</div>
</div>
</div>
<div id="search-results" class="search-results" style="display:none">
<div class="container">
<div class="search-section search-api">
<h4>JavaScript</h4>
<ul id="results-api"></ul>
</div>
<div class="search-section search-css">
<h4>CSS</h4>
<ul id="results-css"></ul>
</div>
<div class="search-section search-content">
<h4>Resources</h4>
<ul id="results-content"></ul>
</div>
</div>
</div>
<div class="container content-container">
<div class="row">
<div class="col-md-2 col-sm-3 aside-menu">
<div>
<ul class="nav left-menu">
<li class="menu-title">
<a href="/docs/overview/">Overview</a>
</li>
</ul>
<ul class="nav left-menu">
<li class="menu-title">
<a href="/docs/components/">CSS</a>
</li>
</ul>
<ul class="nav left-menu">
<li class="menu-title">
<a href="/docs/platform-customization/">Platform Customization</a>
</li>
</ul>
<!-- Docs: JavaScript -->
<ul class="nav left-menu active-menu">
<li class="menu-title">
<a href="/docs/api/">
JavaScript
</a>
</li>
<!-- Action Sheet -->
<li class="menu-section">
<a href="/docs/api/service/$ionicActionSheet/" class="api-section">
Action Sheet
</a>
<ul>
<li>
<a href="/docs/api/service/$ionicActionSheet/">
$ionicActionSheet
</a>
</li>
</ul>
</li>
<!-- Backdrop -->
<li class="menu-section">
<a href="/docs/api/service/$ionicBackdrop/" class="api-section">
Backdrop
</a>
<ul>
<li>
<a href="/docs/api/service/$ionicBackdrop/">
$ionicBackdrop
</a>
</li>
</ul>
</li>
<!-- Content -->
<li class="menu-section">
<a href="/docs/api/directive/ionContent/" class="api-section">
Content
</a>
<ul>
<li>
<a href="/docs/api/directive/ionContent/">
ion-content
</a>
</li>
<li>
<a href="/docs/api/directive/ionRefresher/">
ion-refresher
</a>
</li>
<li>
<a href="/docs/api/directive/ionPane/">
ion-pane
</a>
</li>
</ul>
</li>
<!-- Form Inputs -->
<li class="menu-section">
<a href="/docs/api/directive/ionCheckbox/" class="api-section">
Form Inputs
</a>
<ul>
<li>
<a href="/docs/api/directive/ionCheckbox/">
ion-checkbox
</a>
</li>
<li>
<a href="/docs/api/directive/ionRadio/">
ion-radio
</a>
</li>
<li>
<a href="/docs/api/directive/ionToggle/">
ion-toggle
</a>
</li>
</ul>
</li>
<!-- Gesture and Events -->
<li class="menu-section">
<a href="/docs/api/directive/onHold/" class="api-section">
Gestures and Events
</a>
<ul>
<li>
<a href="/docs/api/directive/onHold/">
on-hold
</a>
</li>
<li>
<a href="/docs/api/directive/onTap/">
on-tap
</a>
</li>
<li>
<a href="/docs/api/directive/onDoubleTap/">
on-double-tap
</a>
</li>
<li>
<a href="/docs/api/directive/onTouch/">
on-touch
</a>
</li>
<li>
<a href="/docs/api/directive/onRelease/">
on-release
</a>
</li>
<li>
<a href="/docs/api/directive/onDrag/">
on-drag
</a>
</li>
<li>
<a href="/docs/api/directive/onDragUp/">
on-drag-up
</a>
</li>
<li>
<a href="/docs/api/directive/onDragRight/">
on-drag-right
</a>
</li>
<li>
<a href="/docs/api/directive/onDragDown/">
on-drag-down
</a>
</li>
<li>
<a href="/docs/api/directive/onDragLeft/">
on-drag-left
</a>
</li>
<li>
<a href="/docs/api/directive/onSwipe/">
on-swipe
</a>
</li>
<li>
<a href="/docs/api/directive/onSwipeUp/">
on-swipe-up
</a>
</li>
<li>
<a href="/docs/api/directive/onSwipeRight/">
on-swipe-right
</a>
</li>
<li>
<a href="/docs/api/directive/onSwipeDown/">
on-swipe-down
</a>
</li>
<li>
<a href="/docs/api/directive/onSwipeLeft/">
on-swipe-left
</a>
</li>
<li>
<a href="/docs/api/service/$ionicGesture/">
$ionicGesture
</a>
</li>
</ul>
</li>
<!-- Headers/Footers -->
<li class="menu-section">
<a href="/docs/api/directive/ionHeaderBar/" class="api-section">
Headers/Footers
</a>
<ul>
<li>
<a href="/docs/api/directive/ionHeaderBar/">
ion-header-bar
</a>
</li>
<li>
<a href="/docs/api/directive/ionFooterBar/">
ion-footer-bar
</a>
</li>
</ul>
</li>
<!-- Keyboard -->
<li class="menu-section">
<a href="/docs/api/page/keyboard/" class="api-section">
Keyboard
</a>
<ul>
<li>
<a href="/docs/api/page/keyboard/">
Keyboard
</a>
</li>
<li>
<a href="/docs/api/directive/keyboardAttach/">
keyboard-attach
</a>
</li>
</ul>
</li>
<!-- Lists -->
<li class="menu-section">
<a href="/docs/api/directive/ionList/" class="api-section">
Lists
</a>
<ul>
<li>
<a href="/docs/api/directive/ionList/">
ion-list
</a>
</li>
<li>
<a href="/docs/api/directive/ionItem/">
ion-item
</a>
</li>
<li>
<a href="/docs/api/directive/ionDeleteButton/">
ion-delete-button
</a>
</li>
<li>
<a href="/docs/api/directive/ionReorderButton/">
ion-reorder-button
</a>
</li>
<li>
<a href="/docs/api/directive/ionOptionButton/">
ion-option-button
</a>
</li>
<li>
<a href="/docs/api/directive/collectionRepeat/">
collection-repeat
</a>
</li>
<li>
<a href="/docs/api/service/$ionicListDelegate/">
$ionicListDelegate
</a>
</li>
</ul>
</li>
<!-- Loading -->
<li class="menu-section">
<a href="/docs/api/service/$ionicLoading/" class="api-section">
Loading
</a>
<ul>
<li>
<a href="/docs/api/service/$ionicLoading/">
$ionicLoading
</a>
</li>
</ul>
<ul>
<li>
<a href="/docs/api/object/$ionicLoadingConfig/">
$ionicLoadingConfig
</a>
</li>
</ul>
</li>
<!-- Modal -->
<li class="menu-section">
<a href="/docs/api/service/$ionicModal/" class="api-section">
Modal
</a>
<ul>
<li>
<a href="/docs/api/service/$ionicModal/">
$ionicModal
</a>
</li>
<li>
<a href="/docs/api/controller/ionicModal/">
ionicModal
</a>
</li>
</ul>
</li>
<!-- Navigation -->
<li class="menu-section">
<a href="/docs/api/directive/ionNavView/" class="api-section">
Navigation
</a>
<ul>
<li>
<a href="/docs/api/directive/ionNavView/">
ion-nav-view
</a>
</li>
<li>
<a href="/docs/api/directive/ionView/">
ion-view
</a>
</li>
<li>
<a href="/docs/api/directive/ionNavBar/">
ion-nav-bar
</a>
</li>
<li>
<a href="/docs/api/directive/ionNavBackButton/">
ion-nav-back-button
</a>
</li>
<li>
<a href="/docs/api/directive/ionNavButtons/">
ion-nav-buttons
</a>
</li>
<li>
<a href="/docs/api/directive/ionNavTitle/">
ion-nav-title
</a>
</li>
<li>
<a href="/docs/api/directive/navTransition/">
nav-transition
</a>
</li>
<li>
<a href="/docs/api/directive/navDirection/">
nav-direction
</a>
</li>
<li>
<a href="/docs/api/service/$ionicNavBarDelegate/">
$ionicNavBarDelegate
</a>
</li>
<li>
<a href="/docs/api/service/$ionicHistory/">
$ionicHistory
</a>
</li>
</ul>
</li>
<!-- Platform -->
<li class="menu-section">
<a href="/docs/api/service/$ionicPlatform/" class="api-section">
Platform
</a>
<ul>
<li>
<a href="/docs/api/service/$ionicPlatform/">
$ionicPlatform
</a>
</li>
</ul>
</li>
<!-- Popover -->
<li class="menu-section">
<a href="/docs/api/service/$ionicPopover/" class="api-section">
Popover
</a>
<ul>
<li>
<a href="/docs/api/service/$ionicPopover/">
$ionicPopover
</a>
</li>
<li>
<a href="/docs/api/controller/ionicPopover/">
ionicPopover
</a>
</li>
</ul>
</li>
<!-- Popup -->
<li class="menu-section">
<a href="/docs/api/service/$ionicPopup/" class="api-section">
Popup
</a>
<ul>
<li>
<a href="/docs/api/service/$ionicPopup/">
$ionicPopup
</a>
</li>
</ul>
</li>
<!-- Scroll -->
<li class="menu-section">
<a href="/docs/api/directive/ionScroll/" class="api-section">
Scroll
</a>
<ul>
<li>
<a href="/docs/api/directive/ionScroll/">
ion-scroll
</a>
</li>
<li>
<a href="/docs/api/directive/ionInfiniteScroll/">
ion-infinite-scroll
</a>
</li>
<li>
<a href="/docs/api/service/$ionicScrollDelegate/">
$ionicScrollDelegate
</a>
</li>
</ul>
</li>
<!-- Side Menus -->
<li class="menu-section">
<a href="/docs/api/directive/ionSideMenus/" class="api-section">
Side Menus
</a>
<ul>
<li>
<a href="/docs/api/directive/ionSideMenus/">
ion-side-menus
</a>
</li>
<li>
<a href="/docs/api/directive/ionSideMenuContent/">
ion-side-menu-content
</a>
</li>
<li>
<a href="/docs/api/directive/ionSideMenu/">
ion-side-menu
</a>
</li>
<li>
<a href="/docs/api/directive/exposeAsideWhen/">
expose-aside-when
</a>
</li>
<li>
<a href="/docs/api/directive/menuToggle/">
menu-toggle
</a>
</li>
<li>
<a href="/docs/api/directive/menuClose/">
menu-close
</a>
</li>
<li>
<a href="/docs/api/service/$ionicSideMenuDelegate/">
$ionicSideMenuDelegate
</a>
</li>
</ul>
</li>
<!-- Slide Box -->
<li class="menu-section">
<a href="/docs/api/directive/ionSlideBox/" class="api-section">
Slide Box
</a>
<ul>
<li>
<a href="/docs/api/directive/ionSlideBox/">
ion-slide-box
</a>
</li>
<li>
<a href="/docs/api/directive/ionSlidePager/">
ion-slide-pager
</a>
</li>
<li>
<a href="/docs/api/directive/ionSlide/">
ion-slide
</a>
</li>
<li>
<a href="/docs/api/service/$ionicSlideBoxDelegate/">
$ionicSlideBoxDelegate
</a>
</li>
</ul>
</li>
<!-- Spinner -->
<li class="menu-section">
<a href="/docs/api/directive/ionSpinner/" class="api-section">
Spinner
</a>
<ul>
<li>
<a href="/docs/api/directive/ionSpinner/">
ion-spinner
</a>
</li>
</ul>
</li>
<!-- Tabs -->
<li class="menu-section">
<a href="/docs/api/directive/ionTabs/" class="api-section">
Tabs
</a>
<ul>
<li>
<a href="/docs/api/directive/ionTabs/">
ion-tabs
</a>
</li>
<li>
<a href="/docs/api/directive/ionTab/">
ion-tab
</a>
</li>
<li>
<a href="/docs/api/service/$ionicTabsDelegate/">
$ionicTabsDelegate
</a>
</li>
</ul>
</li>
<!-- Tap -->
<li class="menu-section">
<a href="/docs/api/page/tap/" class="api-section">
Tap & Click
</a>
</li>
<!-- Utility -->
<li class="menu-section">
<a href="#" class="api-section">
Utility
</a>
<ul>
<li>
<a href="/docs/api/provider/$ionicConfigProvider/">
$ionicConfigProvider
</a>
</li>
<li>
<a href="/docs/api/utility/ionic.Platform/">
ionic.Platform
</a>
</li>
<li>
<a href="/docs/api/utility/ionic.DomUtil/">
ionic.DomUtil
</a>
</li>
<li>
<a href="/docs/api/utility/ionic.EventController/">
ionic.EventController
</a>
</li>
<li>
<a href="/docs/api/service/$ionicPosition/">
$ionicPosition
</a>
</li>
</ul>
</li>
</ul>
<ul class="nav left-menu">
<li class="menu-title">
<a href="/docs/cli/">CLI</a>
</li>
</ul>
<ul class="nav left-menu">
<li class="menu-title">
<a href="http://learn.ionicframework.com/">Learn Ionic</a>
</li>
</ul>
<ul class="nav left-menu">
<li class="menu-title">
<a href="/docs/guide/">Guide</a>
</li>
</ul>
<ul class="nav left-menu">
<li class="menu-title">
<a href="/docs/ionic-cli-faq/">FAQ</a>
</li>
</ul>
<ul class="nav left-menu">
<li class="menu-title">
<a href="/docs/getting-help/">Getting Help</a>
</li>
</ul>
<ul class="nav left-menu">
<li class="menu-title">
<a href="/docs/concepts/">Ionic Concepts</a>
</li>
</ul>
</div>
</div>
<div class="col-md-10 col-sm-9 main-content">
<div class="improve-docs">
<a href="http://github.com/driftyco/ionic/tree/master/js/angular/directive/navTitle.js#L1">
View Source
</a>
<a href="http://github.com/driftyco/ionic/edit/master/js/angular/directive/navTitle.js#L1">
Improve this doc
</a>
</div>
<h1 class="api-title">
ion-nav-title
<br />
<small>
Child of <a href="/docs/api/directive/ionNavView/"><code>ionNavView</code></a>
</small>
</h1>
<p>The nav title directive replaces an <a href="/docs/api/directive/ionNavBar/"><code>ionNavBar</code></a> title text with<br />
custom HTML from within an <a href="/docs/api/directive/ionView/"><code>ionView</code></a> template. This gives each<br />
view the ability to specify its own custom title element, such as an image or any HTML,<br />
rather than being text-only. Alternatively, text-only titles can be updated using the<br />
<code>view-title</code> <a href="/docs/api/directive/ionView/"><code>ionView</code></a> attribute.</p>
<p>Note that <code>ion-nav-title</code> must be an immediate descendant of the <code>ion-view</code> or<br />
<code>ion-nav-bar</code> element (basically don’t wrap it in another div).</p>
<h2 id="usage">Usage</h2>
<pre><code class="language-html"><ion-nav-bar>
</ion-nav-bar>
<ion-nav-view>
<ion-view>
<ion-nav-title>
<img src="logo.svg">
</ion-nav-title>
<ion-content>
Some super content here!
</ion-content>
</ion-view>
</ion-nav-view>
</code></pre>
</div>
</div>
</div>
<div class="pre-footer">
<div class="row ionic">
<div class="col-sm-6 col-a">
<h4>
<a href="/getting-started/">Getting started <span class="icon ion-arrow-right-c"></span></a>
</h4>
<p>
Learn more about how Ionic was built, why you should use it, and what's included. We'll cover
the basics and help you get started from the ground up.
</p>
</div>
<div class="col-sm-6 col-b">
<h4>
<a href="/docs/">Documentation <span class="icon ion-arrow-right-c"></span></a>
</h4>
<p>
What are you waiting for? Take a look and get coding! Our documentation covers all you need to know
to get an app up and running in minutes.
</p>
</div>
</div>
</div>
<footer class="footer">
<nav class="base-links">
<dl>
<dt>Docs</dt>
<dd><a href="http://ionicframework.com/docs/">Documentation</a></dd>
<dd><a href="http://ionicframework.com/getting-started/">Getting Started</a></dd>
<dd><a href="http://ionicframework.com/docs/overview/">Overview</a></dd>
<dd><a href="http://ionicframework.com/docs/components/">Components</a></dd>
<dd><a href="http://ionicframework.com/docs/api/">JavaScript</a></dd>
<dd><a href="http://ionicframework.com/submit-issue/">Submit Issue</a></dd>
</dl>
<dl>
<dt>Resources</dt>
<dd><a href="http://learn.ionicframework.com/">Learn Ionic</a></dd>
<dd><a href="http://ngcordova.com/">ngCordova</a></dd>
<dd><a href="http://ionicons.com/">Ionicons</a></dd>
<dd><a href="http://creator.ionic.io/">Creator</a></dd>
<dd><a href="http://showcase.ionicframework.com/">Showcase</a></dd>
<dd><a href="http://manning.com/wilken/?a_aid=ionicinactionben&a_bid=1f0a0e1d">The Ionic Book</a></dd>
</dl>
<dl>
<dt>Contribute</dt>
<dd><a href="http://forum.ionicframework.com/">Community Forum</a></dd>
<dd><a href="http://webchat.freenode.net/?randomnick=1&channels=%23ionic&uio=d4">Ionic IRC</a></dd>
<dd><a href="http://ionicframework.com/present-ionic/">Present Ionic</a></dd>
<dd><a href="http://ionicframework.com/contribute/">Contribute</a></dd>
<dd><a href="https://github.com/driftyco/ionic-learn/issues/new">Write for us</a></dd>
<dd><a href="http://shop.ionic.io/">Ionic Shop</a></dd>
</dl>
<dl class="small-break">
<dt>About</dt>
<dd><a href="http://blog.ionic.io/">Blog</a></dd>
<dd><a href="http://ionic.io">Services</a></dd>
<dd><a href="http://drifty.com">Company</a></dd>
<dd><a href="https://s3.amazonaws.com/ionicframework.com/logo-pack.zip">Logo Pack</a></dd>
<dd><a href="mailto:[email protected]">Contact</a></dd>
<dd><a href="http://ionicframework.com/jobs/">Jobs</a></dd>
</dl>
<dl>
<dt>Connect</dt>
<dd><a href="https://twitter.com/IonicFramework">Twitter</a></dd>
<dd><a href="https://github.com/driftyco/ionic">GitHub</a></dd>
<dd><a href="https://www.facebook.com/ionicframework">Facebook</a></dd>
<dd><a href="https://plus.google.com/b/112280728135675018538/+Ionicframework/posts">Google+</a></dd>
<dd><a href="https://www.youtube.com/channel/UChYheBnVeCfhCmqZfCUdJQw">YouTube</a></dd>
<dd><a href="https://twitter.com/ionitron">Ionitron</a></dd>
</dl>
</nav>
<div class="newsletter row">
<div class="newsletter-container">
<div class="col-sm-7">
<div class="newsletter-text">Stay in the loop</div>
<div class="sign-up">Sign up to receive emails for the latest updates, features, and news on the framework.</div>
</div>
<form action="http://codiqa.createsend.com/t/t/s/jytylh/" method="post" class="input-group col-sm-5">
<input id="fieldEmail" name="cm-jytylh-jytylh" class="form-control" type="email" placeholder="Email" required />
<span class="input-group-btn">
<button class="btn btn-default" type="submit">Subscribe</button>
</span>
</form>
</div>
</div>
<div class="copy">
<div class="copy-container">
<p class="authors">
Code licensed under <a href="/docs/#license">MIT</a>.
Docs under <a href="https://tldrlegal.com/license/apache-license-2.0-(apache-2.0)">Apache 2</a>
<span>|</span>
© 2013-2015 <a href="http://drifty.com/">Drifty Co</a>
</p>
</div>
</div>
</footer>
<script type="text/javascript">
var _sf_async_config = { uid: 54141, domain: 'ionicframework.com', useCanonical: true };
(function() {
function loadChartbeat() {
window._sf_endpt = (new Date()).getTime();
var e = document.createElement('script');
e.setAttribute('language', 'javascript');
e.setAttribute('type', 'text/javascript');
e.setAttribute('src','//static.chartbeat.com/js/chartbeat.js');
document.body.appendChild(e);
};
var oldonload = window.onload;
window.onload = (typeof window.onload != 'function') ?
loadChartbeat : function() { oldonload(); loadChartbeat(); };
})();
</script>
<script src="//netdna.bootstrapcdn.com/bootstrap/3.0.2/js/bootstrap.min.js"></script>
<script src="/js/site.js?1"></script>
<script src="//cdnjs.cloudflare.com/ajax/libs/Cookies.js/0.4.0/cookies.min.js"></script>
<script>
$('.navbar .dropdown').on('show.bs.dropdown', function(e){
//$(this).find('.dropdown-menu').addClass('animated fadeInDown');
});
// ADD SLIDEUP ANIMATION TO DROPDOWN //
$('.navbar .dropdown').on('hide.bs.dropdown', function(e){
//$(this).find('.dropdown-menu').first().stop(true, true).slideUp(200);
//$(this).find('.dropdown-menu').removeClass('animated fadeInDown');
});
try {
var d = new Date('2015-03-20 05:00:00 -0500');
var ts = d.getTime();
var cd = Cookies.get('_iondj');
if(cd) {
cd = JSON.parse(atob(cd));
if(parseInt(cd.lp) < ts) {
var bt = document.getElementById('blog-badge');
bt.style.display = 'block';
}
cd.lp = ts;
} else {
var bt = document.getElementById('blog-badge');
bt.style.display = 'block';
cd = {
lp: ts
}
}
Cookies.set('_iondj', btoa(JSON.stringify(cd)));
} catch(e) {
}
</script>
<div id="fb-root"></div>
<script>(function(d, s, id) {
var js, fjs = d.getElementsByTagName(s)[0];
if (d.getElementById(id)) return;
js = d.createElement(s); js.id = id;
js.src = "//connect.facebook.net/en_US/all.js#xfbml=1";
fjs.parentNode.insertBefore(js, fjs);
}(document, 'script', 'facebook-jssdk'));</script>
</body>
</html>
| apache-2.0 |
isgustavo/AnimatedMoviesMakeMeCry | iOS/Animated Movies Make Me Cry/Pods/Firebase/Samples/authentication/AuthenticationExample/CustomTokenViewController.h | 681 | //
// Copyright (c) 2016 Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
@import UIKit;
@interface CustomTokenViewController : UIViewController
@end | apache-2.0 |
medicayun/medicayundicom | dcm4chee-usr/trunk/dcm4chee-usr-war/src/main/java/org/dcm4chee/usr/war/common/PageExpiredErrorPage.java | 2548 | /* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (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.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is part of dcm4che, an implementation of DICOM(TM) in
* Java(TM), hosted at http://sourceforge.net/projects/dcm4che.
*
* The Initial Developer of the Original Code is
* Agfa-Gevaert AG.
* Portions created by the Initial Developer are Copyright (C) 2008
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
* See listed authors below.
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
package org.dcm4chee.usr.war.common;
import org.apache.wicket.markup.html.WebPage;
import org.apache.wicket.markup.html.link.Link;
import org.dcm4chee.usr.war.pages.LoginPage;
/**
* @author Robert David <[email protected]>
* @version $Revision$ $Date$
* @since 28.09.2009
*/
public class PageExpiredErrorPage extends WebPage {
public PageExpiredErrorPage() {
Link<?> backToLoginLink = new Link<Object>("back-to-login") {
private static final long serialVersionUID = 1L;
@Override
public void onClick() {
this.getSession().invalidateNow();
setResponsePage(LoginPage.class);
}
};
add(backToLoginLink);
}
}
| apache-2.0 |
openweave/openweave-core | third_party/openssl/openssl/.travis-create-release.sh | 258 | #! /bin/sh
# $1 is expected to be $TRAVIS_OS_NAME
./Configure dist
if [ "$1" == osx ]; then
make NAME='_srcdist' TARFILE='_srcdist.tar' \
TAR_COMMAND='$(TAR) $(TARFLAGS) -cvf -' tar
else
make TARFILE='_srcdist.tar' NAME='_srcdist' dist
fi
| apache-2.0 |
SourceStudyNotes/log4j2 | src/main/java/org/apache/logging/log4j/core/appender/mom/JmsManager.java | 7359 | /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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.apache.logging.log4j.core.appender.mom;
import java.io.Serializable;
import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageConsumer;
import javax.jms.MessageProducer;
import javax.jms.Session;
import javax.naming.NamingException;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.core.appender.AbstractManager;
import org.apache.logging.log4j.core.appender.ManagerFactory;
import org.apache.logging.log4j.core.net.JndiManager;
import org.apache.logging.log4j.status.StatusLogger;
/**
* JMS connection and session manager. Can be used to access MessageProducer, MessageConsumer, and Message objects
* involving a configured ConnectionFactory and Destination.
*/
public class JmsManager extends AbstractManager {
private static final Logger LOGGER = StatusLogger.getLogger();
private static final JmsManagerFactory FACTORY = new JmsManagerFactory();
private final JndiManager jndiManager;
private final Connection connection;
private final Session session;
private final Destination destination;
private JmsManager(final String name, final JndiManager jndiManager, final String connectionFactoryName,
final String destinationName, final String username, final String password)
throws NamingException, JMSException {
super(name);
this.jndiManager = jndiManager;
final ConnectionFactory connectionFactory = this.jndiManager.lookup(connectionFactoryName);
if (username != null && password != null) {
this.connection = connectionFactory.createConnection(username, password);
} else {
this.connection = connectionFactory.createConnection();
}
this.session = this.connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
this.destination = this.jndiManager.lookup(destinationName);
this.connection.start();
}
/**
* Gets a JmsManager using the specified configuration parameters.
*
* @param name The name to use for this JmsManager.
* @param jndiManager The JndiManager to look up JMS information through.
* @param connectionFactoryName The binding name for the {@link javax.jms.ConnectionFactory}.
* @param destinationName The binding name for the {@link javax.jms.Destination}.
* @param username The username to connect with or {@code null} for no authentication.
* @param password The password to use with the given username or {@code null} for no authentication.
* @return The JmsManager as configured.
*/
public static JmsManager getJmsManager(final String name, final JndiManager jndiManager,
final String connectionFactoryName, final String destinationName,
final String username, final String password) {
final JmsConfiguration configuration = new JmsConfiguration(jndiManager, connectionFactoryName, destinationName,
username, password);
return FACTORY.createManager(name, configuration);
}
/**
* Creates a MessageConsumer on this Destination using the current Session.
*
* @return A MessageConsumer on this Destination.
* @throws JMSException
*/
public MessageConsumer createMessageConsumer() throws JMSException {
return this.session.createConsumer(this.destination);
}
/**
* Creates a MessageProducer on this Destination using the current Session.
*
* @return A MessageProducer on this Destination.
* @throws JMSException
*/
public MessageProducer createMessageProducer() throws JMSException {
return this.session.createProducer(this.destination);
}
/**
* Creates a TextMessage or ObjectMessage from a Serializable object. For instance, when using a text-based
* {@link org.apache.logging.log4j.core.Layout} such as {@link org.apache.logging.log4j.core.layout.PatternLayout},
* the {@link org.apache.logging.log4j.core.LogEvent} message will be serialized to a String. When using a
* layout such as {@link org.apache.logging.log4j.core.layout.SerializedLayout}, the LogEvent message will be
* serialized as a Java object.
*
* @param object The LogEvent or String message to wrap.
* @return A new JMS message containing the provided object.
* @throws JMSException
*/
public Message createMessage(final Serializable object) throws JMSException {
if (object instanceof String) {
return this.session.createTextMessage((String) object);
}
return this.session.createObjectMessage(object);
}
@Override
protected void releaseSub() {
try {
this.session.close();
} catch (final JMSException ignored) {
}
try {
this.connection.close();
} catch (final JMSException ignored) {
}
this.jndiManager.release();
}
private static class JmsConfiguration {
private final JndiManager jndiManager;
private final String connectionFactoryName;
private final String destinationName;
private final String username;
private final String password;
private JmsConfiguration(final JndiManager jndiManager, final String connectionFactoryName, final String destinationName,
final String username, final String password) {
this.jndiManager = jndiManager;
this.connectionFactoryName = connectionFactoryName;
this.destinationName = destinationName;
this.username = username;
this.password = password;
}
}
private static class JmsManagerFactory implements ManagerFactory<JmsManager, JmsConfiguration> {
@Override
public JmsManager createManager(final String name, final JmsConfiguration data) {
try {
return new JmsManager(name, data.jndiManager, data.connectionFactoryName, data.destinationName,
data.username, data.password);
} catch (final Exception e) {
LOGGER.error("Error creating JmsManager using ConnectionFactory [{}] and Destination [{}].",
data.connectionFactoryName, data.destinationName, e);
return null;
}
}
}
}
| apache-2.0 |
stdlib-js/stdlib | lib/node_modules/@stdlib/stats/base/dists/weibull/mgf/test/test.js | 1090 | /**
* @license Apache-2.0
*
* Copyright (c) 2018 The Stdlib Authors.
*
* 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.
*/
'use strict';
// MODULES //
var tape = require( 'tape' );
var mgf = require( './../lib' );
// TESTS //
tape( 'main export is a function', function test( t ) {
t.ok( true, __filename );
t.strictEqual( typeof mgf, 'function', 'main export is a function' );
t.end();
});
tape( 'attached to the main export is a factory method for generating `mgf` functions', function test( t ) {
t.equal( typeof mgf.factory, 'function', 'exports a factory method' );
t.end();
});
| apache-2.0 |
hfp/tensorflow-xsmm | tensorflow/core/ops/resource_variable_ops.cc | 11757 | // Copyright 2016 The TensorFlow Authors. All Rights Reserved.
//
// 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.
// ============================================================================
#include "tensorflow/core/framework/common_shape_fns.h"
#include "tensorflow/core/framework/function.h"
#include "tensorflow/core/framework/node_def_util.h"
#include "tensorflow/core/framework/op.h"
#include "tensorflow/core/framework/resource_mgr.h"
#include "tensorflow/core/framework/shape_inference.h"
#include "tensorflow/core/lib/core/errors.h"
using ::tensorflow::shape_inference::InferenceContext;
using ::tensorflow::shape_inference::ShapeAndType;
using ::tensorflow::shape_inference::ShapeHandle;
namespace tensorflow {
namespace {
Status ValidateVariableResourceHandle(InferenceContext* c,
ShapeAndType* shape_and_type) {
auto* handle_data = c->input_handle_shapes_and_types(0);
if (handle_data == nullptr || handle_data->empty()) {
shape_and_type->shape = c->UnknownShape();
shape_and_type->dtype = DT_INVALID;
} else {
*shape_and_type = (*handle_data)[0];
DataType value_dtype;
TF_RETURN_IF_ERROR(c->GetAttr("dtype", &value_dtype));
if (shape_and_type->dtype != value_dtype) {
return errors::InvalidArgument(
"Trying to read variable with wrong dtype. "
"Expected ",
DataTypeString(shape_and_type->dtype), " got ",
DataTypeString(value_dtype));
}
}
return Status::OK();
}
Status ReadVariableShapeFn(InferenceContext* c) {
ShapeAndType shape_and_type;
TF_RETURN_IF_ERROR(ValidateVariableResourceHandle(c, &shape_and_type));
c->set_output(0, shape_and_type.shape);
return Status::OK();
}
Status ReadVariablesShapeFn(InferenceContext* c) {
int n;
TF_RETURN_IF_ERROR(c->GetAttr("N", &n));
DataTypeVector value_dtypes;
TF_RETURN_IF_ERROR(c->GetAttr("dtypes", &value_dtypes));
if (n != value_dtypes.size()) {
return errors::InvalidArgument(
"Mismatched number of arguments to ReadVariablesOp");
}
for (int i = 0; i < n; ++i) {
ShapeAndType shape_and_type;
auto* handle_data = c->input_handle_shapes_and_types(i);
if (handle_data == nullptr || handle_data->empty()) {
shape_and_type.shape = c->UnknownShape();
shape_and_type.dtype = DT_INVALID;
} else {
shape_and_type = (*handle_data)[0];
if (shape_and_type.dtype != value_dtypes[i]) {
return errors::InvalidArgument(
"Trying to read variable with wrong dtype. "
"Expected ",
DataTypeString(shape_and_type.dtype), " got ",
DataTypeString(value_dtypes[i]));
}
}
c->set_output(i, shape_and_type.shape);
}
return Status::OK();
}
} // namespace
REGISTER_OP("VarHandleOp")
.Attr("container: string = ''")
.Attr("shared_name: string = ''")
.Attr("dtype: type")
.Attr("shape: shape")
.Output("resource: resource")
.SetIsStateful()
.SetShapeFn([](InferenceContext* c) {
c->set_output(0, c->Scalar());
DataType t;
TF_RETURN_IF_ERROR(c->GetAttr("dtype", &t));
PartialTensorShape p;
TF_RETURN_IF_ERROR(c->GetAttr("shape", &p));
ShapeHandle s;
TF_RETURN_IF_ERROR(c->MakeShapeFromPartialTensorShape(p, &s));
c->set_output_handle_shapes_and_types(0,
std::vector<ShapeAndType>{{s, t}});
return Status::OK();
});
REGISTER_OP("_VarHandlesOp")
.Attr("containers: list(string)")
.Attr("shared_names: list(string)")
.Attr("N: int >= 0")
.Attr("dtypes: list(type)")
.Attr("shapes: list(shape)")
.Output("resources: N * resource")
.SetIsStateful()
.SetShapeFn([](InferenceContext* c) {
int n;
TF_RETURN_IF_ERROR(c->GetAttr("N", &n));
DataTypeVector dtypes;
TF_RETURN_IF_ERROR(c->GetAttr("dtypes", &dtypes));
std::vector<PartialTensorShape> shapes;
TF_RETURN_IF_ERROR(c->GetAttr("shapes", &shapes));
if (dtypes.size() != n) {
return errors::InvalidArgument("Mismatched number of dtypes (n=", n,
", num dtypes=", dtypes.size(), ")");
}
if (shapes.size() != n) {
return errors::InvalidArgument("Mismatched number of shapes (n=", n,
", num shapes=", shapes.size(), ")");
}
for (int i = 0; i < n; ++i) {
c->set_output(i, c->Scalar());
ShapeHandle s;
TF_RETURN_IF_ERROR(c->MakeShapeFromPartialTensorShape(shapes[i], &s));
c->set_output_handle_shapes_and_types(
i, std::vector<ShapeAndType>{{s, dtypes[i]}});
}
return Status::OK();
});
REGISTER_OP("ReadVariableOp")
.Input("resource: resource")
.Output("value: dtype")
.Attr("dtype: type")
.SetShapeFn(ReadVariableShapeFn);
REGISTER_OP("_ReadVariablesOp")
.Attr("N: int >= 0")
.Input("resources: N * resource")
.Output("values: dtypes")
.Attr("dtypes: list(type)")
.SetShapeFn(ReadVariablesShapeFn);
Status ReadGrad(const AttrSlice& attrs, FunctionDef* g) {
// clang-format off
*g = FunctionDefHelper::Define(
// Arg defs
{"x: resource", "dy: float"},
// Ret val defs
{"dy: float"},
// Attr defs
{},
// Nodes
{});
// clang-format on
return Status::OK();
}
REGISTER_OP_GRADIENT("ReadVariableOp", ReadGrad);
REGISTER_OP("DestroyResourceOp")
.Input("resource: resource")
.Attr("ignore_lookup_error: bool = true")
.SetIsStateful()
.SetShapeFn(shape_inference::NoOutputs);
Status CreateAssignShapeFn(InferenceContext* c) {
ShapeAndType handle_shape_and_type;
TF_RETURN_IF_ERROR(ValidateVariableResourceHandle(c, &handle_shape_and_type));
ShapeHandle value_shape = c->input(1);
ShapeHandle unused;
TF_RETURN_IF_ERROR(
c->Merge(handle_shape_and_type.shape, value_shape, &unused));
return Status::OK();
}
REGISTER_OP("AssignVariableOp")
.Input("resource: resource")
.Input("value: dtype")
.Attr("dtype: type")
.SetShapeFn(CreateAssignShapeFn);
REGISTER_OP("AssignAddVariableOp")
.Input("resource: resource")
.Input("value: dtype")
.Attr("dtype: type")
.SetShapeFn(CreateAssignShapeFn);
REGISTER_OP("AssignSubVariableOp")
.Input("resource: resource")
.Input("value: dtype")
.Attr("dtype: type")
.SetShapeFn(CreateAssignShapeFn);
REGISTER_OP("VarIsInitializedOp")
.Input("resource: resource")
.Output("is_initialized: bool")
.SetShapeFn(tensorflow::shape_inference::ScalarShape);
Status VariableShapeShapeFn(InferenceContext* c) {
auto* handle_data = c->input_handle_shapes_and_types(0);
if (handle_data == nullptr || handle_data->empty()) {
c->set_output(0, c->Vector(c->UnknownDim()));
return Status::OK();
}
ShapeHandle var_shape = (*handle_data)[0].shape;
int64 rank = c->RankKnown(var_shape) ? c->Rank(var_shape)
: InferenceContext::kUnknownDim;
c->set_output(0, c->Vector(rank));
return Status::OK();
}
REGISTER_OP("VariableShape")
.Input("input: resource")
.Output("output: out_type")
.Attr("out_type: {int32, int64} = DT_INT32")
.SetShapeFn(VariableShapeShapeFn);
REGISTER_OP("ResourceGather")
.Input("resource: resource")
.Input("indices: Tindices")
.Attr("validate_indices: bool = true")
.Output("output: dtype")
.Attr("dtype: type")
.Attr("Tindices: {int32,int64}")
.SetShapeFn([](InferenceContext* c) {
ShapeAndType handle_shape_and_type;
TF_RETURN_IF_ERROR(
ValidateVariableResourceHandle(c, &handle_shape_and_type));
ShapeHandle unused;
TF_RETURN_IF_ERROR(
c->WithRankAtLeast(handle_shape_and_type.shape, 1, &unused));
ShapeHandle params_subshape;
TF_RETURN_IF_ERROR(
c->Subshape(handle_shape_and_type.shape, 1, ¶ms_subshape));
ShapeHandle indices_shape = c->input(1);
ShapeHandle out;
TF_RETURN_IF_ERROR(c->Concatenate(indices_shape, params_subshape, &out));
c->set_output(0, out);
return Status::OK();
});
namespace {
Status ResourceScatterUpdateShape(InferenceContext* c) {
ShapeAndType handle_shape_and_type;
TF_RETURN_IF_ERROR(ValidateVariableResourceHandle(c, &handle_shape_and_type));
ShapeHandle var_shape = handle_shape_and_type.shape;
ShapeHandle indices_shape = c->input(1);
ShapeHandle unused_updates_shape;
ShapeHandle concat;
ShapeHandle var_subshape;
TF_RETURN_IF_ERROR(c->Subshape(var_shape, 1, &var_subshape));
TF_RETURN_IF_ERROR(c->Concatenate(indices_shape, var_subshape, &concat));
TF_RETURN_IF_ERROR(
InferenceContext::Rank(c->input(2)) == 0
? Status::OK()
: c->Merge(c->input(2), concat, &unused_updates_shape));
return Status::OK();
}
} // namespace
REGISTER_OP("ResourceScatterAdd")
.Input("resource: resource")
.Input("indices: Tindices")
.Input("updates: dtype")
.Attr("dtype: numbertype")
.Attr("Tindices: {int32, int64}")
.SetShapeFn(ResourceScatterUpdateShape);
REGISTER_OP("ResourceScatterSub")
.Input("resource: resource")
.Input("indices: Tindices")
.Input("updates: dtype")
.Attr("dtype: numbertype")
.Attr("Tindices: {int32, int64}")
.SetShapeFn(ResourceScatterUpdateShape);
REGISTER_OP("ResourceScatterMul")
.Input("resource: resource")
.Input("indices: Tindices")
.Input("updates: dtype")
.Attr("dtype: numbertype")
.Attr("Tindices: {int32, int64}")
.SetShapeFn(ResourceScatterUpdateShape);
REGISTER_OP("ResourceScatterDiv")
.Input("resource: resource")
.Input("indices: Tindices")
.Input("updates: dtype")
.Attr("dtype: numbertype")
.Attr("Tindices: {int32, int64}")
.SetShapeFn(ResourceScatterUpdateShape);
REGISTER_OP("ResourceScatterMin")
.Input("resource: resource")
.Input("indices: Tindices")
.Input("updates: dtype")
.Attr("dtype: numbertype")
.Attr("Tindices: {int32, int64}")
.SetShapeFn(ResourceScatterUpdateShape);
REGISTER_OP("ResourceScatterMax")
.Input("resource: resource")
.Input("indices: Tindices")
.Input("updates: dtype")
.Attr("dtype: numbertype")
.Attr("Tindices: {int32, int64}")
.SetShapeFn(ResourceScatterUpdateShape);
REGISTER_OP("ResourceScatterUpdate")
.Input("resource: resource")
.Input("indices: Tindices")
.Input("updates: dtype")
.Attr("dtype: type")
.Attr("Tindices: {int32, int64}")
.SetShapeFn(ResourceScatterUpdateShape);
REGISTER_OP("MutexV2")
.Attr("container: string = ''")
.Attr("shared_name: string = ''")
.Output("resource: resource")
.SetIsStateful()
.SetShapeFn([](InferenceContext* c) {
c->set_output(0, c->Scalar());
return Status::OK();
});
REGISTER_OP("MutexLock")
.Input("mutex: resource")
.Output("mutex_lock: variant")
.SetIsStateful()
.SetShapeFn([](InferenceContext* c) {
c->set_output(0, c->Scalar());
return Status::OK();
});
REGISTER_OP("ConsumeMutexLock")
.Input("mutex_lock: variant")
.SetIsStateful()
.SetShapeFn([](InferenceContext* c) { return Status::OK(); });
} // namespace tensorflow
| apache-2.0 |
0xbb/homebrew | Library/Formula/libpng.rb | 844 | require "formula"
class Libpng < Formula
homepage "http://www.libpng.org/pub/png/libpng.html"
url "https://downloads.sf.net/project/libpng/libpng16/1.6.13/libpng-1.6.13.tar.xz"
sha1 "5ae32b6b99cef6c5c85feab8edf9d619e1773b15"
bottle do
cellar :any
sha1 "c4c5f94b771ea53620d9b6c508b382b3a40d6c80" => :yosemite
sha1 "09af92d209c67dd0719d16866dc26c05bbbef77b" => :mavericks
sha1 "23812e76bf0e3f98603c6d22ab69258b219918ca" => :mountain_lion
sha1 "af1fe6844a0614652bbc9b60fd84c57e24da93ee" => :lion
end
keg_only :provided_pre_mountain_lion
option :universal
def install
ENV.universal_binary if build.universal?
system "./configure", "--disable-dependency-tracking",
"--disable-silent-rules",
"--prefix=#{prefix}"
system "make install"
end
end
| bsd-2-clause |
D3f0/coreemu | daemon/examples/netns/wlanemanetests.py | 33033 | #!/usr/bin/python
# Copyright (c)2011-2014 the Boeing Company.
# See the LICENSE file included in this distribution.
#
# author: Jeff Ahrenholz <[email protected]>
#
'''
wlanemanetests.py - This script tests the performance of the WLAN device in
CORE by measuring various metrics:
- delay experienced when pinging end-to-end
- maximum TCP throughput achieved using iperf end-to-end
- the CPU used and loss experienced when running an MGEN flow of UDP traffic
All MANET nodes are arranged in a row, so that any given node can only
communicate with the node to its right or to its left. Performance is measured
using traffic that travels across each hop in the network. Static /32 routing
is used instead of any dynamic routing protocol.
Various underlying network types are tested:
- bridged (the CORE default, uses ebtables)
- bridged with netem (add link effects to the bridge using tc queues)
- EMANE bypass - the bypass model just forwards traffic
- EMANE RF-PIPE - the bandwidth (bitrate) is set very high / no restrictions
- EMANE RF-PIPE - bandwidth is set similar to netem case
- EMANE RF-PIPE - default connectivity is off and pathloss events are
generated to connect the nodes in a line
Results are printed/logged in CSV format.
'''
import os, sys, time, optparse, datetime, math
from string import Template
try:
from core import pycore
except ImportError:
# hack for Fedora autoconf that uses the following pythondir:
if "/usr/lib/python2.6/site-packages" in sys.path:
sys.path.append("/usr/local/lib/python2.6/site-packages")
if "/usr/lib64/python2.6/site-packages" in sys.path:
sys.path.append("/usr/local/lib64/python2.6/site-packages")
if "/usr/lib/python2.7/site-packages" in sys.path:
sys.path.append("/usr/local/lib/python2.7/site-packages")
if "/usr/lib64/python2.7/site-packages" in sys.path:
sys.path.append("/usr/local/lib64/python2.7/site-packages")
from core import pycore
from core.misc import ipaddr
from core.misc.utils import mutecall
from core.constants import QUAGGA_STATE_DIR
from core.emane.emane import Emane
from core.emane.bypass import EmaneBypassModel
from core.emane.rfpipe import EmaneRfPipeModel
try:
import emaneeventservice
import emaneeventpathloss
except Exception, e:
try:
from emanesh.events import EventService
from emanesh.events import PathlossEvent
except Exception, e2:
raise ImportError, "failed to import EMANE Python bindings:\n%s\n%s" % \
(e, e2)
# global Experiment object (for interaction with 'python -i')
exp = None
# move these to core.misc.utils
def readstat():
f = open("/proc/stat", "r")
lines = f.readlines()
f.close()
return lines
def numcpus():
lines = readstat()
n = 0
for l in lines[1:]:
if l[:3] != "cpu":
break
n += 1
return n
def getcputimes(line):
# return (user, nice, sys, idle) from a /proc/stat cpu line
# assume columns are:
# cpu# user nice sys idle iowait irq softirq steal guest (man 5 proc)
items = line.split()
(user, nice, sys, idle) = map(lambda(x): int(x), items[1:5])
return [user, nice, sys, idle]
def calculatecpu(timesa, timesb):
for i in range(len(timesa)):
timesb[i] -= timesa[i]
total = sum(timesb)
if total == 0:
return 0.0
else:
# subtract % time spent in idle time
return 100 - ((100.0 * timesb[-1]) / total)
# end move these to core.misc.utils
class Cmd(object):
''' Helper class for running a command on a node and parsing the result. '''
args = ""
def __init__(self, node, verbose=False):
''' Initialize with a CoreNode (LxcNode) '''
self.id = None
self.stdin = None
self.out = None
self.node = node
self.verbose = verbose
def info(self, msg):
''' Utility method for writing output to stdout.'''
print msg
sys.stdout.flush()
def warn(self, msg):
''' Utility method for writing output to stderr. '''
print >> sys.stderr, "XXX %s:" % self.node.name, msg
sys.stderr.flush()
def run(self):
''' This is the primary method used for running this command. '''
self.open()
status = self.id.wait()
r = self.parse()
self.cleanup()
return r
def open(self):
''' Exceute call to node.popen(). '''
self.id, self.stdin, self.out, self.err = \
self.node.popen((self.args))
def parse(self):
''' This method is overloaded by child classes and should return some
result.
'''
return None
def cleanup(self):
''' Close the Popen channels.'''
self.stdin.close()
self.out.close()
self.err.close()
tmp = self.id.wait()
if tmp:
self.warn("nonzero exit status:", tmp)
class ClientServerCmd(Cmd):
''' Helper class for running a command on a node and parsing the result. '''
args = ""
client_args = ""
def __init__(self, node, client_node, verbose=False):
''' Initialize with two CoreNodes, node is the server '''
Cmd.__init__(self, node, verbose)
self.client_node = client_node
def run(self):
''' Run the server command, then the client command, then
kill the server '''
self.open() # server
self.client_open() # client
status = self.client_id.wait()
self.node.cmdresult(['killall', self.args[0]]) # stop the server
r = self.parse()
self.cleanup()
return r
def client_open(self):
''' Exceute call to client_node.popen(). '''
self.client_id, self.client_stdin, self.client_out, self.client_err = \
self.client_node.popen((self.client_args))
def parse(self):
''' This method is overloaded by child classes and should return some
result.
'''
return None
def cleanup(self):
''' Close the Popen channels.'''
self.stdin.close()
self.out.close()
self.err.close()
tmp = self.id.wait()
if tmp:
self.warn("nonzero exit status: %s" % tmp)
self.warn("command was: %s" % ((self.args, )))
class PingCmd(Cmd):
''' Test latency using ping.
'''
def __init__(self, node, verbose=False, addr=None, count=50, interval=0.1, ):
Cmd.__init__(self, node, verbose)
self.addr = addr
self.count = count
self.interval = interval
self.args = ['ping', '-q', '-c', '%s' % count, '-i', '%s' % interval,
addr]
def run(self):
if self.verbose:
self.info("%s initial test ping (max 1 second)..." % self.node.name)
(status, result) = self.node.cmdresult(["ping", "-q", "-c", "1", "-w",
"1", self.addr])
if status != 0:
self.warn("initial ping from %s to %s failed! result:\n%s" % \
(self.node.name, self.addr, result))
return (0.0, 0.0)
if self.verbose:
self.info("%s pinging %s (%d seconds)..." % \
(self.node.name, self.addr, self.count * self.interval))
return Cmd.run(self)
def parse(self):
lines = self.out.readlines()
avg_latency = 0
mdev = 0
try:
stats_str = lines[-1].split('=')[1]
stats = stats_str.split('/')
avg_latency = float(stats[1])
mdev = float(stats[3].split(' ')[0])
except Exception, e:
self.warn("ping parsing exception: %s" % e)
return (avg_latency, mdev)
class IperfCmd(ClientServerCmd):
''' Test throughput using iperf.
'''
def __init__(self, node, client_node, verbose=False, addr=None, time=10):
# node is the server
ClientServerCmd.__init__(self, node, client_node, verbose)
self.addr = addr
self.time = time
# -s server, -y c CSV report output
self.args = ["iperf", "-s", "-y", "c"]
self.client_args = ["iperf", "-c", self.addr, "-t", "%s" % self.time]
def run(self):
if self.verbose:
self.info("Launching the iperf server on %s..." % self.node.name)
self.info("Running the iperf client on %s (%s seconds)..." % \
(self.client_node.name, self.time))
return ClientServerCmd.run(self)
def parse(self):
lines = self.out.readlines()
try:
bps = int(lines[-1].split(',')[-1].strip('\n'))
except Exception, e:
self.warn("iperf parsing exception: %s" % e)
bps = 0
return bps
class MgenCmd(ClientServerCmd):
''' Run a test traffic flow using an MGEN sender and receiver.
'''
def __init__(self, node, client_node, verbose=False, addr=None, time=10,
rate=512):
ClientServerCmd.__init__(self, node, client_node, verbose)
self.addr = addr
self.time = time
self.args = ['mgen', 'event', 'listen udp 5000', 'output',
'/var/log/mgen.log']
self.rate = rate
sendevent = "ON 1 UDP DST %s/5000 PERIODIC [%s]" % \
(addr, self.mgenrate(self.rate))
stopevent = "%s OFF 1" % time
self.client_args = ['mgen', 'event', sendevent, 'event', stopevent,
'output', '/var/log/mgen.log']
@staticmethod
def mgenrate(kbps):
''' Return a MGEN periodic rate string for the given kilobits-per-sec.
Assume 1500 byte MTU, 20-byte IP + 8-byte UDP headers, leaving
1472 bytes for data.
'''
bps = (kbps / 8) * 1000.0
maxdata = 1472
pps = math.ceil(bps / maxdata)
return "%s %s" % (pps, maxdata)
def run(self):
if self.verbose:
self.info("Launching the MGEN receiver on %s..." % self.node.name)
self.info("Running the MGEN sender on %s (%s seconds)..." % \
(self.client_node.name, self.time))
return ClientServerCmd.run(self)
def cleanup(self):
''' Close the Popen channels.'''
self.stdin.close()
self.out.close()
self.err.close()
tmp = self.id.wait() # non-zero mgen exit status OK
def parse(self):
''' Check MGEN receiver's log file for packet sequence numbers, and
return the percentage of lost packets.
'''
logfile = os.path.join(self.node.nodedir, 'var.log/mgen.log')
f = open(logfile, 'r')
numlost = 0
lastseq = 0
for line in f.readlines():
fields = line.split()
if fields[1] != 'RECV':
continue
try:
seq = int(fields[4].split('>')[1])
except:
self.info("Unexpected MGEN line:\n%s" % fields)
if seq > (lastseq + 1):
numlost += seq - (lastseq + 1)
lastseq = seq
f.close()
if lastseq > 0:
loss = 100.0 * numlost / lastseq
else:
loss = 0
if self.verbose:
self.info("Receiver log shows %d of %d packets lost" % \
(numlost, lastseq))
return loss
class Experiment(object):
''' Experiment object to organize tests.
'''
def __init__(self, opt, start):
''' Initialize with opt and start time. '''
self.session = None
# node list
self.nodes = []
# WLAN network
self.net = None
self.verbose = opt.verbose
# dict from OptionParser
self.opt = opt
self.start = start
self.numping = opt.numping
self.numiperf = opt.numiperf
self.nummgen = opt.nummgen
self.logbegin()
def info(self, msg):
''' Utility method for writing output to stdout. '''
print msg
sys.stdout.flush()
self.log(msg)
def warn(self, msg):
''' Utility method for writing output to stderr. '''
print >> sys.stderr, msg
sys.stderr.flush()
self.log(msg)
def logbegin(self):
''' Start logging. '''
self.logfp = None
if not self.opt.logfile:
return
self.logfp = open(self.opt.logfile, "w")
self.log("%s begin: %s\n" % (sys.argv[0], self.start.ctime()))
self.log("%s args: %s\n" % (sys.argv[0], sys.argv[1:]))
(sysname, rel, ver, machine, nodename) = os.uname()
self.log("%s %s %s %s on %s" % (sysname, rel, ver, machine, nodename))
def logend(self):
''' End logging. '''
if not self.logfp:
return
end = datetime.datetime.now()
self.log("%s end: %s (%s)\n" % \
(sys.argv[0], end.ctime(), end - self.start))
self.logfp.flush()
self.logfp.close()
self.logfp = None
def log(self, msg):
''' Write to the log file, if any. '''
if not self.logfp:
return
print >> self.logfp, msg
def reset(self):
''' Prepare for another experiment run.
'''
if self.session:
self.session.shutdown()
del self.session
self.session = None
self.nodes = []
self.net = None
def createbridgedsession(self, numnodes, verbose = False):
''' Build a topology consisting of the given number of LxcNodes
connected to a WLAN.
'''
# IP subnet
prefix = ipaddr.IPv4Prefix("10.0.0.0/16")
self.session = pycore.Session()
# emulated network
self.net = self.session.addobj(cls = pycore.nodes.WlanNode,
name = "wlan1")
prev = None
for i in xrange(1, numnodes + 1):
addr = "%s/%s" % (prefix.addr(i), 32)
tmp = self.session.addobj(cls = pycore.nodes.CoreNode, objid = i,
name = "n%d" % i)
tmp.newnetif(self.net, [addr])
self.nodes.append(tmp)
self.session.services.addservicestonode(tmp, "router",
"IPForward", self.verbose)
self.session.services.bootnodeservices(tmp)
self.staticroutes(i, prefix, numnodes)
# link each node in a chain, with the previous node
if prev:
self.net.link(prev.netif(0), tmp.netif(0))
prev = tmp
def createemanesession(self, numnodes, verbose = False, cls = None,
values = None):
''' Build a topology consisting of the given number of LxcNodes
connected to an EMANE WLAN.
'''
prefix = ipaddr.IPv4Prefix("10.0.0.0/16")
self.session = pycore.Session()
self.session.node_count = str(numnodes + 1)
self.session.master = True
self.session.location.setrefgeo(47.57917,-122.13232,2.00000)
self.session.location.refscale = 150.0
self.session.cfg['emane_models'] = "RfPipe, Ieee80211abg, Bypass"
self.session.emane.loadmodels()
self.net = self.session.addobj(cls = pycore.nodes.EmaneNode,
objid = numnodes + 1, name = "wlan1")
self.net.verbose = verbose
#self.session.emane.addobj(self.net)
for i in xrange(1, numnodes + 1):
addr = "%s/%s" % (prefix.addr(i), 32)
tmp = self.session.addobj(cls = pycore.nodes.CoreNode, objid = i,
name = "n%d" % i)
#tmp.setposition(i * 20, 50, None)
tmp.setposition(50, 50, None)
tmp.newnetif(self.net, [addr])
self.nodes.append(tmp)
self.session.services.addservicestonode(tmp, "router",
"IPForward", self.verbose)
if values is None:
values = cls.getdefaultvalues()
self.session.emane.setconfig(self.net.objid, cls._name, values)
self.session.instantiate()
self.info("waiting %s sec (TAP bring-up)" % 2)
time.sleep(2)
for i in xrange(1, numnodes + 1):
tmp = self.nodes[i-1]
self.session.services.bootnodeservices(tmp)
self.staticroutes(i, prefix, numnodes)
def setnodes(self):
''' Set the sender and receiver nodes for use in this experiment,
along with the address of the receiver to be used.
'''
self.firstnode = self.nodes[0]
self.lastnode = self.nodes[-1]
self.lastaddr = self.lastnode.netif(0).addrlist[0].split('/')[0]
def staticroutes(self, i, prefix, numnodes):
''' Add static routes on node number i to the other nodes in the chain.
'''
routecmd = ["/sbin/ip", "route", "add"]
node = self.nodes[i-1]
neigh_left = ""
neigh_right = ""
# add direct interface routes first
if i > 1:
neigh_left = "%s" % prefix.addr(i - 1)
cmd = routecmd + [neigh_left, "dev", node.netif(0).name]
(status, result) = node.cmdresult(cmd)
if status != 0:
self.warn("failed to add interface route: %s" % cmd)
if i < numnodes:
neigh_right = "%s" % prefix.addr(i + 1)
cmd = routecmd + [neigh_right, "dev", node.netif(0).name]
(status, result) = node.cmdresult(cmd)
if status != 0:
self.warn("failed to add interface route: %s" % cmd)
# add static routes to all other nodes via left/right neighbors
for j in xrange(1, numnodes + 1):
if abs(j - i) < 2:
continue
addr = "%s" % prefix.addr(j)
if j < i:
gw = neigh_left
else:
gw = neigh_right
cmd = routecmd + [addr, "via", gw]
(status, result) = node.cmdresult(cmd)
if status != 0:
self.warn("failed to add route: %s" % cmd)
def setpathloss(self, numnodes):
''' Send EMANE pathloss events to connect all NEMs in a chain.
'''
if self.session.emane.version < self.session.emane.EMANE091:
service = emaneeventservice.EventService()
e = emaneeventpathloss.EventPathloss(1)
old = True
else:
if self.session.emane.version == self.session.emane.EMANE091:
dev = 'lo'
else:
dev = self.session.obj('ctrlnet').brname
service = EventService(eventchannel=("224.1.2.8", 45703, dev),
otachannel=None)
old = False
for i in xrange(1, numnodes + 1):
rxnem = i
# inform rxnem that it can hear node to the left with 10dB noise
txnem = rxnem - 1
if txnem > 0:
if old:
e.set(0, txnem, 10.0, 10.0)
service.publish(emaneeventpathloss.EVENT_ID,
emaneeventservice.PLATFORMID_ANY, rxnem,
emaneeventservice.COMPONENTID_ANY, e.export())
else:
e = PathlossEvent()
e.append(txnem, forward=10.0, reverse=10.0)
service.publish(rxnem, e)
# inform rxnem that it can hear node to the right with 10dB noise
txnem = rxnem + 1
if txnem > numnodes:
continue
if old:
e.set(0, txnem, 10.0, 10.0)
service.publish(emaneeventpathloss.EVENT_ID,
emaneeventservice.PLATFORMID_ANY, rxnem,
emaneeventservice.COMPONENTID_ANY, e.export())
else:
e = PathlossEvent()
e.append(txnem, forward=10.0, reverse=10.0)
service.publish(rxnem, e)
def setneteffects(self, bw = None, delay = None):
''' Set link effects for all interfaces attached to the network node.
'''
if not self.net:
self.warn("failed to set effects: no network node")
return
for netif in self.net.netifs():
self.net.linkconfig(netif, bw = bw, delay = delay)
def runalltests(self, title=""):
''' Convenience helper to run all defined experiment tests.
If tests are run multiple times, this returns the average of
those runs.
'''
duration = self.opt.duration
rate = self.opt.rate
if len(title) > 0:
self.info("----- running %s tests (duration=%s, rate=%s) -----" % \
(title, duration, rate))
(latency, mdev, throughput, cpu, loss) = (0,0,0,0,0)
self.info("number of runs: ping=%d, iperf=%d, mgen=%d" % \
(self.numping, self.numiperf, self.nummgen))
if self.numping > 0:
(latency, mdev) = self.pingtest(count=self.numping)
if self.numiperf > 0:
throughputs = []
for i in range(1, self.numiperf + 1):
throughput = self.iperftest(time=duration)
if self.numiperf > 1:
throughputs += throughput
time.sleep(1) # iperf is very CPU intensive
if self.numiperf > 1:
throughput = sum(throughputs) / len(throughputs)
self.info("throughputs=%s" % ["%.2f" % v for v in throughputs])
if self.nummgen > 0:
cpus = []
losses = []
for i in range(1, self.nummgen + 1):
(cpu, loss) = self.cputest(time=duration, rate=rate)
if self.nummgen > 1:
cpus += cpu,
losses += loss,
if self.nummgen > 1:
cpu = sum(cpus) / len(cpus)
loss = sum(losses) / len(losses)
self.info("cpus=%s" % ["%.2f" % v for v in cpus])
self.info("losses=%s" % ["%.2f" % v for v in losses])
return (latency, mdev, throughput, cpu, loss)
def pingtest(self, count=50):
''' Ping through a chain of nodes and report the average latency.
'''
p = PingCmd(node=self.firstnode, verbose=self.verbose,
addr = self.lastaddr, count=count, interval=0.1).run()
(latency, mdev) = p
self.info("latency (ms): %.03f, %.03f" % (latency, mdev))
return p
def iperftest(self, time=10):
''' Run iperf through a chain of nodes and report the maximum
throughput.
'''
bps = IperfCmd(node=self.lastnode, client_node=self.firstnode,
verbose=False, addr=self.lastaddr, time=time).run()
self.info("throughput (bps): %s" % bps)
return bps
def cputest(self, time=10, rate=512):
''' Run MGEN through a chain of nodes and report the CPU usage and
percent of lost packets. Rate is in kbps.
'''
if self.verbose:
self.info("%s initial test ping (max 1 second)..." % \
self.firstnode.name)
(status, result) = self.firstnode.cmdresult(["ping", "-q", "-c", "1",
"-w", "1", self.lastaddr])
if status != 0:
self.warn("initial ping from %s to %s failed! result:\n%s" % \
(self.firstnode.name, self.lastaddr, result))
return (0.0, 0.0)
lines = readstat()
cpustart = getcputimes(lines[0])
loss = MgenCmd(node=self.lastnode, client_node=self.firstnode,
verbose=False, addr=self.lastaddr,
time=time, rate=rate).run()
lines = readstat()
cpuend = getcputimes(lines[0])
percent = calculatecpu(cpustart, cpuend)
self.info("CPU usage (%%): %.02f, %.02f loss" % (percent, loss))
return percent, loss
def main():
''' Main routine when running from command-line.
'''
usagestr = "usage: %prog [-h] [options] [args]"
parser = optparse.OptionParser(usage = usagestr)
parser.set_defaults(numnodes = 10, delay = 3, duration = 10, rate = 512,
verbose = False,
numping = 50, numiperf = 1, nummgen = 1)
parser.add_option("-d", "--delay", dest = "delay", type = float,
help = "wait time before testing")
parser.add_option("-l", "--logfile", dest = "logfile", type = str,
help = "log detailed output to the specified file")
parser.add_option("-n", "--numnodes", dest = "numnodes", type = int,
help = "number of nodes")
parser.add_option("-r", "--rate", dest = "rate", type = float,
help = "kbps rate to use for MGEN CPU tests")
parser.add_option("--numping", dest = "numping", type = int,
help = "number of ping latency test runs")
parser.add_option("--numiperf", dest = "numiperf", type = int,
help = "number of iperf throughput test runs")
parser.add_option("--nummgen", dest = "nummgen", type = int,
help = "number of MGEN CPU tests runs")
parser.add_option("-t", "--time", dest = "duration", type = int,
help = "duration in seconds of throughput and CPU tests")
parser.add_option("-v", "--verbose", dest = "verbose",
action = "store_true", help = "be more verbose")
def usage(msg = None, err = 0):
sys.stdout.write("\n")
if msg:
sys.stdout.write(msg + "\n\n")
parser.print_help()
sys.exit(err)
# parse command line opt
(opt, args) = parser.parse_args()
if opt.numnodes < 2:
usage("invalid numnodes: %s" % opt.numnodes)
if opt.delay < 0.0:
usage("invalid delay: %s" % opt.delay)
if opt.rate < 0.0:
usage("invalid rate: %s" % opt.rate)
for a in args:
sys.stderr.write("ignoring command line argument: '%s'\n" % a)
results = {}
starttime = datetime.datetime.now()
exp = Experiment(opt = opt, start=starttime)
exp.info("Starting wlanemanetests.py tests %s" % starttime.ctime())
# system sanity checks here
emanever, emaneverstr = Emane.detectversionfromcmd()
if opt.verbose:
exp.info("Detected EMANE version %s" % (emaneverstr,))
# bridged
exp.info("setting up bridged tests 1/2 no link effects")
exp.info("creating topology: numnodes = %s" % \
(opt.numnodes, ))
exp.createbridgedsession(numnodes=opt.numnodes, verbose=opt.verbose)
exp.setnodes()
exp.info("waiting %s sec (node/route bring-up)" % opt.delay)
time.sleep(opt.delay)
results['0 bridged'] = exp.runalltests("bridged")
exp.info("done; elapsed time: %s" % (datetime.datetime.now() - exp.start))
# bridged with netem
exp.info("setting up bridged tests 2/2 with netem")
exp.setneteffects(bw=54000000, delay=0)
exp.info("waiting %s sec (queue bring-up)" % opt.delay)
results['1.0 netem'] = exp.runalltests("netem")
exp.info("shutting down bridged session")
# bridged with netem (1 Mbps,200ms)
exp.info("setting up bridged tests 3/2 with netem")
exp.setneteffects(bw=1000000, delay=20000)
exp.info("waiting %s sec (queue bring-up)" % opt.delay)
results['1.2 netem_1M'] = exp.runalltests("netem_1M")
exp.info("shutting down bridged session")
# bridged with netem (54 kbps,500ms)
exp.info("setting up bridged tests 3/2 with netem")
exp.setneteffects(bw=54000, delay=100000)
exp.info("waiting %s sec (queue bring-up)" % opt.delay)
results['1.4 netem_54K'] = exp.runalltests("netem_54K")
exp.info("shutting down bridged session")
exp.reset()
# EMANE bypass model
exp.info("setting up EMANE tests 1/2 with bypass model")
exp.createemanesession(numnodes=opt.numnodes, verbose=opt.verbose,
cls=EmaneBypassModel, values=None)
exp.setnodes()
exp.info("waiting %s sec (node/route bring-up)" % opt.delay)
time.sleep(opt.delay)
results['2.0 bypass'] = exp.runalltests("bypass")
exp.info("shutting down bypass session")
exp.reset()
exp.info("waiting %s sec (between EMANE tests)" % opt.delay)
time.sleep(opt.delay)
# EMANE RF-PIPE model: no restrictions (max datarate)
exp.info("setting up EMANE tests 2/4 with RF-PIPE model")
rfpipevals = list(EmaneRfPipeModel.getdefaultvalues())
rfpnames = EmaneRfPipeModel.getnames()
rfpipevals[ rfpnames.index('datarate') ] = '4294967295' # max value
if emanever < Emane.EMANE091:
rfpipevals[ rfpnames.index('pathlossmode') ] = '2ray'
rfpipevals[ rfpnames.index('defaultconnectivitymode') ] = '1'
else:
rfpipevals[ rfpnames.index('propagationmodel') ] = '2ray'
exp.createemanesession(numnodes=opt.numnodes, verbose=opt.verbose,
cls=EmaneRfPipeModel, values=rfpipevals)
exp.setnodes()
exp.info("waiting %s sec (node/route bring-up)" % opt.delay)
time.sleep(opt.delay)
results['3.0 rfpipe'] = exp.runalltests("rfpipe")
exp.info("shutting down RF-PIPE session")
exp.reset()
# EMANE RF-PIPE model: 54M datarate
exp.info("setting up EMANE tests 3/4 with RF-PIPE model 54M")
rfpipevals = list(EmaneRfPipeModel.getdefaultvalues())
rfpnames = EmaneRfPipeModel.getnames()
rfpipevals[ rfpnames.index('datarate') ] = '54000000'
# TX delay != propagation delay
#rfpipevals[ rfpnames.index('delay') ] = '5000'
if emanever < Emane.EMANE091:
rfpipevals[ rfpnames.index('pathlossmode') ] = '2ray'
rfpipevals[ rfpnames.index('defaultconnectivitymode') ] = '1'
else:
rfpipevals[ rfpnames.index('propagationmodel') ] = '2ray'
exp.createemanesession(numnodes=opt.numnodes, verbose=opt.verbose,
cls=EmaneRfPipeModel, values=rfpipevals)
exp.setnodes()
exp.info("waiting %s sec (node/route bring-up)" % opt.delay)
time.sleep(opt.delay)
results['4.0 rfpipe54m'] = exp.runalltests("rfpipe54m")
exp.info("shutting down RF-PIPE session")
exp.reset()
# EMANE RF-PIPE model: 54K datarate
exp.info("setting up EMANE tests 4/4 with RF-PIPE model pathloss")
rfpipevals = list(EmaneRfPipeModel.getdefaultvalues())
rfpnames = EmaneRfPipeModel.getnames()
rfpipevals[ rfpnames.index('datarate') ] = '54000'
if emanever < Emane.EMANE091:
rfpipevals[ rfpnames.index('pathlossmode') ] = 'pathloss'
rfpipevals[ rfpnames.index('defaultconnectivitymode') ] = '0'
else:
rfpipevals[ rfpnames.index('propagationmodel') ] = 'precomputed'
exp.createemanesession(numnodes=opt.numnodes, verbose=opt.verbose,
cls=EmaneRfPipeModel, values=rfpipevals)
exp.setnodes()
exp.info("waiting %s sec (node/route bring-up)" % opt.delay)
time.sleep(opt.delay)
exp.info("sending pathloss events to govern connectivity")
exp.setpathloss(opt.numnodes)
results['5.0 pathloss'] = exp.runalltests("pathloss")
exp.info("shutting down RF-PIPE session")
exp.reset()
# EMANE RF-PIPE model (512K, 200ms)
exp.info("setting up EMANE tests 4/4 with RF-PIPE model pathloss")
rfpipevals = list(EmaneRfPipeModel.getdefaultvalues())
rfpnames = EmaneRfPipeModel.getnames()
rfpipevals[ rfpnames.index('datarate') ] = '512000'
rfpipevals[ rfpnames.index('delay') ] = '200'
rfpipevals[ rfpnames.index('pathlossmode') ] = 'pathloss'
rfpipevals[ rfpnames.index('defaultconnectivitymode') ] = '0'
exp.createemanesession(numnodes=opt.numnodes, verbose=opt.verbose,
cls=EmaneRfPipeModel, values=rfpipevals)
exp.setnodes()
exp.info("waiting %s sec (node/route bring-up)" % opt.delay)
time.sleep(opt.delay)
exp.info("sending pathloss events to govern connectivity")
exp.setpathloss(opt.numnodes)
results['5.1 pathloss'] = exp.runalltests("pathloss")
exp.info("shutting down RF-PIPE session")
exp.reset()
# summary of results in CSV format
exp.info("----- summary of results (%s nodes, rate=%s, duration=%s) -----" \
% (opt.numnodes, opt.rate, opt.duration))
exp.info("netname:latency,mdev,throughput,cpu,loss")
for test in sorted(results.keys()):
(latency, mdev, throughput, cpu, loss) = results[test]
exp.info("%s:%.03f,%.03f,%d,%.02f,%.02f" % \
(test, latency, mdev, throughput, cpu,loss))
exp.logend()
return exp
if __name__ == "__main__":
exp = main()
| bsd-2-clause |
ad-l/djcl | tools/jsdoc/lib/jsdoc/tag/dictionary/definitions.js | 21625 | /*global app: true, env: true */
/**
Define tags that are known in JSDoc.
@module jsdoc/tag/dictionary/definitions
@author Michael Mathews <[email protected]>
@license Apache License 2.0 - See file 'LICENSE.md' in this project.
*/
'use strict';
var logger = require('jsdoc/util/logger');
var path = require('jsdoc/path');
var Syntax = require('jsdoc/src/syntax').Syntax;
function getSourcePaths() {
var sourcePaths = env.sourceFiles.slice(0) || [];
if (env.opts._) {
env.opts._.forEach(function(sourcePath) {
var resolved = path.resolve(env.pwd, sourcePath);
if (sourcePaths.indexOf(resolved) === -1) {
sourcePaths.push(resolved);
}
});
}
return sourcePaths;
}
function filepathMinusPrefix(filepath) {
var sourcePaths = getSourcePaths();
var commonPrefix = path.commonPrefix(sourcePaths);
var result = '';
if (filepath) {
// always use forward slashes
result = (filepath + path.sep).replace(commonPrefix, '')
.replace(/\\/g, '/');
}
if (result.length > 0 && result[result.length - 1] !== '/') {
result += '/';
}
return result;
}
/** @private */
function setDocletKindToTitle(doclet, tag) {
doclet.addTag( 'kind', tag.title );
}
function setDocletScopeToTitle(doclet, tag) {
try {
doclet.setScope(tag.title);
}
catch(e) {
logger.error(e.message);
}
}
function setDocletNameToValue(doclet, tag) {
if (tag.value && tag.value.description) { // as in a long tag
doclet.addTag( 'name', tag.value.description);
}
else if (tag.text) { // or a short tag
doclet.addTag('name', tag.text);
}
}
function setDocletNameToValueName(doclet, tag) {
if (tag.value && tag.value.name) {
doclet.addTag('name', tag.value.name);
}
}
function setDocletDescriptionToValue(doclet, tag) {
if (tag.value) {
doclet.addTag( 'description', tag.value );
}
}
function setDocletTypeToValueType(doclet, tag) {
if (tag.value && tag.value.type) {
doclet.type = tag.value.type;
}
}
function setNameToFile(doclet, tag) {
var name;
if (doclet.meta.filename) {
name = filepathMinusPrefix(doclet.meta.path) + doclet.meta.filename;
doclet.addTag('name', name);
}
}
function setDocletMemberof(doclet, tag) {
if (tag.value && tag.value !== '<global>') {
doclet.setMemberof(tag.value);
}
}
function applyNamespace(docletOrNs, tag) {
if (typeof docletOrNs === 'string') { // ns
tag.value = app.jsdoc.name.applyNamespace(tag.value, docletOrNs);
}
else { // doclet
if (!docletOrNs.name) {
return; // error?
}
//doclet.displayname = doclet.name;
docletOrNs.longname = app.jsdoc.name.applyNamespace(docletOrNs.name, tag.title);
}
}
function setDocletNameToFilename(doclet, tag) {
var name = '';
if (doclet.meta.path) {
name = filepathMinusPrefix(doclet.meta.path);
}
name += doclet.meta.filename.replace(/\.js$/i, '');
doclet.name = name;
}
function parseBorrows(doclet, tag) {
var m = /^(\S+)(?:\s+as\s+(\S+))?$/.exec(tag.text);
if (m) {
if (m[1] && m[2]) {
return { target: m[1], source: m[2] };
}
else if (m[1]) {
return { target: m[1] };
}
} else {
return {};
}
}
function firstWordOf(string) {
var m = /^(\S+)/.exec(string);
if (m) { return m[1]; }
else { return ''; }
}
/** Populate the given dictionary with all known JSDoc tag definitions.
@param {module:jsdoc/tag/dictionary} dictionary
*/
exports.defineTags = function(dictionary) {
dictionary.defineTag('abstract', {
mustNotHaveValue: true,
onTagged: function(doclet, tag) {
// since "abstract" is reserved word in JavaScript let's use "virtual" in code
doclet.virtual = true;
}
})
.synonym('virtual');
dictionary.defineTag('access', {
mustHaveValue: true,
onTagged: function(doclet, tag) {
// only valid values are private and protected, public is default
if ( /^(private|protected)$/i.test(tag.value) ) {
doclet.access = tag.value.toLowerCase();
}
else {
delete doclet.access;
}
}
});
dictionary.defineTag('alias', {
mustHaveValue: true,
onTagged: function(doclet, tag) {
doclet.alias = tag.value;
}
});
// Special separator tag indicating that multiple doclets should be generated for the same
// comment. Used internally (and by some JSDoc users, although it's not officially supported).
//
// In the following example, the parser will replace `//**` with an `@also` tag:
//
// /**
// * Foo.
// *//**
// * Foo with a param.
// * @param {string} bar
// */
// function foo(bar) {}
dictionary.defineTag('also', {
onTagged: function(doclet, tag) {
// let the parser handle it; we define the tag here to avoid "not a known tag" errors
}
});
// this symbol inherits from the specified symbol
dictionary.defineTag('augments', {
mustHaveValue: true,
// Allow augments value to be specified as a normal type, e.g. {Type}
onTagText: function(text) {
var type = require('jsdoc/tag/type'),
tagType = type.parse(text, false, true);
return tagType.typeExpression || text;
},
onTagged: function(doclet, tag) {
doclet.augment( firstWordOf(tag.value) );
}
})
.synonym('extends');
dictionary.defineTag('author', {
mustHaveValue: true,
onTagged: function(doclet, tag) {
if (!doclet.author) { doclet.author = []; }
doclet.author.push(tag.value);
}
});
// this symbol has a member that should use the same docs as another symbol
dictionary.defineTag('borrows', {
mustHaveValue: true,
onTagged: function(doclet, tag) {
var borrows = parseBorrows(doclet, tag);
doclet.borrow(borrows.target, borrows.source);
}
});
dictionary.defineTag('class', {
onTagged: function(doclet, tag) {
doclet.addTag('kind', 'class');
// handle special case where both @class and @constructor tags exist in same doclet
if (tag.originalTitle === 'class') {
var looksLikeDesc = (tag.value || '').match(/\S+\s+\S+/); // multiple words after @class?
if ( looksLikeDesc || /@construct(s|or)\b/i.test(doclet.comment) ) {
doclet.classdesc = tag.value; // treat the @class tag as a @classdesc tag instead
return;
}
}
setDocletNameToValue(doclet, tag);
}
})
.synonym('constructor');
dictionary.defineTag('classdesc', {
onTagged: function(doclet, tag) {
doclet.classdesc = tag.value;
}
});
dictionary.defineTag('constant', {
canHaveType: true,
canHaveName: true,
onTagged: function(doclet, tag) {
setDocletKindToTitle(doclet, tag);
setDocletNameToValueName(doclet, tag);
setDocletTypeToValueType(doclet, tag);
}
})
.synonym('const');
dictionary.defineTag('constructs', {
onTagged: function(doclet, tag) {
var ownerClassName;
if (!tag.value) {
ownerClassName = '{@thisClass}'; // this can be resolved later in the handlers
}
else {
ownerClassName = firstWordOf(tag.value);
}
doclet.addTag('alias', ownerClassName);
doclet.addTag('kind', 'class');
}
});
dictionary.defineTag('copyright', {
mustHaveValue: true,
onTagged: function(doclet, tag) {
doclet.copyright = tag.value;
}
});
dictionary.defineTag('default', {
onTagged: function(doclet, tag) {
var type;
var value;
if (tag.value) {
doclet.defaultvalue = tag.value;
}
else if (doclet.meta && doclet.meta.code && doclet.meta.code.value) {
type = doclet.meta.code.type;
value = doclet.meta.code.value;
if (type === Syntax.Literal) {
doclet.defaultvalue = String(value);
}
// TODO: reenable the changes for https://github.com/jsdoc3/jsdoc/pull/419
/*
else if (doclet.meta.code.type === 'OBJECTLIT') {
doclet.defaultvalue = String(doclet.meta.code.node.toSource());
doclet.defaultvaluetype = 'object';
}
*/
}
}
})
.synonym('defaultvalue');
dictionary.defineTag('deprecated', {
// value is optional
onTagged: function(doclet, tag) {
doclet.deprecated = tag.value || true;
}
});
dictionary.defineTag('description', {
mustHaveValue: true
})
.synonym('desc');
dictionary.defineTag('enum', {
canHaveType: true,
onTagged: function(doclet, tag) {
doclet.kind = 'member';
doclet.isEnum = true;
setDocletTypeToValueType(doclet, tag);
}
});
dictionary.defineTag('event', {
isNamespace: true,
onTagged: function(doclet, tag) {
setDocletKindToTitle(doclet, tag);
setDocletNameToValue(doclet, tag);
}
});
dictionary.defineTag('example', {
keepsWhitespace: true,
removesIndent: true,
mustHaveValue: true,
onTagged: function(doclet, tag) {
if (!doclet.examples) { doclet.examples = []; }
doclet.examples.push(tag.value);
}
});
dictionary.defineTag('exception', {
mustHaveValue: true,
canHaveType: true,
onTagged: function(doclet, tag) {
if (!doclet.exceptions) { doclet.exceptions = []; }
doclet.exceptions.push(tag.value);
setDocletTypeToValueType(doclet, tag);
}
})
.synonym('throws');
dictionary.defineTag('exports', {
mustHaveValue: true,
onTagged: function(doclet, tag) {
var modName = firstWordOf(tag.value);
doclet.addTag('alias', modName);
doclet.addTag('kind', 'module');
}
});
dictionary.defineTag('external', {
canHaveType: true,
isNamespace: true,
onTagged: function(doclet, tag) {
setDocletKindToTitle(doclet, tag);
if (tag.value && tag.value.type) {
setDocletTypeToValueType(doclet, tag);
doclet.addTag('name', doclet.type.names[0]);
}
}
})
.synonym('host');
dictionary.defineTag('file', {
onTagged: function(doclet, tag) {
setNameToFile(doclet, tag);
setDocletKindToTitle(doclet, tag);
setDocletDescriptionToValue(doclet, tag);
doclet.preserveName = true;
}
})
.synonym('fileoverview')
.synonym('overview');
dictionary.defineTag('fires', {
mustHaveValue: true,
onTagged: function(doclet, tag) {
if (!doclet.fires) { doclet.fires = []; }
applyNamespace('event', tag);
doclet.fires.push(tag.value);
}
})
.synonym('emits');
dictionary.defineTag('function', {
onTagged: function(doclet, tag) {
setDocletKindToTitle(doclet, tag);
setDocletNameToValue(doclet, tag);
}
})
.synonym('func')
.synonym('method');
dictionary.defineTag('global', {
mustNotHaveValue: true,
onTagged: function(doclet, tag) {
doclet.scope = 'global';
delete doclet.memberof;
}
});
dictionary.defineTag('ignore', {
mustNotHaveValue: true,
onTagged: function(doclet, tag) {
doclet.ignore = true;
}
});
dictionary.defineTag('inner', {
onTagged: function(doclet, tag) {
setDocletScopeToTitle(doclet, tag);
}
});
dictionary.defineTag('instance', {
onTagged: function(doclet, tag) {
setDocletScopeToTitle(doclet, tag);
}
});
dictionary.defineTag('kind', {
mustHaveValue: true
});
dictionary.defineTag('lends', {
onTagged: function(doclet, tag) {
var GLOBAL_LONGNAME = require('jsdoc/doclet').GLOBAL_LONGNAME;
doclet.alias = tag.value || GLOBAL_LONGNAME;
doclet.addTag('undocumented');
}
});
dictionary.defineTag('license', {
mustHaveValue: true,
onTagged: function(doclet, tag) {
doclet.license = tag.value;
}
});
dictionary.defineTag('listens', {
mustHaveValue: true,
onTagged: function (doclet, tag) {
if (!doclet.listens) { doclet.listens = []; }
applyNamespace('event', tag);
doclet.listens.push(tag.value);
// TODO: verify that parameters match the event parameters?
}
});
dictionary.defineTag('member', {
canHaveType: true,
canHaveName: true,
onTagged: function(doclet, tag) {
setDocletKindToTitle(doclet, tag);
setDocletNameToValueName(doclet, tag);
setDocletTypeToValueType(doclet, tag);
}
})
.synonym('var');
dictionary.defineTag('memberof', {
mustHaveValue: true,
onTagged: function(doclet, tag) {
var GLOBAL_LONGNAME = require('jsdoc/doclet').GLOBAL_LONGNAME;
if (tag.originalTitle === 'memberof!') {
doclet.forceMemberof = true;
if (tag.value === GLOBAL_LONGNAME) {
doclet.addTag('global');
delete doclet.memberof;
}
}
setDocletMemberof(doclet, tag);
}
})
.synonym('memberof!');
// this symbol mixes in all of the specified object's members
dictionary.defineTag('mixes', {
mustHaveValue: true,
onTagged: function(doclet, tag) {
var source = firstWordOf(tag.value);
doclet.mix(source);
}
});
dictionary.defineTag('mixin', {
onTagged: function(doclet, tag) {
setDocletKindToTitle(doclet, tag);
setDocletNameToValue(doclet, tag);
}
});
dictionary.defineTag('module', {
canHaveType: true,
isNamespace: true,
onTagged: function(doclet, tag) {
setDocletKindToTitle(doclet, tag);
setDocletNameToValue(doclet, tag);
if (!doclet.name) {
setDocletNameToFilename(doclet, tag);
}
setDocletTypeToValueType(doclet, tag);
}
});
dictionary.defineTag('name', {
mustHaveValue: true
});
dictionary.defineTag('namespace', {
canHaveType: true,
onTagged: function(doclet, tag) {
setDocletKindToTitle(doclet, tag);
setDocletNameToValue(doclet, tag);
setDocletTypeToValueType(doclet, tag);
}
});
dictionary.defineTag('param', {
//mustHaveValue: true, // param name can be found in the source code if not provided
canHaveType: true,
canHaveName: true,
onTagged: function(doclet, tag) {
if (!doclet.params) { doclet.params = []; }
doclet.params.push(tag.value||{});
}
})
.synonym('argument')
.synonym('arg');
dictionary.defineTag('private', {
mustNotHaveValue: true,
onTagged: function(doclet, tag) {
doclet.access = 'private';
}
});
dictionary.defineTag('property', {
mustHaveValue: true,
canHaveType: true,
canHaveName: true,
onTagged: function(doclet, tag) {
if (!doclet.properties) { doclet.properties = []; }
doclet.properties.push(tag.value);
}
})
.synonym('prop');
dictionary.defineTag('protected', {
mustNotHaveValue: true,
onTagged: function(doclet, tag) {
doclet.access = 'protected';
}
});
dictionary.defineTag('public', {
mustNotHaveValue: true,
onTagged: function(doclet, tag) {
delete doclet.access; // public is default
}
});
// use this instead of old deprecated @final tag
dictionary.defineTag('readonly', {
mustNotHaveValue: true,
onTagged: function(doclet, tag) {
doclet.readonly = true;
}
});
dictionary.defineTag('requires', {
mustHaveValue: true,
onTagged: function(doclet, tag) {
var requiresName;
var MODULE_PREFIX = require('jsdoc/name').MODULE_PREFIX;
// inline link tags are passed through as-is so that `@requires {@link foo}` works
if ( require('jsdoc/tag/inline').isInlineTag(tag.value, 'link\\S*') ) {
requiresName = tag.value;
}
// otherwise, assume it's a module
else {
requiresName = firstWordOf(tag.value);
if (requiresName.indexOf(MODULE_PREFIX) !== 0) {
requiresName = MODULE_PREFIX + requiresName;
}
}
if (!doclet.requires) { doclet.requires = []; }
doclet.requires.push(requiresName);
}
});
dictionary.defineTag('returns', {
mustHaveValue: true,
canHaveType: true,
onTagged: function(doclet, tag) {
if (!doclet.returns) { doclet.returns = []; }
doclet.returns.push(tag.value);
}
})
.synonym('return');
dictionary.defineTag('see', {
mustHaveValue: true,
onTagged: function(doclet, tag) {
if (!doclet.see) { doclet.see = []; }
doclet.see.push(tag.value);
}
});
dictionary.defineTag('since', {
mustHaveValue: true,
onTagged: function(doclet, tag) {
doclet.since = tag.value;
}
});
dictionary.defineTag('static', {
onTagged: function(doclet, tag) {
setDocletScopeToTitle(doclet, tag);
}
});
dictionary.defineTag('summary', {
mustHaveValue: true,
onTagged: function(doclet, tag) {
doclet.summary = tag.value;
}
});
dictionary.defineTag('this', {
mustHaveValue: true,
onTagged: function(doclet, tag) {
doclet['this'] = firstWordOf(tag.value);
}
});
dictionary.defineTag('todo', {
mustHaveValue: true,
onTagged: function(doclet, tag) {
if (!doclet.todo) { doclet.todo = []; }
doclet.todo.push(tag.value);
}
});
dictionary.defineTag('tutorial', {
mustHaveValue: true,
onTagged: function(doclet, tag) {
if (!doclet.tutorials) { doclet.tutorials = []; }
doclet.tutorials.push(tag.value);
}
});
dictionary.defineTag('type', {
mustHaveValue: true,
canHaveType: true,
onTagText: function(text) {
// remove line breaks so we can parse the type expression correctly
text = text.replace(/[\n\r]/g, '');
// any text must be formatted as a type, but for back compat braces are optional
if ( !/^\{[\s\S]+\}$/.test(text) ) {
text = '{' + text + '}';
}
return text;
},
onTagged: function(doclet, tag) {
if (tag.value && tag.value.type) {
setDocletTypeToValueType(doclet, tag);
// for backwards compatibility, we allow @type for functions to imply return type
if (doclet.kind === 'function') {
doclet.addTag('returns', tag.text);
}
}
}
});
dictionary.defineTag('typedef', {
canHaveType: true,
canHaveName: true,
onTagged: function(doclet, tag) {
setDocletKindToTitle(doclet, tag);
if (tag.value) {
setDocletNameToValueName(doclet, tag);
// callbacks are always type {function}
if (tag.originalTitle === 'callback') {
doclet.type = {
names: [
'function'
]
};
}
else {
setDocletTypeToValueType(doclet, tag);
}
}
}
})
.synonym('callback');
dictionary.defineTag('undocumented', {
mustNotHaveValue: true,
onTagged: function(doclet, tag) {
doclet.undocumented = true;
doclet.comment = '';
}
});
dictionary.defineTag('variation', {
mustHaveValue: true,
onTagged: function(doclet, tag) {
doclet.variation = tag.value;
}
});
dictionary.defineTag('version', {
mustHaveValue: true,
onTagged: function(doclet, tag) {
doclet.version = tag.value;
}
});
};
| bsd-2-clause |
aviarypl/mozilla-l10n-addons-server | src/olympia/amo/tests/test_pytest_fixtures.py | 955 | """Testing the pytest fixtures themselves which are declared in conftest.py."""
import pytest
import responses
import requests
from requests.exceptions import ConnectionError
from olympia.access.models import Group
def test_admin_group(admin_group):
assert Group.objects.count() == 1
admin_group = Group.objects.get()
assert admin_group.name == 'Admins'
assert admin_group.rules == '*:*'
def test_mozilla_user(mozilla_user):
admin_group = mozilla_user.groups.get()
assert admin_group.name == 'Admins'
assert admin_group.rules == '*:*'
@pytest.mark.allow_external_http_requests
def test_external_requests_enabled():
with pytest.raises(ConnectionError):
requests.get('http://example.invalid')
assert len(responses.calls) == 0
def test_external_requests_disabled_by_default():
with pytest.raises(ConnectionError):
requests.get('http://example.invalid')
assert len(responses.calls) == 1
| bsd-3-clause |
glayzzle/tests | zend/bug43483.phpt | 389 | --TEST--
Bug #43483 (get_class_methods() does not list all visible methods)
--FILE--
<?php
class C {
public static function test() {
D::prot();
print_r(get_class_methods("D"));
}
}
class D extends C {
protected static function prot() {
echo "Successfully called D::prot().\n";
}
}
D::test();
?>
--EXPECT--
Successfully called D::prot().
Array
(
[0] => prot
[1] => test
)
| bsd-3-clause |
shaotuanchen/sunflower_exp | tools/source/gcc-4.2.4/libstdc++-v3/testsuite/23_containers/list/cons/4.cc | 2030 | // Copyright (C) 2001, 2004, 2005 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING. If not, write to the Free
// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
// 23.2.2.1 list constructors, copy, and assignment
#include <list>
#include <testsuite_hooks.h>
bool test __attribute__((unused)) = true;
// Range constructor
//
// This test verifies the following.
// 23.2.2.1 template list(InputIterator f, InputIterator l, const Allocator& a = Allocator())
// 23.2.2 const_iterator begin() const
// 23.2.2 const_iterator end() const
// 23.2.2 size_type size() const
//
void
test03()
{
const int A[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17};
const std::size_t N = sizeof(A) / sizeof(int);
std::size_t count;
std::list<int>::const_iterator i;
// construct from a dissimilar range
std::list<int> list0301(A, A + N);
for (i = list0301.begin(), count = 0;
i != list0301.end();
++i, ++count)
VERIFY(*i == A[count]);
VERIFY(count == N);
VERIFY(list0301.size() == N);
// construct from a similar range
std::list<int> list0302(list0301.begin(), list0301.end());
for (i = list0302.begin(), count = 0;
i != list0302.end();
++i, ++count)
VERIFY(*i == A[count]);
VERIFY(count == N);
VERIFY(list0302.size() == N);
}
int main()
{
test03();
return 0;
}
| bsd-3-clause |
Bhullnatik/react-native | local-cli/core/__tests__/ios/getProjectConfig.spec.js | 1475 | /**
* Copyright (c) 2013-present, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @format
* @emails oncall+javascript_foundation
*/
'use strict';
jest.mock('fs');
const getProjectConfig = require('../../ios').projectConfig;
const fs = require('fs');
const projects = require('../../__fixtures__/projects');
describe('ios::getProjectConfig', () => {
const userConfig = {};
beforeEach(() => {
fs.__setMockFilesystem({testDir: projects});
});
it('returns an object with ios project configuration', () => {
const folder = '/testDir/nested';
expect(getProjectConfig(folder, userConfig)).not.toBeNull();
expect(typeof getProjectConfig(folder, userConfig)).toBe('object');
});
it('returns `null` if ios project was not found', () => {
const folder = '/testDir/empty';
expect(getProjectConfig(folder, userConfig)).toBeNull();
});
it('returns normalized shared library names', () => {
const projectConfig = getProjectConfig('/testDir/nested', {
sharedLibraries: ['libc++', 'libz.tbd', 'HealthKit', 'HomeKit.framework'],
});
expect(projectConfig.sharedLibraries).toEqual([
'libc++.tbd',
'libz.tbd',
'HealthKit.framework',
'HomeKit.framework',
]);
});
});
| bsd-3-clause |
scheib/chromium | third_party/blink/web_tests/webaudio/resources/audionodeoptions.js | 8919 | // Test that constructor for the node with name |nodeName| handles the
// various possible values for channelCount, channelCountMode, and
// channelInterpretation.
// The |should| parameter is the test function from new |Audit|.
function testAudioNodeOptions(should, context, nodeName, expectedNodeOptions) {
if (expectedNodeOptions === undefined)
expectedNodeOptions = {};
let node;
// Test that we can set channelCount and that errors are thrown for
// invalid values
let testChannelCount = 17;
if (expectedNodeOptions.channelCount) {
testChannelCount = expectedNodeOptions.channelCount.value;
}
should(
() => {
node = new window[nodeName](
context, Object.assign({}, expectedNodeOptions.additionalOptions, {
channelCount: testChannelCount
}));
},
'new ' + nodeName + '(c, {channelCount: ' + testChannelCount + '}}')
.notThrow();
should(node.channelCount, 'node.channelCount').beEqualTo(testChannelCount);
if (expectedNodeOptions.channelCount &&
expectedNodeOptions.channelCount.isFixed) {
// The channel count is fixed. Verify that we throw an error if
// we try to change it. Arbitrarily set the count to be one more
// than the expected value.
testChannelCount = expectedNodeOptions.channelCount.value + 1;
should(
() => {
node = new window[nodeName](
context,
Object.assign(
{}, expectedNodeOptions.additionalOptions,
{channelCount: testChannelCount}));
},
'new ' + nodeName + '(c, {channelCount: ' + testChannelCount + '}}')
.throw(expectedNodeOptions.channelCount.errorType || TypeError);
} else {
// The channel count is not fixed. Try to set the count to invalid
// values and make sure an error is thrown.
[0, 99].forEach(testValue => {
should(() => {
node = new window[nodeName](
context, Object.assign({}, expectedNodeOptions.additionalOptions, {
channelCount: testValue
}));
}, `new ${nodeName}(c, {channelCount: ${testValue}})`)
.throw(DOMException, 'NotSupportedError');
});
}
// Test channelCountMode
let testChannelCountMode = 'max';
if (expectedNodeOptions.channelCountMode) {
testChannelCountMode = expectedNodeOptions.channelCountMode.value;
}
should(
() => {
node = new window[nodeName](
context, Object.assign({}, expectedNodeOptions.additionalOptions, {
channelCountMode: testChannelCountMode
}));
},
'new ' + nodeName + '(c, {channelCountMode: "' + testChannelCountMode +
'"}')
.notThrow();
should(node.channelCountMode, 'node.channelCountMode')
.beEqualTo(testChannelCountMode);
if (expectedNodeOptions.channelCountMode &&
expectedNodeOptions.channelCountMode.isFixed) {
// Channel count mode is fixed. Test setting to something else throws.
['max', 'clamped-max', 'explicit'].forEach(testValue => {
if (testValue !== expectedNodeOptions.channelCountMode.value) {
should(
() => {
node = new window[nodeName](
context,
Object.assign(
{}, expectedNodeOptions.additionalOptions,
{channelCountMode: testValue}));
},
`new ${nodeName}(c, {channelCountMode: "${testValue}"})`)
.throw(expectedNodeOptions.channelCountMode.errorType);
}
});
} else {
// Mode is not fixed. Verify that we can set the mode to all valid
// values, and that we throw for invalid values.
let testValues = ['max', 'clamped-max', 'explicit'];
testValues.forEach(testValue => {
should(() => {
node = new window[nodeName](
context, Object.assign({}, expectedNodeOptions.additionalOptions, {
channelCountMode: testValue
}));
}, `new ${nodeName}(c, {channelCountMode: "${testValue}"})`).notThrow();
should(
node.channelCountMode, 'node.channelCountMode after valid setter')
.beEqualTo(testValue);
});
should(
() => {
node = new window[nodeName](
context,
Object.assign(
{}, expectedNodeOptions.additionalOptions,
{channelCountMode: 'foobar'}));
},
'new ' + nodeName + '(c, {channelCountMode: "foobar"}')
.throw(TypeError);
should(node.channelCountMode, 'node.channelCountMode after invalid setter')
.beEqualTo(testValues[testValues.length - 1]);
}
// Test channelInterpretation
if (expectedNodeOptions.channelInterpretation &&
expectedNodeOptions.channelInterpretation.isFixed) {
// The channel interpretation is fixed. Verify that we throw an
// error if we try to change it.
['speakers', 'discrete'].forEach(testValue => {
if (testValue !== expectedNodeOptions.channelInterpretation.value) {
should(
() => {
node = new window[nodeName](
context,
Object.assign(
{}, expectedNodeOptions.additionOptions,
{channelInterpretation: testValue}));
},
`new ${nodeName}(c, {channelInterpretation: "${testValue}"})`)
.throw(expectedNodeOptions.channelInterpretation.errorType);
}
});
} else {
// Channel interpretation is not fixed. Verify that we can set it
// to all possible values.
should(
() => {
node = new window[nodeName](
context,
Object.assign(
{}, expectedNodeOptions.additionalOptions,
{channelInterpretation: 'speakers'}));
},
'new ' + nodeName + '(c, {channelInterpretation: "speakers"})')
.notThrow();
should(node.channelInterpretation, 'node.channelInterpretation')
.beEqualTo('speakers');
should(
() => {
node = new window[nodeName](
context,
Object.assign(
{}, expectedNodeOptions.additionalOptions,
{channelInterpretation: 'discrete'}));
},
'new ' + nodeName + '(c, {channelInterpretation: "discrete"})')
.notThrow();
should(node.channelInterpretation, 'node.channelInterpretation')
.beEqualTo('discrete');
should(
() => {
node = new window[nodeName](
context,
Object.assign(
{}, expectedNodeOptions.additionalOptions,
{channelInterpretation: 'foobar'}));
},
'new ' + nodeName + '(c, {channelInterpretation: "foobar"})')
.throw(TypeError);
should(
node.channelInterpretation,
'node.channelInterpretation after invalid setter')
.beEqualTo('discrete');
}
}
function initializeContext(should) {
let c;
should(() => {
c = new OfflineAudioContext(1, 1, 48000);
}, 'context = new OfflineAudioContext(...)').notThrow();
return c;
}
function testInvalidConstructor(should, name, context) {
should(() => {
new window[name]();
}, 'new ' + name + '()').throw(TypeError);
should(() => {
new window[name](1);
}, 'new ' + name + '(1)').throw(TypeError);
should(() => {
new window[name](context, 42);
}, 'new ' + name + '(context, 42)').throw(TypeError);
}
function testDefaultConstructor(should, name, context, options) {
let node;
let message = options.prefix + ' = new ' + name + '(context';
if (options.constructorOptions)
message += ', ' + JSON.stringify(options.constructorOptions);
message += ')'
should(() => {
node = new window[name](context, options.constructorOptions);
}, message).notThrow();
should(node instanceof window[name], options.prefix + ' instanceof ' + name)
.beEqualTo(true);
should(node.numberOfInputs, options.prefix + '.numberOfInputs')
.beEqualTo(options.numberOfInputs);
should(node.numberOfOutputs, options.prefix + '.numberOfOutputs')
.beEqualTo(options.numberOfOutputs);
should(node.channelCount, options.prefix + '.channelCount')
.beEqualTo(options.channelCount);
should(node.channelCountMode, options.prefix + '.channelCountMode')
.beEqualTo(options.channelCountMode);
should(node.channelInterpretation, options.prefix + '.channelInterpretation')
.beEqualTo(options.channelInterpretation);
return node;
}
function testDefaultAttributes(should, node, prefix, items) {
items.forEach((item) => {
let attr = node[item.name];
if (attr instanceof AudioParam) {
should(attr.value, prefix + '.' + item.name + '.value')
.beEqualTo(item.value);
} else {
should(attr, prefix + '.' + item.name).beEqualTo(item.value);
}
});
}
| bsd-3-clause |
xandroidx/voip_ios | voipengine/voipsdk/webrtc/src/webrtc/modules/audio_processing/agc/agc.h | 1900 | /*
* Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#ifndef WEBRTC_MODULES_AUDIO_PROCESSING_AGC_AGC_H_
#define WEBRTC_MODULES_AUDIO_PROCESSING_AGC_AGC_H_
#include "webrtc/base/scoped_ptr.h"
#include "webrtc/modules/audio_processing/vad/voice_activity_detector.h"
#include "webrtc/typedefs.h"
namespace webrtc {
class AudioFrame;
class Histogram;
class Agc {
public:
Agc();
virtual ~Agc();
// Returns the proportion of samples in the buffer which are at full-scale
// (and presumably clipped).
virtual float AnalyzePreproc(const int16_t* audio, size_t length);
// |audio| must be mono; in a multi-channel stream, provide the first (usually
// left) channel.
virtual int Process(const int16_t* audio, size_t length, int sample_rate_hz);
// Retrieves the difference between the target RMS level and the current
// signal RMS level in dB. Returns true if an update is available and false
// otherwise, in which case |error| should be ignored and no action taken.
virtual bool GetRmsErrorDb(int* error);
virtual void Reset();
virtual int set_target_level_dbfs(int level);
virtual int target_level_dbfs() const { return target_level_dbfs_; }
virtual float voice_probability() const {
return vad_.last_voice_probability();
}
private:
double target_level_loudness_;
int target_level_dbfs_;
rtc::scoped_ptr<Histogram> histogram_;
rtc::scoped_ptr<Histogram> inactive_histogram_;
VoiceActivityDetector vad_;
};
} // namespace webrtc
#endif // WEBRTC_MODULES_AUDIO_PROCESSING_AGC_AGC_H_
| bsd-3-clause |
rcuvgd/Webmin22.01.2016 | postgresql/help/list_users.ja_JP.UTF-8.html | 408 | <header>PostgreSQLユーザ</header>
このページではPostgreSQLデータベースに接続できるユーザを新規に作成、または編集することができます。各ユーザに対してユーザ名、任意のパスワード、任意の有効期限、それとそのユーザが新たにユーザ/データベースを作成できる権限があるか、を設定できます。<p>
<hr>
| bsd-3-clause |
chandler14362/panda3d | contrib/src/rplight/config_rplight.h | 1498 | /**
*
* RenderPipeline
*
* Copyright (c) 2014-2016 tobspr <[email protected]>
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*/
#ifndef CONFIG_RPLIGHT_H
#define CONFIG_RPLIGHT_H
#include "pandabase.h"
#include "notifyCategoryProxy.h"
#include "configVariableDouble.h"
#include "configVariableString.h"
#include "configVariableInt.h"
NotifyCategoryDecl(rplight, EXPORT_CLASS, EXPORT_TEMPL);
extern void init_librplight();
#endif // CONFIG_RPLIGHT_H
| bsd-3-clause |
koshalt/modules | odk/src/main/java/org/motechproject/odk/domain/FormFailure.java | 1577 | package org.motechproject.odk.domain;
import org.motechproject.mds.annotations.Entity;
import org.motechproject.mds.annotations.Field;
/**
* Domain object relating to a form receipt failure event
*/
@Entity
public class FormFailure {
@Field
private String configName;
@Field
private String formTitle;
@Field
private String message;
@Field
private String exception;
@Field(type = "TEXT")
private String jsonContent;
public FormFailure(String configName, String formTitle, String message, String exception, String jsonContent) {
this.configName = configName;
this.formTitle = formTitle;
this.message = message;
this.exception = exception;
this.jsonContent = jsonContent;
}
public String getConfigName() {
return configName;
}
public void setConfigName(String configName) {
this.configName = configName;
}
public String getFormTitle() {
return formTitle;
}
public void setFormTitle(String formTitle) {
this.formTitle = formTitle;
}
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
public String getException() {
return exception;
}
public void setException(String exception) {
this.exception = exception;
}
public String getJsonContent() {
return jsonContent;
}
public void setJsonContent(String jsonContent) {
this.jsonContent = jsonContent;
}
}
| bsd-3-clause |
Subsets and Splits