max_stars_count
int64 301
224k
| text
stringlengths 6
1.05M
| token_count
int64 3
727k
|
|---|---|---|
892 | {
"schema_version": "1.2.0",
"id": "GHSA-q4f8-9474-jr7m",
"modified": "2022-05-13T01:01:12Z",
"published": "2022-05-13T01:01:12Z",
"aliases": [
"CVE-2016-8331"
],
"details": "An exploitable remote code execution vulnerability exists in the handling of TIFF images in LibTIFF version 4.0.6. A crafted TIFF document can lead to a type confusion vulnerability resulting in remote code execution. This vulnerability can be triggered via a TIFF file delivered to the application using LibTIFF's tag extension functionality.",
"severity": [
{
"type": "CVSS_V3",
"score": "CVSS:3.0/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H"
}
],
"affected": [
],
"references": [
{
"type": "ADVISORY",
"url": "https://nvd.nist.gov/vuln/detail/CVE-2016-8331"
},
{
"type": "WEB",
"url": "https://security.gentoo.org/glsa/201701-16"
},
{
"type": "WEB",
"url": "http://www.securityfocus.com/bid/93898"
},
{
"type": "WEB",
"url": "http://www.talosintelligence.com/reports/TALOS-2016-0190/"
}
],
"database_specific": {
"cwe_ids": [
],
"severity": "HIGH",
"github_reviewed": false
}
} | 537 |
582 | #coding=utf-8
from django.contrib import admin
# Register your models here.
from appscan.models import poc_list
from appscan.models import navigation,navigation_url,vul_scan, user_scan,vul_state
#POC 数据
class poc_listAdmin(admin.ModelAdmin):
list_display = ('vulID','category','vulType','cvss','filename','appName','appPowerLink','appVersion','author','createDate','desc','install_requires','name','references','samples','updateDate','version',) # 列表显示的字段
admin.site.register(poc_list,poc_listAdmin)
#导航菜单
class navigationAdmin(admin.ModelAdmin):
list_display = ('id','nav_name',) # 列表显示的字段
admin.site.register(navigation,navigationAdmin)
#导航数据
class navigation_urlAdmin(admin.ModelAdmin):
list_display = ('id','nav_name','nav_title','nav_url',) # 列表显示的字段
admin.site.register(navigation_url,navigation_urlAdmin)
#漏洞扫描
class vul_scanAdmin(admin.ModelAdmin):
list_display = ('id','username','appname','url', 'pocname', 'date', 'cvss') # 列表显示的字段
admin.site.register(vul_scan,vul_scanAdmin)
#用户扫描
class user_scanAdmin(admin.ModelAdmin):
list_display = ('id', 'username', 'url', 'date')
admin.site.register(user_scan,user_scanAdmin)
#漏洞修复
class vul_stateAdmin(admin.ModelAdmin):
list_display = ('id', 'url', 'vulname','cvss','state')
admin.site.register(vul_state, vul_stateAdmin)
| 553 |
335 | package com.pgexercises;
import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Scanner;
import javax.servlet.ServletContext;
import org.json.simple.JSONObject;
import org.postgresql.copy.CopyIn;
import org.postgresql.copy.CopyManager;
import org.postgresql.core.BaseConnection;
class CallOnWriter {
private final String query;
private final String tableToReturn;
private final String recreateSchemaSQL;
private final String bookingsData;
private final String facilitiesData;
private final String membersData;
private final String finaliseRecreateSQL;
public CallOnWriter(ServletContext servletContext, String query, String tableToReturn) throws IOException {
this.query = query;
this.tableToReturn = tableToReturn;
recreateSchemaSQL = getResourceAsString(servletContext, "/WEB-INF/SQL/clubdata-schemaonly.sql");
bookingsData = getResourceAsString(servletContext, "/WEB-INF/SQL/clubdata-bookings.sql");
facilitiesData = getResourceAsString(servletContext, "/WEB-INF/SQL/clubdata-facilities.sql");
membersData = getResourceAsString(servletContext, "/WEB-INF/SQL/clubdata-members.sql");
finaliseRecreateSQL = getResourceAsString(servletContext, "/WEB-INF/SQL/clubdata-finalise.sql");
}
private String getResourceAsString(ServletContext servletContext, String resource) throws IOException {
try (
InputStream is = servletContext.getResourceAsStream(resource);
Scanner stemp = new java.util.Scanner(is);
Scanner s = stemp.useDelimiter("\\A");) {
return s.hasNext() ? s.next() : "";
}
}
public JSONObject runUsingDataSource(WriteableDbSource writeableDbSource) throws SQLException, PGEQueryResultSizeTooBigException {
try (Connection adminTempConn = writeableDbSource.getAdminDataSource().getConnection();
Connection userTempConn = writeableDbSource.getUserDataSource().getConnection();
Statement adminStatement = adminTempConn.createStatement();
Statement userStatement = userTempConn.createStatement();
) {
BaseConnection adminConnection = (BaseConnection)adminTempConn.unwrap(BaseConnection.class);
resetDb(adminConnection, adminStatement);
JSONObject toReturn = doDML(userStatement);
if (toReturn == null) {
toReturn = getReturnTableContents(userStatement);
}
return toReturn;
}
}
private JSONObject doDML(Statement userStatement) throws SQLException, PGEQueryResultSizeTooBigException {
userStatement.execute(query);
try (ResultSet rs = userStatement.getResultSet()) {
if (rs != null) {
return JSONUtils.queryToJSON(rs);
}
}
return null;
}
private JSONObject getReturnTableContents(Statement userStatement) throws SQLException, PGEQueryResultSizeTooBigException {
// Normally string concatenation with user input is bad, but we
// let the user do whatever they have permissions to do anyway :-).
try (ResultSet rs = userStatement.executeQuery("select * from " + tableToReturn + " order by 1")) {
return JSONUtils.queryToJSON(rs);
}
}
private void resetDb(BaseConnection adminConnection, Statement adminStatement) throws SQLException {
adminStatement.executeUpdate("drop schema if exists cd cascade");
adminStatement.executeUpdate(recreateSchemaSQL);
doCopyIn(adminConnection, "COPY bookings (bookid, facid, memid, starttime, slots) FROM stdin", bookingsData);
doCopyIn(adminConnection, "COPY facilities (facid, name, membercost, guestcost, initialoutlay, monthlymaintenance) FROM stdin;", facilitiesData);
doCopyIn(adminConnection, "COPY members (memid, surname, firstname, address, zipcode, telephone, recommendedby, joindate) FROM stdin;", membersData);
adminStatement.executeUpdate(finaliseRecreateSQL);
}
private void doCopyIn(BaseConnection connection, String copyStr, String data) throws SQLException {
CopyManager copyManager = new CopyManager(connection);
CopyIn copyIn = copyManager.copyIn(copyStr);
try {
byte[] bytes = data.getBytes();
copyIn.writeToCopy(bytes, 0, bytes.length);
copyIn.endCopy();
} finally {
if (copyIn.isActive()) {
copyIn.cancelCopy();
}
}
}
} | 1,330 |
335 | <filename>D/Daytime_noun.json
{
"word": "Daytime",
"definitions": [
"The time of the day between sunrise and sunset."
],
"parts-of-speech": "Noun"
} | 75 |
892 | <gh_stars>100-1000
{
"schema_version": "1.2.0",
"id": "GHSA-p6m5-7rpv-gjcj",
"modified": "2022-05-01T06:42:58Z",
"published": "2022-05-01T06:42:58Z",
"aliases": [
"CVE-2006-0830"
],
"details": "The scripting engine in Internet Explorer allows remote attackers to cause a denial of service (resource consumption) and possibly execute arbitrary code via a web page that contains a recurrent call to an infinite loop in Javascript or VBscript, which consumes the stack, as demonstrated by resetting the \"location\" variable within the loop.",
"severity": [
],
"affected": [
],
"references": [
{
"type": "ADVISORY",
"url": "https://nvd.nist.gov/vuln/detail/CVE-2006-0830"
},
{
"type": "WEB",
"url": "https://exchange.xforce.ibmcloud.com/vulnerabilities/24788"
},
{
"type": "WEB",
"url": "http://www.securityfocus.com/archive/1/425283/100/0/threaded"
},
{
"type": "WEB",
"url": "http://www.securityfocus.com/archive/1/425378/100/0/threaded"
},
{
"type": "WEB",
"url": "http://www.securityfocus.com/bid/16687"
}
],
"database_specific": {
"cwe_ids": [
],
"severity": "HIGH",
"github_reviewed": false
}
} | 529 |
15,337 | <filename>saleor/graphql/webhook/types.py
import graphene
from ...webhook import models
from ...webhook.event_types import WebhookEventType
from ..core.connection import CountableDjangoObjectType
from .enums import WebhookEventTypeEnum
class WebhookEvent(CountableDjangoObjectType):
name = graphene.String(description="Display name of the event.", required=True)
event_type = WebhookEventTypeEnum(
description="Internal name of the event type.", required=True
)
class Meta:
model = models.WebhookEvent
description = "Webhook event."
only_fields = ["event_type"]
@staticmethod
def resolve_name(root: models.WebhookEvent, *_args, **_kwargs):
return WebhookEventType.DISPLAY_LABELS.get(root.event_type) or root.event_type
class Webhook(CountableDjangoObjectType):
name = graphene.String(required=True)
events = graphene.List(
graphene.NonNull(WebhookEvent),
description="List of webhook events.",
required=True,
)
app = graphene.Field("saleor.graphql.app.types.App", required=True)
class Meta:
description = "Webhook."
model = models.Webhook
interfaces = [graphene.relay.Node]
only_fields = [
"target_url",
"is_active",
"secret_key",
"name",
]
@staticmethod
def resolve_events(root: models.Webhook, *_args, **_kwargs):
return root.events.all()
| 569 |
737 | # encoding: utf-8
from .make_densebox_target import make_densebox_target
__all__ = [make_densebox_target]
| 45 |
1,752 | <reponame>icovada/napalm
import re
def strip_config_header(config):
"""Normalize items that should not show up in IOS-XR compare_config."""
config = re.sub(r"^Building config.*\n!! IOS.*", "", config, flags=re.M)
config = config.strip()
config = re.sub(r"^!!.*", "", config)
config = re.sub(r"end$", "", config)
return config.strip()
| 142 |
14,668 | // Copyright 2014 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.
package org.chromium.base.annotations;
import java.lang.annotation.ElementType;
import java.lang.annotation.Target;
/**
* Annotation used for marking methods and fields that are called by reflection.
* Useful for keeping components that would otherwise be removed by Proguard.
* Use the value parameter to mention a file that calls this method.
*
* Note that adding this annotation to a method is not enough to guarantee that
* it is kept - either its class must be referenced elsewhere in the program, or
* the class must be annotated with this as well.
*/
@Target({
ElementType.METHOD, ElementType.FIELD, ElementType.TYPE,
ElementType.CONSTRUCTOR })
public @interface UsedByReflection {
String value();
}
| 238 |
1,001 | # 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.
from aliyunsdkcore.request import RpcRequest
class AddOrgMemberRequest(RpcRequest):
def __init__(self):
RpcRequest.__init__(self, 'Workbench-ide', '2021-01-21', 'AddOrgMember')
self.set_method('POST')
def get_Uid(self):
return self.get_query_params().get('Uid')
def set_Uid(self,Uid):
self.add_query_param('Uid',Uid)
def get_Role(self):
return self.get_query_params().get('Role')
def set_Role(self,Role):
self.add_query_param('Role',Role)
def get_CurrentOrgId(self):
return self.get_query_params().get('CurrentOrgId')
def set_CurrentOrgId(self,CurrentOrgId):
self.add_query_param('CurrentOrgId',CurrentOrgId)
def get_AccountType(self):
return self.get_query_params().get('AccountType')
def set_AccountType(self,AccountType):
self.add_query_param('AccountType',AccountType) | 536 |
892 | <reponame>westonsteimel/advisory-database-github
{
"schema_version": "1.2.0",
"id": "GHSA-c36f-rpx7-9qq3",
"modified": "2022-04-29T03:01:52Z",
"published": "2022-04-29T03:01:52Z",
"aliases": [
"CVE-2004-2664"
],
"details": "John Lim ADOdb Library for PHP before 4.23 allows remote attackers to obtain sensitive information via direct requests to certain scripts that result in an undefined value of ADODB_DIR, which reveals the installation path in an error message.",
"severity": [
],
"affected": [
],
"references": [
{
"type": "ADVISORY",
"url": "https://nvd.nist.gov/vuln/detail/CVE-2004-2664"
},
{
"type": "WEB",
"url": "http://phplens.com/lens/adodb/docs-adodb.htm#changes"
}
],
"database_specific": {
"cwe_ids": [
],
"severity": "MODERATE",
"github_reviewed": false
}
} | 367 |
8,664 | /*
* Copyright 2016 WebAssembly Community Group participants
*
* 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 "src/binding-hash.h"
#include <algorithm>
#include <vector>
#include "src/ir.h"
namespace wabt {
void BindingHash::FindDuplicates(DuplicateCallback callback) const {
if (size() > 0) {
ValueTypeVector duplicates;
CreateDuplicatesVector(&duplicates);
SortDuplicatesVectorByLocation(&duplicates);
CallCallbacks(duplicates, callback);
}
}
Index BindingHash::FindIndex(const Var& var) const {
if (var.is_name()) {
return FindIndex(var.name());
}
return var.index();
}
void BindingHash::CreateDuplicatesVector(
ValueTypeVector* out_duplicates) const {
// This relies on the fact that in an unordered_multimap, all values with the
// same key are adjacent in iteration order.
auto first = begin();
bool is_first = true;
for (auto iter = std::next(first); iter != end(); ++iter) {
if (first->first == iter->first) {
if (is_first) {
out_duplicates->push_back(&*first);
}
out_duplicates->push_back(&*iter);
is_first = false;
} else {
is_first = true;
first = iter;
}
}
}
void BindingHash::SortDuplicatesVectorByLocation(
ValueTypeVector* duplicates) const {
std::sort(
duplicates->begin(), duplicates->end(),
[](const value_type* lhs, const value_type* rhs) -> bool {
return lhs->second.loc.line < rhs->second.loc.line ||
(lhs->second.loc.line == rhs->second.loc.line &&
lhs->second.loc.first_column < rhs->second.loc.first_column);
});
}
void BindingHash::CallCallbacks(const ValueTypeVector& duplicates,
DuplicateCallback callback) const {
// Loop through all duplicates in order, and call callback with first
// occurrence.
for (auto iter = duplicates.begin(), end = duplicates.end(); iter != end;
++iter) {
auto first = std::find_if(duplicates.begin(), duplicates.end(),
[iter](const value_type* x) -> bool {
return x->first == (*iter)->first;
});
if (first == iter) {
continue;
}
assert(first != duplicates.end());
callback(**first, **iter);
}
}
} // namespace wabt
| 1,064 |
546 | <filename>include/Msnhnet/core/MsnhSimd.h<gh_stars>100-1000
#ifndef MSNHSIMD_H
#define MSNHSIMD_H
#include <iostream>
#include <string>
#include "Msnhnet/config/MsnhnetCfg.h"
#ifdef USE_X86
#ifdef WIN32
#include <intrin.h>
#include <ammintrin.h>
#include <immintrin.h>
#include <smmintrin.h>
#include <array>
#else
#include <x86intrin.h>
#include <ammintrin.h>
#include <immintrin.h>
#include <smmintrin.h>
#include <avxintrin.h>
#include <string.h>
#include <math.h>
#endif
#endif
#ifdef USE_ARM
#include <math.h>
#include <string.h>
#ifdef USE_NEON
#include <arm_neon.h>
#endif
#endif
namespace Msnhnet
{
using namespace std;
class MsnhNet_API SimdInfo
{
public:
#ifdef USE_X86
static bool checkSimd()
{
if(checked)
return true;
#ifdef linux
char buf[10240] = {0};
FILE *pf = NULL;
string strCmd = "cat /proc/cpuinfo | grep flag";
if( (pf = popen(strCmd.c_str(), "r")) == NULL )
{
return false;
}
string strResult;
while(fgets(buf, sizeof buf, pf))
{
strResult += buf;
}
pclose(pf);
unsigned int iSize = strResult.size();
if(iSize > 0 && strResult[iSize - 1] == '\n')
{
strResult = strResult.substr(0, iSize - 1);
}
if(strResult.find("sse") != string::npos)
{
supportSSE = true;
}
if(strResult.find("sse2") != string::npos)
{
supportSSE2 = true;
}
if(strResult.find("sse3") != string::npos)
{
supportSSE3 = true;
}
if(strResult.find("ssse3") != string::npos)
{
supportSSSE3 = true;
}
if(strResult.find("sse4_1") != string::npos)
{
supportSSE4_1 = true;
}
if(strResult.find("sse4_2") != string::npos)
{
supportSSE4_2 = true;
}
if(strResult.find("avx") != string::npos)
{
supportAVX = true;
}
if(strResult.find("avx2") != string::npos)
{
supportAVX2 = true;
}
if(strResult.find("fma") != string::npos)
{
supportFMA3 = true;
}
if(strResult.find("avx512") != string::npos)
{
supportAVX2 = true;
}
checked = true;
return true;
#endif
#ifdef WIN32
supportSSE = cpuHasSSE();
supportSSE2 = cpuHasSSE2();
supportSSE3 = cpuHasSSE3();
supportSSSE3 = cpuHasSSSE3();
supportSSE4_1 = cpuHasSSE4_1();
supportSSE4_2 = cpuHasSSE4_2();
supportFMA3 = cpuHasFMA3();
supportAVX = cpuHasAVX();
supportAVX2 = cpuHasAVX2();
checked = true;
return true;
#endif
}
static bool supportSSE ;
static bool supportSSE2 ;
static bool supportSSE3 ;
static bool supportSSSE3 ;
static bool supportSSE4_1;
static bool supportSSE4_2;
static bool supportFMA3 ;
static bool supportAVX ;
static bool supportAVX2 ;
static bool supportAVX512;
static bool checked;
#ifdef WIN32
static inline std::array<unsigned int,4> cpuid(int function_id)
{
std::array<unsigned int,4> info;
__cpuid((int*)info.data(), function_id);
return info;
}
static inline bool cpuHasSSE() {return 0!=(cpuid(1)[3]&(1<<25));}
static inline bool cpuHasSSE2() { return 0!=(cpuid(1)[3]&(1<<26)); }
static inline bool cpuHasSSE3() { return 0!=(cpuid(1)[2]&(1<<0)); }
static inline bool cpuHasSSSE3() { return 0!=(cpuid(1)[2]&(1<<9)); }
static inline bool cpuHasSSE4_1() { return 0!=(cpuid(1)[2]&(1<<19)); }
static inline bool cpuHasSSE4_2() { return 0!=(cpuid(1)[2]&(1<<20)); }
static inline bool cpuHasFMA3() { return 0!=(cpuid(1)[2]&(1<<12)); }
static inline bool cpuHasAVX() { return 0!=(cpuid(1)[2]&(1<<28)); }
static inline bool cpuHasAVX2() { return 0!=(cpuid(7)[1]&(1<<5)); }
static inline bool cpuHasAVX512() { return 0!=(cpuid(7)[1]&(1<<16)); }
#endif
#endif
};
}
#endif
| 2,153 |
2,453 | //
// Generated by class-dump 3.5 (64 bit) (Debug version compiled Sep 30 2020 21:18:12).
//
// Copyright (C) 1997-2019 <NAME>.
//
#import <IDEKit/IDELibraryController.h>
@class MISSING_TYPE;
@interface _TtC6IDEKit17CapabilityLibrary : IDELibraryController
{
MISSING_TYPE *sourceTitle;
MISSING_TYPE *lastManagerError;
MISSING_TYPE *isLibrarySourceInitialized;
MISSING_TYPE *section;
MISSING_TYPE *$__lazy_storage_$_detailViewController;
MISSING_TYPE *progress;
MISSING_TYPE *manager;
}
+ (id)pasteboardType;
- (void).cxx_destruct;
- (id)initWithCoder:(id)arg1;
- (id)initWithNibName:(id)arg1 bundle:(id)arg2;
- (id)initWithLibrary:(id)arg1;
- (id)initWithWorkspaceDocument:(id)arg1 andLibrary:(id)arg2;
- (void)invalidate;
- (void)activeEditorDidChange:(id)arg1;
- (id)inlineDetailViewForAssets:(id)arg1;
- (id)inlineDetailViewPlaceholderForAssets:(id)arg1;
- (void)populatePasteboard:(id)arg1 withAssets:(id)arg2;
- (void)libraryDidLoad;
- (void)viewWillDisappear;
- (void)viewWillAppear;
@end
| 408 |
4,756 | <reponame>smithersstonerandal/libphonenumber<gh_stars>1000+
// Copyright (C) 2020 The Libphonenumber 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.
#ifndef I18N_PHONENUMBERS_BASE_MEMORY_SINGLETON_BOOST_H_
#define I18N_PHONENUMBERS_BASE_MEMORY_SINGLETON_BOOST_H_
#include <boost/scoped_ptr.hpp>
#include <boost/thread/once.hpp>
#include <boost/utility.hpp>
namespace i18n {
namespace phonenumbers {
template <class T>
class Singleton : private boost::noncopyable {
public:
Singleton() {}
virtual ~Singleton() {}
static T* GetInstance() {
boost::call_once(Init, flag_);
return instance_.get();
}
private:
static void Init() {
instance_.reset(new T());
}
static boost::scoped_ptr<T> instance_;
static boost::once_flag flag_;
};
template <class T> boost::scoped_ptr<T> Singleton<T>::instance_;
template <class T> boost::once_flag Singleton<T>::flag_ = BOOST_ONCE_INIT;
} // namespace phonenumbers
} // namespace i18n
#endif // I18N_PHONENUMBERS_BASE_MEMORY_SINGLETON_BOOST_H_
| 528 |
377 | //------------------------------------------------------------------------------
// profiling.cc
// (C) 2020 Individual contributors, see AUTHORS file
//------------------------------------------------------------------------------
#include "foundation/stdneb.h"
#include "profiling/profiling.h"
namespace Profiling
{
Util::Array<ProfilingContext> profilingContexts;
Util::Array<Threading::AssertingMutex> contextMutexes;
Util::Dictionary<Util::StringAtom, Util::Array<ProfilingScope>> scopesByCategory;
Threading::CriticalSection categoryLock;
std::atomic_uint ProfilingContextCounter = 0;
thread_local IndexT ProfilingContextIndex = InvalidIndex;
//------------------------------------------------------------------------------
/**
*/
void
ProfilingPushScope(const ProfilingScope& scope)
{
n_assert(ProfilingContextIndex != InvalidIndex);
Threading::AssertingScope lock(&contextMutexes[ProfilingContextIndex]);
// get thread context
ProfilingContext& ctx = profilingContexts[ProfilingContextIndex];
ctx.scopes.Push(scope);
ctx.scopes.Peek().start = ctx.timer.GetTime();
}
//------------------------------------------------------------------------------
/**
*/
void
ProfilingPopScope()
{
n_assert(ProfilingContextIndex != InvalidIndex);
Threading::AssertingScope lock(&contextMutexes[ProfilingContextIndex]);
// get thread context
ProfilingContext& ctx = profilingContexts[ProfilingContextIndex];
// we can safely assume the scope and timers won't be modified from different threads here
ProfilingScope scope = ctx.scopes.Pop();
// add to category lookup
scope.duration = ctx.timer.GetTime() - scope.start;
//categoryLock.Enter();
//scopesByCategory.AddUnique(scope.category).Append(scope);
//categoryLock.Leave();
// add to top level scopes if stack is empty
if (ctx.scopes.IsEmpty())
{
if (scope.accum)
{
if (!ctx.topLevelScopes.IsEmpty())
{
ProfilingScope& parent = ctx.topLevelScopes.Back();
if (parent.name == scope.name)
parent.duration += scope.duration;
else
ctx.topLevelScopes.Append(scope);
}
else
ctx.topLevelScopes.Append(scope);
}
else
ctx.topLevelScopes.Append(scope);
}
else
{
// add as child scope
ProfilingScope& parent = ctx.scopes.Peek();
if (scope.accum && parent.name == scope.name)
parent.duration += scope.duration;
else
parent.children.Append(scope);
}
}
//------------------------------------------------------------------------------
/**
*/
void
ProfilingNewFrame()
{
// get thread context
ProfilingContext& ctx = profilingContexts[ProfilingContextIndex];
//n_assert(ctx.threadName == "MainThread");
for (IndexT i = 0; i < profilingContexts.Size(); i++)
{
profilingContexts[i].topLevelScopes.Clear();
profilingContexts[i].timer.Reset();
}
}
//------------------------------------------------------------------------------
/**
*/
Timing::Time
ProfilingGetTime()
{
// get current context and return time
ProfilingContext& ctx = profilingContexts[ProfilingContextIndex];
return ctx.timer.GetTime();
}
//------------------------------------------------------------------------------
/**
*/
void
ProfilingRegisterThread()
{
// make sure we don't add contexts simulatenously
Threading::CriticalScope lock(&categoryLock);
Threading::ThreadId thread = Threading::Thread::GetMyThreadId();
ProfilingContextIndex = ProfilingContextCounter.fetch_add(1);
profilingContexts.Append(ProfilingContext());
profilingContexts.Back().timer.Start();
contextMutexes.Append(Threading::AssertingMutex());
}
//------------------------------------------------------------------------------
/**
*/
const Util::Array<ProfilingScope>&
ProfilingGetScopes(Threading::ThreadId thread)
{
#if NEBULA_DEBUG
n_assert(profilingContexts[thread].topLevelScopes.IsEmpty());
#endif
Threading::CriticalScope lock(&categoryLock);
return profilingContexts[thread].topLevelScopes;
}
//------------------------------------------------------------------------------
/**
*/
const Util::Array<ProfilingContext>
ProfilingGetContexts()
{
return profilingContexts;
}
//------------------------------------------------------------------------------
/**
*/
void
ProfilingClear()
{
for (IndexT i = 0; i < profilingContexts.Size(); i++)
{
n_assert(profilingContexts[i].scopes.Size() == 0);
profilingContexts[i].topLevelScopes.Reset();
}
}
Threading::CriticalSection counterLock;
Util::Dictionary<const char*, uint64> counters;
//------------------------------------------------------------------------------
/**
*/
void
ProfilingIncreaseCounter(const char* id, uint64 value)
{
counterLock.Enter();
IndexT idx = counters.FindIndex(id);
if (idx == InvalidIndex)
counters.Add(id, value);
else
{
counters.ValueAtIndex(idx) += value;
}
counterLock.Leave();
}
//------------------------------------------------------------------------------
/**
*/
void
ProfilingDecreaseCounter(const char* id, uint64 value)
{
counterLock.Enter();
IndexT idx = counters.FindIndex(id);
n_assert(idx != InvalidIndex);
counters.ValueAtIndex(idx) -= value;
counterLock.Leave();
}
//------------------------------------------------------------------------------
/**
*/
const Util::Dictionary<const char*, uint64>&
ProfilingGetCounters()
{
return counters;
}
} // namespace Profiling
| 1,846 |
4,054 | <reponame>Anlon-Burke/vespa<gh_stars>1000+
// Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
package com.yahoo.jdisc.application;
import com.google.common.collect.ImmutableList;
import com.yahoo.jdisc.Container;
import com.yahoo.jdisc.service.ServerProvider;
import org.osgi.framework.Bundle;
import java.util.*;
import java.util.logging.Logger;
/**
* This is a repository of {@link ServerProvider}s. An instance of this class is owned by the {@link ContainerBuilder},
* and is used to configure the set of ServerProviders that eventually become part of the active {@link Container}.
*
* @author <NAME>
*/
public class ServerRepository implements Iterable<ServerProvider> {
private static final Logger log = Logger.getLogger(ServerRepository.class.getName());
private final List<ServerProvider> servers = new LinkedList<>();
private final GuiceRepository guice;
public ServerRepository(GuiceRepository guice) {
this.guice = guice;
}
public Iterable<ServerProvider> activate() { return ImmutableList.copyOf(servers); }
public List<ServerProvider> installAll(Bundle bundle, Iterable<String> serverNames) throws ClassNotFoundException {
List<ServerProvider> lst = new LinkedList<>();
for (String serverName : serverNames) {
lst.add(install(bundle, serverName));
}
return lst;
}
public ServerProvider install(Bundle bundle, String serverName) throws ClassNotFoundException {
log.finer("Installing server provider '" + serverName + "'.");
Class<?> namedClass = bundle.loadClass(serverName);
Class<ServerProvider> serverClass = ContainerBuilder.safeClassCast(ServerProvider.class, namedClass);
ServerProvider server = guice.getInstance(serverClass);
install(server);
return server;
}
public void installAll(Iterable<? extends ServerProvider> servers) {
for (ServerProvider server : servers) {
install(server);
}
}
public void install(ServerProvider server) {
servers.add(server);
}
public void uninstallAll(Iterable<? extends ServerProvider> handlers) {
for (ServerProvider handler : handlers) {
uninstall(handler);
}
}
public void uninstall(ServerProvider handler) {
servers.remove(handler);
}
public Collection<ServerProvider> collection() {
return Collections.unmodifiableCollection(servers);
}
@Override
public Iterator<ServerProvider> iterator() {
return collection().iterator();
}
}
| 883 |
679 | <gh_stars>100-1000
/**************************************************************
*
* 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.
*
*************************************************************/
#ifndef _GVFS_UCP_RESULTSET_HXX
#define _GVFS_UCP_RESULTSET_HXX
#include <rtl/ref.hxx>
#include <ucbhelper/resultset.hxx>
#include <ucbhelper/resultsethelper.hxx>
#include "gvfs_content.hxx"
namespace gvfs {
class DynamicResultSet : public ::ucbhelper::ResultSetImplHelper
{
rtl::Reference< Content > m_xContent;
com::sun::star::uno::Reference<
com::sun::star::ucb::XCommandEnvironment > m_xEnv;
private:
virtual void initStatic();
virtual void initDynamic();
public:
DynamicResultSet( const com::sun::star::uno::Reference<
com::sun::star::lang::XMultiServiceFactory >& rxSMgr,
const rtl::Reference< Content >& rxContent,
const com::sun::star::ucb::OpenCommandArgument2& rCommand,
const com::sun::star::uno::Reference<
com::sun::star::ucb::XCommandEnvironment >& rxEnv );
};
struct DataSupplier_Impl;
class DataSupplier : public ucbhelper::ResultSetDataSupplier
{
private:
gvfs::DataSupplier_Impl *m_pImpl;
sal_Bool getData();
public:
DataSupplier( const com::sun::star::uno::Reference<
com::sun::star::lang::XMultiServiceFactory >& rxSMgr,
const rtl::Reference< Content >& rContent,
sal_Int32 nOpenMode);
virtual ~DataSupplier();
virtual rtl::OUString queryContentIdentifierString( sal_uInt32 nIndex );
virtual com::sun::star::uno::Reference<
com::sun::star::ucb::XContentIdentifier >
queryContentIdentifier( sal_uInt32 nIndex );
virtual com::sun::star::uno::Reference< com::sun::star::ucb::XContent >
queryContent( sal_uInt32 nIndex );
virtual sal_Bool getResult( sal_uInt32 nIndex );
virtual sal_uInt32 totalCount();
virtual sal_uInt32 currentCount();
virtual sal_Bool isCountFinal();
virtual com::sun::star::uno::Reference< com::sun::star::sdbc::XRow >
queryPropertyValues( sal_uInt32 nIndex );
virtual void releasePropertyValues( sal_uInt32 nIndex );
virtual void close();
virtual void validate()
throw( com::sun::star::ucb::ResultSetException );
};
}
#endif
| 1,220 |
852 | import FWCore.ParameterSet.Config as cms
process = cms.Process("TEST")
process.load("FWCore.MessageLogger.MessageLogger_cfi")
process.CSCFakeDBGains = cms.ESSource("CSCFakeDBGains")
process.prefer("CSCFakeDBGains")
process.CSCFakeDBPedestals = cms.ESSource("CSCFakeDBPedestals")
process.prefer("CSCFakeDBPedestals")
process.CSCFakeDBNoiseMatrix = cms.ESSource("CSCFakeDBNoiseMatrix")
process.prefer("CSCFakeDBNoiseMatrix")
process.CSCFakeDBCrosstalk = cms.ESSource("CSCFakeDBCrosstalk")
process.prefer("CSCFakeDBCrosstalk")
process.maxEvents = cms.untracked.PSet(
input = cms.untracked.int32(1)
)
process.source = cms.Source("EmptySource")
process.prod1 = cms.EDAnalyzer("CSCGainsDBReadAnalyzer")
process.prod2 = cms.EDAnalyzer("CSCPedestalDBReadAnalyzer")
process.prod3 = cms.EDAnalyzer("CSCCrossTalkDBReadAnalyzer")
process.prod4 = cms.EDAnalyzer("CSCNoiseMatrixDBReadAnalyzer")
process.output = cms.OutputModule("AsciiOutputModule")
process.p = cms.Path(process.prod1*process.prod2*process.prod3*process.prod4)
process.ep = cms.EndPath(process.output)
| 419 |
575 | <filename>chrome/browser/ui/webui/settings/chromeos/device_name_handler_unittest.cc
// Copyright 2020 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 "chrome/browser/ui/webui/settings/chromeos/device_name_handler.h"
#include <memory>
#include <string>
#include "chrome/browser/chromeos/device_name_store.h"
#include "chrome/common/pref_names.h"
#include "components/prefs/testing_pref_service.h"
#include "content/public/test/browser_task_environment.h"
#include "content/public/test/test_web_ui.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace chromeos {
namespace settings {
class TestDeviceNameHandler : public DeviceNameHandler {
public:
explicit TestDeviceNameHandler(content::WebUI* web_ui) : DeviceNameHandler() {
set_web_ui(web_ui);
}
// Raise visibility to public.
void HandleGetDeviceNameMetadata(const base::ListValue* args) {
DeviceNameHandler::HandleGetDeviceNameMetadata(args);
}
};
class DeviceNameHandlerTest : public testing::Test {
public:
DeviceNameHandlerTest() = default;
void SetUp() override {
testing::Test::SetUp();
handler_ = std::make_unique<TestDeviceNameHandler>(web_ui());
handler()->AllowJavascriptForTesting();
web_ui()->ClearTrackedCalls();
DeviceNameStore::RegisterLocalStatePrefs(local_state_.registry());
local_state()->SetString(prefs::kDeviceName, "TestDeviceName");
DeviceNameStore::GetInstance()->Initialize(&local_state_);
}
TestDeviceNameHandler* handler() { return handler_.get(); }
content::TestWebUI* web_ui() { return &web_ui_; }
TestingPrefServiceSimple* local_state() { return &local_state_; }
private:
// Run on the UI thread.
content::BrowserTaskEnvironment task_environment_;
// Test backing store for prefs.
TestingPrefServiceSimple local_state_;
content::TestWebUI web_ui_;
std::unique_ptr<TestDeviceNameHandler> handler_;
};
TEST_F(DeviceNameHandlerTest, DeviceNameMetadata_DeviceName) {
base::ListValue args;
args.AppendString("callback-id");
handler()->HandleGetDeviceNameMetadata(&args);
const content::TestWebUI::CallData& call_data = *web_ui()->call_data().back();
EXPECT_EQ("cr.webUIResponse", call_data.function_name());
EXPECT_EQ("callback-id", call_data.arg1()->GetString());
EXPECT_TRUE(call_data.arg2()->GetBool());
const base::DictionaryValue* returned_data;
ASSERT_TRUE(call_data.arg3()->GetAsDictionary(&returned_data));
std::string device_name;
ASSERT_TRUE(returned_data->GetString("deviceName", &device_name));
EXPECT_EQ("TestDeviceName", device_name);
}
} // namespace settings
} // namespace chromeos
| 885 |
448 | /* This file was generated from a modified version UCData's ucgendat.
*
* DO NOT EDIT THIS FILE!
*
* Instead, compile ucgendat.c (bundled with PHP in ext/mbstring), download
* the appropriate UnicodeData-x.x.x.txt and CompositionExclusions-x.x.x.txt
* files from http://www.unicode.org/Public/ and run this program.
*
* More information can be found in the UCData package. Unfortunately,
* the project's page doesn't seem to be live anymore, so you can use
* OpenLDAPs modified copy (look in libraries/liblunicode/ucdata) */
static const unsigned short _ucprop_size = 44;
static const unsigned short _ucprop_offsets[] = {
0x0000, 0x0272, 0x03be, 0x03c8, 0x043a, 0x0452, 0x04d8, 0x04e6,
0x04e8, 0x04ea, 0x04ee, 0x0514, 0x0516, 0xffff, 0x051c, 0x0a0a,
0x0f06, 0x0f1a, 0x0f8c, 0x1338, 0x1344, 0x1366, 0x13fc, 0x148c,
0x15ea, 0x166a, 0x1690, 0x16ca, 0x1826, 0x1d74, 0x1df6, 0x1e0e,
0x1e20, 0x1e4c, 0x1e5a, 0x1e74, 0x1e7e, 0x1e84, 0x1e92, 0x2256,
0x226c, 0x2280, 0x22fa, 0x2410, 0x2724, 0x0000, 0x0000, 0x0000
};
static const unsigned int _ucprop_ranges[] = {
0x00000300, 0x0000036f, 0x00000483, 0x00000487,
0x00000591, 0x000005bd, 0x000005bf, 0x000005bf,
0x000005c1, 0x000005c2, 0x000005c4, 0x000005c5,
0x000005c7, 0x000005c7, 0x00000610, 0x0000061a,
0x0000064b, 0x0000065f, 0x00000670, 0x00000670,
0x000006d6, 0x000006dc, 0x000006df, 0x000006e4,
0x000006e7, 0x000006e8, 0x000006ea, 0x000006ed,
0x00000711, 0x00000711, 0x00000730, 0x0000074a,
0x000007a6, 0x000007b0, 0x000007eb, 0x000007f3,
0x000007fd, 0x000007fd, 0x00000816, 0x00000819,
0x0000081b, 0x00000823, 0x00000825, 0x00000827,
0x00000829, 0x0000082d, 0x00000859, 0x0000085b,
0x000008d3, 0x000008e1, 0x000008e3, 0x00000902,
0x0000093a, 0x0000093a, 0x0000093c, 0x0000093c,
0x00000941, 0x00000948, 0x0000094d, 0x0000094d,
0x00000951, 0x00000957, 0x00000962, 0x00000963,
0x00000981, 0x00000981, 0x000009bc, 0x000009bc,
0x000009c1, 0x000009c4, 0x000009cd, 0x000009cd,
0x000009e2, 0x000009e3, 0x000009fe, 0x000009fe,
0x00000a01, 0x00000a02, 0x00000a3c, 0x00000a3c,
0x00000a41, 0x00000a42, 0x00000a47, 0x00000a48,
0x00000a4b, 0x00000a4d, 0x00000a51, 0x00000a51,
0x00000a70, 0x00000a71, 0x00000a75, 0x00000a75,
0x00000a81, 0x00000a82, 0x00000abc, 0x00000abc,
0x00000ac1, 0x00000ac5, 0x00000ac7, 0x00000ac8,
0x00000acd, 0x00000acd, 0x00000ae2, 0x00000ae3,
0x00000afa, 0x00000aff, 0x00000b01, 0x00000b01,
0x00000b3c, 0x00000b3c, 0x00000b3f, 0x00000b3f,
0x00000b41, 0x00000b44, 0x00000b4d, 0x00000b4d,
0x00000b56, 0x00000b56, 0x00000b62, 0x00000b63,
0x00000b82, 0x00000b82, 0x00000bc0, 0x00000bc0,
0x00000bcd, 0x00000bcd, 0x00000c00, 0x00000c00,
0x00000c04, 0x00000c04, 0x00000c3e, 0x00000c40,
0x00000c46, 0x00000c48, 0x00000c4a, 0x00000c4d,
0x00000c55, 0x00000c56, 0x00000c62, 0x00000c63,
0x00000c81, 0x00000c81, 0x00000cbc, 0x00000cbc,
0x00000cbf, 0x00000cbf, 0x00000cc6, 0x00000cc6,
0x00000ccc, 0x00000ccd, 0x00000ce2, 0x00000ce3,
0x00000d00, 0x00000d01, 0x00000d3b, 0x00000d3c,
0x00000d41, 0x00000d44, 0x00000d4d, 0x00000d4d,
0x00000d62, 0x00000d63, 0x00000dca, 0x00000dca,
0x00000dd2, 0x00000dd4, 0x00000dd6, 0x00000dd6,
0x00000e31, 0x00000e31, 0x00000e34, 0x00000e3a,
0x00000e47, 0x00000e4e, 0x00000eb1, 0x00000eb1,
0x00000eb4, 0x00000eb9, 0x00000ebb, 0x00000ebc,
0x00000ec8, 0x00000ecd, 0x00000f18, 0x00000f19,
0x00000f35, 0x00000f35, 0x00000f37, 0x00000f37,
0x00000f39, 0x00000f39, 0x00000f71, 0x00000f7e,
0x00000f80, 0x00000f84, 0x00000f86, 0x00000f87,
0x00000f8d, 0x00000f97, 0x00000f99, 0x00000fbc,
0x00000fc6, 0x00000fc6, 0x0000102d, 0x00001030,
0x00001032, 0x00001037, 0x00001039, 0x0000103a,
0x0000103d, 0x0000103e, 0x00001058, 0x00001059,
0x0000105e, 0x00001060, 0x00001071, 0x00001074,
0x00001082, 0x00001082, 0x00001085, 0x00001086,
0x0000108d, 0x0000108d, 0x0000109d, 0x0000109d,
0x0000135d, 0x0000135f, 0x00001712, 0x00001714,
0x00001732, 0x00001734, 0x00001752, 0x00001753,
0x00001772, 0x00001773, 0x000017b4, 0x000017b5,
0x000017b7, 0x000017bd, 0x000017c6, 0x000017c6,
0x000017c9, 0x000017d3, 0x000017dd, 0x000017dd,
0x0000180b, 0x0000180d, 0x00001885, 0x00001886,
0x000018a9, 0x000018a9, 0x00001920, 0x00001922,
0x00001927, 0x00001928, 0x00001932, 0x00001932,
0x00001939, 0x0000193b, 0x00001a17, 0x00001a18,
0x00001a1b, 0x00001a1b, 0x00001a56, 0x00001a56,
0x00001a58, 0x00001a5e, 0x00001a60, 0x00001a60,
0x00001a62, 0x00001a62, 0x00001a65, 0x00001a6c,
0x00001a73, 0x00001a7c, 0x00001a7f, 0x00001a7f,
0x00001ab0, 0x00001abd, 0x00001b00, 0x00001b03,
0x00001b34, 0x00001b34, 0x00001b36, 0x00001b3a,
0x00001b3c, 0x00001b3c, 0x00001b42, 0x00001b42,
0x00001b6b, 0x00001b73, 0x00001b80, 0x00001b81,
0x00001ba2, 0x00001ba5, 0x00001ba8, 0x00001ba9,
0x00001bab, 0x00001bad, 0x00001be6, 0x00001be6,
0x00001be8, 0x00001be9, 0x00001bed, 0x00001bed,
0x00001bef, 0x00001bf1, 0x00001c2c, 0x00001c33,
0x00001c36, 0x00001c37, 0x00001cd0, 0x00001cd2,
0x00001cd4, 0x00001ce0, 0x00001ce2, 0x00001ce8,
0x00001ced, 0x00001ced, 0x00001cf4, 0x00001cf4,
0x00001cf8, 0x00001cf9, 0x00001dc0, 0x00001df9,
0x00001dfb, 0x00001dff, 0x000020d0, 0x000020dc,
0x000020e1, 0x000020e1, 0x000020e5, 0x000020f0,
0x00002cef, 0x00002cf1, 0x00002d7f, 0x00002d7f,
0x00002de0, 0x00002dff, 0x0000302a, 0x0000302d,
0x00003099, 0x0000309a, 0x0000a66f, 0x0000a66f,
0x0000a674, 0x0000a67d, 0x0000a69e, 0x0000a69f,
0x0000a6f0, 0x0000a6f1, 0x0000a802, 0x0000a802,
0x0000a806, 0x0000a806, 0x0000a80b, 0x0000a80b,
0x0000a825, 0x0000a826, 0x0000a8c4, 0x0000a8c5,
0x0000a8e0, 0x0000a8f1, 0x0000a8ff, 0x0000a8ff,
0x0000a926, 0x0000a92d, 0x0000a947, 0x0000a951,
0x0000a980, 0x0000a982, 0x0000a9b3, 0x0000a9b3,
0x0000a9b6, 0x0000a9b9, 0x0000a9bc, 0x0000a9bc,
0x0000a9e5, 0x0000a9e5, 0x0000aa29, 0x0000aa2e,
0x0000aa31, 0x0000aa32, 0x0000aa35, 0x0000aa36,
0x0000aa43, 0x0000aa43, 0x0000aa4c, 0x0000aa4c,
0x0000aa7c, 0x0000aa7c, 0x0000aab0, 0x0000aab0,
0x0000aab2, 0x0000aab4, 0x0000aab7, 0x0000aab8,
0x0000aabe, 0x0000aabf, 0x0000aac1, 0x0000aac1,
0x0000aaec, 0x0000aaed, 0x0000aaf6, 0x0000aaf6,
0x0000abe5, 0x0000abe5, 0x0000abe8, 0x0000abe8,
0x0000abed, 0x0000abed, 0x0000fb1e, 0x0000fb1e,
0x0000fe00, 0x0000fe0f, 0x0000fe20, 0x0000fe2f,
0x000101fd, 0x000101fd, 0x000102e0, 0x000102e0,
0x00010376, 0x0001037a, 0x00010a01, 0x00010a03,
0x00010a05, 0x00010a06, 0x00010a0c, 0x00010a0f,
0x00010a38, 0x00010a3a, 0x00010a3f, 0x00010a3f,
0x00010ae5, 0x00010ae6, 0x00010d24, 0x00010d27,
0x00010f46, 0x00010f50, 0x00011001, 0x00011001,
0x00011038, 0x00011046, 0x0001107f, 0x00011081,
0x000110b3, 0x000110b6, 0x000110b9, 0x000110ba,
0x00011100, 0x00011102, 0x00011127, 0x0001112b,
0x0001112d, 0x00011134, 0x00011173, 0x00011173,
0x00011180, 0x00011181, 0x000111b6, 0x000111be,
0x000111c9, 0x000111cc, 0x0001122f, 0x00011231,
0x00011234, 0x00011234, 0x00011236, 0x00011237,
0x0001123e, 0x0001123e, 0x000112df, 0x000112df,
0x000112e3, 0x000112ea, 0x00011300, 0x00011301,
0x0001133b, 0x0001133c, 0x00011340, 0x00011340,
0x00011366, 0x0001136c, 0x00011370, 0x00011374,
0x00011438, 0x0001143f, 0x00011442, 0x00011444,
0x00011446, 0x00011446, 0x0001145e, 0x0001145e,
0x000114b3, 0x000114b8, 0x000114ba, 0x000114ba,
0x000114bf, 0x000114c0, 0x000114c2, 0x000114c3,
0x000115b2, 0x000115b5, 0x000115bc, 0x000115bd,
0x000115bf, 0x000115c0, 0x000115dc, 0x000115dd,
0x00011633, 0x0001163a, 0x0001163d, 0x0001163d,
0x0001163f, 0x00011640, 0x000116ab, 0x000116ab,
0x000116ad, 0x000116ad, 0x000116b0, 0x000116b5,
0x000116b7, 0x000116b7, 0x0001171d, 0x0001171f,
0x00011722, 0x00011725, 0x00011727, 0x0001172b,
0x0001182f, 0x00011837, 0x00011839, 0x0001183a,
0x00011a01, 0x00011a0a, 0x00011a33, 0x00011a38,
0x00011a3b, 0x00011a3e, 0x00011a47, 0x00011a47,
0x00011a51, 0x00011a56, 0x00011a59, 0x00011a5b,
0x00011a8a, 0x00011a96, 0x00011a98, 0x00011a99,
0x00011c30, 0x00011c36, 0x00011c38, 0x00011c3d,
0x00011c3f, 0x00011c3f, 0x00011c92, 0x00011ca7,
0x00011caa, 0x00011cb0, 0x00011cb2, 0x00011cb3,
0x00011cb5, 0x00011cb6, 0x00011d31, 0x00011d36,
0x00011d3a, 0x00011d3a, 0x00011d3c, 0x00011d3d,
0x00011d3f, 0x00011d45, 0x00011d47, 0x00011d47,
0x00011d90, 0x00011d91, 0x00011d95, 0x00011d95,
0x00011d97, 0x00011d97, 0x00011ef3, 0x00011ef4,
0x00016af0, 0x00016af4, 0x00016b30, 0x00016b36,
0x00016f8f, 0x00016f92, 0x0001bc9d, 0x0001bc9e,
0x0001d167, 0x0001d169, 0x0001d17b, 0x0001d182,
0x0001d185, 0x0001d18b, 0x0001d1aa, 0x0001d1ad,
0x0001d242, 0x0001d244, 0x0001da00, 0x0001da36,
0x0001da3b, 0x0001da6c, 0x0001da75, 0x0001da75,
0x0001da84, 0x0001da84, 0x0001da9b, 0x0001da9f,
0x0001daa1, 0x0001daaf, 0x0001e000, 0x0001e006,
0x0001e008, 0x0001e018, 0x0001e01b, 0x0001e021,
0x0001e023, 0x0001e024, 0x0001e026, 0x0001e02a,
0x0001e8d0, 0x0001e8d6, 0x0001e944, 0x0001e94a,
0x000e0100, 0x000e01ef, 0x00000903, 0x00000903,
0x0000093b, 0x0000093b, 0x0000093e, 0x00000940,
0x00000949, 0x0000094c, 0x0000094e, 0x0000094f,
0x00000982, 0x00000983, 0x000009be, 0x000009c0,
0x000009c7, 0x000009c8, 0x000009cb, 0x000009cc,
0x000009d7, 0x000009d7, 0x00000a03, 0x00000a03,
0x00000a3e, 0x00000a40, 0x00000a83, 0x00000a83,
0x00000abe, 0x00000ac0, 0x00000ac9, 0x00000ac9,
0x00000acb, 0x00000acc, 0x00000b02, 0x00000b03,
0x00000b3e, 0x00000b3e, 0x00000b40, 0x00000b40,
0x00000b47, 0x00000b48, 0x00000b4b, 0x00000b4c,
0x00000b57, 0x00000b57, 0x00000bbe, 0x00000bbf,
0x00000bc1, 0x00000bc2, 0x00000bc6, 0x00000bc8,
0x00000bca, 0x00000bcc, 0x00000bd7, 0x00000bd7,
0x00000c01, 0x00000c03, 0x00000c41, 0x00000c44,
0x00000c82, 0x00000c83, 0x00000cbe, 0x00000cbe,
0x00000cc0, 0x00000cc4, 0x00000cc7, 0x00000cc8,
0x00000cca, 0x00000ccb, 0x00000cd5, 0x00000cd6,
0x00000d02, 0x00000d03, 0x00000d3e, 0x00000d40,
0x00000d46, 0x00000d48, 0x00000d4a, 0x00000d4c,
0x00000d57, 0x00000d57, 0x00000d82, 0x00000d83,
0x00000dcf, 0x00000dd1, 0x00000dd8, 0x00000ddf,
0x00000df2, 0x00000df3, 0x00000f3e, 0x00000f3f,
0x00000f7f, 0x00000f7f, 0x0000102b, 0x0000102c,
0x00001031, 0x00001031, 0x00001038, 0x00001038,
0x0000103b, 0x0000103c, 0x00001056, 0x00001057,
0x00001062, 0x00001064, 0x00001067, 0x0000106d,
0x00001083, 0x00001084, 0x00001087, 0x0000108c,
0x0000108f, 0x0000108f, 0x0000109a, 0x0000109c,
0x000017b6, 0x000017b6, 0x000017be, 0x000017c5,
0x000017c7, 0x000017c8, 0x00001923, 0x00001926,
0x00001929, 0x0000192b, 0x00001930, 0x00001931,
0x00001933, 0x00001938, 0x00001a19, 0x00001a1a,
0x00001a55, 0x00001a55, 0x00001a57, 0x00001a57,
0x00001a61, 0x00001a61, 0x00001a63, 0x00001a64,
0x00001a6d, 0x00001a72, 0x00001b04, 0x00001b04,
0x00001b35, 0x00001b35, 0x00001b3b, 0x00001b3b,
0x00001b3d, 0x00001b41, 0x00001b43, 0x00001b44,
0x00001b82, 0x00001b82, 0x00001ba1, 0x00001ba1,
0x00001ba6, 0x00001ba7, 0x00001baa, 0x00001baa,
0x00001be7, 0x00001be7, 0x00001bea, 0x00001bec,
0x00001bee, 0x00001bee, 0x00001bf2, 0x00001bf3,
0x00001c24, 0x00001c2b, 0x00001c34, 0x00001c35,
0x00001ce1, 0x00001ce1, 0x00001cf2, 0x00001cf3,
0x00001cf7, 0x00001cf7, 0x0000302e, 0x0000302f,
0x0000a823, 0x0000a824, 0x0000a827, 0x0000a827,
0x0000a880, 0x0000a881, 0x0000a8b4, 0x0000a8c3,
0x0000a952, 0x0000a953, 0x0000a983, 0x0000a983,
0x0000a9b4, 0x0000a9b5, 0x0000a9ba, 0x0000a9bb,
0x0000a9bd, 0x0000a9c0, 0x0000aa2f, 0x0000aa30,
0x0000aa33, 0x0000aa34, 0x0000aa4d, 0x0000aa4d,
0x0000aa7b, 0x0000aa7b, 0x0000aa7d, 0x0000aa7d,
0x0000aaeb, 0x0000aaeb, 0x0000aaee, 0x0000aaef,
0x0000aaf5, 0x0000aaf5, 0x0000abe3, 0x0000abe4,
0x0000abe6, 0x0000abe7, 0x0000abe9, 0x0000abea,
0x0000abec, 0x0000abec, 0x00011000, 0x00011000,
0x00011002, 0x00011002, 0x00011082, 0x00011082,
0x000110b0, 0x000110b2, 0x000110b7, 0x000110b8,
0x0001112c, 0x0001112c, 0x00011145, 0x00011146,
0x00011182, 0x00011182, 0x000111b3, 0x000111b5,
0x000111bf, 0x000111c0, 0x0001122c, 0x0001122e,
0x00011232, 0x00011233, 0x00011235, 0x00011235,
0x000112e0, 0x000112e2, 0x00011302, 0x00011303,
0x0001133e, 0x0001133f, 0x00011341, 0x00011344,
0x00011347, 0x00011348, 0x0001134b, 0x0001134d,
0x00011357, 0x00011357, 0x00011362, 0x00011363,
0x00011435, 0x00011437, 0x00011440, 0x00011441,
0x00011445, 0x00011445, 0x000114b0, 0x000114b2,
0x000114b9, 0x000114b9, 0x000114bb, 0x000114be,
0x000114c1, 0x000114c1, 0x000115af, 0x000115b1,
0x000115b8, 0x000115bb, 0x000115be, 0x000115be,
0x00011630, 0x00011632, 0x0001163b, 0x0001163c,
0x0001163e, 0x0001163e, 0x000116ac, 0x000116ac,
0x000116ae, 0x000116af, 0x000116b6, 0x000116b6,
0x00011720, 0x00011721, 0x00011726, 0x00011726,
0x0001182c, 0x0001182e, 0x00011838, 0x00011838,
0x00011a39, 0x00011a39, 0x00011a57, 0x00011a58,
0x00011a97, 0x00011a97, 0x00011c2f, 0x00011c2f,
0x00011c3e, 0x00011c3e, 0x00011ca9, 0x00011ca9,
0x00011cb1, 0x00011cb1, 0x00011cb4, 0x00011cb4,
0x00011d8a, 0x00011d8e, 0x00011d93, 0x00011d94,
0x00011d96, 0x00011d96, 0x00011ef5, 0x00011ef6,
0x00016f51, 0x00016f7e, 0x0001d165, 0x0001d166,
0x0001d16d, 0x0001d172, 0x00000488, 0x00000489,
0x00001abe, 0x00001abe, 0x000020dd, 0x000020e0,
0x000020e2, 0x000020e4, 0x0000a670, 0x0000a672,
0x00000030, 0x00000039, 0x00000660, 0x00000669,
0x000006f0, 0x000006f9, 0x000007c0, 0x000007c9,
0x00000966, 0x0000096f, 0x000009e6, 0x000009ef,
0x00000a66, 0x00000a6f, 0x00000ae6, 0x00000aef,
0x00000b66, 0x00000b6f, 0x00000be6, 0x00000bef,
0x00000c66, 0x00000c6f, 0x00000ce6, 0x00000cef,
0x00000d66, 0x00000d6f, 0x00000de6, 0x00000def,
0x00000e50, 0x00000e59, 0x00000ed0, 0x00000ed9,
0x00000f20, 0x00000f29, 0x00001040, 0x00001049,
0x00001090, 0x00001099, 0x000017e0, 0x000017e9,
0x00001810, 0x00001819, 0x00001946, 0x0000194f,
0x000019d0, 0x000019d9, 0x00001a80, 0x00001a89,
0x00001a90, 0x00001a99, 0x00001b50, 0x00001b59,
0x00001bb0, 0x00001bb9, 0x00001c40, 0x00001c49,
0x00001c50, 0x00001c59, 0x0000a620, 0x0000a629,
0x0000a8d0, 0x0000a8d9, 0x0000a900, 0x0000a909,
0x0000a9d0, 0x0000a9d9, 0x0000a9f0, 0x0000a9f9,
0x0000aa50, 0x0000aa59, 0x0000abf0, 0x0000abf9,
0x0000ff10, 0x0000ff19, 0x000104a0, 0x000104a9,
0x00010d30, 0x00010d39, 0x00011066, 0x0001106f,
0x000110f0, 0x000110f9, 0x00011136, 0x0001113f,
0x000111d0, 0x000111d9, 0x000112f0, 0x000112f9,
0x00011450, 0x00011459, 0x000114d0, 0x000114d9,
0x00011650, 0x00011659, 0x000116c0, 0x000116c9,
0x00011730, 0x00011739, 0x000118e0, 0x000118e9,
0x00011c50, 0x00011c59, 0x00011d50, 0x00011d59,
0x00011da0, 0x00011da9, 0x00016a60, 0x00016a69,
0x00016b50, 0x00016b59, 0x0001d7ce, 0x0001d7ff,
0x0001e950, 0x0001e959, 0x000016ee, 0x000016f0,
0x00002160, 0x00002182, 0x00002185, 0x00002188,
0x00003007, 0x00003007, 0x00003021, 0x00003029,
0x00003038, 0x0000303a, 0x0000a6e6, 0x0000a6ef,
0x00010140, 0x00010174, 0x00010341, 0x00010341,
0x0001034a, 0x0001034a, 0x000103d1, 0x000103d5,
0x00012400, 0x0001246e, 0x000000b2, 0x000000b3,
0x000000b9, 0x000000b9, 0x000000bc, 0x000000be,
0x000009f4, 0x000009f9, 0x00000b72, 0x00000b77,
0x00000bf0, 0x00000bf2, 0x00000c78, 0x00000c7e,
0x00000d58, 0x00000d5e, 0x00000d70, 0x00000d78,
0x00000f2a, 0x00000f33, 0x00001369, 0x0000137c,
0x000017f0, 0x000017f9, 0x000019da, 0x000019da,
0x00002070, 0x00002070, 0x00002074, 0x00002079,
0x00002080, 0x00002089, 0x00002150, 0x0000215f,
0x00002189, 0x00002189, 0x00002460, 0x0000249b,
0x000024ea, 0x000024ff, 0x00002776, 0x00002793,
0x00002cfd, 0x00002cfd, 0x00003192, 0x00003195,
0x00003220, 0x00003229, 0x00003248, 0x0000324f,
0x00003251, 0x0000325f, 0x00003280, 0x00003289,
0x000032b1, 0x000032bf, 0x0000a830, 0x0000a835,
0x00010107, 0x00010133, 0x00010175, 0x00010178,
0x0001018a, 0x0001018b, 0x000102e1, 0x000102fb,
0x00010320, 0x00010323, 0x00010858, 0x0001085f,
0x00010879, 0x0001087f, 0x000108a7, 0x000108af,
0x000108fb, 0x000108ff, 0x00010916, 0x0001091b,
0x000109bc, 0x000109bd, 0x000109c0, 0x000109cf,
0x000109d2, 0x000109ff, 0x00010a40, 0x00010a48,
0x00010a7d, 0x00010a7e, 0x00010a9d, 0x00010a9f,
0x00010aeb, 0x00010aef, 0x00010b58, 0x00010b5f,
0x00010b78, 0x00010b7f, 0x00010ba9, 0x00010baf,
0x00010cfa, 0x00010cff, 0x00010e60, 0x00010e7e,
0x00010f1d, 0x00010f26, 0x00010f51, 0x00010f54,
0x00011052, 0x00011065, 0x000111e1, 0x000111f4,
0x0001173a, 0x0001173b, 0x000118ea, 0x000118f2,
0x00011c5a, 0x00011c6c, 0x00016b5b, 0x00016b61,
0x00016e80, 0x00016e96, 0x0001d2e0, 0x0001d2f3,
0x0001d360, 0x0001d378, 0x0001e8c7, 0x0001e8cf,
0x0001ec71, 0x0001ecab, 0x0001ecad, 0x0001ecaf,
0x0001ecb1, 0x0001ecb4, 0x0001f100, 0x0001f10c,
0x00000020, 0x00000020, 0x000000a0, 0x000000a0,
0x00001680, 0x00001680, 0x00002000, 0x0000200a,
0x0000202f, 0x0000202f, 0x0000205f, 0x0000205f,
0x00003000, 0x00003000, 0x00002028, 0x00002028,
0x00002029, 0x00002029, 0x00000000, 0x0000001f,
0x0000007f, 0x0000009f, 0x000000ad, 0x000000ad,
0x00000600, 0x00000605, 0x0000061c, 0x0000061c,
0x000006dd, 0x000006dd, 0x0000070f, 0x0000070f,
0x000008e2, 0x000008e2, 0x0000180e, 0x0000180e,
0x0000200b, 0x0000200f, 0x0000202a, 0x0000202e,
0x00002060, 0x00002064, 0x00002066, 0x0000206f,
0x0000feff, 0x0000feff, 0x0000fff9, 0x0000fffb,
0x000110bd, 0x000110bd, 0x000110cd, 0x000110cd,
0x0001bca0, 0x0001bca3, 0x0001d173, 0x0001d17a,
0x000e0001, 0x000e0001, 0x000e0020, 0x000e007f,
0x0000d800, 0x0000dfff, 0x0000e000, 0x0000f8ff,
0x000f0000, 0x000ffffd, 0x00100000, 0x0010fffd,
0x00000041, 0x0000005a, 0x000000c0, 0x000000d6,
0x000000d8, 0x000000de, 0x00000100, 0x00000100,
0x00000102, 0x00000102, 0x00000104, 0x00000104,
0x00000106, 0x00000106, 0x00000108, 0x00000108,
0x0000010a, 0x0000010a, 0x0000010c, 0x0000010c,
0x0000010e, 0x0000010e, 0x00000110, 0x00000110,
0x00000112, 0x00000112, 0x00000114, 0x00000114,
0x00000116, 0x00000116, 0x00000118, 0x00000118,
0x0000011a, 0x0000011a, 0x0000011c, 0x0000011c,
0x0000011e, 0x0000011e, 0x00000120, 0x00000120,
0x00000122, 0x00000122, 0x00000124, 0x00000124,
0x00000126, 0x00000126, 0x00000128, 0x00000128,
0x0000012a, 0x0000012a, 0x0000012c, 0x0000012c,
0x0000012e, 0x0000012e, 0x00000130, 0x00000130,
0x00000132, 0x00000132, 0x00000134, 0x00000134,
0x00000136, 0x00000136, 0x00000139, 0x00000139,
0x0000013b, 0x0000013b, 0x0000013d, 0x0000013d,
0x0000013f, 0x0000013f, 0x00000141, 0x00000141,
0x00000143, 0x00000143, 0x00000145, 0x00000145,
0x00000147, 0x00000147, 0x0000014a, 0x0000014a,
0x0000014c, 0x0000014c, 0x0000014e, 0x0000014e,
0x00000150, 0x00000150, 0x00000152, 0x00000152,
0x00000154, 0x00000154, 0x00000156, 0x00000156,
0x00000158, 0x00000158, 0x0000015a, 0x0000015a,
0x0000015c, 0x0000015c, 0x0000015e, 0x0000015e,
0x00000160, 0x00000160, 0x00000162, 0x00000162,
0x00000164, 0x00000164, 0x00000166, 0x00000166,
0x00000168, 0x00000168, 0x0000016a, 0x0000016a,
0x0000016c, 0x0000016c, 0x0000016e, 0x0000016e,
0x00000170, 0x00000170, 0x00000172, 0x00000172,
0x00000174, 0x00000174, 0x00000176, 0x00000176,
0x00000178, 0x00000179, 0x0000017b, 0x0000017b,
0x0000017d, 0x0000017d, 0x00000181, 0x00000182,
0x00000184, 0x00000184, 0x00000186, 0x00000187,
0x00000189, 0x0000018b, 0x0000018e, 0x00000191,
0x00000193, 0x00000194, 0x00000196, 0x00000198,
0x0000019c, 0x0000019d, 0x0000019f, 0x000001a0,
0x000001a2, 0x000001a2, 0x000001a4, 0x000001a4,
0x000001a6, 0x000001a7, 0x000001a9, 0x000001a9,
0x000001ac, 0x000001ac, 0x000001ae, 0x000001af,
0x000001b1, 0x000001b3, 0x000001b5, 0x000001b5,
0x000001b7, 0x000001b8, 0x000001bc, 0x000001bc,
0x000001c4, 0x000001c4, 0x000001c7, 0x000001c7,
0x000001ca, 0x000001ca, 0x000001cd, 0x000001cd,
0x000001cf, 0x000001cf, 0x000001d1, 0x000001d1,
0x000001d3, 0x000001d3, 0x000001d5, 0x000001d5,
0x000001d7, 0x000001d7, 0x000001d9, 0x000001d9,
0x000001db, 0x000001db, 0x000001de, 0x000001de,
0x000001e0, 0x000001e0, 0x000001e2, 0x000001e2,
0x000001e4, 0x000001e4, 0x000001e6, 0x000001e6,
0x000001e8, 0x000001e8, 0x000001ea, 0x000001ea,
0x000001ec, 0x000001ec, 0x000001ee, 0x000001ee,
0x000001f1, 0x000001f1, 0x000001f4, 0x000001f4,
0x000001f6, 0x000001f8, 0x000001fa, 0x000001fa,
0x000001fc, 0x000001fc, 0x000001fe, 0x000001fe,
0x00000200, 0x00000200, 0x00000202, 0x00000202,
0x00000204, 0x00000204, 0x00000206, 0x00000206,
0x00000208, 0x00000208, 0x0000020a, 0x0000020a,
0x0000020c, 0x0000020c, 0x0000020e, 0x0000020e,
0x00000210, 0x00000210, 0x00000212, 0x00000212,
0x00000214, 0x00000214, 0x00000216, 0x00000216,
0x00000218, 0x00000218, 0x0000021a, 0x0000021a,
0x0000021c, 0x0000021c, 0x0000021e, 0x0000021e,
0x00000220, 0x00000220, 0x00000222, 0x00000222,
0x00000224, 0x00000224, 0x00000226, 0x00000226,
0x00000228, 0x00000228, 0x0000022a, 0x0000022a,
0x0000022c, 0x0000022c, 0x0000022e, 0x0000022e,
0x00000230, 0x00000230, 0x00000232, 0x00000232,
0x0000023a, 0x0000023b, 0x0000023d, 0x0000023e,
0x00000241, 0x00000241, 0x00000243, 0x00000246,
0x00000248, 0x00000248, 0x0000024a, 0x0000024a,
0x0000024c, 0x0000024c, 0x0000024e, 0x0000024e,
0x00000370, 0x00000370, 0x00000372, 0x00000372,
0x00000376, 0x00000376, 0x0000037f, 0x0000037f,
0x00000386, 0x00000386, 0x00000388, 0x0000038a,
0x0000038c, 0x0000038c, 0x0000038e, 0x0000038f,
0x00000391, 0x000003a1, 0x000003a3, 0x000003ab,
0x000003cf, 0x000003cf, 0x000003d2, 0x000003d4,
0x000003d8, 0x000003d8, 0x000003da, 0x000003da,
0x000003dc, 0x000003dc, 0x000003de, 0x000003de,
0x000003e0, 0x000003e0, 0x000003e2, 0x000003e2,
0x000003e4, 0x000003e4, 0x000003e6, 0x000003e6,
0x000003e8, 0x000003e8, 0x000003ea, 0x000003ea,
0x000003ec, 0x000003ec, 0x000003ee, 0x000003ee,
0x000003f4, 0x000003f4, 0x000003f7, 0x000003f7,
0x000003f9, 0x000003fa, 0x000003fd, 0x0000042f,
0x00000460, 0x00000460, 0x00000462, 0x00000462,
0x00000464, 0x00000464, 0x00000466, 0x00000466,
0x00000468, 0x00000468, 0x0000046a, 0x0000046a,
0x0000046c, 0x0000046c, 0x0000046e, 0x0000046e,
0x00000470, 0x00000470, 0x00000472, 0x00000472,
0x00000474, 0x00000474, 0x00000476, 0x00000476,
0x00000478, 0x00000478, 0x0000047a, 0x0000047a,
0x0000047c, 0x0000047c, 0x0000047e, 0x0000047e,
0x00000480, 0x00000480, 0x0000048a, 0x0000048a,
0x0000048c, 0x0000048c, 0x0000048e, 0x0000048e,
0x00000490, 0x00000490, 0x00000492, 0x00000492,
0x00000494, 0x00000494, 0x00000496, 0x00000496,
0x00000498, 0x00000498, 0x0000049a, 0x0000049a,
0x0000049c, 0x0000049c, 0x0000049e, 0x0000049e,
0x000004a0, 0x000004a0, 0x000004a2, 0x000004a2,
0x000004a4, 0x000004a4, 0x000004a6, 0x000004a6,
0x000004a8, 0x000004a8, 0x000004aa, 0x000004aa,
0x000004ac, 0x000004ac, 0x000004ae, 0x000004ae,
0x000004b0, 0x000004b0, 0x000004b2, 0x000004b2,
0x000004b4, 0x000004b4, 0x000004b6, 0x000004b6,
0x000004b8, 0x000004b8, 0x000004ba, 0x000004ba,
0x000004bc, 0x000004bc, 0x000004be, 0x000004be,
0x000004c0, 0x000004c1, 0x000004c3, 0x000004c3,
0x000004c5, 0x000004c5, 0x000004c7, 0x000004c7,
0x000004c9, 0x000004c9, 0x000004cb, 0x000004cb,
0x000004cd, 0x000004cd, 0x000004d0, 0x000004d0,
0x000004d2, 0x000004d2, 0x000004d4, 0x000004d4,
0x000004d6, 0x000004d6, 0x000004d8, 0x000004d8,
0x000004da, 0x000004da, 0x000004dc, 0x000004dc,
0x000004de, 0x000004de, 0x000004e0, 0x000004e0,
0x000004e2, 0x000004e2, 0x000004e4, 0x000004e4,
0x000004e6, 0x000004e6, 0x000004e8, 0x000004e8,
0x000004ea, 0x000004ea, 0x000004ec, 0x000004ec,
0x000004ee, 0x000004ee, 0x000004f0, 0x000004f0,
0x000004f2, 0x000004f2, 0x000004f4, 0x000004f4,
0x000004f6, 0x000004f6, 0x000004f8, 0x000004f8,
0x000004fa, 0x000004fa, 0x000004fc, 0x000004fc,
0x000004fe, 0x000004fe, 0x00000500, 0x00000500,
0x00000502, 0x00000502, 0x00000504, 0x00000504,
0x00000506, 0x00000506, 0x00000508, 0x00000508,
0x0000050a, 0x0000050a, 0x0000050c, 0x0000050c,
0x0000050e, 0x0000050e, 0x00000510, 0x00000510,
0x00000512, 0x00000512, 0x00000514, 0x00000514,
0x00000516, 0x00000516, 0x00000518, 0x00000518,
0x0000051a, 0x0000051a, 0x0000051c, 0x0000051c,
0x0000051e, 0x0000051e, 0x00000520, 0x00000520,
0x00000522, 0x00000522, 0x00000524, 0x00000524,
0x00000526, 0x00000526, 0x00000528, 0x00000528,
0x0000052a, 0x0000052a, 0x0000052c, 0x0000052c,
0x0000052e, 0x0000052e, 0x00000531, 0x00000556,
0x000010a0, 0x000010c5, 0x000010c7, 0x000010c7,
0x000010cd, 0x000010cd, 0x000013a0, 0x000013f5,
0x00001c90, 0x00001cba, 0x00001cbd, 0x00001cbf,
0x00001e00, 0x00001e00, 0x00001e02, 0x00001e02,
0x00001e04, 0x00001e04, 0x00001e06, 0x00001e06,
0x00001e08, 0x00001e08, 0x00001e0a, 0x00001e0a,
0x00001e0c, 0x00001e0c, 0x00001e0e, 0x00001e0e,
0x00001e10, 0x00001e10, 0x00001e12, 0x00001e12,
0x00001e14, 0x00001e14, 0x00001e16, 0x00001e16,
0x00001e18, 0x00001e18, 0x00001e1a, 0x00001e1a,
0x00001e1c, 0x00001e1c, 0x00001e1e, 0x00001e1e,
0x00001e20, 0x00001e20, 0x00001e22, 0x00001e22,
0x00001e24, 0x00001e24, 0x00001e26, 0x00001e26,
0x00001e28, 0x00001e28, 0x00001e2a, 0x00001e2a,
0x00001e2c, 0x00001e2c, 0x00001e2e, 0x00001e2e,
0x00001e30, 0x00001e30, 0x00001e32, 0x00001e32,
0x00001e34, 0x00001e34, 0x00001e36, 0x00001e36,
0x00001e38, 0x00001e38, 0x00001e3a, 0x00001e3a,
0x00001e3c, 0x00001e3c, 0x00001e3e, 0x00001e3e,
0x00001e40, 0x00001e40, 0x00001e42, 0x00001e42,
0x00001e44, 0x00001e44, 0x00001e46, 0x00001e46,
0x00001e48, 0x00001e48, 0x00001e4a, 0x00001e4a,
0x00001e4c, 0x00001e4c, 0x00001e4e, 0x00001e4e,
0x00001e50, 0x00001e50, 0x00001e52, 0x00001e52,
0x00001e54, 0x00001e54, 0x00001e56, 0x00001e56,
0x00001e58, 0x00001e58, 0x00001e5a, 0x00001e5a,
0x00001e5c, 0x00001e5c, 0x00001e5e, 0x00001e5e,
0x00001e60, 0x00001e60, 0x00001e62, 0x00001e62,
0x00001e64, 0x00001e64, 0x00001e66, 0x00001e66,
0x00001e68, 0x00001e68, 0x00001e6a, 0x00001e6a,
0x00001e6c, 0x00001e6c, 0x00001e6e, 0x00001e6e,
0x00001e70, 0x00001e70, 0x00001e72, 0x00001e72,
0x00001e74, 0x00001e74, 0x00001e76, 0x00001e76,
0x00001e78, 0x00001e78, 0x00001e7a, 0x00001e7a,
0x00001e7c, 0x00001e7c, 0x00001e7e, 0x00001e7e,
0x00001e80, 0x00001e80, 0x00001e82, 0x00001e82,
0x00001e84, 0x00001e84, 0x00001e86, 0x00001e86,
0x00001e88, 0x00001e88, 0x00001e8a, 0x00001e8a,
0x00001e8c, 0x00001e8c, 0x00001e8e, 0x00001e8e,
0x00001e90, 0x00001e90, 0x00001e92, 0x00001e92,
0x00001e94, 0x00001e94, 0x00001e9e, 0x00001e9e,
0x00001ea0, 0x00001ea0, 0x00001ea2, 0x00001ea2,
0x00001ea4, 0x00001ea4, 0x00001ea6, 0x00001ea6,
0x00001ea8, 0x00001ea8, 0x00001eaa, 0x00001eaa,
0x00001eac, 0x00001eac, 0x00001eae, 0x00001eae,
0x00001eb0, 0x00001eb0, 0x00001eb2, 0x00001eb2,
0x00001eb4, 0x00001eb4, 0x00001eb6, 0x00001eb6,
0x00001eb8, 0x00001eb8, 0x00001eba, 0x00001eba,
0x00001ebc, 0x00001ebc, 0x00001ebe, 0x00001ebe,
0x00001ec0, 0x00001ec0, 0x00001ec2, 0x00001ec2,
0x00001ec4, 0x00001ec4, 0x00001ec6, 0x00001ec6,
0x00001ec8, 0x00001ec8, 0x00001eca, 0x00001eca,
0x00001ecc, 0x00001ecc, 0x00001ece, 0x00001ece,
0x00001ed0, 0x00001ed0, 0x00001ed2, 0x00001ed2,
0x00001ed4, 0x00001ed4, 0x00001ed6, 0x00001ed6,
0x00001ed8, 0x00001ed8, 0x00001eda, 0x00001eda,
0x00001edc, 0x00001edc, 0x00001ede, 0x00001ede,
0x00001ee0, 0x00001ee0, 0x00001ee2, 0x00001ee2,
0x00001ee4, 0x00001ee4, 0x00001ee6, 0x00001ee6,
0x00001ee8, 0x00001ee8, 0x00001eea, 0x00001eea,
0x00001eec, 0x00001eec, 0x00001eee, 0x00001eee,
0x00001ef0, 0x00001ef0, 0x00001ef2, 0x00001ef2,
0x00001ef4, 0x00001ef4, 0x00001ef6, 0x00001ef6,
0x00001ef8, 0x00001ef8, 0x00001efa, 0x00001efa,
0x00001efc, 0x00001efc, 0x00001efe, 0x00001efe,
0x00001f08, 0x00001f0f, 0x00001f18, 0x00001f1d,
0x00001f28, 0x00001f2f, 0x00001f38, 0x00001f3f,
0x00001f48, 0x00001f4d, 0x00001f59, 0x00001f59,
0x00001f5b, 0x00001f5b, 0x00001f5d, 0x00001f5d,
0x00001f5f, 0x00001f5f, 0x00001f68, 0x00001f6f,
0x00001fb8, 0x00001fbb, 0x00001fc8, 0x00001fcb,
0x00001fd8, 0x00001fdb, 0x00001fe8, 0x00001fec,
0x00001ff8, 0x00001ffb, 0x00002102, 0x00002102,
0x00002107, 0x00002107, 0x0000210b, 0x0000210d,
0x00002110, 0x00002112, 0x00002115, 0x00002115,
0x00002119, 0x0000211d, 0x00002124, 0x00002124,
0x00002126, 0x00002126, 0x00002128, 0x00002128,
0x0000212a, 0x0000212d, 0x00002130, 0x00002133,
0x0000213e, 0x0000213f, 0x00002145, 0x00002145,
0x00002183, 0x00002183, 0x00002c00, 0x00002c2e,
0x00002c60, 0x00002c60, 0x00002c62, 0x00002c64,
0x00002c67, 0x00002c67, 0x00002c69, 0x00002c69,
0x00002c6b, 0x00002c6b, 0x00002c6d, 0x00002c70,
0x00002c72, 0x00002c72, 0x00002c75, 0x00002c75,
0x00002c7e, 0x00002c80, 0x00002c82, 0x00002c82,
0x00002c84, 0x00002c84, 0x00002c86, 0x00002c86,
0x00002c88, 0x00002c88, 0x00002c8a, 0x00002c8a,
0x00002c8c, 0x00002c8c, 0x00002c8e, 0x00002c8e,
0x00002c90, 0x00002c90, 0x00002c92, 0x00002c92,
0x00002c94, 0x00002c94, 0x00002c96, 0x00002c96,
0x00002c98, 0x00002c98, 0x00002c9a, 0x00002c9a,
0x00002c9c, 0x00002c9c, 0x00002c9e, 0x00002c9e,
0x00002ca0, 0x00002ca0, 0x00002ca2, 0x00002ca2,
0x00002ca4, 0x00002ca4, 0x00002ca6, 0x00002ca6,
0x00002ca8, 0x00002ca8, 0x00002caa, 0x00002caa,
0x00002cac, 0x00002cac, 0x00002cae, 0x00002cae,
0x00002cb0, 0x00002cb0, 0x00002cb2, 0x00002cb2,
0x00002cb4, 0x00002cb4, 0x00002cb6, 0x00002cb6,
0x00002cb8, 0x00002cb8, 0x00002cba, 0x00002cba,
0x00002cbc, 0x00002cbc, 0x00002cbe, 0x00002cbe,
0x00002cc0, 0x00002cc0, 0x00002cc2, 0x00002cc2,
0x00002cc4, 0x00002cc4, 0x00002cc6, 0x00002cc6,
0x00002cc8, 0x00002cc8, 0x00002cca, 0x00002cca,
0x00002ccc, 0x00002ccc, 0x00002cce, 0x00002cce,
0x00002cd0, 0x00002cd0, 0x00002cd2, 0x00002cd2,
0x00002cd4, 0x00002cd4, 0x00002cd6, 0x00002cd6,
0x00002cd8, 0x00002cd8, 0x00002cda, 0x00002cda,
0x00002cdc, 0x00002cdc, 0x00002cde, 0x00002cde,
0x00002ce0, 0x00002ce0, 0x00002ce2, 0x00002ce2,
0x00002ceb, 0x00002ceb, 0x00002ced, 0x00002ced,
0x00002cf2, 0x00002cf2, 0x0000a640, 0x0000a640,
0x0000a642, 0x0000a642, 0x0000a644, 0x0000a644,
0x0000a646, 0x0000a646, 0x0000a648, 0x0000a648,
0x0000a64a, 0x0000a64a, 0x0000a64c, 0x0000a64c,
0x0000a64e, 0x0000a64e, 0x0000a650, 0x0000a650,
0x0000a652, 0x0000a652, 0x0000a654, 0x0000a654,
0x0000a656, 0x0000a656, 0x0000a658, 0x0000a658,
0x0000a65a, 0x0000a65a, 0x0000a65c, 0x0000a65c,
0x0000a65e, 0x0000a65e, 0x0000a660, 0x0000a660,
0x0000a662, 0x0000a662, 0x0000a664, 0x0000a664,
0x0000a666, 0x0000a666, 0x0000a668, 0x0000a668,
0x0000a66a, 0x0000a66a, 0x0000a66c, 0x0000a66c,
0x0000a680, 0x0000a680, 0x0000a682, 0x0000a682,
0x0000a684, 0x0000a684, 0x0000a686, 0x0000a686,
0x0000a688, 0x0000a688, 0x0000a68a, 0x0000a68a,
0x0000a68c, 0x0000a68c, 0x0000a68e, 0x0000a68e,
0x0000a690, 0x0000a690, 0x0000a692, 0x0000a692,
0x0000a694, 0x0000a694, 0x0000a696, 0x0000a696,
0x0000a698, 0x0000a698, 0x0000a69a, 0x0000a69a,
0x0000a722, 0x0000a722, 0x0000a724, 0x0000a724,
0x0000a726, 0x0000a726, 0x0000a728, 0x0000a728,
0x0000a72a, 0x0000a72a, 0x0000a72c, 0x0000a72c,
0x0000a72e, 0x0000a72e, 0x0000a732, 0x0000a732,
0x0000a734, 0x0000a734, 0x0000a736, 0x0000a736,
0x0000a738, 0x0000a738, 0x0000a73a, 0x0000a73a,
0x0000a73c, 0x0000a73c, 0x0000a73e, 0x0000a73e,
0x0000a740, 0x0000a740, 0x0000a742, 0x0000a742,
0x0000a744, 0x0000a744, 0x0000a746, 0x0000a746,
0x0000a748, 0x0000a748, 0x0000a74a, 0x0000a74a,
0x0000a74c, 0x0000a74c, 0x0000a74e, 0x0000a74e,
0x0000a750, 0x0000a750, 0x0000a752, 0x0000a752,
0x0000a754, 0x0000a754, 0x0000a756, 0x0000a756,
0x0000a758, 0x0000a758, 0x0000a75a, 0x0000a75a,
0x0000a75c, 0x0000a75c, 0x0000a75e, 0x0000a75e,
0x0000a760, 0x0000a760, 0x0000a762, 0x0000a762,
0x0000a764, 0x0000a764, 0x0000a766, 0x0000a766,
0x0000a768, 0x0000a768, 0x0000a76a, 0x0000a76a,
0x0000a76c, 0x0000a76c, 0x0000a76e, 0x0000a76e,
0x0000a779, 0x0000a779, 0x0000a77b, 0x0000a77b,
0x0000a77d, 0x0000a77e, 0x0000a780, 0x0000a780,
0x0000a782, 0x0000a782, 0x0000a784, 0x0000a784,
0x0000a786, 0x0000a786, 0x0000a78b, 0x0000a78b,
0x0000a78d, 0x0000a78d, 0x0000a790, 0x0000a790,
0x0000a792, 0x0000a792, 0x0000a796, 0x0000a796,
0x0000a798, 0x0000a798, 0x0000a79a, 0x0000a79a,
0x0000a79c, 0x0000a79c, 0x0000a79e, 0x0000a79e,
0x0000a7a0, 0x0000a7a0, 0x0000a7a2, 0x0000a7a2,
0x0000a7a4, 0x0000a7a4, 0x0000a7a6, 0x0000a7a6,
0x0000a7a8, 0x0000a7a8, 0x0000a7aa, 0x0000a7ae,
0x0000a7b0, 0x0000a7b4, 0x0000a7b6, 0x0000a7b6,
0x0000a7b8, 0x0000a7b8, 0x0000ff21, 0x0000ff3a,
0x00010400, 0x00010427, 0x000104b0, 0x000104d3,
0x00010c80, 0x00010cb2, 0x000118a0, 0x000118bf,
0x00016e40, 0x00016e5f, 0x0001d400, 0x0001d419,
0x0001d434, 0x0001d44d, 0x0001d468, 0x0001d481,
0x0001d49c, 0x0001d49c, 0x0001d49e, 0x0001d49f,
0x0001d4a2, 0x0001d4a2, 0x0001d4a5, 0x0001d4a6,
0x0001d4a9, 0x0001d4ac, 0x0001d4ae, 0x0001d4b5,
0x0001d4d0, 0x0001d4e9, 0x0001d504, 0x0001d505,
0x0001d507, 0x0001d50a, 0x0001d50d, 0x0001d514,
0x0001d516, 0x0001d51c, 0x0001d538, 0x0001d539,
0x0001d53b, 0x0001d53e, 0x0001d540, 0x0001d544,
0x0001d546, 0x0001d546, 0x0001d54a, 0x0001d550,
0x0001d56c, 0x0001d585, 0x0001d5a0, 0x0001d5b9,
0x0001d5d4, 0x0001d5ed, 0x0001d608, 0x0001d621,
0x0001d63c, 0x0001d655, 0x0001d670, 0x0001d689,
0x0001d6a8, 0x0001d6c0, 0x0001d6e2, 0x0001d6fa,
0x0001d71c, 0x0001d734, 0x0001d756, 0x0001d76e,
0x0001d790, 0x0001d7a8, 0x0001d7ca, 0x0001d7ca,
0x0001e900, 0x0001e921, 0x00000061, 0x0000007a,
0x000000b5, 0x000000b5, 0x000000df, 0x000000f6,
0x000000f8, 0x000000ff, 0x00000101, 0x00000101,
0x00000103, 0x00000103, 0x00000105, 0x00000105,
0x00000107, 0x00000107, 0x00000109, 0x00000109,
0x0000010b, 0x0000010b, 0x0000010d, 0x0000010d,
0x0000010f, 0x0000010f, 0x00000111, 0x00000111,
0x00000113, 0x00000113, 0x00000115, 0x00000115,
0x00000117, 0x00000117, 0x00000119, 0x00000119,
0x0000011b, 0x0000011b, 0x0000011d, 0x0000011d,
0x0000011f, 0x0000011f, 0x00000121, 0x00000121,
0x00000123, 0x00000123, 0x00000125, 0x00000125,
0x00000127, 0x00000127, 0x00000129, 0x00000129,
0x0000012b, 0x0000012b, 0x0000012d, 0x0000012d,
0x0000012f, 0x0000012f, 0x00000131, 0x00000131,
0x00000133, 0x00000133, 0x00000135, 0x00000135,
0x00000137, 0x00000138, 0x0000013a, 0x0000013a,
0x0000013c, 0x0000013c, 0x0000013e, 0x0000013e,
0x00000140, 0x00000140, 0x00000142, 0x00000142,
0x00000144, 0x00000144, 0x00000146, 0x00000146,
0x00000148, 0x00000149, 0x0000014b, 0x0000014b,
0x0000014d, 0x0000014d, 0x0000014f, 0x0000014f,
0x00000151, 0x00000151, 0x00000153, 0x00000153,
0x00000155, 0x00000155, 0x00000157, 0x00000157,
0x00000159, 0x00000159, 0x0000015b, 0x0000015b,
0x0000015d, 0x0000015d, 0x0000015f, 0x0000015f,
0x00000161, 0x00000161, 0x00000163, 0x00000163,
0x00000165, 0x00000165, 0x00000167, 0x00000167,
0x00000169, 0x00000169, 0x0000016b, 0x0000016b,
0x0000016d, 0x0000016d, 0x0000016f, 0x0000016f,
0x00000171, 0x00000171, 0x00000173, 0x00000173,
0x00000175, 0x00000175, 0x00000177, 0x00000177,
0x0000017a, 0x0000017a, 0x0000017c, 0x0000017c,
0x0000017e, 0x00000180, 0x00000183, 0x00000183,
0x00000185, 0x00000185, 0x00000188, 0x00000188,
0x0000018c, 0x0000018d, 0x00000192, 0x00000192,
0x00000195, 0x00000195, 0x00000199, 0x0000019b,
0x0000019e, 0x0000019e, 0x000001a1, 0x000001a1,
0x000001a3, 0x000001a3, 0x000001a5, 0x000001a5,
0x000001a8, 0x000001a8, 0x000001aa, 0x000001ab,
0x000001ad, 0x000001ad, 0x000001b0, 0x000001b0,
0x000001b4, 0x000001b4, 0x000001b6, 0x000001b6,
0x000001b9, 0x000001ba, 0x000001bd, 0x000001bf,
0x000001c6, 0x000001c6, 0x000001c9, 0x000001c9,
0x000001cc, 0x000001cc, 0x000001ce, 0x000001ce,
0x000001d0, 0x000001d0, 0x000001d2, 0x000001d2,
0x000001d4, 0x000001d4, 0x000001d6, 0x000001d6,
0x000001d8, 0x000001d8, 0x000001da, 0x000001da,
0x000001dc, 0x000001dd, 0x000001df, 0x000001df,
0x000001e1, 0x000001e1, 0x000001e3, 0x000001e3,
0x000001e5, 0x000001e5, 0x000001e7, 0x000001e7,
0x000001e9, 0x000001e9, 0x000001eb, 0x000001eb,
0x000001ed, 0x000001ed, 0x000001ef, 0x000001f0,
0x000001f3, 0x000001f3, 0x000001f5, 0x000001f5,
0x000001f9, 0x000001f9, 0x000001fb, 0x000001fb,
0x000001fd, 0x000001fd, 0x000001ff, 0x000001ff,
0x00000201, 0x00000201, 0x00000203, 0x00000203,
0x00000205, 0x00000205, 0x00000207, 0x00000207,
0x00000209, 0x00000209, 0x0000020b, 0x0000020b,
0x0000020d, 0x0000020d, 0x0000020f, 0x0000020f,
0x00000211, 0x00000211, 0x00000213, 0x00000213,
0x00000215, 0x00000215, 0x00000217, 0x00000217,
0x00000219, 0x00000219, 0x0000021b, 0x0000021b,
0x0000021d, 0x0000021d, 0x0000021f, 0x0000021f,
0x00000221, 0x00000221, 0x00000223, 0x00000223,
0x00000225, 0x00000225, 0x00000227, 0x00000227,
0x00000229, 0x00000229, 0x0000022b, 0x0000022b,
0x0000022d, 0x0000022d, 0x0000022f, 0x0000022f,
0x00000231, 0x00000231, 0x00000233, 0x00000239,
0x0000023c, 0x0000023c, 0x0000023f, 0x00000240,
0x00000242, 0x00000242, 0x00000247, 0x00000247,
0x00000249, 0x00000249, 0x0000024b, 0x0000024b,
0x0000024d, 0x0000024d, 0x0000024f, 0x00000293,
0x00000295, 0x000002af, 0x00000371, 0x00000371,
0x00000373, 0x00000373, 0x00000377, 0x00000377,
0x0000037b, 0x0000037d, 0x00000390, 0x00000390,
0x000003ac, 0x000003ce, 0x000003d0, 0x000003d1,
0x000003d5, 0x000003d7, 0x000003d9, 0x000003d9,
0x000003db, 0x000003db, 0x000003dd, 0x000003dd,
0x000003df, 0x000003df, 0x000003e1, 0x000003e1,
0x000003e3, 0x000003e3, 0x000003e5, 0x000003e5,
0x000003e7, 0x000003e7, 0x000003e9, 0x000003e9,
0x000003eb, 0x000003eb, 0x000003ed, 0x000003ed,
0x000003ef, 0x000003f3, 0x000003f5, 0x000003f5,
0x000003f8, 0x000003f8, 0x000003fb, 0x000003fc,
0x00000430, 0x0000045f, 0x00000461, 0x00000461,
0x00000463, 0x00000463, 0x00000465, 0x00000465,
0x00000467, 0x00000467, 0x00000469, 0x00000469,
0x0000046b, 0x0000046b, 0x0000046d, 0x0000046d,
0x0000046f, 0x0000046f, 0x00000471, 0x00000471,
0x00000473, 0x00000473, 0x00000475, 0x00000475,
0x00000477, 0x00000477, 0x00000479, 0x00000479,
0x0000047b, 0x0000047b, 0x0000047d, 0x0000047d,
0x0000047f, 0x0000047f, 0x00000481, 0x00000481,
0x0000048b, 0x0000048b, 0x0000048d, 0x0000048d,
0x0000048f, 0x0000048f, 0x00000491, 0x00000491,
0x00000493, 0x00000493, 0x00000495, 0x00000495,
0x00000497, 0x00000497, 0x00000499, 0x00000499,
0x0000049b, 0x0000049b, 0x0000049d, 0x0000049d,
0x0000049f, 0x0000049f, 0x000004a1, 0x000004a1,
0x000004a3, 0x000004a3, 0x000004a5, 0x000004a5,
0x000004a7, 0x000004a7, 0x000004a9, 0x000004a9,
0x000004ab, 0x000004ab, 0x000004ad, 0x000004ad,
0x000004af, 0x000004af, 0x000004b1, 0x000004b1,
0x000004b3, 0x000004b3, 0x000004b5, 0x000004b5,
0x000004b7, 0x000004b7, 0x000004b9, 0x000004b9,
0x000004bb, 0x000004bb, 0x000004bd, 0x000004bd,
0x000004bf, 0x000004bf, 0x000004c2, 0x000004c2,
0x000004c4, 0x000004c4, 0x000004c6, 0x000004c6,
0x000004c8, 0x000004c8, 0x000004ca, 0x000004ca,
0x000004cc, 0x000004cc, 0x000004ce, 0x000004cf,
0x000004d1, 0x000004d1, 0x000004d3, 0x000004d3,
0x000004d5, 0x000004d5, 0x000004d7, 0x000004d7,
0x000004d9, 0x000004d9, 0x000004db, 0x000004db,
0x000004dd, 0x000004dd, 0x000004df, 0x000004df,
0x000004e1, 0x000004e1, 0x000004e3, 0x000004e3,
0x000004e5, 0x000004e5, 0x000004e7, 0x000004e7,
0x000004e9, 0x000004e9, 0x000004eb, 0x000004eb,
0x000004ed, 0x000004ed, 0x000004ef, 0x000004ef,
0x000004f1, 0x000004f1, 0x000004f3, 0x000004f3,
0x000004f5, 0x000004f5, 0x000004f7, 0x000004f7,
0x000004f9, 0x000004f9, 0x000004fb, 0x000004fb,
0x000004fd, 0x000004fd, 0x000004ff, 0x000004ff,
0x00000501, 0x00000501, 0x00000503, 0x00000503,
0x00000505, 0x00000505, 0x00000507, 0x00000507,
0x00000509, 0x00000509, 0x0000050b, 0x0000050b,
0x0000050d, 0x0000050d, 0x0000050f, 0x0000050f,
0x00000511, 0x00000511, 0x00000513, 0x00000513,
0x00000515, 0x00000515, 0x00000517, 0x00000517,
0x00000519, 0x00000519, 0x0000051b, 0x0000051b,
0x0000051d, 0x0000051d, 0x0000051f, 0x0000051f,
0x00000521, 0x00000521, 0x00000523, 0x00000523,
0x00000525, 0x00000525, 0x00000527, 0x00000527,
0x00000529, 0x00000529, 0x0000052b, 0x0000052b,
0x0000052d, 0x0000052d, 0x0000052f, 0x0000052f,
0x00000560, 0x00000588, 0x000010d0, 0x000010fa,
0x000010fd, 0x000010ff, 0x000013f8, 0x000013fd,
0x00001c80, 0x00001c88, 0x00001d00, 0x00001d2b,
0x00001d6b, 0x00001d77, 0x00001d79, 0x00001d9a,
0x00001e01, 0x00001e01, 0x00001e03, 0x00001e03,
0x00001e05, 0x00001e05, 0x00001e07, 0x00001e07,
0x00001e09, 0x00001e09, 0x00001e0b, 0x00001e0b,
0x00001e0d, 0x00001e0d, 0x00001e0f, 0x00001e0f,
0x00001e11, 0x00001e11, 0x00001e13, 0x00001e13,
0x00001e15, 0x00001e15, 0x00001e17, 0x00001e17,
0x00001e19, 0x00001e19, 0x00001e1b, 0x00001e1b,
0x00001e1d, 0x00001e1d, 0x00001e1f, 0x00001e1f,
0x00001e21, 0x00001e21, 0x00001e23, 0x00001e23,
0x00001e25, 0x00001e25, 0x00001e27, 0x00001e27,
0x00001e29, 0x00001e29, 0x00001e2b, 0x00001e2b,
0x00001e2d, 0x00001e2d, 0x00001e2f, 0x00001e2f,
0x00001e31, 0x00001e31, 0x00001e33, 0x00001e33,
0x00001e35, 0x00001e35, 0x00001e37, 0x00001e37,
0x00001e39, 0x00001e39, 0x00001e3b, 0x00001e3b,
0x00001e3d, 0x00001e3d, 0x00001e3f, 0x00001e3f,
0x00001e41, 0x00001e41, 0x00001e43, 0x00001e43,
0x00001e45, 0x00001e45, 0x00001e47, 0x00001e47,
0x00001e49, 0x00001e49, 0x00001e4b, 0x00001e4b,
0x00001e4d, 0x00001e4d, 0x00001e4f, 0x00001e4f,
0x00001e51, 0x00001e51, 0x00001e53, 0x00001e53,
0x00001e55, 0x00001e55, 0x00001e57, 0x00001e57,
0x00001e59, 0x00001e59, 0x00001e5b, 0x00001e5b,
0x00001e5d, 0x00001e5d, 0x00001e5f, 0x00001e5f,
0x00001e61, 0x00001e61, 0x00001e63, 0x00001e63,
0x00001e65, 0x00001e65, 0x00001e67, 0x00001e67,
0x00001e69, 0x00001e69, 0x00001e6b, 0x00001e6b,
0x00001e6d, 0x00001e6d, 0x00001e6f, 0x00001e6f,
0x00001e71, 0x00001e71, 0x00001e73, 0x00001e73,
0x00001e75, 0x00001e75, 0x00001e77, 0x00001e77,
0x00001e79, 0x00001e79, 0x00001e7b, 0x00001e7b,
0x00001e7d, 0x00001e7d, 0x00001e7f, 0x00001e7f,
0x00001e81, 0x00001e81, 0x00001e83, 0x00001e83,
0x00001e85, 0x00001e85, 0x00001e87, 0x00001e87,
0x00001e89, 0x00001e89, 0x00001e8b, 0x00001e8b,
0x00001e8d, 0x00001e8d, 0x00001e8f, 0x00001e8f,
0x00001e91, 0x00001e91, 0x00001e93, 0x00001e93,
0x00001e95, 0x00001e9d, 0x00001e9f, 0x00001e9f,
0x00001ea1, 0x00001ea1, 0x00001ea3, 0x00001ea3,
0x00001ea5, 0x00001ea5, 0x00001ea7, 0x00001ea7,
0x00001ea9, 0x00001ea9, 0x00001eab, 0x00001eab,
0x00001ead, 0x00001ead, 0x00001eaf, 0x00001eaf,
0x00001eb1, 0x00001eb1, 0x00001eb3, 0x00001eb3,
0x00001eb5, 0x00001eb5, 0x00001eb7, 0x00001eb7,
0x00001eb9, 0x00001eb9, 0x00001ebb, 0x00001ebb,
0x00001ebd, 0x00001ebd, 0x00001ebf, 0x00001ebf,
0x00001ec1, 0x00001ec1, 0x00001ec3, 0x00001ec3,
0x00001ec5, 0x00001ec5, 0x00001ec7, 0x00001ec7,
0x00001ec9, 0x00001ec9, 0x00001ecb, 0x00001ecb,
0x00001ecd, 0x00001ecd, 0x00001ecf, 0x00001ecf,
0x00001ed1, 0x00001ed1, 0x00001ed3, 0x00001ed3,
0x00001ed5, 0x00001ed5, 0x00001ed7, 0x00001ed7,
0x00001ed9, 0x00001ed9, 0x00001edb, 0x00001edb,
0x00001edd, 0x00001edd, 0x00001edf, 0x00001edf,
0x00001ee1, 0x00001ee1, 0x00001ee3, 0x00001ee3,
0x00001ee5, 0x00001ee5, 0x00001ee7, 0x00001ee7,
0x00001ee9, 0x00001ee9, 0x00001eeb, 0x00001eeb,
0x00001eed, 0x00001eed, 0x00001eef, 0x00001eef,
0x00001ef1, 0x00001ef1, 0x00001ef3, 0x00001ef3,
0x00001ef5, 0x00001ef5, 0x00001ef7, 0x00001ef7,
0x00001ef9, 0x00001ef9, 0x00001efb, 0x00001efb,
0x00001efd, 0x00001efd, 0x00001eff, 0x00001f07,
0x00001f10, 0x00001f15, 0x00001f20, 0x00001f27,
0x00001f30, 0x00001f37, 0x00001f40, 0x00001f45,
0x00001f50, 0x00001f57, 0x00001f60, 0x00001f67,
0x00001f70, 0x00001f7d, 0x00001f80, 0x00001f87,
0x00001f90, 0x00001f97, 0x00001fa0, 0x00001fa7,
0x00001fb0, 0x00001fb4, 0x00001fb6, 0x00001fb7,
0x00001fbe, 0x00001fbe, 0x00001fc2, 0x00001fc4,
0x00001fc6, 0x00001fc7, 0x00001fd0, 0x00001fd3,
0x00001fd6, 0x00001fd7, 0x00001fe0, 0x00001fe7,
0x00001ff2, 0x00001ff4, 0x00001ff6, 0x00001ff7,
0x0000210a, 0x0000210a, 0x0000210e, 0x0000210f,
0x00002113, 0x00002113, 0x0000212f, 0x0000212f,
0x00002134, 0x00002134, 0x00002139, 0x00002139,
0x0000213c, 0x0000213d, 0x00002146, 0x00002149,
0x0000214e, 0x0000214e, 0x00002184, 0x00002184,
0x00002c30, 0x00002c5e, 0x00002c61, 0x00002c61,
0x00002c65, 0x00002c66, 0x00002c68, 0x00002c68,
0x00002c6a, 0x00002c6a, 0x00002c6c, 0x00002c6c,
0x00002c71, 0x00002c71, 0x00002c73, 0x00002c74,
0x00002c76, 0x00002c7b, 0x00002c81, 0x00002c81,
0x00002c83, 0x00002c83, 0x00002c85, 0x00002c85,
0x00002c87, 0x00002c87, 0x00002c89, 0x00002c89,
0x00002c8b, 0x00002c8b, 0x00002c8d, 0x00002c8d,
0x00002c8f, 0x00002c8f, 0x00002c91, 0x00002c91,
0x00002c93, 0x00002c93, 0x00002c95, 0x00002c95,
0x00002c97, 0x00002c97, 0x00002c99, 0x00002c99,
0x00002c9b, 0x00002c9b, 0x00002c9d, 0x00002c9d,
0x00002c9f, 0x00002c9f, 0x00002ca1, 0x00002ca1,
0x00002ca3, 0x00002ca3, 0x00002ca5, 0x00002ca5,
0x00002ca7, 0x00002ca7, 0x00002ca9, 0x00002ca9,
0x00002cab, 0x00002cab, 0x00002cad, 0x00002cad,
0x00002caf, 0x00002caf, 0x00002cb1, 0x00002cb1,
0x00002cb3, 0x00002cb3, 0x00002cb5, 0x00002cb5,
0x00002cb7, 0x00002cb7, 0x00002cb9, 0x00002cb9,
0x00002cbb, 0x00002cbb, 0x00002cbd, 0x00002cbd,
0x00002cbf, 0x00002cbf, 0x00002cc1, 0x00002cc1,
0x00002cc3, 0x00002cc3, 0x00002cc5, 0x00002cc5,
0x00002cc7, 0x00002cc7, 0x00002cc9, 0x00002cc9,
0x00002ccb, 0x00002ccb, 0x00002ccd, 0x00002ccd,
0x00002ccf, 0x00002ccf, 0x00002cd1, 0x00002cd1,
0x00002cd3, 0x00002cd3, 0x00002cd5, 0x00002cd5,
0x00002cd7, 0x00002cd7, 0x00002cd9, 0x00002cd9,
0x00002cdb, 0x00002cdb, 0x00002cdd, 0x00002cdd,
0x00002cdf, 0x00002cdf, 0x00002ce1, 0x00002ce1,
0x00002ce3, 0x00002ce4, 0x00002cec, 0x00002cec,
0x00002cee, 0x00002cee, 0x00002cf3, 0x00002cf3,
0x00002d00, 0x00002d25, 0x00002d27, 0x00002d27,
0x00002d2d, 0x00002d2d, 0x0000a641, 0x0000a641,
0x0000a643, 0x0000a643, 0x0000a645, 0x0000a645,
0x0000a647, 0x0000a647, 0x0000a649, 0x0000a649,
0x0000a64b, 0x0000a64b, 0x0000a64d, 0x0000a64d,
0x0000a64f, 0x0000a64f, 0x0000a651, 0x0000a651,
0x0000a653, 0x0000a653, 0x0000a655, 0x0000a655,
0x0000a657, 0x0000a657, 0x0000a659, 0x0000a659,
0x0000a65b, 0x0000a65b, 0x0000a65d, 0x0000a65d,
0x0000a65f, 0x0000a65f, 0x0000a661, 0x0000a661,
0x0000a663, 0x0000a663, 0x0000a665, 0x0000a665,
0x0000a667, 0x0000a667, 0x0000a669, 0x0000a669,
0x0000a66b, 0x0000a66b, 0x0000a66d, 0x0000a66d,
0x0000a681, 0x0000a681, 0x0000a683, 0x0000a683,
0x0000a685, 0x0000a685, 0x0000a687, 0x0000a687,
0x0000a689, 0x0000a689, 0x0000a68b, 0x0000a68b,
0x0000a68d, 0x0000a68d, 0x0000a68f, 0x0000a68f,
0x0000a691, 0x0000a691, 0x0000a693, 0x0000a693,
0x0000a695, 0x0000a695, 0x0000a697, 0x0000a697,
0x0000a699, 0x0000a699, 0x0000a69b, 0x0000a69b,
0x0000a723, 0x0000a723, 0x0000a725, 0x0000a725,
0x0000a727, 0x0000a727, 0x0000a729, 0x0000a729,
0x0000a72b, 0x0000a72b, 0x0000a72d, 0x0000a72d,
0x0000a72f, 0x0000a731, 0x0000a733, 0x0000a733,
0x0000a735, 0x0000a735, 0x0000a737, 0x0000a737,
0x0000a739, 0x0000a739, 0x0000a73b, 0x0000a73b,
0x0000a73d, 0x0000a73d, 0x0000a73f, 0x0000a73f,
0x0000a741, 0x0000a741, 0x0000a743, 0x0000a743,
0x0000a745, 0x0000a745, 0x0000a747, 0x0000a747,
0x0000a749, 0x0000a749, 0x0000a74b, 0x0000a74b,
0x0000a74d, 0x0000a74d, 0x0000a74f, 0x0000a74f,
0x0000a751, 0x0000a751, 0x0000a753, 0x0000a753,
0x0000a755, 0x0000a755, 0x0000a757, 0x0000a757,
0x0000a759, 0x0000a759, 0x0000a75b, 0x0000a75b,
0x0000a75d, 0x0000a75d, 0x0000a75f, 0x0000a75f,
0x0000a761, 0x0000a761, 0x0000a763, 0x0000a763,
0x0000a765, 0x0000a765, 0x0000a767, 0x0000a767,
0x0000a769, 0x0000a769, 0x0000a76b, 0x0000a76b,
0x0000a76d, 0x0000a76d, 0x0000a76f, 0x0000a76f,
0x0000a771, 0x0000a778, 0x0000a77a, 0x0000a77a,
0x0000a77c, 0x0000a77c, 0x0000a77f, 0x0000a77f,
0x0000a781, 0x0000a781, 0x0000a783, 0x0000a783,
0x0000a785, 0x0000a785, 0x0000a787, 0x0000a787,
0x0000a78c, 0x0000a78c, 0x0000a78e, 0x0000a78e,
0x0000a791, 0x0000a791, 0x0000a793, 0x0000a795,
0x0000a797, 0x0000a797, 0x0000a799, 0x0000a799,
0x0000a79b, 0x0000a79b, 0x0000a79d, 0x0000a79d,
0x0000a79f, 0x0000a79f, 0x0000a7a1, 0x0000a7a1,
0x0000a7a3, 0x0000a7a3, 0x0000a7a5, 0x0000a7a5,
0x0000a7a7, 0x0000a7a7, 0x0000a7a9, 0x0000a7a9,
0x0000a7af, 0x0000a7af, 0x0000a7b5, 0x0000a7b5,
0x0000a7b7, 0x0000a7b7, 0x0000a7b9, 0x0000a7b9,
0x0000a7fa, 0x0000a7fa, 0x0000ab30, 0x0000ab5a,
0x0000ab60, 0x0000ab65, 0x0000ab70, 0x0000abbf,
0x0000fb00, 0x0000fb06, 0x0000fb13, 0x0000fb17,
0x0000ff41, 0x0000ff5a, 0x00010428, 0x0001044f,
0x000104d8, 0x000104fb, 0x00010cc0, 0x00010cf2,
0x000118c0, 0x000118df, 0x00016e60, 0x00016e7f,
0x0001d41a, 0x0001d433, 0x0001d44e, 0x0001d454,
0x0001d456, 0x0001d467, 0x0001d482, 0x0001d49b,
0x0001d4b6, 0x0001d4b9, 0x0001d4bb, 0x0001d4bb,
0x0001d4bd, 0x0001d4c3, 0x0001d4c5, 0x0001d4cf,
0x0001d4ea, 0x0001d503, 0x0001d51e, 0x0001d537,
0x0001d552, 0x0001d56b, 0x0001d586, 0x0001d59f,
0x0001d5ba, 0x0001d5d3, 0x0001d5ee, 0x0001d607,
0x0001d622, 0x0001d63b, 0x0001d656, 0x0001d66f,
0x0001d68a, 0x0001d6a5, 0x0001d6c2, 0x0001d6da,
0x0001d6dc, 0x0001d6e1, 0x0001d6fc, 0x0001d714,
0x0001d716, 0x0001d71b, 0x0001d736, 0x0001d74e,
0x0001d750, 0x0001d755, 0x0001d770, 0x0001d788,
0x0001d78a, 0x0001d78f, 0x0001d7aa, 0x0001d7c2,
0x0001d7c4, 0x0001d7c9, 0x0001d7cb, 0x0001d7cb,
0x0001e922, 0x0001e943, 0x000001c5, 0x000001c5,
0x000001c8, 0x000001c8, 0x000001cb, 0x000001cb,
0x000001f2, 0x000001f2, 0x00001f88, 0x00001f8f,
0x00001f98, 0x00001f9f, 0x00001fa8, 0x00001faf,
0x00001fbc, 0x00001fbc, 0x00001fcc, 0x00001fcc,
0x00001ffc, 0x00001ffc, 0x000002b0, 0x000002c1,
0x000002c6, 0x000002d1, 0x000002e0, 0x000002e4,
0x000002ec, 0x000002ec, 0x000002ee, 0x000002ee,
0x00000374, 0x00000374, 0x0000037a, 0x0000037a,
0x00000559, 0x00000559, 0x00000640, 0x00000640,
0x000006e5, 0x000006e6, 0x000007f4, 0x000007f5,
0x000007fa, 0x000007fa, 0x0000081a, 0x0000081a,
0x00000824, 0x00000824, 0x00000828, 0x00000828,
0x00000971, 0x00000971, 0x00000e46, 0x00000e46,
0x00000ec6, 0x00000ec6, 0x000010fc, 0x000010fc,
0x000017d7, 0x000017d7, 0x00001843, 0x00001843,
0x00001aa7, 0x00001aa7, 0x00001c78, 0x00001c7d,
0x00001d2c, 0x00001d6a, 0x00001d78, 0x00001d78,
0x00001d9b, 0x00001dbf, 0x00002071, 0x00002071,
0x0000207f, 0x0000207f, 0x00002090, 0x0000209c,
0x00002c7c, 0x00002c7d, 0x00002d6f, 0x00002d6f,
0x00002e2f, 0x00002e2f, 0x00003005, 0x00003005,
0x00003031, 0x00003035, 0x0000303b, 0x0000303b,
0x0000309d, 0x0000309e, 0x000030fc, 0x000030fe,
0x0000a015, 0x0000a015, 0x0000a4f8, 0x0000a4fd,
0x0000a60c, 0x0000a60c, 0x0000a67f, 0x0000a67f,
0x0000a69c, 0x0000a69d, 0x0000a717, 0x0000a71f,
0x0000a770, 0x0000a770, 0x0000a788, 0x0000a788,
0x0000a7f8, 0x0000a7f9, 0x0000a9cf, 0x0000a9cf,
0x0000a9e6, 0x0000a9e6, 0x0000aa70, 0x0000aa70,
0x0000aadd, 0x0000aadd, 0x0000aaf3, 0x0000aaf4,
0x0000ab5c, 0x0000ab5f, 0x0000ff70, 0x0000ff70,
0x0000ff9e, 0x0000ff9f, 0x00016b40, 0x00016b43,
0x00016f93, 0x00016f9f, 0x00016fe0, 0x00016fe1,
0x000000aa, 0x000000aa, 0x000000ba, 0x000000ba,
0x000001bb, 0x000001bb, 0x000001c0, 0x000001c3,
0x00000294, 0x00000294, 0x000005d0, 0x000005ea,
0x000005ef, 0x000005f2, 0x00000620, 0x0000063f,
0x00000641, 0x0000064a, 0x0000066e, 0x0000066f,
0x00000671, 0x000006d3, 0x000006d5, 0x000006d5,
0x000006ee, 0x000006ef, 0x000006fa, 0x000006fc,
0x000006ff, 0x000006ff, 0x00000710, 0x00000710,
0x00000712, 0x0000072f, 0x0000074d, 0x000007a5,
0x000007b1, 0x000007b1, 0x000007ca, 0x000007ea,
0x00000800, 0x00000815, 0x00000840, 0x00000858,
0x00000860, 0x0000086a, 0x000008a0, 0x000008b4,
0x000008b6, 0x000008bd, 0x00000904, 0x00000939,
0x0000093d, 0x0000093d, 0x00000950, 0x00000950,
0x00000958, 0x00000961, 0x00000972, 0x00000980,
0x00000985, 0x0000098c, 0x0000098f, 0x00000990,
0x00000993, 0x000009a8, 0x000009aa, 0x000009b0,
0x000009b2, 0x000009b2, 0x000009b6, 0x000009b9,
0x000009bd, 0x000009bd, 0x000009ce, 0x000009ce,
0x000009dc, 0x000009dd, 0x000009df, 0x000009e1,
0x000009f0, 0x000009f1, 0x000009fc, 0x000009fc,
0x00000a05, 0x00000a0a, 0x00000a0f, 0x00000a10,
0x00000a13, 0x00000a28, 0x00000a2a, 0x00000a30,
0x00000a32, 0x00000a33, 0x00000a35, 0x00000a36,
0x00000a38, 0x00000a39, 0x00000a59, 0x00000a5c,
0x00000a5e, 0x00000a5e, 0x00000a72, 0x00000a74,
0x00000a85, 0x00000a8d, 0x00000a8f, 0x00000a91,
0x00000a93, 0x00000aa8, 0x00000aaa, 0x00000ab0,
0x00000ab2, 0x00000ab3, 0x00000ab5, 0x00000ab9,
0x00000abd, 0x00000abd, 0x00000ad0, 0x00000ad0,
0x00000ae0, 0x00000ae1, 0x00000af9, 0x00000af9,
0x00000b05, 0x00000b0c, 0x00000b0f, 0x00000b10,
0x00000b13, 0x00000b28, 0x00000b2a, 0x00000b30,
0x00000b32, 0x00000b33, 0x00000b35, 0x00000b39,
0x00000b3d, 0x00000b3d, 0x00000b5c, 0x00000b5d,
0x00000b5f, 0x00000b61, 0x00000b71, 0x00000b71,
0x00000b83, 0x00000b83, 0x00000b85, 0x00000b8a,
0x00000b8e, 0x00000b90, 0x00000b92, 0x00000b95,
0x00000b99, 0x00000b9a, 0x00000b9c, 0x00000b9c,
0x00000b9e, 0x00000b9f, 0x00000ba3, 0x00000ba4,
0x00000ba8, 0x00000baa, 0x00000bae, 0x00000bb9,
0x00000bd0, 0x00000bd0, 0x00000c05, 0x00000c0c,
0x00000c0e, 0x00000c10, 0x00000c12, 0x00000c28,
0x00000c2a, 0x00000c39, 0x00000c3d, 0x00000c3d,
0x00000c58, 0x00000c5a, 0x00000c60, 0x00000c61,
0x00000c80, 0x00000c80, 0x00000c85, 0x00000c8c,
0x00000c8e, 0x00000c90, 0x00000c92, 0x00000ca8,
0x00000caa, 0x00000cb3, 0x00000cb5, 0x00000cb9,
0x00000cbd, 0x00000cbd, 0x00000cde, 0x00000cde,
0x00000ce0, 0x00000ce1, 0x00000cf1, 0x00000cf2,
0x00000d05, 0x00000d0c, 0x00000d0e, 0x00000d10,
0x00000d12, 0x00000d3a, 0x00000d3d, 0x00000d3d,
0x00000d4e, 0x00000d4e, 0x00000d54, 0x00000d56,
0x00000d5f, 0x00000d61, 0x00000d7a, 0x00000d7f,
0x00000d85, 0x00000d96, 0x00000d9a, 0x00000db1,
0x00000db3, 0x00000dbb, 0x00000dbd, 0x00000dbd,
0x00000dc0, 0x00000dc6, 0x00000e01, 0x00000e30,
0x00000e32, 0x00000e33, 0x00000e40, 0x00000e45,
0x00000e81, 0x00000e82, 0x00000e84, 0x00000e84,
0x00000e87, 0x00000e88, 0x00000e8a, 0x00000e8a,
0x00000e8d, 0x00000e8d, 0x00000e94, 0x00000e97,
0x00000e99, 0x00000e9f, 0x00000ea1, 0x00000ea3,
0x00000ea5, 0x00000ea5, 0x00000ea7, 0x00000ea7,
0x00000eaa, 0x00000eab, 0x00000ead, 0x00000eb0,
0x00000eb2, 0x00000eb3, 0x00000ebd, 0x00000ebd,
0x00000ec0, 0x00000ec4, 0x00000edc, 0x00000edf,
0x00000f00, 0x00000f00, 0x00000f40, 0x00000f47,
0x00000f49, 0x00000f6c, 0x00000f88, 0x00000f8c,
0x00001000, 0x0000102a, 0x0000103f, 0x0000103f,
0x00001050, 0x00001055, 0x0000105a, 0x0000105d,
0x00001061, 0x00001061, 0x00001065, 0x00001066,
0x0000106e, 0x00001070, 0x00001075, 0x00001081,
0x0000108e, 0x0000108e, 0x00001100, 0x00001248,
0x0000124a, 0x0000124d, 0x00001250, 0x00001256,
0x00001258, 0x00001258, 0x0000125a, 0x0000125d,
0x00001260, 0x00001288, 0x0000128a, 0x0000128d,
0x00001290, 0x000012b0, 0x000012b2, 0x000012b5,
0x000012b8, 0x000012be, 0x000012c0, 0x000012c0,
0x000012c2, 0x000012c5, 0x000012c8, 0x000012d6,
0x000012d8, 0x00001310, 0x00001312, 0x00001315,
0x00001318, 0x0000135a, 0x00001380, 0x0000138f,
0x00001401, 0x0000166c, 0x0000166f, 0x0000167f,
0x00001681, 0x0000169a, 0x000016a0, 0x000016ea,
0x000016f1, 0x000016f8, 0x00001700, 0x0000170c,
0x0000170e, 0x00001711, 0x00001720, 0x00001731,
0x00001740, 0x00001751, 0x00001760, 0x0000176c,
0x0000176e, 0x00001770, 0x00001780, 0x000017b3,
0x000017dc, 0x000017dc, 0x00001820, 0x00001842,
0x00001844, 0x00001878, 0x00001880, 0x00001884,
0x00001887, 0x000018a8, 0x000018aa, 0x000018aa,
0x000018b0, 0x000018f5, 0x00001900, 0x0000191e,
0x00001950, 0x0000196d, 0x00001970, 0x00001974,
0x00001980, 0x000019ab, 0x000019b0, 0x000019c9,
0x00001a00, 0x00001a16, 0x00001a20, 0x00001a54,
0x00001b05, 0x00001b33, 0x00001b45, 0x00001b4b,
0x00001b83, 0x00001ba0, 0x00001bae, 0x00001baf,
0x00001bba, 0x00001be5, 0x00001c00, 0x00001c23,
0x00001c4d, 0x00001c4f, 0x00001c5a, 0x00001c77,
0x00001ce9, 0x00001cec, 0x00001cee, 0x00001cf1,
0x00001cf5, 0x00001cf6, 0x00002135, 0x00002138,
0x00002d30, 0x00002d67, 0x00002d80, 0x00002d96,
0x00002da0, 0x00002da6, 0x00002da8, 0x00002dae,
0x00002db0, 0x00002db6, 0x00002db8, 0x00002dbe,
0x00002dc0, 0x00002dc6, 0x00002dc8, 0x00002dce,
0x00002dd0, 0x00002dd6, 0x00002dd8, 0x00002dde,
0x00003006, 0x00003006, 0x0000303c, 0x0000303c,
0x00003041, 0x00003096, 0x0000309f, 0x0000309f,
0x000030a1, 0x000030fa, 0x000030ff, 0x000030ff,
0x00003105, 0x0000312f, 0x00003131, 0x0000318e,
0x000031a0, 0x000031ba, 0x000031f0, 0x000031ff,
0x00003400, 0x00004db5, 0x00004e00, 0x00009fef,
0x0000a000, 0x0000a014, 0x0000a016, 0x0000a48c,
0x0000a4d0, 0x0000a4f7, 0x0000a500, 0x0000a60b,
0x0000a610, 0x0000a61f, 0x0000a62a, 0x0000a62b,
0x0000a66e, 0x0000a66e, 0x0000a6a0, 0x0000a6e5,
0x0000a78f, 0x0000a78f, 0x0000a7f7, 0x0000a7f7,
0x0000a7fb, 0x0000a801, 0x0000a803, 0x0000a805,
0x0000a807, 0x0000a80a, 0x0000a80c, 0x0000a822,
0x0000a840, 0x0000a873, 0x0000a882, 0x0000a8b3,
0x0000a8f2, 0x0000a8f7, 0x0000a8fb, 0x0000a8fb,
0x0000a8fd, 0x0000a8fe, 0x0000a90a, 0x0000a925,
0x0000a930, 0x0000a946, 0x0000a960, 0x0000a97c,
0x0000a984, 0x0000a9b2, 0x0000a9e0, 0x0000a9e4,
0x0000a9e7, 0x0000a9ef, 0x0000a9fa, 0x0000a9fe,
0x0000aa00, 0x0000aa28, 0x0000aa40, 0x0000aa42,
0x0000aa44, 0x0000aa4b, 0x0000aa60, 0x0000aa6f,
0x0000aa71, 0x0000aa76, 0x0000aa7a, 0x0000aa7a,
0x0000aa7e, 0x0000aaaf, 0x0000aab1, 0x0000aab1,
0x0000aab5, 0x0000aab6, 0x0000aab9, 0x0000aabd,
0x0000aac0, 0x0000aac0, 0x0000aac2, 0x0000aac2,
0x0000aadb, 0x0000aadc, 0x0000aae0, 0x0000aaea,
0x0000aaf2, 0x0000aaf2, 0x0000ab01, 0x0000ab06,
0x0000ab09, 0x0000ab0e, 0x0000ab11, 0x0000ab16,
0x0000ab20, 0x0000ab26, 0x0000ab28, 0x0000ab2e,
0x0000abc0, 0x0000abe2, 0x0000ac00, 0x0000d7a3,
0x0000d7b0, 0x0000d7c6, 0x0000d7cb, 0x0000d7fb,
0x0000f900, 0x0000fa6d, 0x0000fa70, 0x0000fad9,
0x0000fb1d, 0x0000fb1d, 0x0000fb1f, 0x0000fb28,
0x0000fb2a, 0x0000fb36, 0x0000fb38, 0x0000fb3c,
0x0000fb3e, 0x0000fb3e, 0x0000fb40, 0x0000fb41,
0x0000fb43, 0x0000fb44, 0x0000fb46, 0x0000fbb1,
0x0000fbd3, 0x0000fd3d, 0x0000fd50, 0x0000fd8f,
0x0000fd92, 0x0000fdc7, 0x0000fdf0, 0x0000fdfb,
0x0000fe70, 0x0000fe74, 0x0000fe76, 0x0000fefc,
0x0000ff66, 0x0000ff6f, 0x0000ff71, 0x0000ff9d,
0x0000ffa0, 0x0000ffbe, 0x0000ffc2, 0x0000ffc7,
0x0000ffca, 0x0000ffcf, 0x0000ffd2, 0x0000ffd7,
0x0000ffda, 0x0000ffdc, 0x00010000, 0x0001000b,
0x0001000d, 0x00010026, 0x00010028, 0x0001003a,
0x0001003c, 0x0001003d, 0x0001003f, 0x0001004d,
0x00010050, 0x0001005d, 0x00010080, 0x000100fa,
0x00010280, 0x0001029c, 0x000102a0, 0x000102d0,
0x00010300, 0x0001031f, 0x0001032d, 0x00010340,
0x00010342, 0x00010349, 0x00010350, 0x00010375,
0x00010380, 0x0001039d, 0x000103a0, 0x000103c3,
0x000103c8, 0x000103cf, 0x00010450, 0x0001049d,
0x00010500, 0x00010527, 0x00010530, 0x00010563,
0x00010600, 0x00010736, 0x00010740, 0x00010755,
0x00010760, 0x00010767, 0x00010800, 0x00010805,
0x00010808, 0x00010808, 0x0001080a, 0x00010835,
0x00010837, 0x00010838, 0x0001083c, 0x0001083c,
0x0001083f, 0x00010855, 0x00010860, 0x00010876,
0x00010880, 0x0001089e, 0x000108e0, 0x000108f2,
0x000108f4, 0x000108f5, 0x00010900, 0x00010915,
0x00010920, 0x00010939, 0x00010980, 0x000109b7,
0x000109be, 0x000109bf, 0x00010a00, 0x00010a00,
0x00010a10, 0x00010a13, 0x00010a15, 0x00010a17,
0x00010a19, 0x00010a35, 0x00010a60, 0x00010a7c,
0x00010a80, 0x00010a9c, 0x00010ac0, 0x00010ac7,
0x00010ac9, 0x00010ae4, 0x00010b00, 0x00010b35,
0x00010b40, 0x00010b55, 0x00010b60, 0x00010b72,
0x00010b80, 0x00010b91, 0x00010c00, 0x00010c48,
0x00010d00, 0x00010d23, 0x00010f00, 0x00010f1c,
0x00010f27, 0x00010f27, 0x00010f30, 0x00010f45,
0x00011003, 0x00011037, 0x00011083, 0x000110af,
0x000110d0, 0x000110e8, 0x00011103, 0x00011126,
0x00011144, 0x00011144, 0x00011150, 0x00011172,
0x00011176, 0x00011176, 0x00011183, 0x000111b2,
0x000111c1, 0x000111c4, 0x000111da, 0x000111da,
0x000111dc, 0x000111dc, 0x00011200, 0x00011211,
0x00011213, 0x0001122b, 0x00011280, 0x00011286,
0x00011288, 0x00011288, 0x0001128a, 0x0001128d,
0x0001128f, 0x0001129d, 0x0001129f, 0x000112a8,
0x000112b0, 0x000112de, 0x00011305, 0x0001130c,
0x0001130f, 0x00011310, 0x00011313, 0x00011328,
0x0001132a, 0x00011330, 0x00011332, 0x00011333,
0x00011335, 0x00011339, 0x0001133d, 0x0001133d,
0x00011350, 0x00011350, 0x0001135d, 0x00011361,
0x00011400, 0x00011434, 0x00011447, 0x0001144a,
0x00011480, 0x000114af, 0x000114c4, 0x000114c5,
0x000114c7, 0x000114c7, 0x00011580, 0x000115ae,
0x000115d8, 0x000115db, 0x00011600, 0x0001162f,
0x00011644, 0x00011644, 0x00011680, 0x000116aa,
0x00011700, 0x0001171a, 0x00011800, 0x0001182b,
0x000118ff, 0x000118ff, 0x00011a00, 0x00011a00,
0x00011a0b, 0x00011a32, 0x00011a3a, 0x00011a3a,
0x00011a50, 0x00011a50, 0x00011a5c, 0x00011a83,
0x00011a86, 0x00011a89, 0x00011a9d, 0x00011a9d,
0x00011ac0, 0x00011af8, 0x00011c00, 0x00011c08,
0x00011c0a, 0x00011c2e, 0x00011c40, 0x00011c40,
0x00011c72, 0x00011c8f, 0x00011d00, 0x00011d06,
0x00011d08, 0x00011d09, 0x00011d0b, 0x00011d30,
0x00011d46, 0x00011d46, 0x00011d60, 0x00011d65,
0x00011d67, 0x00011d68, 0x00011d6a, 0x00011d89,
0x00011d98, 0x00011d98, 0x00011ee0, 0x00011ef2,
0x00012000, 0x00012399, 0x00012480, 0x00012543,
0x00013000, 0x0001342e, 0x00014400, 0x00014646,
0x00016800, 0x00016a38, 0x00016a40, 0x00016a5e,
0x00016ad0, 0x00016aed, 0x00016b00, 0x00016b2f,
0x00016b63, 0x00016b77, 0x00016b7d, 0x00016b8f,
0x00016f00, 0x00016f44, 0x00016f50, 0x00016f50,
0x00017000, 0x000187f1, 0x00018800, 0x00018af2,
0x0001b000, 0x0001b11e, 0x0001b170, 0x0001b2fb,
0x0001bc00, 0x0001bc6a, 0x0001bc70, 0x0001bc7c,
0x0001bc80, 0x0001bc88, 0x0001bc90, 0x0001bc99,
0x0001e800, 0x0001e8c4, 0x0001ee00, 0x0001ee03,
0x0001ee05, 0x0001ee1f, 0x0001ee21, 0x0001ee22,
0x0001ee24, 0x0001ee24, 0x0001ee27, 0x0001ee27,
0x0001ee29, 0x0001ee32, 0x0001ee34, 0x0001ee37,
0x0001ee39, 0x0001ee39, 0x0001ee3b, 0x0001ee3b,
0x0001ee42, 0x0001ee42, 0x0001ee47, 0x0001ee47,
0x0001ee49, 0x0001ee49, 0x0001ee4b, 0x0001ee4b,
0x0001ee4d, 0x0001ee4f, 0x0001ee51, 0x0001ee52,
0x0001ee54, 0x0001ee54, 0x0001ee57, 0x0001ee57,
0x0001ee59, 0x0001ee59, 0x0001ee5b, 0x0001ee5b,
0x0001ee5d, 0x0001ee5d, 0x0001ee5f, 0x0001ee5f,
0x0001ee61, 0x0001ee62, 0x0001ee64, 0x0001ee64,
0x0001ee67, 0x0001ee6a, 0x0001ee6c, 0x0001ee72,
0x0001ee74, 0x0001ee77, 0x0001ee79, 0x0001ee7c,
0x0001ee7e, 0x0001ee7e, 0x0001ee80, 0x0001ee89,
0x0001ee8b, 0x0001ee9b, 0x0001eea1, 0x0001eea3,
0x0001eea5, 0x0001eea9, 0x0001eeab, 0x0001eebb,
0x00020000, 0x0002a6d6, 0x0002a700, 0x0002b734,
0x0002b740, 0x0002b81d, 0x0002b820, 0x0002cea1,
0x0002ceb0, 0x0002ebe0, 0x0002f800, 0x0002fa1d,
0x0000005f, 0x0000005f, 0x0000203f, 0x00002040,
0x00002054, 0x00002054, 0x0000fe33, 0x0000fe34,
0x0000fe4d, 0x0000fe4f, 0x0000ff3f, 0x0000ff3f,
0x0000002d, 0x0000002d, 0x0000058a, 0x0000058a,
0x000005be, 0x000005be, 0x00001400, 0x00001400,
0x00001806, 0x00001806, 0x00002010, 0x00002015,
0x00002e17, 0x00002e17, 0x00002e1a, 0x00002e1a,
0x00002e3a, 0x00002e3b, 0x00002e40, 0x00002e40,
0x0000301c, 0x0000301c, 0x00003030, 0x00003030,
0x000030a0, 0x000030a0, 0x0000fe31, 0x0000fe32,
0x0000fe58, 0x0000fe58, 0x0000fe63, 0x0000fe63,
0x0000ff0d, 0x0000ff0d, 0x00000028, 0x00000028,
0x0000005b, 0x0000005b, 0x0000007b, 0x0000007b,
0x00000f3a, 0x00000f3a, 0x00000f3c, 0x00000f3c,
0x0000169b, 0x0000169b, 0x0000201a, 0x0000201a,
0x0000201e, 0x0000201e, 0x00002045, 0x00002045,
0x0000207d, 0x0000207d, 0x0000208d, 0x0000208d,
0x00002308, 0x00002308, 0x0000230a, 0x0000230a,
0x00002329, 0x00002329, 0x00002768, 0x00002768,
0x0000276a, 0x0000276a, 0x0000276c, 0x0000276c,
0x0000276e, 0x0000276e, 0x00002770, 0x00002770,
0x00002772, 0x00002772, 0x00002774, 0x00002774,
0x000027c5, 0x000027c5, 0x000027e6, 0x000027e6,
0x000027e8, 0x000027e8, 0x000027ea, 0x000027ea,
0x000027ec, 0x000027ec, 0x000027ee, 0x000027ee,
0x00002983, 0x00002983, 0x00002985, 0x00002985,
0x00002987, 0x00002987, 0x00002989, 0x00002989,
0x0000298b, 0x0000298b, 0x0000298d, 0x0000298d,
0x0000298f, 0x0000298f, 0x00002991, 0x00002991,
0x00002993, 0x00002993, 0x00002995, 0x00002995,
0x00002997, 0x00002997, 0x000029d8, 0x000029d8,
0x000029da, 0x000029da, 0x000029fc, 0x000029fc,
0x00002e22, 0x00002e22, 0x00002e24, 0x00002e24,
0x00002e26, 0x00002e26, 0x00002e28, 0x00002e28,
0x00002e42, 0x00002e42, 0x00003008, 0x00003008,
0x0000300a, 0x0000300a, 0x0000300c, 0x0000300c,
0x0000300e, 0x0000300e, 0x00003010, 0x00003010,
0x00003014, 0x00003014, 0x00003016, 0x00003016,
0x00003018, 0x00003018, 0x0000301a, 0x0000301a,
0x0000301d, 0x0000301d, 0x0000fd3f, 0x0000fd3f,
0x0000fe17, 0x0000fe17, 0x0000fe35, 0x0000fe35,
0x0000fe37, 0x0000fe37, 0x0000fe39, 0x0000fe39,
0x0000fe3b, 0x0000fe3b, 0x0000fe3d, 0x0000fe3d,
0x0000fe3f, 0x0000fe3f, 0x0000fe41, 0x0000fe41,
0x0000fe43, 0x0000fe43, 0x0000fe47, 0x0000fe47,
0x0000fe59, 0x0000fe59, 0x0000fe5b, 0x0000fe5b,
0x0000fe5d, 0x0000fe5d, 0x0000ff08, 0x0000ff08,
0x0000ff3b, 0x0000ff3b, 0x0000ff5b, 0x0000ff5b,
0x0000ff5f, 0x0000ff5f, 0x0000ff62, 0x0000ff62,
0x00000029, 0x00000029, 0x0000005d, 0x0000005d,
0x0000007d, 0x0000007d, 0x00000f3b, 0x00000f3b,
0x00000f3d, 0x00000f3d, 0x0000169c, 0x0000169c,
0x00002046, 0x00002046, 0x0000207e, 0x0000207e,
0x0000208e, 0x0000208e, 0x00002309, 0x00002309,
0x0000230b, 0x0000230b, 0x0000232a, 0x0000232a,
0x00002769, 0x00002769, 0x0000276b, 0x0000276b,
0x0000276d, 0x0000276d, 0x0000276f, 0x0000276f,
0x00002771, 0x00002771, 0x00002773, 0x00002773,
0x00002775, 0x00002775, 0x000027c6, 0x000027c6,
0x000027e7, 0x000027e7, 0x000027e9, 0x000027e9,
0x000027eb, 0x000027eb, 0x000027ed, 0x000027ed,
0x000027ef, 0x000027ef, 0x00002984, 0x00002984,
0x00002986, 0x00002986, 0x00002988, 0x00002988,
0x0000298a, 0x0000298a, 0x0000298c, 0x0000298c,
0x0000298e, 0x0000298e, 0x00002990, 0x00002990,
0x00002992, 0x00002992, 0x00002994, 0x00002994,
0x00002996, 0x00002996, 0x00002998, 0x00002998,
0x000029d9, 0x000029d9, 0x000029db, 0x000029db,
0x000029fd, 0x000029fd, 0x00002e23, 0x00002e23,
0x00002e25, 0x00002e25, 0x00002e27, 0x00002e27,
0x00002e29, 0x00002e29, 0x00003009, 0x00003009,
0x0000300b, 0x0000300b, 0x0000300d, 0x0000300d,
0x0000300f, 0x0000300f, 0x00003011, 0x00003011,
0x00003015, 0x00003015, 0x00003017, 0x00003017,
0x00003019, 0x00003019, 0x0000301b, 0x0000301b,
0x0000301e, 0x0000301f, 0x0000fd3e, 0x0000fd3e,
0x0000fe18, 0x0000fe18, 0x0000fe36, 0x0000fe36,
0x0000fe38, 0x0000fe38, 0x0000fe3a, 0x0000fe3a,
0x0000fe3c, 0x0000fe3c, 0x0000fe3e, 0x0000fe3e,
0x0000fe40, 0x0000fe40, 0x0000fe42, 0x0000fe42,
0x0000fe44, 0x0000fe44, 0x0000fe48, 0x0000fe48,
0x0000fe5a, 0x0000fe5a, 0x0000fe5c, 0x0000fe5c,
0x0000fe5e, 0x0000fe5e, 0x0000ff09, 0x0000ff09,
0x0000ff3d, 0x0000ff3d, 0x0000ff5d, 0x0000ff5d,
0x0000ff60, 0x0000ff60, 0x0000ff63, 0x0000ff63,
0x00000021, 0x00000023, 0x00000025, 0x00000027,
0x0000002a, 0x0000002a, 0x0000002c, 0x0000002c,
0x0000002e, 0x0000002f, 0x0000003a, 0x0000003b,
0x0000003f, 0x00000040, 0x0000005c, 0x0000005c,
0x000000a1, 0x000000a1, 0x000000a7, 0x000000a7,
0x000000b6, 0x000000b7, 0x000000bf, 0x000000bf,
0x0000037e, 0x0000037e, 0x00000387, 0x00000387,
0x0000055a, 0x0000055f, 0x00000589, 0x00000589,
0x000005c0, 0x000005c0, 0x000005c3, 0x000005c3,
0x000005c6, 0x000005c6, 0x000005f3, 0x000005f4,
0x00000609, 0x0000060a, 0x0000060c, 0x0000060d,
0x0000061b, 0x0000061b, 0x0000061e, 0x0000061f,
0x0000066a, 0x0000066d, 0x000006d4, 0x000006d4,
0x00000700, 0x0000070d, 0x000007f7, 0x000007f9,
0x00000830, 0x0000083e, 0x0000085e, 0x0000085e,
0x00000964, 0x00000965, 0x00000970, 0x00000970,
0x000009fd, 0x000009fd, 0x00000a76, 0x00000a76,
0x00000af0, 0x00000af0, 0x00000c84, 0x00000c84,
0x00000df4, 0x00000df4, 0x00000e4f, 0x00000e4f,
0x00000e5a, 0x00000e5b, 0x00000f04, 0x00000f12,
0x00000f14, 0x00000f14, 0x00000f85, 0x00000f85,
0x00000fd0, 0x00000fd4, 0x00000fd9, 0x00000fda,
0x0000104a, 0x0000104f, 0x000010fb, 0x000010fb,
0x00001360, 0x00001368, 0x0000166d, 0x0000166e,
0x000016eb, 0x000016ed, 0x00001735, 0x00001736,
0x000017d4, 0x000017d6, 0x000017d8, 0x000017da,
0x00001800, 0x00001805, 0x00001807, 0x0000180a,
0x00001944, 0x00001945, 0x00001a1e, 0x00001a1f,
0x00001aa0, 0x00001aa6, 0x00001aa8, 0x00001aad,
0x00001b5a, 0x00001b60, 0x00001bfc, 0x00001bff,
0x00001c3b, 0x00001c3f, 0x00001c7e, 0x00001c7f,
0x00001cc0, 0x00001cc7, 0x00001cd3, 0x00001cd3,
0x00002016, 0x00002017, 0x00002020, 0x00002027,
0x00002030, 0x00002038, 0x0000203b, 0x0000203e,
0x00002041, 0x00002043, 0x00002047, 0x00002051,
0x00002053, 0x00002053, 0x00002055, 0x0000205e,
0x00002cf9, 0x00002cfc, 0x00002cfe, 0x00002cff,
0x00002d70, 0x00002d70, 0x00002e00, 0x00002e01,
0x00002e06, 0x00002e08, 0x00002e0b, 0x00002e0b,
0x00002e0e, 0x00002e16, 0x00002e18, 0x00002e19,
0x00002e1b, 0x00002e1b, 0x00002e1e, 0x00002e1f,
0x00002e2a, 0x00002e2e, 0x00002e30, 0x00002e39,
0x00002e3c, 0x00002e3f, 0x00002e41, 0x00002e41,
0x00002e43, 0x00002e4e, 0x00003001, 0x00003003,
0x0000303d, 0x0000303d, 0x000030fb, 0x000030fb,
0x0000a4fe, 0x0000a4ff, 0x0000a60d, 0x0000a60f,
0x0000a673, 0x0000a673, 0x0000a67e, 0x0000a67e,
0x0000a6f2, 0x0000a6f7, 0x0000a874, 0x0000a877,
0x0000a8ce, 0x0000a8cf, 0x0000a8f8, 0x0000a8fa,
0x0000a8fc, 0x0000a8fc, 0x0000a92e, 0x0000a92f,
0x0000a95f, 0x0000a95f, 0x0000a9c1, 0x0000a9cd,
0x0000a9de, 0x0000a9df, 0x0000aa5c, 0x0000aa5f,
0x0000aade, 0x0000aadf, 0x0000aaf0, 0x0000aaf1,
0x0000abeb, 0x0000abeb, 0x0000fe10, 0x0000fe16,
0x0000fe19, 0x0000fe19, 0x0000fe30, 0x0000fe30,
0x0000fe45, 0x0000fe46, 0x0000fe49, 0x0000fe4c,
0x0000fe50, 0x0000fe52, 0x0000fe54, 0x0000fe57,
0x0000fe5f, 0x0000fe61, 0x0000fe68, 0x0000fe68,
0x0000fe6a, 0x0000fe6b, 0x0000ff01, 0x0000ff03,
0x0000ff05, 0x0000ff07, 0x0000ff0a, 0x0000ff0a,
0x0000ff0c, 0x0000ff0c, 0x0000ff0e, 0x0000ff0f,
0x0000ff1a, 0x0000ff1b, 0x0000ff1f, 0x0000ff20,
0x0000ff3c, 0x0000ff3c, 0x0000ff61, 0x0000ff61,
0x0000ff64, 0x0000ff65, 0x00010100, 0x00010102,
0x0001039f, 0x0001039f, 0x000103d0, 0x000103d0,
0x0001056f, 0x0001056f, 0x00010857, 0x00010857,
0x0001091f, 0x0001091f, 0x0001093f, 0x0001093f,
0x00010a50, 0x00010a58, 0x00010a7f, 0x00010a7f,
0x00010af0, 0x00010af6, 0x00010b39, 0x00010b3f,
0x00010b99, 0x00010b9c, 0x00010f55, 0x00010f59,
0x00011047, 0x0001104d, 0x000110bb, 0x000110bc,
0x000110be, 0x000110c1, 0x00011140, 0x00011143,
0x00011174, 0x00011175, 0x000111c5, 0x000111c8,
0x000111cd, 0x000111cd, 0x000111db, 0x000111db,
0x000111dd, 0x000111df, 0x00011238, 0x0001123d,
0x000112a9, 0x000112a9, 0x0001144b, 0x0001144f,
0x0001145b, 0x0001145b, 0x0001145d, 0x0001145d,
0x000114c6, 0x000114c6, 0x000115c1, 0x000115d7,
0x00011641, 0x00011643, 0x00011660, 0x0001166c,
0x0001173c, 0x0001173e, 0x0001183b, 0x0001183b,
0x00011a3f, 0x00011a46, 0x00011a9a, 0x00011a9c,
0x00011a9e, 0x00011aa2, 0x00011c41, 0x00011c45,
0x00011c70, 0x00011c71, 0x00011ef7, 0x00011ef8,
0x00012470, 0x00012474, 0x00016a6e, 0x00016a6f,
0x00016af5, 0x00016af5, 0x00016b37, 0x00016b3b,
0x00016b44, 0x00016b44, 0x00016e97, 0x00016e9a,
0x0001bc9f, 0x0001bc9f, 0x0001da87, 0x0001da8b,
0x0001e95e, 0x0001e95f, 0x0000002b, 0x0000002b,
0x0000003c, 0x0000003e, 0x0000007c, 0x0000007c,
0x0000007e, 0x0000007e, 0x000000ac, 0x000000ac,
0x000000b1, 0x000000b1, 0x000000d7, 0x000000d7,
0x000000f7, 0x000000f7, 0x000003f6, 0x000003f6,
0x00000606, 0x00000608, 0x00002044, 0x00002044,
0x00002052, 0x00002052, 0x0000207a, 0x0000207c,
0x0000208a, 0x0000208c, 0x00002118, 0x00002118,
0x00002140, 0x00002144, 0x0000214b, 0x0000214b,
0x00002190, 0x00002194, 0x0000219a, 0x0000219b,
0x000021a0, 0x000021a0, 0x000021a3, 0x000021a3,
0x000021a6, 0x000021a6, 0x000021ae, 0x000021ae,
0x000021ce, 0x000021cf, 0x000021d2, 0x000021d2,
0x000021d4, 0x000021d4, 0x000021f4, 0x000022ff,
0x00002320, 0x00002321, 0x0000237c, 0x0000237c,
0x0000239b, 0x000023b3, 0x000023dc, 0x000023e1,
0x000025b7, 0x000025b7, 0x000025c1, 0x000025c1,
0x000025f8, 0x000025ff, 0x0000266f, 0x0000266f,
0x000027c0, 0x000027c4, 0x000027c7, 0x000027e5,
0x000027f0, 0x000027ff, 0x00002900, 0x00002982,
0x00002999, 0x000029d7, 0x000029dc, 0x000029fb,
0x000029fe, 0x00002aff, 0x00002b30, 0x00002b44,
0x00002b47, 0x00002b4c, 0x0000fb29, 0x0000fb29,
0x0000fe62, 0x0000fe62, 0x0000fe64, 0x0000fe66,
0x0000ff0b, 0x0000ff0b, 0x0000ff1c, 0x0000ff1e,
0x0000ff5c, 0x0000ff5c, 0x0000ff5e, 0x0000ff5e,
0x0000ffe2, 0x0000ffe2, 0x0000ffe9, 0x0000ffec,
0x0001d6c1, 0x0001d6c1, 0x0001d6db, 0x0001d6db,
0x0001d6fb, 0x0001d6fb, 0x0001d715, 0x0001d715,
0x0001d735, 0x0001d735, 0x0001d74f, 0x0001d74f,
0x0001d76f, 0x0001d76f, 0x0001d789, 0x0001d789,
0x0001d7a9, 0x0001d7a9, 0x0001d7c3, 0x0001d7c3,
0x0001eef0, 0x0001eef1, 0x00000024, 0x00000024,
0x000000a2, 0x000000a5, 0x0000058f, 0x0000058f,
0x0000060b, 0x0000060b, 0x000007fe, 0x000007ff,
0x000009f2, 0x000009f3, 0x000009fb, 0x000009fb,
0x00000af1, 0x00000af1, 0x00000bf9, 0x00000bf9,
0x00000e3f, 0x00000e3f, 0x000017db, 0x000017db,
0x000020a0, 0x000020bf, 0x0000a838, 0x0000a838,
0x0000fdfc, 0x0000fdfc, 0x0000fe69, 0x0000fe69,
0x0000ff04, 0x0000ff04, 0x0000ffe0, 0x0000ffe1,
0x0000ffe5, 0x0000ffe6, 0x0001ecb0, 0x0001ecb0,
0x0000005e, 0x0000005e, 0x00000060, 0x00000060,
0x000000a8, 0x000000a8, 0x000000af, 0x000000af,
0x000000b4, 0x000000b4, 0x000000b8, 0x000000b8,
0x000002c2, 0x000002c5, 0x000002d2, 0x000002df,
0x000002e5, 0x000002eb, 0x000002ed, 0x000002ed,
0x000002ef, 0x000002ff, 0x00000375, 0x00000375,
0x00000384, 0x00000385, 0x00001fbd, 0x00001fbd,
0x00001fbf, 0x00001fc1, 0x00001fcd, 0x00001fcf,
0x00001fdd, 0x00001fdf, 0x00001fed, 0x00001fef,
0x00001ffd, 0x00001ffe, 0x0000309b, 0x0000309c,
0x0000a700, 0x0000a716, 0x0000a720, 0x0000a721,
0x0000a789, 0x0000a78a, 0x0000ab5b, 0x0000ab5b,
0x0000fbb2, 0x0000fbc1, 0x0000ff3e, 0x0000ff3e,
0x0000ff40, 0x0000ff40, 0x0000ffe3, 0x0000ffe3,
0x0001f3fb, 0x0001f3ff, 0x000000a6, 0x000000a6,
0x000000a9, 0x000000a9, 0x000000ae, 0x000000ae,
0x000000b0, 0x000000b0, 0x00000482, 0x00000482,
0x0000058d, 0x0000058e, 0x0000060e, 0x0000060f,
0x000006de, 0x000006de, 0x000006e9, 0x000006e9,
0x000006fd, 0x000006fe, 0x000007f6, 0x000007f6,
0x000009fa, 0x000009fa, 0x00000b70, 0x00000b70,
0x00000bf3, 0x00000bf8, 0x00000bfa, 0x00000bfa,
0x00000c7f, 0x00000c7f, 0x00000d4f, 0x00000d4f,
0x00000d79, 0x00000d79, 0x00000f01, 0x00000f03,
0x00000f13, 0x00000f13, 0x00000f15, 0x00000f17,
0x00000f1a, 0x00000f1f, 0x00000f34, 0x00000f34,
0x00000f36, 0x00000f36, 0x00000f38, 0x00000f38,
0x00000fbe, 0x00000fc5, 0x00000fc7, 0x00000fcc,
0x00000fce, 0x00000fcf, 0x00000fd5, 0x00000fd8,
0x0000109e, 0x0000109f, 0x00001390, 0x00001399,
0x00001940, 0x00001940, 0x000019de, 0x000019ff,
0x00001b61, 0x00001b6a, 0x00001b74, 0x00001b7c,
0x00002100, 0x00002101, 0x00002103, 0x00002106,
0x00002108, 0x00002109, 0x00002114, 0x00002114,
0x00002116, 0x00002117, 0x0000211e, 0x00002123,
0x00002125, 0x00002125, 0x00002127, 0x00002127,
0x00002129, 0x00002129, 0x0000212e, 0x0000212e,
0x0000213a, 0x0000213b, 0x0000214a, 0x0000214a,
0x0000214c, 0x0000214d, 0x0000214f, 0x0000214f,
0x0000218a, 0x0000218b, 0x00002195, 0x00002199,
0x0000219c, 0x0000219f, 0x000021a1, 0x000021a2,
0x000021a4, 0x000021a5, 0x000021a7, 0x000021ad,
0x000021af, 0x000021cd, 0x000021d0, 0x000021d1,
0x000021d3, 0x000021d3, 0x000021d5, 0x000021f3,
0x00002300, 0x00002307, 0x0000230c, 0x0000231f,
0x00002322, 0x00002328, 0x0000232b, 0x0000237b,
0x0000237d, 0x0000239a, 0x000023b4, 0x000023db,
0x000023e2, 0x00002426, 0x00002440, 0x0000244a,
0x0000249c, 0x000024e9, 0x00002500, 0x000025b6,
0x000025b8, 0x000025c0, 0x000025c2, 0x000025f7,
0x00002600, 0x0000266e, 0x00002670, 0x00002767,
0x00002794, 0x000027bf, 0x00002800, 0x000028ff,
0x00002b00, 0x00002b2f, 0x00002b45, 0x00002b46,
0x00002b4d, 0x00002b73, 0x00002b76, 0x00002b95,
0x00002b98, 0x00002bc8, 0x00002bca, 0x00002bfe,
0x00002ce5, 0x00002cea, 0x00002e80, 0x00002e99,
0x00002e9b, 0x00002ef3, 0x00002f00, 0x00002fd5,
0x00002ff0, 0x00002ffb, 0x00003004, 0x00003004,
0x00003012, 0x00003013, 0x00003020, 0x00003020,
0x00003036, 0x00003037, 0x0000303e, 0x0000303f,
0x00003190, 0x00003191, 0x00003196, 0x0000319f,
0x000031c0, 0x000031e3, 0x00003200, 0x0000321e,
0x0000322a, 0x00003247, 0x00003250, 0x00003250,
0x00003260, 0x0000327f, 0x0000328a, 0x000032b0,
0x000032c0, 0x000032fe, 0x00003300, 0x000033ff,
0x00004dc0, 0x00004dff, 0x0000a490, 0x0000a4c6,
0x0000a828, 0x0000a82b, 0x0000a836, 0x0000a837,
0x0000a839, 0x0000a839, 0x0000aa77, 0x0000aa79,
0x0000fdfd, 0x0000fdfd, 0x0000ffe4, 0x0000ffe4,
0x0000ffe8, 0x0000ffe8, 0x0000ffed, 0x0000ffee,
0x0000fffc, 0x0000fffd, 0x00010137, 0x0001013f,
0x00010179, 0x00010189, 0x0001018c, 0x0001018e,
0x00010190, 0x0001019b, 0x000101a0, 0x000101a0,
0x000101d0, 0x000101fc, 0x00010877, 0x00010878,
0x00010ac8, 0x00010ac8, 0x0001173f, 0x0001173f,
0x00016b3c, 0x00016b3f, 0x00016b45, 0x00016b45,
0x0001bc9c, 0x0001bc9c, 0x0001d000, 0x0001d0f5,
0x0001d100, 0x0001d126, 0x0001d129, 0x0001d164,
0x0001d16a, 0x0001d16c, 0x0001d183, 0x0001d184,
0x0001d18c, 0x0001d1a9, 0x0001d1ae, 0x0001d1e8,
0x0001d200, 0x0001d241, 0x0001d245, 0x0001d245,
0x0001d300, 0x0001d356, 0x0001d800, 0x0001d9ff,
0x0001da37, 0x0001da3a, 0x0001da6d, 0x0001da74,
0x0001da76, 0x0001da83, 0x0001da85, 0x0001da86,
0x0001ecac, 0x0001ecac, 0x0001f000, 0x0001f02b,
0x0001f030, 0x0001f093, 0x0001f0a0, 0x0001f0ae,
0x0001f0b1, 0x0001f0bf, 0x0001f0c1, 0x0001f0cf,
0x0001f0d1, 0x0001f0f5, 0x0001f110, 0x0001f16b,
0x0001f170, 0x0001f1ac, 0x0001f1e6, 0x0001f202,
0x0001f210, 0x0001f23b, 0x0001f240, 0x0001f248,
0x0001f250, 0x0001f251, 0x0001f260, 0x0001f265,
0x0001f300, 0x0001f3fa, 0x0001f400, 0x0001f6d4,
0x0001f6e0, 0x0001f6ec, 0x0001f6f0, 0x0001f6f9,
0x0001f700, 0x0001f773, 0x0001f780, 0x0001f7d8,
0x0001f800, 0x0001f80b, 0x0001f810, 0x0001f847,
0x0001f850, 0x0001f859, 0x0001f860, 0x0001f887,
0x0001f890, 0x0001f8ad, 0x0001f900, 0x0001f90b,
0x0001f910, 0x0001f93e, 0x0001f940, 0x0001f970,
0x0001f973, 0x0001f976, 0x0001f97a, 0x0001f97a,
0x0001f97c, 0x0001f9a2, 0x0001f9b0, 0x0001f9b9,
0x0001f9c0, 0x0001f9c2, 0x0001f9d0, 0x0001f9ff,
0x0001fa60, 0x0001fa6d, 0x00000041, 0x0000005a,
0x00000061, 0x0000007a, 0x000000aa, 0x000000aa,
0x000000b5, 0x000000b5, 0x000000ba, 0x000000ba,
0x000000c0, 0x000000d6, 0x000000d8, 0x000000f6,
0x000000f8, 0x000002b8, 0x000002bb, 0x000002c1,
0x000002d0, 0x000002d1, 0x000002e0, 0x000002e4,
0x000002ee, 0x000002ee, 0x00000370, 0x00000373,
0x00000376, 0x00000377, 0x0000037a, 0x0000037d,
0x0000037f, 0x0000037f, 0x00000386, 0x00000386,
0x00000388, 0x0000038a, 0x0000038c, 0x0000038c,
0x0000038e, 0x000003a1, 0x000003a3, 0x000003f5,
0x000003f7, 0x00000482, 0x0000048a, 0x0000052f,
0x00000531, 0x00000556, 0x00000559, 0x00000589,
0x00000903, 0x00000939, 0x0000093b, 0x0000093b,
0x0000093d, 0x00000940, 0x00000949, 0x0000094c,
0x0000094e, 0x00000950, 0x00000958, 0x00000961,
0x00000964, 0x00000980, 0x00000982, 0x00000983,
0x00000985, 0x0000098c, 0x0000098f, 0x00000990,
0x00000993, 0x000009a8, 0x000009aa, 0x000009b0,
0x000009b2, 0x000009b2, 0x000009b6, 0x000009b9,
0x000009bd, 0x000009c0, 0x000009c7, 0x000009c8,
0x000009cb, 0x000009cc, 0x000009ce, 0x000009ce,
0x000009d7, 0x000009d7, 0x000009dc, 0x000009dd,
0x000009df, 0x000009e1, 0x000009e6, 0x000009f1,
0x000009f4, 0x000009fa, 0x000009fc, 0x000009fd,
0x00000a03, 0x00000a03, 0x00000a05, 0x00000a0a,
0x00000a0f, 0x00000a10, 0x00000a13, 0x00000a28,
0x00000a2a, 0x00000a30, 0x00000a32, 0x00000a33,
0x00000a35, 0x00000a36, 0x00000a38, 0x00000a39,
0x00000a3e, 0x00000a40, 0x00000a59, 0x00000a5c,
0x00000a5e, 0x00000a5e, 0x00000a66, 0x00000a6f,
0x00000a72, 0x00000a74, 0x00000a76, 0x00000a76,
0x00000a83, 0x00000a83, 0x00000a85, 0x00000a8d,
0x00000a8f, 0x00000a91, 0x00000a93, 0x00000aa8,
0x00000aaa, 0x00000ab0, 0x00000ab2, 0x00000ab3,
0x00000ab5, 0x00000ab9, 0x00000abd, 0x00000ac0,
0x00000ac9, 0x00000ac9, 0x00000acb, 0x00000acc,
0x00000ad0, 0x00000ad0, 0x00000ae0, 0x00000ae1,
0x00000ae6, 0x00000af0, 0x00000af9, 0x00000af9,
0x00000b02, 0x00000b03, 0x00000b05, 0x00000b0c,
0x00000b0f, 0x00000b10, 0x00000b13, 0x00000b28,
0x00000b2a, 0x00000b30, 0x00000b32, 0x00000b33,
0x00000b35, 0x00000b39, 0x00000b3d, 0x00000b3e,
0x00000b40, 0x00000b40, 0x00000b47, 0x00000b48,
0x00000b4b, 0x00000b4c, 0x00000b57, 0x00000b57,
0x00000b5c, 0x00000b5d, 0x00000b5f, 0x00000b61,
0x00000b66, 0x00000b77, 0x00000b83, 0x00000b83,
0x00000b85, 0x00000b8a, 0x00000b8e, 0x00000b90,
0x00000b92, 0x00000b95, 0x00000b99, 0x00000b9a,
0x00000b9c, 0x00000b9c, 0x00000b9e, 0x00000b9f,
0x00000ba3, 0x00000ba4, 0x00000ba8, 0x00000baa,
0x00000bae, 0x00000bb9, 0x00000bbe, 0x00000bbf,
0x00000bc1, 0x00000bc2, 0x00000bc6, 0x00000bc8,
0x00000bca, 0x00000bcc, 0x00000bd0, 0x00000bd0,
0x00000bd7, 0x00000bd7, 0x00000be6, 0x00000bf2,
0x00000c01, 0x00000c03, 0x00000c05, 0x00000c0c,
0x00000c0e, 0x00000c10, 0x00000c12, 0x00000c28,
0x00000c2a, 0x00000c39, 0x00000c3d, 0x00000c3d,
0x00000c41, 0x00000c44, 0x00000c58, 0x00000c5a,
0x00000c60, 0x00000c61, 0x00000c66, 0x00000c6f,
0x00000c7f, 0x00000c80, 0x00000c82, 0x00000c8c,
0x00000c8e, 0x00000c90, 0x00000c92, 0x00000ca8,
0x00000caa, 0x00000cb3, 0x00000cb5, 0x00000cb9,
0x00000cbd, 0x00000cc4, 0x00000cc6, 0x00000cc8,
0x00000cca, 0x00000ccb, 0x00000cd5, 0x00000cd6,
0x00000cde, 0x00000cde, 0x00000ce0, 0x00000ce1,
0x00000ce6, 0x00000cef, 0x00000cf1, 0x00000cf2,
0x00000d02, 0x00000d03, 0x00000d05, 0x00000d0c,
0x00000d0e, 0x00000d10, 0x00000d12, 0x00000d3a,
0x00000d3d, 0x00000d40, 0x00000d46, 0x00000d48,
0x00000d4a, 0x00000d4c, 0x00000d4e, 0x00000d4f,
0x00000d54, 0x00000d61, 0x00000d66, 0x00000d7f,
0x00000d82, 0x00000d83, 0x00000d85, 0x00000d96,
0x00000d9a, 0x00000db1, 0x00000db3, 0x00000dbb,
0x00000dbd, 0x00000dbd, 0x00000dc0, 0x00000dc6,
0x00000dcf, 0x00000dd1, 0x00000dd8, 0x00000ddf,
0x00000de6, 0x00000def, 0x00000df2, 0x00000df4,
0x00000e01, 0x00000e30, 0x00000e32, 0x00000e33,
0x00000e40, 0x00000e46, 0x00000e4f, 0x00000e5b,
0x00000e81, 0x00000e82, 0x00000e84, 0x00000e84,
0x00000e87, 0x00000e88, 0x00000e8a, 0x00000e8a,
0x00000e8d, 0x00000e8d, 0x00000e94, 0x00000e97,
0x00000e99, 0x00000e9f, 0x00000ea1, 0x00000ea3,
0x00000ea5, 0x00000ea5, 0x00000ea7, 0x00000ea7,
0x00000eaa, 0x00000eab, 0x00000ead, 0x00000eb0,
0x00000eb2, 0x00000eb3, 0x00000ebd, 0x00000ebd,
0x00000ec0, 0x00000ec4, 0x00000ec6, 0x00000ec6,
0x00000ed0, 0x00000ed9, 0x00000edc, 0x00000edf,
0x00000f00, 0x00000f17, 0x00000f1a, 0x00000f34,
0x00000f36, 0x00000f36, 0x00000f38, 0x00000f38,
0x00000f3e, 0x00000f47, 0x00000f49, 0x00000f6c,
0x00000f7f, 0x00000f7f, 0x00000f85, 0x00000f85,
0x00000f88, 0x00000f8c, 0x00000fbe, 0x00000fc5,
0x00000fc7, 0x00000fcc, 0x00000fce, 0x00000fda,
0x00001000, 0x0000102c, 0x00001031, 0x00001031,
0x00001038, 0x00001038, 0x0000103b, 0x0000103c,
0x0000103f, 0x00001057, 0x0000105a, 0x0000105d,
0x00001061, 0x00001070, 0x00001075, 0x00001081,
0x00001083, 0x00001084, 0x00001087, 0x0000108c,
0x0000108e, 0x0000109c, 0x0000109e, 0x000010c5,
0x000010c7, 0x000010c7, 0x000010cd, 0x000010cd,
0x000010d0, 0x00001248, 0x0000124a, 0x0000124d,
0x00001250, 0x00001256, 0x00001258, 0x00001258,
0x0000125a, 0x0000125d, 0x00001260, 0x00001288,
0x0000128a, 0x0000128d, 0x00001290, 0x000012b0,
0x000012b2, 0x000012b5, 0x000012b8, 0x000012be,
0x000012c0, 0x000012c0, 0x000012c2, 0x000012c5,
0x000012c8, 0x000012d6, 0x000012d8, 0x00001310,
0x00001312, 0x00001315, 0x00001318, 0x0000135a,
0x00001360, 0x0000137c, 0x00001380, 0x0000138f,
0x000013a0, 0x000013f5, 0x000013f8, 0x000013fd,
0x00001401, 0x0000167f, 0x00001681, 0x0000169a,
0x000016a0, 0x000016f8, 0x00001700, 0x0000170c,
0x0000170e, 0x00001711, 0x00001720, 0x00001731,
0x00001735, 0x00001736, 0x00001740, 0x00001751,
0x00001760, 0x0000176c, 0x0000176e, 0x00001770,
0x00001780, 0x000017b3, 0x000017b6, 0x000017b6,
0x000017be, 0x000017c5, 0x000017c7, 0x000017c8,
0x000017d4, 0x000017da, 0x000017dc, 0x000017dc,
0x000017e0, 0x000017e9, 0x00001810, 0x00001819,
0x00001820, 0x00001878, 0x00001880, 0x00001884,
0x00001887, 0x000018a8, 0x000018aa, 0x000018aa,
0x000018b0, 0x000018f5, 0x00001900, 0x0000191e,
0x00001923, 0x00001926, 0x00001929, 0x0000192b,
0x00001930, 0x00001931, 0x00001933, 0x00001938,
0x00001946, 0x0000196d, 0x00001970, 0x00001974,
0x00001980, 0x000019ab, 0x000019b0, 0x000019c9,
0x000019d0, 0x000019da, 0x00001a00, 0x00001a16,
0x00001a19, 0x00001a1a, 0x00001a1e, 0x00001a55,
0x00001a57, 0x00001a57, 0x00001a61, 0x00001a61,
0x00001a63, 0x00001a64, 0x00001a6d, 0x00001a72,
0x00001a80, 0x00001a89, 0x00001a90, 0x00001a99,
0x00001aa0, 0x00001aad, 0x00001b04, 0x00001b33,
0x00001b35, 0x00001b35, 0x00001b3b, 0x00001b3b,
0x00001b3d, 0x00001b41, 0x00001b43, 0x00001b4b,
0x00001b50, 0x00001b6a, 0x00001b74, 0x00001b7c,
0x00001b82, 0x00001ba1, 0x00001ba6, 0x00001ba7,
0x00001baa, 0x00001baa, 0x00001bae, 0x00001be5,
0x00001be7, 0x00001be7, 0x00001bea, 0x00001bec,
0x00001bee, 0x00001bee, 0x00001bf2, 0x00001bf3,
0x00001bfc, 0x00001c2b, 0x00001c34, 0x00001c35,
0x00001c3b, 0x00001c49, 0x00001c4d, 0x00001c88,
0x00001c90, 0x00001cba, 0x00001cbd, 0x00001cc7,
0x00001cd3, 0x00001cd3, 0x00001ce1, 0x00001ce1,
0x00001ce9, 0x00001cec, 0x00001cee, 0x00001cf3,
0x00001cf5, 0x00001cf7, 0x00001d00, 0x00001dbf,
0x00001e00, 0x00001f15, 0x00001f18, 0x00001f1d,
0x00001f20, 0x00001f45, 0x00001f48, 0x00001f4d,
0x00001f50, 0x00001f57, 0x00001f59, 0x00001f59,
0x00001f5b, 0x00001f5b, 0x00001f5d, 0x00001f5d,
0x00001f5f, 0x00001f7d, 0x00001f80, 0x00001fb4,
0x00001fb6, 0x00001fbc, 0x00001fbe, 0x00001fbe,
0x00001fc2, 0x00001fc4, 0x00001fc6, 0x00001fcc,
0x00001fd0, 0x00001fd3, 0x00001fd6, 0x00001fdb,
0x00001fe0, 0x00001fec, 0x00001ff2, 0x00001ff4,
0x00001ff6, 0x00001ffc, 0x0000200e, 0x0000200e,
0x00002071, 0x00002071, 0x0000207f, 0x0000207f,
0x00002090, 0x0000209c, 0x00002102, 0x00002102,
0x00002107, 0x00002107, 0x0000210a, 0x00002113,
0x00002115, 0x00002115, 0x00002119, 0x0000211d,
0x00002124, 0x00002124, 0x00002126, 0x00002126,
0x00002128, 0x00002128, 0x0000212a, 0x0000212d,
0x0000212f, 0x00002139, 0x0000213c, 0x0000213f,
0x00002145, 0x00002149, 0x0000214e, 0x0000214f,
0x00002160, 0x00002188, 0x00002336, 0x0000237a,
0x00002395, 0x00002395, 0x0000249c, 0x000024e9,
0x000026ac, 0x000026ac, 0x00002800, 0x000028ff,
0x00002c00, 0x00002c2e, 0x00002c30, 0x00002c5e,
0x00002c60, 0x00002ce4, 0x00002ceb, 0x00002cee,
0x00002cf2, 0x00002cf3, 0x00002d00, 0x00002d25,
0x00002d27, 0x00002d27, 0x00002d2d, 0x00002d2d,
0x00002d30, 0x00002d67, 0x00002d6f, 0x00002d70,
0x00002d80, 0x00002d96, 0x00002da0, 0x00002da6,
0x00002da8, 0x00002dae, 0x00002db0, 0x00002db6,
0x00002db8, 0x00002dbe, 0x00002dc0, 0x00002dc6,
0x00002dc8, 0x00002dce, 0x00002dd0, 0x00002dd6,
0x00002dd8, 0x00002dde, 0x00003005, 0x00003007,
0x00003021, 0x00003029, 0x0000302e, 0x0000302f,
0x00003031, 0x00003035, 0x00003038, 0x0000303c,
0x00003041, 0x00003096, 0x0000309d, 0x0000309f,
0x000030a1, 0x000030fa, 0x000030fc, 0x000030ff,
0x00003105, 0x0000312f, 0x00003131, 0x0000318e,
0x00003190, 0x000031ba, 0x000031f0, 0x0000321c,
0x00003220, 0x0000324f, 0x00003260, 0x0000327b,
0x0000327f, 0x000032b0, 0x000032c0, 0x000032cb,
0x000032d0, 0x000032fe, 0x00003300, 0x00003376,
0x0000337b, 0x000033dd, 0x000033e0, 0x000033fe,
0x00003400, 0x00004db5, 0x00004e00, 0x00009fef,
0x0000a000, 0x0000a48c, 0x0000a4d0, 0x0000a60c,
0x0000a610, 0x0000a62b, 0x0000a640, 0x0000a66e,
0x0000a680, 0x0000a69d, 0x0000a6a0, 0x0000a6ef,
0x0000a6f2, 0x0000a6f7, 0x0000a722, 0x0000a787,
0x0000a789, 0x0000a7b9, 0x0000a7f7, 0x0000a801,
0x0000a803, 0x0000a805, 0x0000a807, 0x0000a80a,
0x0000a80c, 0x0000a824, 0x0000a827, 0x0000a827,
0x0000a830, 0x0000a837, 0x0000a840, 0x0000a873,
0x0000a880, 0x0000a8c3, 0x0000a8ce, 0x0000a8d9,
0x0000a8f2, 0x0000a8fe, 0x0000a900, 0x0000a925,
0x0000a92e, 0x0000a946, 0x0000a952, 0x0000a953,
0x0000a95f, 0x0000a97c, 0x0000a983, 0x0000a9b2,
0x0000a9b4, 0x0000a9b5, 0x0000a9ba, 0x0000a9bb,
0x0000a9bd, 0x0000a9cd, 0x0000a9cf, 0x0000a9d9,
0x0000a9de, 0x0000a9e4, 0x0000a9e6, 0x0000a9fe,
0x0000aa00, 0x0000aa28, 0x0000aa2f, 0x0000aa30,
0x0000aa33, 0x0000aa34, 0x0000aa40, 0x0000aa42,
0x0000aa44, 0x0000aa4b, 0x0000aa4d, 0x0000aa4d,
0x0000aa50, 0x0000aa59, 0x0000aa5c, 0x0000aa7b,
0x0000aa7d, 0x0000aaaf, 0x0000aab1, 0x0000aab1,
0x0000aab5, 0x0000aab6, 0x0000aab9, 0x0000aabd,
0x0000aac0, 0x0000aac0, 0x0000aac2, 0x0000aac2,
0x0000aadb, 0x0000aaeb, 0x0000aaee, 0x0000aaf5,
0x0000ab01, 0x0000ab06, 0x0000ab09, 0x0000ab0e,
0x0000ab11, 0x0000ab16, 0x0000ab20, 0x0000ab26,
0x0000ab28, 0x0000ab2e, 0x0000ab30, 0x0000ab65,
0x0000ab70, 0x0000abe4, 0x0000abe6, 0x0000abe7,
0x0000abe9, 0x0000abec, 0x0000abf0, 0x0000abf9,
0x0000ac00, 0x0000d7a3, 0x0000d7b0, 0x0000d7c6,
0x0000d7cb, 0x0000d7fb, 0x0000d800, 0x0000fa6d,
0x0000fa70, 0x0000fad9, 0x0000fb00, 0x0000fb06,
0x0000fb13, 0x0000fb17, 0x0000ff21, 0x0000ff3a,
0x0000ff41, 0x0000ff5a, 0x0000ff66, 0x0000ffbe,
0x0000ffc2, 0x0000ffc7, 0x0000ffca, 0x0000ffcf,
0x0000ffd2, 0x0000ffd7, 0x0000ffda, 0x0000ffdc,
0x00010000, 0x0001000b, 0x0001000d, 0x00010026,
0x00010028, 0x0001003a, 0x0001003c, 0x0001003d,
0x0001003f, 0x0001004d, 0x00010050, 0x0001005d,
0x00010080, 0x000100fa, 0x00010100, 0x00010100,
0x00010102, 0x00010102, 0x00010107, 0x00010133,
0x00010137, 0x0001013f, 0x0001018d, 0x0001018e,
0x000101d0, 0x000101fc, 0x00010280, 0x0001029c,
0x000102a0, 0x000102d0, 0x00010300, 0x00010323,
0x0001032d, 0x0001034a, 0x00010350, 0x00010375,
0x00010380, 0x0001039d, 0x0001039f, 0x000103c3,
0x000103c8, 0x000103d5, 0x00010400, 0x0001049d,
0x000104a0, 0x000104a9, 0x000104b0, 0x000104d3,
0x000104d8, 0x000104fb, 0x00010500, 0x00010527,
0x00010530, 0x00010563, 0x0001056f, 0x0001056f,
0x00010600, 0x00010736, 0x00010740, 0x00010755,
0x00010760, 0x00010767, 0x00011000, 0x00011000,
0x00011002, 0x00011037, 0x00011047, 0x0001104d,
0x00011066, 0x0001106f, 0x00011082, 0x000110b2,
0x000110b7, 0x000110b8, 0x000110bb, 0x000110c1,
0x000110cd, 0x000110cd, 0x000110d0, 0x000110e8,
0x000110f0, 0x000110f9, 0x00011103, 0x00011126,
0x0001112c, 0x0001112c, 0x00011136, 0x00011146,
0x00011150, 0x00011172, 0x00011174, 0x00011176,
0x00011182, 0x000111b5, 0x000111bf, 0x000111c8,
0x000111cd, 0x000111cd, 0x000111d0, 0x000111df,
0x000111e1, 0x000111f4, 0x00011200, 0x00011211,
0x00011213, 0x0001122e, 0x00011232, 0x00011233,
0x00011235, 0x00011235, 0x00011238, 0x0001123d,
0x00011280, 0x00011286, 0x00011288, 0x00011288,
0x0001128a, 0x0001128d, 0x0001128f, 0x0001129d,
0x0001129f, 0x000112a9, 0x000112b0, 0x000112de,
0x000112e0, 0x000112e2, 0x000112f0, 0x000112f9,
0x00011302, 0x00011303, 0x00011305, 0x0001130c,
0x0001130f, 0x00011310, 0x00011313, 0x00011328,
0x0001132a, 0x00011330, 0x00011332, 0x00011333,
0x00011335, 0x00011339, 0x0001133d, 0x0001133f,
0x00011341, 0x00011344, 0x00011347, 0x00011348,
0x0001134b, 0x0001134d, 0x00011350, 0x00011350,
0x00011357, 0x00011357, 0x0001135d, 0x00011363,
0x00011400, 0x00011437, 0x00011440, 0x00011441,
0x00011445, 0x00011445, 0x00011447, 0x00011459,
0x0001145b, 0x0001145b, 0x0001145d, 0x0001145d,
0x00011480, 0x000114b2, 0x000114b9, 0x000114b9,
0x000114bb, 0x000114be, 0x000114c1, 0x000114c1,
0x000114c4, 0x000114c7, 0x000114d0, 0x000114d9,
0x00011580, 0x000115b1, 0x000115b8, 0x000115bb,
0x000115be, 0x000115be, 0x000115c1, 0x000115db,
0x00011600, 0x00011632, 0x0001163b, 0x0001163c,
0x0001163e, 0x0001163e, 0x00011641, 0x00011644,
0x00011650, 0x00011659, 0x00011680, 0x000116aa,
0x000116ac, 0x000116ac, 0x000116ae, 0x000116af,
0x000116b6, 0x000116b6, 0x000116c0, 0x000116c9,
0x00011700, 0x0001171a, 0x00011720, 0x00011721,
0x00011726, 0x00011726, 0x00011730, 0x0001173f,
0x00011800, 0x0001182e, 0x00011838, 0x00011838,
0x0001183b, 0x0001183b, 0x000118a0, 0x000118f2,
0x000118ff, 0x000118ff, 0x00011a00, 0x00011a00,
0x00011a07, 0x00011a08, 0x00011a0b, 0x00011a32,
0x00011a39, 0x00011a3a, 0x00011a3f, 0x00011a46,
0x00011a50, 0x00011a50, 0x00011a57, 0x00011a58,
0x00011a5c, 0x00011a83, 0x00011a86, 0x00011a89,
0x00011a97, 0x00011a97, 0x00011a9a, 0x00011aa2,
0x00011ac0, 0x00011af8, 0x00011c00, 0x00011c08,
0x00011c0a, 0x00011c2f, 0x00011c3e, 0x00011c45,
0x00011c50, 0x00011c6c, 0x00011c70, 0x00011c8f,
0x00011ca9, 0x00011ca9, 0x00011cb1, 0x00011cb1,
0x00011cb4, 0x00011cb4, 0x00011d00, 0x00011d06,
0x00011d08, 0x00011d09, 0x00011d0b, 0x00011d30,
0x00011d46, 0x00011d46, 0x00011d50, 0x00011d59,
0x00011d60, 0x00011d65, 0x00011d67, 0x00011d68,
0x00011d6a, 0x00011d8e, 0x00011d93, 0x00011d94,
0x00011d96, 0x00011d96, 0x00011d98, 0x00011d98,
0x00011da0, 0x00011da9, 0x00011ee0, 0x00011ef2,
0x00011ef5, 0x00011ef8, 0x00012000, 0x00012399,
0x00012400, 0x0001246e, 0x00012470, 0x00012474,
0x00012480, 0x00012543, 0x00013000, 0x0001342e,
0x00014400, 0x00014646, 0x00016800, 0x00016a38,
0x00016a40, 0x00016a5e, 0x00016a60, 0x00016a69,
0x00016a6e, 0x00016a6f, 0x00016ad0, 0x00016aed,
0x00016af5, 0x00016af5, 0x00016b00, 0x00016b2f,
0x00016b37, 0x00016b45, 0x00016b50, 0x00016b59,
0x00016b5b, 0x00016b61, 0x00016b63, 0x00016b77,
0x00016b7d, 0x00016b8f, 0x00016e40, 0x00016e9a,
0x00016f00, 0x00016f44, 0x00016f50, 0x00016f7e,
0x00016f93, 0x00016f9f, 0x00016fe0, 0x00016fe1,
0x00017000, 0x000187f1, 0x00018800, 0x00018af2,
0x0001b000, 0x0001b11e, 0x0001b170, 0x0001b2fb,
0x0001bc00, 0x0001bc6a, 0x0001bc70, 0x0001bc7c,
0x0001bc80, 0x0001bc88, 0x0001bc90, 0x0001bc99,
0x0001bc9c, 0x0001bc9c, 0x0001bc9f, 0x0001bc9f,
0x0001d000, 0x0001d0f5, 0x0001d100, 0x0001d126,
0x0001d129, 0x0001d166, 0x0001d16a, 0x0001d172,
0x0001d183, 0x0001d184, 0x0001d18c, 0x0001d1a9,
0x0001d1ae, 0x0001d1e8, 0x0001d2e0, 0x0001d2f3,
0x0001d360, 0x0001d378, 0x0001d400, 0x0001d454,
0x0001d456, 0x0001d49c, 0x0001d49e, 0x0001d49f,
0x0001d4a2, 0x0001d4a2, 0x0001d4a5, 0x0001d4a6,
0x0001d4a9, 0x0001d4ac, 0x0001d4ae, 0x0001d4b9,
0x0001d4bb, 0x0001d4bb, 0x0001d4bd, 0x0001d4c3,
0x0001d4c5, 0x0001d505, 0x0001d507, 0x0001d50a,
0x0001d50d, 0x0001d514, 0x0001d516, 0x0001d51c,
0x0001d51e, 0x0001d539, 0x0001d53b, 0x0001d53e,
0x0001d540, 0x0001d544, 0x0001d546, 0x0001d546,
0x0001d54a, 0x0001d550, 0x0001d552, 0x0001d6a5,
0x0001d6a8, 0x0001d6da, 0x0001d6dc, 0x0001d714,
0x0001d716, 0x0001d74e, 0x0001d750, 0x0001d788,
0x0001d78a, 0x0001d7c2, 0x0001d7c4, 0x0001d7cb,
0x0001d800, 0x0001d9ff, 0x0001da37, 0x0001da3a,
0x0001da6d, 0x0001da74, 0x0001da76, 0x0001da83,
0x0001da85, 0x0001da8b, 0x0001f110, 0x0001f12e,
0x0001f130, 0x0001f169, 0x0001f170, 0x0001f1ac,
0x0001f1e6, 0x0001f202, 0x0001f210, 0x0001f23b,
0x0001f240, 0x0001f248, 0x0001f250, 0x0001f251,
0x00020000, 0x0002a6d6, 0x0002a700, 0x0002b734,
0x0002b740, 0x0002b81d, 0x0002b820, 0x0002cea1,
0x0002ceb0, 0x0002ebe0, 0x0002f800, 0x0002fa1d,
0x000f0000, 0x000ffffd, 0x00100000, 0x0010fffd,
0x000005be, 0x000005be, 0x000005c0, 0x000005c0,
0x000005c3, 0x000005c3, 0x000005c6, 0x000005c6,
0x000005d0, 0x000005ea, 0x000005ef, 0x000005f4,
0x000007c0, 0x000007ea, 0x000007f4, 0x000007f5,
0x000007fa, 0x000007fa, 0x000007fe, 0x00000815,
0x0000081a, 0x0000081a, 0x00000824, 0x00000824,
0x00000828, 0x00000828, 0x00000830, 0x0000083e,
0x00000840, 0x00000858, 0x0000085e, 0x0000085e,
0x0000200f, 0x0000200f, 0x0000fb1d, 0x0000fb1d,
0x0000fb1f, 0x0000fb28, 0x0000fb2a, 0x0000fb36,
0x0000fb38, 0x0000fb3c, 0x0000fb3e, 0x0000fb3e,
0x0000fb40, 0x0000fb41, 0x0000fb43, 0x0000fb44,
0x0000fb46, 0x0000fb4f, 0x00010800, 0x00010805,
0x00010808, 0x00010808, 0x0001080a, 0x00010835,
0x00010837, 0x00010838, 0x0001083c, 0x0001083c,
0x0001083f, 0x00010855, 0x00010857, 0x0001089e,
0x000108a7, 0x000108af, 0x000108e0, 0x000108f2,
0x000108f4, 0x000108f5, 0x000108fb, 0x0001091b,
0x00010920, 0x00010939, 0x0001093f, 0x0001093f,
0x00010980, 0x000109b7, 0x000109bc, 0x000109cf,
0x000109d2, 0x00010a00, 0x00010a10, 0x00010a13,
0x00010a15, 0x00010a17, 0x00010a19, 0x00010a35,
0x00010a40, 0x00010a48, 0x00010a50, 0x00010a58,
0x00010a60, 0x00010a9f, 0x00010ac0, 0x00010ae4,
0x00010aeb, 0x00010af6, 0x00010b00, 0x00010b35,
0x00010b40, 0x00010b55, 0x00010b58, 0x00010b72,
0x00010b78, 0x00010b91, 0x00010b99, 0x00010b9c,
0x00010ba9, 0x00010baf, 0x00010c00, 0x00010c48,
0x00010c80, 0x00010cb2, 0x00010cc0, 0x00010cf2,
0x00010cfa, 0x00010cff, 0x00010f00, 0x00010f27,
0x0001e800, 0x0001e8c4, 0x0001e8c7, 0x0001e8cf,
0x0001e900, 0x0001e943, 0x0001e950, 0x0001e959,
0x0001e95e, 0x0001e95f, 0x00000030, 0x00000039,
0x000000b2, 0x000000b3, 0x000000b9, 0x000000b9,
0x000006f0, 0x000006f9, 0x00002070, 0x00002070,
0x00002074, 0x00002079, 0x00002080, 0x00002089,
0x00002488, 0x0000249b, 0x0000ff10, 0x0000ff19,
0x000102e1, 0x000102fb, 0x0001d7ce, 0x0001d7ff,
0x0001f100, 0x0001f10a, 0x0000002b, 0x0000002b,
0x0000002d, 0x0000002d, 0x0000207a, 0x0000207b,
0x0000208a, 0x0000208b, 0x00002212, 0x00002212,
0x0000fb29, 0x0000fb29, 0x0000fe62, 0x0000fe63,
0x0000ff0b, 0x0000ff0b, 0x0000ff0d, 0x0000ff0d,
0x00000023, 0x00000025, 0x000000a2, 0x000000a5,
0x000000b0, 0x000000b1, 0x0000058f, 0x0000058f,
0x00000609, 0x0000060a, 0x0000066a, 0x0000066a,
0x000009f2, 0x000009f3, 0x000009fb, 0x000009fb,
0x00000af1, 0x00000af1, 0x00000bf9, 0x00000bf9,
0x00000e3f, 0x00000e3f, 0x000017db, 0x000017db,
0x00002030, 0x00002034, 0x000020a0, 0x000020bf,
0x0000212e, 0x0000212e, 0x00002213, 0x00002213,
0x0000a838, 0x0000a839, 0x0000fe5f, 0x0000fe5f,
0x0000fe69, 0x0000fe6a, 0x0000ff03, 0x0000ff05,
0x0000ffe0, 0x0000ffe1, 0x0000ffe5, 0x0000ffe6,
0x00000600, 0x00000605, 0x00000660, 0x00000669,
0x0000066b, 0x0000066c, 0x000006dd, 0x000006dd,
0x000008e2, 0x000008e2, 0x00010d30, 0x00010d39,
0x00010e60, 0x00010e7e, 0x0000002c, 0x0000002c,
0x0000002e, 0x0000002f, 0x0000003a, 0x0000003a,
0x000000a0, 0x000000a0, 0x0000060c, 0x0000060c,
0x0000202f, 0x0000202f, 0x00002044, 0x00002044,
0x0000fe50, 0x0000fe50, 0x0000fe52, 0x0000fe52,
0x0000fe55, 0x0000fe55, 0x0000ff0c, 0x0000ff0c,
0x0000ff0e, 0x0000ff0f, 0x0000ff1a, 0x0000ff1a,
0x0000000a, 0x0000000a, 0x0000000d, 0x0000000d,
0x0000001c, 0x0000001e, 0x00000085, 0x00000085,
0x00002029, 0x00002029, 0x00000009, 0x00000009,
0x0000000b, 0x0000000b, 0x0000001f, 0x0000001f,
0x0000000c, 0x0000000c, 0x00000020, 0x00000020,
0x00001680, 0x00001680, 0x00002000, 0x0000200a,
0x00002028, 0x00002028, 0x0000205f, 0x0000205f,
0x00003000, 0x00003000, 0x00000000, 0x00000008,
0x0000000e, 0x0000001b, 0x00000021, 0x00000022,
0x00000026, 0x0000002a, 0x0000003b, 0x00000040,
0x0000005b, 0x00000060, 0x0000007b, 0x00000084,
0x00000086, 0x0000009f, 0x000000a1, 0x000000a1,
0x000000a6, 0x000000a9, 0x000000ab, 0x000000af,
0x000000b4, 0x000000b4, 0x000000b6, 0x000000b8,
0x000000bb, 0x000000bf, 0x000000d7, 0x000000d7,
0x000000f7, 0x000000f7, 0x000002b9, 0x000002ba,
0x000002c2, 0x000002cf, 0x000002d2, 0x000002df,
0x000002e5, 0x000002ed, 0x000002ef, 0x0000036f,
0x00000374, 0x00000375, 0x0000037e, 0x0000037e,
0x00000384, 0x00000385, 0x00000387, 0x00000387,
0x000003f6, 0x000003f6, 0x00000483, 0x00000489,
0x0000058a, 0x0000058a, 0x0000058d, 0x0000058e,
0x00000591, 0x000005bd, 0x000005bf, 0x000005bf,
0x000005c1, 0x000005c2, 0x000005c4, 0x000005c5,
0x000005c7, 0x000005c7, 0x00000606, 0x00000607,
0x0000060e, 0x0000061a, 0x0000064b, 0x0000065f,
0x00000670, 0x00000670, 0x000006d6, 0x000006dc,
0x000006de, 0x000006e4, 0x000006e7, 0x000006ed,
0x00000711, 0x00000711, 0x00000730, 0x0000074a,
0x000007a6, 0x000007b0, 0x000007eb, 0x000007f3,
0x000007f6, 0x000007f9, 0x000007fd, 0x000007fd,
0x00000816, 0x00000819, 0x0000081b, 0x00000823,
0x00000825, 0x00000827, 0x00000829, 0x0000082d,
0x00000859, 0x0000085b, 0x000008d3, 0x000008e1,
0x000008e3, 0x00000902, 0x0000093a, 0x0000093a,
0x0000093c, 0x0000093c, 0x00000941, 0x00000948,
0x0000094d, 0x0000094d, 0x00000951, 0x00000957,
0x00000962, 0x00000963, 0x00000981, 0x00000981,
0x000009bc, 0x000009bc, 0x000009c1, 0x000009c4,
0x000009cd, 0x000009cd, 0x000009e2, 0x000009e3,
0x000009fe, 0x000009fe, 0x00000a01, 0x00000a02,
0x00000a3c, 0x00000a3c, 0x00000a41, 0x00000a42,
0x00000a47, 0x00000a48, 0x00000a4b, 0x00000a4d,
0x00000a51, 0x00000a51, 0x00000a70, 0x00000a71,
0x00000a75, 0x00000a75, 0x00000a81, 0x00000a82,
0x00000abc, 0x00000abc, 0x00000ac1, 0x00000ac5,
0x00000ac7, 0x00000ac8, 0x00000acd, 0x00000acd,
0x00000ae2, 0x00000ae3, 0x00000afa, 0x00000aff,
0x00000b01, 0x00000b01, 0x00000b3c, 0x00000b3c,
0x00000b3f, 0x00000b3f, 0x00000b41, 0x00000b44,
0x00000b4d, 0x00000b4d, 0x00000b56, 0x00000b56,
0x00000b62, 0x00000b63, 0x00000b82, 0x00000b82,
0x00000bc0, 0x00000bc0, 0x00000bcd, 0x00000bcd,
0x00000bf3, 0x00000bf8, 0x00000bfa, 0x00000bfa,
0x00000c00, 0x00000c00, 0x00000c04, 0x00000c04,
0x00000c3e, 0x00000c40, 0x00000c46, 0x00000c48,
0x00000c4a, 0x00000c4d, 0x00000c55, 0x00000c56,
0x00000c62, 0x00000c63, 0x00000c78, 0x00000c7e,
0x00000c81, 0x00000c81, 0x00000cbc, 0x00000cbc,
0x00000ccc, 0x00000ccd, 0x00000ce2, 0x00000ce3,
0x00000d00, 0x00000d01, 0x00000d3b, 0x00000d3c,
0x00000d41, 0x00000d44, 0x00000d4d, 0x00000d4d,
0x00000d62, 0x00000d63, 0x00000dca, 0x00000dca,
0x00000dd2, 0x00000dd4, 0x00000dd6, 0x00000dd6,
0x00000e31, 0x00000e31, 0x00000e34, 0x00000e3a,
0x00000e47, 0x00000e4e, 0x00000eb1, 0x00000eb1,
0x00000eb4, 0x00000eb9, 0x00000ebb, 0x00000ebc,
0x00000ec8, 0x00000ecd, 0x00000f18, 0x00000f19,
0x00000f35, 0x00000f35, 0x00000f37, 0x00000f37,
0x00000f39, 0x00000f3d, 0x00000f71, 0x00000f7e,
0x00000f80, 0x00000f84, 0x00000f86, 0x00000f87,
0x00000f8d, 0x00000f97, 0x00000f99, 0x00000fbc,
0x00000fc6, 0x00000fc6, 0x0000102d, 0x00001030,
0x00001032, 0x00001037, 0x00001039, 0x0000103a,
0x0000103d, 0x0000103e, 0x00001058, 0x00001059,
0x0000105e, 0x00001060, 0x00001071, 0x00001074,
0x00001082, 0x00001082, 0x00001085, 0x00001086,
0x0000108d, 0x0000108d, 0x0000109d, 0x0000109d,
0x0000135d, 0x0000135f, 0x00001390, 0x00001399,
0x00001400, 0x00001400, 0x0000169b, 0x0000169c,
0x00001712, 0x00001714, 0x00001732, 0x00001734,
0x00001752, 0x00001753, 0x00001772, 0x00001773,
0x000017b4, 0x000017b5, 0x000017b7, 0x000017bd,
0x000017c6, 0x000017c6, 0x000017c9, 0x000017d3,
0x000017dd, 0x000017dd, 0x000017f0, 0x000017f9,
0x00001800, 0x0000180e, 0x00001885, 0x00001886,
0x000018a9, 0x000018a9, 0x00001920, 0x00001922,
0x00001927, 0x00001928, 0x00001932, 0x00001932,
0x00001939, 0x0000193b, 0x00001940, 0x00001940,
0x00001944, 0x00001945, 0x000019de, 0x000019ff,
0x00001a17, 0x00001a18, 0x00001a1b, 0x00001a1b,
0x00001a56, 0x00001a56, 0x00001a58, 0x00001a5e,
0x00001a60, 0x00001a60, 0x00001a62, 0x00001a62,
0x00001a65, 0x00001a6c, 0x00001a73, 0x00001a7c,
0x00001a7f, 0x00001a7f, 0x00001ab0, 0x00001abe,
0x00001b00, 0x00001b03, 0x00001b34, 0x00001b34,
0x00001b36, 0x00001b3a, 0x00001b3c, 0x00001b3c,
0x00001b42, 0x00001b42, 0x00001b6b, 0x00001b73,
0x00001b80, 0x00001b81, 0x00001ba2, 0x00001ba5,
0x00001ba8, 0x00001ba9, 0x00001bab, 0x00001bad,
0x00001be6, 0x00001be6, 0x00001be8, 0x00001be9,
0x00001bed, 0x00001bed, 0x00001bef, 0x00001bf1,
0x00001c2c, 0x00001c33, 0x00001c36, 0x00001c37,
0x00001cd0, 0x00001cd2, 0x00001cd4, 0x00001ce0,
0x00001ce2, 0x00001ce8, 0x00001ced, 0x00001ced,
0x00001cf4, 0x00001cf4, 0x00001cf8, 0x00001cf9,
0x00001dc0, 0x00001df9, 0x00001dfb, 0x00001dff,
0x00001fbd, 0x00001fbd, 0x00001fbf, 0x00001fc1,
0x00001fcd, 0x00001fcf, 0x00001fdd, 0x00001fdf,
0x00001fed, 0x00001fef, 0x00001ffd, 0x00001ffe,
0x0000200b, 0x0000200d, 0x00002010, 0x00002027,
0x0000202a, 0x0000202e, 0x00002035, 0x00002043,
0x00002045, 0x0000205e, 0x00002060, 0x00002064,
0x00002066, 0x0000206f, 0x0000207c, 0x0000207e,
0x0000208c, 0x0000208e, 0x000020d0, 0x000020f0,
0x00002100, 0x00002101, 0x00002103, 0x00002106,
0x00002108, 0x00002109, 0x00002114, 0x00002114,
0x00002116, 0x00002118, 0x0000211e, 0x00002123,
0x00002125, 0x00002125, 0x00002127, 0x00002127,
0x00002129, 0x00002129, 0x0000213a, 0x0000213b,
0x00002140, 0x00002144, 0x0000214a, 0x0000214d,
0x00002150, 0x0000215f, 0x00002189, 0x0000218b,
0x00002190, 0x00002211, 0x00002214, 0x00002335,
0x0000237b, 0x00002394, 0x00002396, 0x00002426,
0x00002440, 0x0000244a, 0x00002460, 0x00002487,
0x000024ea, 0x000026ab, 0x000026ad, 0x000027ff,
0x00002900, 0x00002b73, 0x00002b76, 0x00002b95,
0x00002b98, 0x00002bc8, 0x00002bca, 0x00002bfe,
0x00002ce5, 0x00002cea, 0x00002cef, 0x00002cf1,
0x00002cf9, 0x00002cff, 0x00002d7f, 0x00002d7f,
0x00002de0, 0x00002e4e, 0x00002e80, 0x00002e99,
0x00002e9b, 0x00002ef3, 0x00002f00, 0x00002fd5,
0x00002ff0, 0x00002ffb, 0x00003001, 0x00003004,
0x00003008, 0x00003020, 0x0000302a, 0x0000302d,
0x00003030, 0x00003030, 0x00003036, 0x00003037,
0x0000303d, 0x0000303f, 0x00003099, 0x0000309c,
0x000030a0, 0x000030a0, 0x000030fb, 0x000030fb,
0x000031c0, 0x000031e3, 0x0000321d, 0x0000321e,
0x00003250, 0x0000325f, 0x0000327c, 0x0000327e,
0x000032b1, 0x000032bf, 0x000032cc, 0x000032cf,
0x00003377, 0x0000337a, 0x000033de, 0x000033df,
0x000033ff, 0x000033ff, 0x00004dc0, 0x00004dff,
0x0000a490, 0x0000a4c6, 0x0000a60d, 0x0000a60f,
0x0000a66f, 0x0000a67f, 0x0000a69e, 0x0000a69f,
0x0000a6f0, 0x0000a6f1, 0x0000a700, 0x0000a721,
0x0000a788, 0x0000a788, 0x0000a802, 0x0000a802,
0x0000a806, 0x0000a806, 0x0000a80b, 0x0000a80b,
0x0000a825, 0x0000a826, 0x0000a828, 0x0000a82b,
0x0000a874, 0x0000a877, 0x0000a8c4, 0x0000a8c5,
0x0000a8e0, 0x0000a8f1, 0x0000a8ff, 0x0000a8ff,
0x0000a926, 0x0000a92d, 0x0000a947, 0x0000a951,
0x0000a980, 0x0000a982, 0x0000a9b3, 0x0000a9b3,
0x0000a9b6, 0x0000a9b9, 0x0000a9bc, 0x0000a9bc,
0x0000a9e5, 0x0000a9e5, 0x0000aa29, 0x0000aa2e,
0x0000aa31, 0x0000aa32, 0x0000aa35, 0x0000aa36,
0x0000aa43, 0x0000aa43, 0x0000aa4c, 0x0000aa4c,
0x0000aa7c, 0x0000aa7c, 0x0000aab0, 0x0000aab0,
0x0000aab2, 0x0000aab4, 0x0000aab7, 0x0000aab8,
0x0000aabe, 0x0000aabf, 0x0000aac1, 0x0000aac1,
0x0000aaec, 0x0000aaed, 0x0000aaf6, 0x0000aaf6,
0x0000abe5, 0x0000abe5, 0x0000abe8, 0x0000abe8,
0x0000abed, 0x0000abed, 0x0000fb1e, 0x0000fb1e,
0x0000fd3e, 0x0000fd3f, 0x0000fdfd, 0x0000fdfd,
0x0000fe00, 0x0000fe19, 0x0000fe20, 0x0000fe4f,
0x0000fe51, 0x0000fe51, 0x0000fe54, 0x0000fe54,
0x0000fe56, 0x0000fe5e, 0x0000fe60, 0x0000fe61,
0x0000fe64, 0x0000fe66, 0x0000fe68, 0x0000fe68,
0x0000fe6b, 0x0000fe6b, 0x0000feff, 0x0000feff,
0x0000ff01, 0x0000ff02, 0x0000ff06, 0x0000ff0a,
0x0000ff1b, 0x0000ff20, 0x0000ff3b, 0x0000ff40,
0x0000ff5b, 0x0000ff65, 0x0000ffe2, 0x0000ffe4,
0x0000ffe8, 0x0000ffee, 0x0000fff9, 0x0000fffd,
0x00010101, 0x00010101, 0x00010140, 0x0001018c,
0x00010190, 0x0001019b, 0x000101a0, 0x000101a0,
0x000101fd, 0x000101fd, 0x000102e0, 0x000102e0,
0x00010376, 0x0001037a, 0x0001091f, 0x0001091f,
0x00010a01, 0x00010a03, 0x00010a05, 0x00010a06,
0x00010a0c, 0x00010a0f, 0x00010a38, 0x00010a3a,
0x00010a3f, 0x00010a3f, 0x00010ae5, 0x00010ae6,
0x00010b39, 0x00010b3f, 0x00010d24, 0x00010d27,
0x00010f46, 0x00010f50, 0x00011001, 0x00011001,
0x00011038, 0x00011046, 0x00011052, 0x00011065,
0x0001107f, 0x00011081, 0x000110b3, 0x000110b6,
0x000110b9, 0x000110ba, 0x00011100, 0x00011102,
0x00011127, 0x0001112b, 0x0001112d, 0x00011134,
0x00011173, 0x00011173, 0x00011180, 0x00011181,
0x000111b6, 0x000111be, 0x000111c9, 0x000111cc,
0x0001122f, 0x00011231, 0x00011234, 0x00011234,
0x00011236, 0x00011237, 0x0001123e, 0x0001123e,
0x000112df, 0x000112df, 0x000112e3, 0x000112ea,
0x00011300, 0x00011301, 0x0001133b, 0x0001133c,
0x00011340, 0x00011340, 0x00011366, 0x0001136c,
0x00011370, 0x00011374, 0x00011438, 0x0001143f,
0x00011442, 0x00011444, 0x00011446, 0x00011446,
0x0001145e, 0x0001145e, 0x000114b3, 0x000114b8,
0x000114ba, 0x000114ba, 0x000114bf, 0x000114c0,
0x000114c2, 0x000114c3, 0x000115b2, 0x000115b5,
0x000115bc, 0x000115bd, 0x000115bf, 0x000115c0,
0x000115dc, 0x000115dd, 0x00011633, 0x0001163a,
0x0001163d, 0x0001163d, 0x0001163f, 0x00011640,
0x00011660, 0x0001166c, 0x000116ab, 0x000116ab,
0x000116ad, 0x000116ad, 0x000116b0, 0x000116b5,
0x000116b7, 0x000116b7, 0x0001171d, 0x0001171f,
0x00011722, 0x00011725, 0x00011727, 0x0001172b,
0x0001182f, 0x00011837, 0x00011839, 0x0001183a,
0x00011a01, 0x00011a06, 0x00011a09, 0x00011a0a,
0x00011a33, 0x00011a38, 0x00011a3b, 0x00011a3e,
0x00011a47, 0x00011a47, 0x00011a51, 0x00011a56,
0x00011a59, 0x00011a5b, 0x00011a8a, 0x00011a96,
0x00011a98, 0x00011a99, 0x00011c30, 0x00011c36,
0x00011c38, 0x00011c3d, 0x00011c92, 0x00011ca7,
0x00011caa, 0x00011cb0, 0x00011cb2, 0x00011cb3,
0x00011cb5, 0x00011cb6, 0x00011d31, 0x00011d36,
0x00011d3a, 0x00011d3a, 0x00011d3c, 0x00011d3d,
0x00011d3f, 0x00011d45, 0x00011d47, 0x00011d47,
0x00011d90, 0x00011d91, 0x00011d95, 0x00011d95,
0x00011d97, 0x00011d97, 0x00011ef3, 0x00011ef4,
0x00016af0, 0x00016af4, 0x00016b30, 0x00016b36,
0x00016f8f, 0x00016f92, 0x0001bc9d, 0x0001bc9e,
0x0001bca0, 0x0001bca3, 0x0001d167, 0x0001d169,
0x0001d173, 0x0001d182, 0x0001d185, 0x0001d18b,
0x0001d1aa, 0x0001d1ad, 0x0001d200, 0x0001d245,
0x0001d300, 0x0001d356, 0x0001d6db, 0x0001d6db,
0x0001d715, 0x0001d715, 0x0001d74f, 0x0001d74f,
0x0001d789, 0x0001d789, 0x0001d7c3, 0x0001d7c3,
0x0001da00, 0x0001da36, 0x0001da3b, 0x0001da6c,
0x0001da75, 0x0001da75, 0x0001da84, 0x0001da84,
0x0001da9b, 0x0001da9f, 0x0001daa1, 0x0001daaf,
0x0001e000, 0x0001e006, 0x0001e008, 0x0001e018,
0x0001e01b, 0x0001e021, 0x0001e023, 0x0001e024,
0x0001e026, 0x0001e02a, 0x0001e8d0, 0x0001e8d6,
0x0001e944, 0x0001e94a, 0x0001eef0, 0x0001eef1,
0x0001f000, 0x0001f02b, 0x0001f030, 0x0001f093,
0x0001f0a0, 0x0001f0ae, 0x0001f0b1, 0x0001f0bf,
0x0001f0c1, 0x0001f0cf, 0x0001f0d1, 0x0001f0f5,
0x0001f10b, 0x0001f10c, 0x0001f12f, 0x0001f12f,
0x0001f16a, 0x0001f16b, 0x0001f260, 0x0001f265,
0x0001f300, 0x0001f6d4, 0x0001f6e0, 0x0001f6ec,
0x0001f6f0, 0x0001f6f9, 0x0001f700, 0x0001f773,
0x0001f780, 0x0001f7d8, 0x0001f800, 0x0001f80b,
0x0001f810, 0x0001f847, 0x0001f850, 0x0001f859,
0x0001f860, 0x0001f887, 0x0001f890, 0x0001f8ad,
0x0001f900, 0x0001f90b, 0x0001f910, 0x0001f93e,
0x0001f940, 0x0001f970, 0x0001f973, 0x0001f976,
0x0001f97a, 0x0001f97a, 0x0001f97c, 0x0001f9a2,
0x0001f9b0, 0x0001f9b9, 0x0001f9c0, 0x0001f9c2,
0x0001f9d0, 0x0001f9ff, 0x0001fa60, 0x0001fa6d,
0x000e0001, 0x000e0001, 0x000e0020, 0x000e007f,
0x000e0100, 0x000e01ef, 0x000000ab, 0x000000ab,
0x00002018, 0x00002018, 0x0000201b, 0x0000201c,
0x0000201f, 0x0000201f, 0x00002039, 0x00002039,
0x00002e02, 0x00002e02, 0x00002e04, 0x00002e04,
0x00002e09, 0x00002e09, 0x00002e0c, 0x00002e0c,
0x00002e1c, 0x00002e1c, 0x00002e20, 0x00002e20,
0x000000bb, 0x000000bb, 0x00002019, 0x00002019,
0x0000201d, 0x0000201d, 0x0000203a, 0x0000203a,
0x00002e03, 0x00002e03, 0x00002e05, 0x00002e05,
0x00002e0a, 0x00002e0a, 0x00002e0d, 0x00002e0d,
0x00002e1d, 0x00002e1d, 0x00002e21, 0x00002e21,
0x00000608, 0x00000608, 0x0000060b, 0x0000060b,
0x0000060d, 0x0000060d, 0x0000061b, 0x0000061c,
0x0000061e, 0x0000064a, 0x0000066d, 0x0000066f,
0x00000671, 0x000006d5, 0x000006e5, 0x000006e6,
0x000006ee, 0x000006ef, 0x000006fa, 0x0000070d,
0x0000070f, 0x00000710, 0x00000712, 0x0000072f,
0x0000074d, 0x000007a5, 0x000007b1, 0x000007b1,
0x00000860, 0x0000086a, 0x000008a0, 0x000008b4,
0x000008b6, 0x000008bd, 0x0000fb50, 0x0000fbc1,
0x0000fbd3, 0x0000fd3d, 0x0000fd50, 0x0000fd8f,
0x0000fd92, 0x0000fdc7, 0x0000fdf0, 0x0000fdfc,
0x0000fe70, 0x0000fe74, 0x0000fe76, 0x0000fefc,
0x00010d00, 0x00010d23, 0x00010f30, 0x00010f45,
0x00010f51, 0x00010f59, 0x0001ec71, 0x0001ecb4,
0x0001ee00, 0x0001ee03, 0x0001ee05, 0x0001ee1f,
0x0001ee21, 0x0001ee22, 0x0001ee24, 0x0001ee24,
0x0001ee27, 0x0001ee27, 0x0001ee29, 0x0001ee32,
0x0001ee34, 0x0001ee37, 0x0001ee39, 0x0001ee39,
0x0001ee3b, 0x0001ee3b, 0x0001ee42, 0x0001ee42,
0x0001ee47, 0x0001ee47, 0x0001ee49, 0x0001ee49,
0x0001ee4b, 0x0001ee4b, 0x0001ee4d, 0x0001ee4f,
0x0001ee51, 0x0001ee52, 0x0001ee54, 0x0001ee54,
0x0001ee57, 0x0001ee57, 0x0001ee59, 0x0001ee59,
0x0001ee5b, 0x0001ee5b, 0x0001ee5d, 0x0001ee5d,
0x0001ee5f, 0x0001ee5f, 0x0001ee61, 0x0001ee62,
0x0001ee64, 0x0001ee64, 0x0001ee67, 0x0001ee6a,
0x0001ee6c, 0x0001ee72, 0x0001ee74, 0x0001ee77,
0x0001ee79, 0x0001ee7c, 0x0001ee7e, 0x0001ee7e,
0x0001ee80, 0x0001ee89, 0x0001ee8b, 0x0001ee9b,
0x0001eea1, 0x0001eea3, 0x0001eea5, 0x0001eea9,
0x0001eeab, 0x0001eebb, 0x00000041, 0x0000005a,
0x00000061, 0x0000007a, 0x000000aa, 0x000000aa,
0x000000b5, 0x000000b5, 0x000000ba, 0x000000ba,
0x000000c0, 0x000000d6, 0x000000d8, 0x000000f6,
0x000000f8, 0x000001ba, 0x000001bc, 0x000001bf,
0x000001c4, 0x00000293, 0x00000295, 0x000002b8,
0x000002c0, 0x000002c1, 0x000002e0, 0x000002e4,
0x00000345, 0x00000345, 0x00000370, 0x00000373,
0x00000376, 0x00000377, 0x0000037a, 0x0000037d,
0x0000037f, 0x0000037f, 0x00000386, 0x00000386,
0x00000388, 0x0000038a, 0x0000038c, 0x0000038c,
0x0000038e, 0x000003a1, 0x000003a3, 0x000003f5,
0x000003f7, 0x00000481, 0x0000048a, 0x0000052f,
0x00000531, 0x00000556, 0x00000560, 0x00000588,
0x000010a0, 0x000010c5, 0x000010c7, 0x000010c7,
0x000010cd, 0x000010cd, 0x000010d0, 0x000010fa,
0x000010fd, 0x000010ff, 0x000013a0, 0x000013f5,
0x000013f8, 0x000013fd, 0x00001c80, 0x00001c88,
0x00001c90, 0x00001cba, 0x00001cbd, 0x00001cbf,
0x00001d00, 0x00001dbf, 0x00001e00, 0x00001f15,
0x00001f18, 0x00001f1d, 0x00001f20, 0x00001f45,
0x00001f48, 0x00001f4d, 0x00001f50, 0x00001f57,
0x00001f59, 0x00001f59, 0x00001f5b, 0x00001f5b,
0x00001f5d, 0x00001f5d, 0x00001f5f, 0x00001f7d,
0x00001f80, 0x00001fb4, 0x00001fb6, 0x00001fbc,
0x00001fbe, 0x00001fbe, 0x00001fc2, 0x00001fc4,
0x00001fc6, 0x00001fcc, 0x00001fd0, 0x00001fd3,
0x00001fd6, 0x00001fdb, 0x00001fe0, 0x00001fec,
0x00001ff2, 0x00001ff4, 0x00001ff6, 0x00001ffc,
0x00002071, 0x00002071, 0x0000207f, 0x0000207f,
0x00002090, 0x0000209c, 0x00002102, 0x00002102,
0x00002107, 0x00002107, 0x0000210a, 0x00002113,
0x00002115, 0x00002115, 0x00002119, 0x0000211d,
0x00002124, 0x00002124, 0x00002126, 0x00002126,
0x00002128, 0x00002128, 0x0000212a, 0x0000212d,
0x0000212f, 0x00002134, 0x00002139, 0x00002139,
0x0000213c, 0x0000213f, 0x00002145, 0x00002149,
0x0000214e, 0x0000214e, 0x00002160, 0x0000217f,
0x00002183, 0x00002184, 0x000024b6, 0x000024e9,
0x00002c00, 0x00002c2e, 0x00002c30, 0x00002c5e,
0x00002c60, 0x00002ce4, 0x00002ceb, 0x00002cee,
0x00002cf2, 0x00002cf3, 0x00002d00, 0x00002d25,
0x00002d27, 0x00002d27, 0x00002d2d, 0x00002d2d,
0x0000a640, 0x0000a66d, 0x0000a680, 0x0000a69d,
0x0000a722, 0x0000a787, 0x0000a78b, 0x0000a78e,
0x0000a790, 0x0000a7b9, 0x0000a7f8, 0x0000a7fa,
0x0000ab30, 0x0000ab5a, 0x0000ab5c, 0x0000ab65,
0x0000ab70, 0x0000abbf, 0x0000fb00, 0x0000fb06,
0x0000fb13, 0x0000fb17, 0x0000ff21, 0x0000ff3a,
0x0000ff41, 0x0000ff5a, 0x00010400, 0x0001044f,
0x000104b0, 0x000104d3, 0x000104d8, 0x000104fb,
0x00010c80, 0x00010cb2, 0x00010cc0, 0x00010cf2,
0x000118a0, 0x000118df, 0x00016e40, 0x00016e7f,
0x0001d400, 0x0001d454, 0x0001d456, 0x0001d49c,
0x0001d49e, 0x0001d49f, 0x0001d4a2, 0x0001d4a2,
0x0001d4a5, 0x0001d4a6, 0x0001d4a9, 0x0001d4ac,
0x0001d4ae, 0x0001d4b9, 0x0001d4bb, 0x0001d4bb,
0x0001d4bd, 0x0001d4c3, 0x0001d4c5, 0x0001d505,
0x0001d507, 0x0001d50a, 0x0001d50d, 0x0001d514,
0x0001d516, 0x0001d51c, 0x0001d51e, 0x0001d539,
0x0001d53b, 0x0001d53e, 0x0001d540, 0x0001d544,
0x0001d546, 0x0001d546, 0x0001d54a, 0x0001d550,
0x0001d552, 0x0001d6a5, 0x0001d6a8, 0x0001d6c0,
0x0001d6c2, 0x0001d6da, 0x0001d6dc, 0x0001d6fa,
0x0001d6fc, 0x0001d714, 0x0001d716, 0x0001d734,
0x0001d736, 0x0001d74e, 0x0001d750, 0x0001d76e,
0x0001d770, 0x0001d788, 0x0001d78a, 0x0001d7a8,
0x0001d7aa, 0x0001d7c2, 0x0001d7c4, 0x0001d7cb,
0x0001e900, 0x0001e943, 0x0001f130, 0x0001f149,
0x0001f150, 0x0001f169, 0x0001f170, 0x0001f189,
0x00000027, 0x00000027, 0x0000002e, 0x0000002e,
0x0000003a, 0x0000003a, 0x0000005e, 0x0000005e,
0x00000060, 0x00000060, 0x000000a8, 0x000000a8,
0x000000ad, 0x000000ad, 0x000000af, 0x000000af,
0x000000b4, 0x000000b4, 0x000000b7, 0x000000b8,
0x000002b0, 0x0000036f, 0x00000374, 0x00000375,
0x0000037a, 0x0000037a, 0x00000384, 0x00000385,
0x00000387, 0x00000387, 0x00000483, 0x00000489,
0x00000559, 0x00000559, 0x00000591, 0x000005bd,
0x000005bf, 0x000005bf, 0x000005c1, 0x000005c2,
0x000005c4, 0x000005c5, 0x000005c7, 0x000005c7,
0x000005f4, 0x000005f4, 0x00000600, 0x00000605,
0x00000610, 0x0000061a, 0x0000061c, 0x0000061c,
0x00000640, 0x00000640, 0x0000064b, 0x0000065f,
0x00000670, 0x00000670, 0x000006d6, 0x000006dd,
0x000006df, 0x000006e8, 0x000006ea, 0x000006ed,
0x0000070f, 0x0000070f, 0x00000711, 0x00000711,
0x00000730, 0x0000074a, 0x000007a6, 0x000007b0,
0x000007eb, 0x000007f5, 0x000007fa, 0x000007fa,
0x000007fd, 0x000007fd, 0x00000816, 0x0000082d,
0x00000859, 0x0000085b, 0x000008d3, 0x00000902,
0x0000093a, 0x0000093a, 0x0000093c, 0x0000093c,
0x00000941, 0x00000948, 0x0000094d, 0x0000094d,
0x00000951, 0x00000957, 0x00000962, 0x00000963,
0x00000971, 0x00000971, 0x00000981, 0x00000981,
0x000009bc, 0x000009bc, 0x000009c1, 0x000009c4,
0x000009cd, 0x000009cd, 0x000009e2, 0x000009e3,
0x000009fe, 0x000009fe, 0x00000a01, 0x00000a02,
0x00000a3c, 0x00000a3c, 0x00000a41, 0x00000a42,
0x00000a47, 0x00000a48, 0x00000a4b, 0x00000a4d,
0x00000a51, 0x00000a51, 0x00000a70, 0x00000a71,
0x00000a75, 0x00000a75, 0x00000a81, 0x00000a82,
0x00000abc, 0x00000abc, 0x00000ac1, 0x00000ac5,
0x00000ac7, 0x00000ac8, 0x00000acd, 0x00000acd,
0x00000ae2, 0x00000ae3, 0x00000afa, 0x00000aff,
0x00000b01, 0x00000b01, 0x00000b3c, 0x00000b3c,
0x00000b3f, 0x00000b3f, 0x00000b41, 0x00000b44,
0x00000b4d, 0x00000b4d, 0x00000b56, 0x00000b56,
0x00000b62, 0x00000b63, 0x00000b82, 0x00000b82,
0x00000bc0, 0x00000bc0, 0x00000bcd, 0x00000bcd,
0x00000c00, 0x00000c00, 0x00000c04, 0x00000c04,
0x00000c3e, 0x00000c40, 0x00000c46, 0x00000c48,
0x00000c4a, 0x00000c4d, 0x00000c55, 0x00000c56,
0x00000c62, 0x00000c63, 0x00000c81, 0x00000c81,
0x00000cbc, 0x00000cbc, 0x00000cbf, 0x00000cbf,
0x00000cc6, 0x00000cc6, 0x00000ccc, 0x00000ccd,
0x00000ce2, 0x00000ce3, 0x00000d00, 0x00000d01,
0x00000d3b, 0x00000d3c, 0x00000d41, 0x00000d44,
0x00000d4d, 0x00000d4d, 0x00000d62, 0x00000d63,
0x00000dca, 0x00000dca, 0x00000dd2, 0x00000dd4,
0x00000dd6, 0x00000dd6, 0x00000e31, 0x00000e31,
0x00000e34, 0x00000e3a, 0x00000e46, 0x00000e4e,
0x00000eb1, 0x00000eb1, 0x00000eb4, 0x00000eb9,
0x00000ebb, 0x00000ebc, 0x00000ec6, 0x00000ec6,
0x00000ec8, 0x00000ecd, 0x00000f18, 0x00000f19,
0x00000f35, 0x00000f35, 0x00000f37, 0x00000f37,
0x00000f39, 0x00000f39, 0x00000f71, 0x00000f7e,
0x00000f80, 0x00000f84, 0x00000f86, 0x00000f87,
0x00000f8d, 0x00000f97, 0x00000f99, 0x00000fbc,
0x00000fc6, 0x00000fc6, 0x0000102d, 0x00001030,
0x00001032, 0x00001037, 0x00001039, 0x0000103a,
0x0000103d, 0x0000103e, 0x00001058, 0x00001059,
0x0000105e, 0x00001060, 0x00001071, 0x00001074,
0x00001082, 0x00001082, 0x00001085, 0x00001086,
0x0000108d, 0x0000108d, 0x0000109d, 0x0000109d,
0x000010fc, 0x000010fc, 0x0000135d, 0x0000135f,
0x00001712, 0x00001714, 0x00001732, 0x00001734,
0x00001752, 0x00001753, 0x00001772, 0x00001773,
0x000017b4, 0x000017b5, 0x000017b7, 0x000017bd,
0x000017c6, 0x000017c6, 0x000017c9, 0x000017d3,
0x000017d7, 0x000017d7, 0x000017dd, 0x000017dd,
0x0000180b, 0x0000180e, 0x00001843, 0x00001843,
0x00001885, 0x00001886, 0x000018a9, 0x000018a9,
0x00001920, 0x00001922, 0x00001927, 0x00001928,
0x00001932, 0x00001932, 0x00001939, 0x0000193b,
0x00001a17, 0x00001a18, 0x00001a1b, 0x00001a1b,
0x00001a56, 0x00001a56, 0x00001a58, 0x00001a5e,
0x00001a60, 0x00001a60, 0x00001a62, 0x00001a62,
0x00001a65, 0x00001a6c, 0x00001a73, 0x00001a7c,
0x00001a7f, 0x00001a7f, 0x00001aa7, 0x00001aa7,
0x00001ab0, 0x00001abe, 0x00001b00, 0x00001b03,
0x00001b34, 0x00001b34, 0x00001b36, 0x00001b3a,
0x00001b3c, 0x00001b3c, 0x00001b42, 0x00001b42,
0x00001b6b, 0x00001b73, 0x00001b80, 0x00001b81,
0x00001ba2, 0x00001ba5, 0x00001ba8, 0x00001ba9,
0x00001bab, 0x00001bad, 0x00001be6, 0x00001be6,
0x00001be8, 0x00001be9, 0x00001bed, 0x00001bed,
0x00001bef, 0x00001bf1, 0x00001c2c, 0x00001c33,
0x00001c36, 0x00001c37, 0x00001c78, 0x00001c7d,
0x00001cd0, 0x00001cd2, 0x00001cd4, 0x00001ce0,
0x00001ce2, 0x00001ce8, 0x00001ced, 0x00001ced,
0x00001cf4, 0x00001cf4, 0x00001cf8, 0x00001cf9,
0x00001d2c, 0x00001d6a, 0x00001d78, 0x00001d78,
0x00001d9b, 0x00001df9, 0x00001dfb, 0x00001dff,
0x00001fbd, 0x00001fbd, 0x00001fbf, 0x00001fc1,
0x00001fcd, 0x00001fcf, 0x00001fdd, 0x00001fdf,
0x00001fed, 0x00001fef, 0x00001ffd, 0x00001ffe,
0x0000200b, 0x0000200f, 0x00002018, 0x00002019,
0x00002024, 0x00002024, 0x00002027, 0x00002027,
0x0000202a, 0x0000202e, 0x00002060, 0x00002064,
0x00002066, 0x0000206f, 0x00002071, 0x00002071,
0x0000207f, 0x0000207f, 0x00002090, 0x0000209c,
0x000020d0, 0x000020f0, 0x00002c7c, 0x00002c7d,
0x00002cef, 0x00002cf1, 0x00002d6f, 0x00002d6f,
0x00002d7f, 0x00002d7f, 0x00002de0, 0x00002dff,
0x00002e2f, 0x00002e2f, 0x00003005, 0x00003005,
0x0000302a, 0x0000302d, 0x00003031, 0x00003035,
0x0000303b, 0x0000303b, 0x00003099, 0x0000309e,
0x000030fc, 0x000030fe, 0x0000a015, 0x0000a015,
0x0000a4f8, 0x0000a4fd, 0x0000a60c, 0x0000a60c,
0x0000a66f, 0x0000a672, 0x0000a674, 0x0000a67d,
0x0000a67f, 0x0000a67f, 0x0000a69c, 0x0000a69f,
0x0000a6f0, 0x0000a6f1, 0x0000a700, 0x0000a721,
0x0000a770, 0x0000a770, 0x0000a788, 0x0000a78a,
0x0000a7f8, 0x0000a7f9, 0x0000a802, 0x0000a802,
0x0000a806, 0x0000a806, 0x0000a80b, 0x0000a80b,
0x0000a825, 0x0000a826, 0x0000a8c4, 0x0000a8c5,
0x0000a8e0, 0x0000a8f1, 0x0000a8ff, 0x0000a8ff,
0x0000a926, 0x0000a92d, 0x0000a947, 0x0000a951,
0x0000a980, 0x0000a982, 0x0000a9b3, 0x0000a9b3,
0x0000a9b6, 0x0000a9b9, 0x0000a9bc, 0x0000a9bc,
0x0000a9cf, 0x0000a9cf, 0x0000a9e5, 0x0000a9e6,
0x0000aa29, 0x0000aa2e, 0x0000aa31, 0x0000aa32,
0x0000aa35, 0x0000aa36, 0x0000aa43, 0x0000aa43,
0x0000aa4c, 0x0000aa4c, 0x0000aa70, 0x0000aa70,
0x0000aa7c, 0x0000aa7c, 0x0000aab0, 0x0000aab0,
0x0000aab2, 0x0000aab4, 0x0000aab7, 0x0000aab8,
0x0000aabe, 0x0000aabf, 0x0000aac1, 0x0000aac1,
0x0000aadd, 0x0000aadd, 0x0000aaec, 0x0000aaed,
0x0000aaf3, 0x0000aaf4, 0x0000aaf6, 0x0000aaf6,
0x0000ab5b, 0x0000ab5f, 0x0000abe5, 0x0000abe5,
0x0000abe8, 0x0000abe8, 0x0000abed, 0x0000abed,
0x0000fb1e, 0x0000fb1e, 0x0000fbb2, 0x0000fbc1,
0x0000fe00, 0x0000fe0f, 0x0000fe13, 0x0000fe13,
0x0000fe20, 0x0000fe2f, 0x0000fe52, 0x0000fe52,
0x0000fe55, 0x0000fe55, 0x0000feff, 0x0000feff,
0x0000ff07, 0x0000ff07, 0x0000ff0e, 0x0000ff0e,
0x0000ff1a, 0x0000ff1a, 0x0000ff3e, 0x0000ff3e,
0x0000ff40, 0x0000ff40, 0x0000ff70, 0x0000ff70,
0x0000ff9e, 0x0000ff9f, 0x0000ffe3, 0x0000ffe3,
0x0000fff9, 0x0000fffb, 0x000101fd, 0x000101fd,
0x000102e0, 0x000102e0, 0x00010376, 0x0001037a,
0x00010a01, 0x00010a03, 0x00010a05, 0x00010a06,
0x00010a0c, 0x00010a0f, 0x00010a38, 0x00010a3a,
0x00010a3f, 0x00010a3f, 0x00010ae5, 0x00010ae6,
0x00010d24, 0x00010d27, 0x00010f46, 0x00010f50,
0x00011001, 0x00011001, 0x00011038, 0x00011046,
0x0001107f, 0x00011081, 0x000110b3, 0x000110b6,
0x000110b9, 0x000110ba, 0x000110bd, 0x000110bd,
0x000110cd, 0x000110cd, 0x00011100, 0x00011102,
0x00011127, 0x0001112b, 0x0001112d, 0x00011134,
0x00011173, 0x00011173, 0x00011180, 0x00011181,
0x000111b6, 0x000111be, 0x000111c9, 0x000111cc,
0x0001122f, 0x00011231, 0x00011234, 0x00011234,
0x00011236, 0x00011237, 0x0001123e, 0x0001123e,
0x000112df, 0x000112df, 0x000112e3, 0x000112ea,
0x00011300, 0x00011301, 0x0001133b, 0x0001133c,
0x00011340, 0x00011340, 0x00011366, 0x0001136c,
0x00011370, 0x00011374, 0x00011438, 0x0001143f,
0x00011442, 0x00011444, 0x00011446, 0x00011446,
0x0001145e, 0x0001145e, 0x000114b3, 0x000114b8,
0x000114ba, 0x000114ba, 0x000114bf, 0x000114c0,
0x000114c2, 0x000114c3, 0x000115b2, 0x000115b5,
0x000115bc, 0x000115bd, 0x000115bf, 0x000115c0,
0x000115dc, 0x000115dd, 0x00011633, 0x0001163a,
0x0001163d, 0x0001163d, 0x0001163f, 0x00011640,
0x000116ab, 0x000116ab, 0x000116ad, 0x000116ad,
0x000116b0, 0x000116b5, 0x000116b7, 0x000116b7,
0x0001171d, 0x0001171f, 0x00011722, 0x00011725,
0x00011727, 0x0001172b, 0x0001182f, 0x00011837,
0x00011839, 0x0001183a, 0x00011a01, 0x00011a0a,
0x00011a33, 0x00011a38, 0x00011a3b, 0x00011a3e,
0x00011a47, 0x00011a47, 0x00011a51, 0x00011a56,
0x00011a59, 0x00011a5b, 0x00011a8a, 0x00011a96,
0x00011a98, 0x00011a99, 0x00011c30, 0x00011c36,
0x00011c38, 0x00011c3d, 0x00011c3f, 0x00011c3f,
0x00011c92, 0x00011ca7, 0x00011caa, 0x00011cb0,
0x00011cb2, 0x00011cb3, 0x00011cb5, 0x00011cb6,
0x00011d31, 0x00011d36, 0x00011d3a, 0x00011d3a,
0x00011d3c, 0x00011d3d, 0x00011d3f, 0x00011d45,
0x00011d47, 0x00011d47, 0x00011d90, 0x00011d91,
0x00011d95, 0x00011d95, 0x00011d97, 0x00011d97,
0x00011ef3, 0x00011ef4, 0x00016af0, 0x00016af4,
0x00016b30, 0x00016b36, 0x00016b40, 0x00016b43,
0x00016f8f, 0x00016f9f, 0x00016fe0, 0x00016fe1,
0x0001bc9d, 0x0001bc9e, 0x0001bca0, 0x0001bca3,
0x0001d167, 0x0001d169, 0x0001d173, 0x0001d182,
0x0001d185, 0x0001d18b, 0x0001d1aa, 0x0001d1ad,
0x0001d242, 0x0001d244, 0x0001da00, 0x0001da36,
0x0001da3b, 0x0001da6c, 0x0001da75, 0x0001da75,
0x0001da84, 0x0001da84, 0x0001da9b, 0x0001da9f,
0x0001daa1, 0x0001daaf, 0x0001e000, 0x0001e006,
0x0001e008, 0x0001e018, 0x0001e01b, 0x0001e021,
0x0001e023, 0x0001e024, 0x0001e026, 0x0001e02a,
0x0001e8d0, 0x0001e8d6, 0x0001e944, 0x0001e94a,
0x0001f3fb, 0x0001f3ff, 0x000e0001, 0x000e0001,
0x000e0020, 0x000e007f, 0x000e0100, 0x000e01ef
};
static const unsigned _uccase_upper_g_size = 275;
static const short _uccase_upper_g[] = {
335, 2234, 8785, 768, 672, 77, 540, 3,
-29, 103, -1410, 520, 21, 8786, 8, 102,
713, 129, 3090, 128, 2080, 256, 514, 7202,
734, 9584, 4406, 616, 845, 112, 534, 40,
14, 1034, 91, 199, 1143, 1070, 4097, 371,
19, 1977, 71, 579, 260, 2073, 322, 61,
106, 2198, 13184, 453, 1429, 4461, 47, 388,
140, 66, 1493, 263, -796, 2992, -611, -1322,
41, 18, 16, 163, -1319, 131, 15543, 3,
20, 296, 3727, 4978, 8670, 58, 5, 615,
515, 32, 62, -1, 268, 32767, 10729, -780,
-1362, 11, 180, 5454, 3, -233, 13, 307,
220, 23, 352, 2268, 3718, 568, 451, 107,
1252, 70, 54, 17, -167, 199, -1113, 2855,
-315, 48, 114, 38, 2870, 148, -812, 204,
4, 347, 8, 1923, 166, 2466, 1793, 13,
4865, 1434, 177, 121, 75, -177, 514, 32767,
686, -334, 314, 3068, 64, 2035, 131, -264,
820, 405, 241, 76, 617, 53, 231, 145,
388, 158, 2, 26, 9, 1128, 1086, 289,
-1158, 365, -386, 5891, 1489, 74, 160, 192,
563, 151, 1814, 267, 512, 33, 104, 1757,
15, 2734, 4203, 16, 147, 330, 706, 373,
268, -1175, 12817, -528, 3753, 10605, 128, 715,
65, 3721, 57, 684, 256, 520, 562, 2,
2063, 591, 1030, 277, 1957, 520, 203, 8470,
3796, 305, 32767, 332, -733, 721, 244, 111,
341, 69, -1184, 53, 35, 256, 512, 166,
52, 2154, 522, 12, 2938, 4790, 256, 1,
2804, -149, 209, 32767, 3264, -792, 623, 56,
134, 1769, 3, -1285, 274, 2053, 384, 583,
2960, 2, 319, 14002, 635, 233, 24227, 277,
1433, 2361, -123, 514, 32767, 20, 391, 409,
9, 17, 24, 192, 3076, 162, 2, 257,
8, 347, 25
};
static const unsigned _uccase_upper_table_size = 1475;
static const unsigned _uccase_upper_table[] = {
0x000004d1, 0x000004d0, 0x0000a68f, 0x0000a68e,
0x000118d8, 0x000118b8, 0x0000a7b9, 0x0000a7b8,
0x000004fb, 0x000004fa, 0x0000abb0, 0x000013e0,
0x00001ff7, 0x0300013e, 0x000001fb, 0x000001fa,
0x000013fc, 0x000013f4, 0x00010cd9, 0x00010c99,
0x00001ee9, 0x00001ee8, 0x000000f5, 0x000000d5,
0x00010cf0, 0x00010cb0, 0x000010da, 0x00001c9a,
0x0000a761, 0x0000a760, 0x00000247, 0x00000246,
0x00000078, 0x00000058, 0x000010f2, 0x00001cb2,
0x00002d13, 0x000010b3, 0x000024df, 0x000024c5,
0x00001fa8, 0x02000103, 0x00016e69, 0x00016e49,
0x00002ca7, 0x00002ca6, 0x0001043e, 0x00010416,
0x00002d20, 0x000010c0, 0x00002c4e, 0x00002c1e,
0x00002cc5, 0x00002cc4, 0x00001fb1, 0x00001fb9,
0x000003fb, 0x000003fa, 0x0000a689, 0x0000a688,
0x0000aba2, 0x000013d2, 0x00000461, 0x00000460,
0x00001e8d, 0x00001e8c, 0x00001f7a, 0x00001fea,
0x00002cb7, 0x00002cb6, 0x0001043b, 0x00010413,
0x0000020f, 0x0000020e, 0x00010cec, 0x00010cac,
0x00002179, 0x00002169, 0x00002174, 0x00002164,
0x00010438, 0x00010410, 0x0000a7a7, 0x0000a7a6,
0x0000abbc, 0x000013ec, 0x00000521, 0x00000520,
0x00001f03, 0x00001f0b, 0x00001fb3, 0x02000048,
0x00001c81, 0x00000414, 0x000004f5, 0x000004f4,
0x00000283, 0x000001a9, 0x00001e2f, 0x00001e2e,
0x000004ca, 0x000004c9, 0x00000584, 0x00000554,
0x00010436, 0x0001040e, 0x00001e69, 0x00001e68,
0x00001ee3, 0x00001ee2, 0x0000ab97, 0x000013c7,
0x00001f77, 0x00001fdb, 0x0000021b, 0x0000021a,
0x00001e87, 0x00001e86, 0x00010cc3, 0x00010c83,
0x000003af, 0x0000038a, 0x000000ed, 0x000000cd,
0x00001e96, 0x0200008b, 0x0000ab7b, 0x000013ab,
0x000003b5, 0x00000395, 0x0001e93b, 0x0001e919,
0x000004d5, 0x000004d4, 0x000118cd, 0x000118ad,
0x000004a1, 0x000004a0, 0x0001042e, 0x00010406,
0x00001eb3, 0x00001eb2, 0x0000aba4, 0x000013d4,
0x00000433, 0x00000413, 0x00001f10, 0x00001f18,
0x00000073, 0x00000053, 0x000004bf, 0x000004be,
0x00002173, 0x00002163, 0x00001f13, 0x00001f1b,
0x000003f1, 0x000003a1, 0x00002c47, 0x00002c17,
0x00010ce0, 0x00010ca0, 0x000104f3, 0x000104cb,
0x000024de, 0x000024c4, 0x00000469, 0x00000468,
0x000010f3, 0x00001cb3, 0x0000a745, 0x0000a744,
0x00001e81, 0x00001e80, 0x000010ff, 0x00001cbf,
0x0000ab90, 0x000013c0, 0x0000fb16, 0x02000077,
0x0001e932, 0x0001e910, 0x00016e79, 0x00016e59,
0x00010cde, 0x00010c9e, 0x00000509, 0x00000508,
0x00001f15, 0x00001f1d, 0x000004e1, 0x000004e0,
0x00010cf1, 0x00010cb1, 0x00000440, 0x00000420,
0x00001f05, 0x00001f0d, 0x00000192, 0x00000191,
0x0000056c, 0x0000053c, 0x00001ebf, 0x00001ebe,
0x000104e2, 0x000104ba, 0x00001e53, 0x00001e52,
0x00000441, 0x00000421, 0x00010cd7, 0x00010c97,
0x00001f84, 0x0200000c, 0x00001fe2, 0x030000be,
0x000001b6, 0x000001b5, 0x000010df, 0x00001c9f,
0x000003e3, 0x000003e2, 0x0000ff56, 0x0000ff36,
0x000010f4, 0x00001cb4, 0x00010cdd, 0x00010c9d,
0x0000a665, 0x0000a664, 0x00001f00, 0x00001f08,
0x00016e64, 0x00016e44, 0x0000aba6, 0x000013d6,
0x00002cbd, 0x00002cbc, 0x000003c7, 0x000003a7,
0x00002d0e, 0x000010ae, 0x00002d17, 0x000010b7,
0x000001ed, 0x000001ec, 0x0000a687, 0x0000a686,
0x0000a79d, 0x0000a79c, 0x00002d0c, 0x000010ac,
0x0000ab96, 0x000013c6, 0x0001044c, 0x00010424,
0x00000513, 0x00000512, 0x000000f6, 0x000000d6,
0x00010cca, 0x00010c8a, 0x0000ff49, 0x0000ff29,
0x00001fd7, 0x030000ba, 0x00000475, 0x00000474,
0x00001fd0, 0x00001fd8, 0x00002c31, 0x00002c01,
0x00001f9c, 0x020000f7, 0x00000211, 0x00000210,
0x0000ab89, 0x000013b9, 0x000003d0, 0x00000392,
0x00001f20, 0x00001f28, 0x00000109, 0x00000108,
0x00000573, 0x00000543, 0x000003d7, 0x000003cf,
0x00001e45, 0x00001e44, 0x00002d03, 0x000010a3,
0x00001e27, 0x00001e26, 0x00000456, 0x00000406,
0x00001fe3, 0x030000c2, 0x0000a69b, 0x0000a69a,
0x000004cc, 0x000004cb, 0x0000ab93, 0x000013c3,
0x0001e942, 0x0001e920, 0x00001f44, 0x00001f4c,
0x000000eb, 0x000000cb, 0x00010cc1, 0x00010c81,
0x0000007a, 0x0000005a, 0x00000066, 0x00000046,
0x00002c35, 0x00002c05, 0x000010d2, 0x00001c92,
0x00000142, 0x00000141, 0x00001ef5, 0x00001ef4,
0x00001e63, 0x00001e62, 0x0000ab8d, 0x000013bd,
0x000003c5, 0x000003a5, 0x000104dc, 0x000104b4,
0x000118c8, 0x000118a8, 0x0000a691, 0x0000a690,
0x00002d1f, 0x000010bf, 0x000024d4, 0x000024ba,
0x000000df, 0x02000051, 0x0000a661, 0x0000a660,
0x000004a5, 0x000004a4, 0x00001f02, 0x00001f0a,
0x0000016d, 0x0000016c, 0x00016e6b, 0x00016e4b,
0x00002c9d, 0x00002c9c, 0x0000a693, 0x0000a692,
0x00000167, 0x00000166, 0x0000a72f, 0x0000a72e,
0x00001faf, 0x02000118, 0x00000473, 0x00000472,
0x000024e4, 0x000024ca, 0x00000240, 0x00002c7f,
0x00000517, 0x00000516, 0x00002ca5, 0x00002ca4,
0x00001eff, 0x00001efe, 0x0000050d, 0x0000050c,
0x0000ab82, 0x000013b2, 0x0000010b, 0x0000010a,
0x000024e5, 0x000024cb, 0x00001fc2, 0x0200012a,
0x000010dc, 0x00001c9c, 0x00000165, 0x00000164,
0x00000280, 0x000001a6, 0x0000a76f, 0x0000a76e,
0x00000079, 0x00000059, 0x00002c4b, 0x00002c1b,
0x0001e92d, 0x0001e90b, 0x0000a787, 0x0000a786,
0x0000006e, 0x0000004e, 0x00000077, 0x00000057,
0x0001042c, 0x00010404, 0x000001fd, 0x000001fc,
0x000000fc, 0x000000dc, 0x00002184, 0x00002183,
0x00001ffc, 0x02000121, 0x0000028b, 0x000001b2,
0x0000045f, 0x0000040f, 0x0000abbe, 0x000013ee,
0x00001f82, 0x02000006, 0x00000288, 0x000001ae,
0x00001c88, 0x0000a64a, 0x0000057d, 0x0000054d,
0x00001e51, 0x00001e50, 0x00010432, 0x0001040a,
0x00016e7c, 0x00016e5c, 0x00001e9b, 0x00001e60,
0x00001e49, 0x00001e48, 0x00010429, 0x00010401,
0x00002d19, 0x000010b9, 0x0000a757, 0x0000a756,
0x00002c40, 0x00002c10, 0x00001f94, 0x02000024,
0x000001d6, 0x000001d5, 0x00000063, 0x00000043,
0x00002ca9, 0x00002ca8, 0x0001044b, 0x00010423,
0x000013fd, 0x000013f5, 0x00002c3c, 0x00002c0c,
0x00010cea, 0x00010caa, 0x0001e943, 0x0001e921,
0x000118dc, 0x000118bc, 0x000003f5, 0x00000395,
0x0000fb04, 0x03000061, 0x00002c8f, 0x00002c8e,
0x0000011d, 0x0000011c, 0x00002cb1, 0x00002cb0,
0x00010cc5, 0x00010c85, 0x0000fb14, 0x02000071,
0x00000275, 0x0000019f, 0x00016e73, 0x00016e53,
0x0000ab7d, 0x000013ad, 0x00002c3a, 0x00002c0a,
0x00010428, 0x00010400, 0x00001f9d, 0x020000fa,
0x00002d0d, 0x000010ad, 0x00000458, 0x00000408,
0x000003bc, 0x0000039c, 0x00001e3d, 0x00001e3c,
0x0000ab73, 0x000013a3, 0x00000163, 0x00000162,
0x000003d5, 0x000003a6, 0x00000195, 0x000001f6,
0x000004f3, 0x000004f2, 0x000004a3, 0x000004a2,
0x00001fe6, 0x020000c9, 0x00001eb5, 0x00001eb4,
0x00000451, 0x00000401, 0x00010ce3, 0x00010ca3,
0x0000a749, 0x0000a748, 0x00000256, 0x00000189,
0x00000201, 0x00000200, 0x00000567, 0x00000537,
0x00002c32, 0x00002c02, 0x0000a651, 0x0000a650,
0x00001fac, 0x0200010f, 0x00010cc8, 0x00010c88,
0x00002d06, 0x000010a6, 0x000003ae, 0x00000389,
0x000000ff, 0x00000178, 0x0000ab84, 0x000013b4,
0x0000044d, 0x0000042d, 0x0001044d, 0x00010425,
0x0000017c, 0x0000017b, 0x00002cc3, 0x00002cc2,
0x0000044b, 0x0000042b, 0x00001fe5, 0x00001fec,
0x000024e8, 0x000024ce, 0x00001d79, 0x0000a77d,
0x00002caf, 0x00002cae, 0x000104db, 0x000104b3,
0x00001e6d, 0x00001e6c, 0x00000446, 0x00000426,
0x0000046b, 0x0000046a, 0x0000a75b, 0x0000a75a,
0x00001f88, 0x020000d3, 0x000001ad, 0x000001ac,
0x00001e13, 0x00001e12, 0x00000223, 0x00000222,
0x0001e92e, 0x0001e90c, 0x000004a7, 0x000004a6,
0x00002d05, 0x000010a5, 0x00000121, 0x00000120,
0x00010434, 0x0001040c, 0x00000169, 0x00000168,
0x00000495, 0x00000494, 0x00002c66, 0x0000023e,
0x00001f07, 0x00001f0f, 0x00000171, 0x00000170,
0x00000571, 0x00000541, 0x00000515, 0x00000514,
0x0001e939, 0x0001e917, 0x00001e77, 0x00001e76,
0x0000a643, 0x0000a642, 0x000004b9, 0x000004b8,
0x00000225, 0x00000224, 0x00001e2d, 0x00001e2c,
0x0000043b, 0x0000041b, 0x000010d9, 0x00001c99,
0x0000014d, 0x0000014c, 0x00001e43, 0x00001e42,
0x00016e60, 0x00016e40, 0x00010cdb, 0x00010c9b,
0x0000014b, 0x0000014a, 0x000000e9, 0x000000c9,
0x00001f8a, 0x020000d9, 0x00000505, 0x00000504,
0x000004df, 0x000004de, 0x000024e6, 0x000024cc,
0x00001e6b, 0x00001e6a, 0x0000a739, 0x0000a738,
0x0000046f, 0x0000046e, 0x0000026f, 0x0000019c,
0x000118cc, 0x000118ac, 0x00001e0f, 0x00001e0e,
0x00000581, 0x00000551, 0x00001f8e, 0x020000e5,
0x000000ef, 0x000000cf, 0x00000064, 0x00000044,
0x00001fa4, 0x0200003c, 0x0000023f, 0x00002c7e,
0x00001e57, 0x00001e56, 0x00000430, 0x00000410,
0x000000e0, 0x000000c0, 0x000003ad, 0x00000388,
0x00000269, 0x00000196, 0x00002cb5, 0x00002cb4,
0x000104f0, 0x000104c8, 0x0000037c, 0x000003fe,
0x000024db, 0x000024c1, 0x000000e1, 0x000000c1,
0x000010db, 0x00001c9b, 0x000104f5, 0x000104cd,
0x000104f7, 0x000104cf, 0x0000a747, 0x0000a746,
0x000104ee, 0x000104c6, 0x00002c50, 0x00002c20,
0x00001ff4, 0x02000133, 0x000118c3, 0x000118a3,
0x0000ab75, 0x000013a5, 0x0000217e, 0x0000216e,
0x00001fa9, 0x02000106, 0x000000fa, 0x000000da,
0x00002c4a, 0x00002c1a, 0x00001ed5, 0x00001ed4,
0x00001fc4, 0x0200012d, 0x000024d3, 0x000024b9,
0x0000a729, 0x0000a728, 0x000001c5, 0x000001c4,
0x0000a669, 0x0000a668, 0x00001e59, 0x00001e58,
0x000010fd, 0x00001cbd, 0x00000570, 0x00000540,
0x000003c2, 0x000003a3, 0x000024d1, 0x000024b7,
0x0000217a, 0x0000216a, 0x00002d1b, 0x000010bb,
0x000004d3, 0x000004d2, 0x00001f21, 0x00001f29,
0x000001d2, 0x000001d1, 0x0000fb17, 0x0200007a,
0x00002c45, 0x00002c15, 0x00010431, 0x00010409,
0x0000046d, 0x0000046c, 0x0000056d, 0x0000053d,
0x0000aba5, 0x000013d5, 0x00001f43, 0x00001f4b,
0x00001f7b, 0x00001feb, 0x00002c3f, 0x00002c0f,
0x0000abb7, 0x000013e7, 0x00001fd1, 0x00001fd9,
0x000003f2, 0x000003f9, 0x00000455, 0x00000405,
0x00010cc7, 0x00010c87, 0x000003b6, 0x00000396,
0x000000e2, 0x000000c2, 0x0000a753, 0x0000a752,
0x00002c9f, 0x00002c9e, 0x000003c9, 0x000003a9,
0x000024dc, 0x000024c2, 0x0000013a, 0x00000139,
0x00001e85, 0x00001e84, 0x00002cec, 0x00002ceb,
0x000013fa, 0x000013f2, 0x00001fb7, 0x03000136,
0x0000ab8e, 0x000013be, 0x00002c56, 0x00002c26,
0x000104f4, 0x000104cc, 0x00001e33, 0x00001e32,
0x00000575, 0x00000545, 0x0000ab9a, 0x000013ca,
0x00001fe1, 0x00001fe9, 0x00001fcc, 0x0200011e,
0x00001e4f, 0x00001e4e, 0x0000052b, 0x0000052a,
0x00001fae, 0x02000115, 0x00002c85, 0x00002c84,
0x0000044a, 0x0000042a, 0x0000ab80, 0x000013b0,
0x000118db, 0x000118bb, 0x0000027d, 0x00002c64,
0x00000129, 0x00000128, 0x000010e5, 0x00001ca5,
0x0000a7a5, 0x0000a7a4, 0x00001f11, 0x00001f19,
0x0000048b, 0x0000048a, 0x000010f1, 0x00001cb1,
0x00002c37, 0x00002c07, 0x0001e937, 0x0001e915,
0x0000a75d, 0x0000a75c, 0x00002cad, 0x00002cac,
0x0000abbd, 0x000013ed, 0x0001e92c, 0x0001e90a,
0x0000a649, 0x0000a648, 0x000004e7, 0x000004e6,
0x00000074, 0x00000054, 0x000104e9, 0x000104c1,
0x00001e09, 0x00001e08, 0x00000467, 0x00000466,
0x000010ec, 0x00001cac, 0x0000022d, 0x0000022c,
0x00000511, 0x00000510, 0x0000043f, 0x0000041f,
0x00010ccd, 0x00010c8d, 0x0000015d, 0x0000015c,
0x00000272, 0x0000019d, 0x00016e7d, 0x00016e5d,
0x0000ab8a, 0x000013ba, 0x000003c3, 0x000003a3,
0x00001d7d, 0x00002c63, 0x0000016b, 0x0000016a,
0x00002cdf, 0x00002cde, 0x00001e83, 0x00001e82,
0x0001042b, 0x00010403, 0x00001fa1, 0x02000033,
0x00000471, 0x00000470, 0x0000abb2, 0x000013e2,
0x0001043d, 0x00010415, 0x0000a793, 0x0000a792,
0x00010449, 0x00010421, 0x00002ccf, 0x00002cce,
0x00001f30, 0x00001f38, 0x00001e05, 0x00001e04,
0x00010cf2, 0x00010cb2, 0x000010e1, 0x00001ca1,
0x0000ff4a, 0x0000ff2a, 0x00001e95, 0x00001e94,
0x00000434, 0x00000414, 0x00010ce6, 0x00010ca6,
0x0000ff59, 0x0000ff39, 0x0000a68b, 0x0000a68a,
0x00016e70, 0x00016e50, 0x0000ab78, 0x000013a8,
0x000003cd, 0x0000038e, 0x0000026a, 0x0000a7ae,
0x00002cc7, 0x00002cc6, 0x000104fb, 0x000104d3,
0x00002c46, 0x00002c16, 0x00001f32, 0x00001f3a,
0x0000017f, 0x00000053, 0x000004a9, 0x000004a8,
0x000004bb, 0x000004ba, 0x00001edd, 0x00001edc,
0x00001fd3, 0x030000b3, 0x00002cf3, 0x00002cf2,
0x00000447, 0x00000427, 0x00010446, 0x0001041e,
0x0000a7b7, 0x0000a7b6, 0x0000a727, 0x0000a726,
0x000010d6, 0x00001c96, 0x000003bf, 0x0000039f,
0x0000020b, 0x0000020a, 0x00002c55, 0x00002c25,
0x00010ce1, 0x00010ca1, 0x0000ff4e, 0x0000ff2e,
0x0000025c, 0x0000a7ab, 0x00016e63, 0x00016e43,
0x000004b1, 0x000004b0, 0x0000ff4c, 0x0000ff2c,
0x000024d0, 0x000024b6, 0x00016e7b, 0x00016e5b,
0x00010cdf, 0x00010c9f, 0x000004b7, 0x000004b6,
0x00001f92, 0x0200001e, 0x00002d1a, 0x000010ba,
0x0000045b, 0x0000040b, 0x0000fb00, 0x02000054,
0x00000263, 0x00000194, 0x00001e07, 0x00001e06,
0x00001eb7, 0x00001eb6, 0x00000452, 0x00000402,
0x000001eb, 0x000001ea, 0x0000a697, 0x0000a696,
0x00000151, 0x00000150, 0x00000583, 0x00000553,
0x000003b4, 0x00000394, 0x00002ca1, 0x00002ca0,
0x00001e65, 0x00001e64, 0x000104e3, 0x000104bb,
0x000024e2, 0x000024c8, 0x00000251, 0x00002c6d,
0x0000a737, 0x0000a736, 0x000010ee, 0x00001cae,
0x0000fb05, 0x02000065, 0x00010433, 0x0001040b,
0x00016e6e, 0x00016e4e, 0x0000057f, 0x0000054f,
0x00001e5f, 0x00001e5e, 0x000104eb, 0x000104c3,
0x00002d0f, 0x000010af, 0x0000a741, 0x0000a740,
0x00000242, 0x00000241, 0x0000006c, 0x0000004c,
0x00001e37, 0x00001e36, 0x00016e62, 0x00016e42,
0x000003ed, 0x000003ec, 0x000104f8, 0x000104d0,
0x000000e4, 0x000000c4, 0x0000a765, 0x0000a764,
0x0000abb4, 0x000013e4, 0x00000135, 0x00000134,
0x00001ef1, 0x00001ef0, 0x0000a73d, 0x0000a73c,
0x00010ccb, 0x00010c8b, 0x0000ff58, 0x0000ff38,
0x00000250, 0x00002c6f, 0x00000155, 0x00000154,
0x0000049b, 0x0000049a, 0x00001fad, 0x02000112,
0x000003c4, 0x000003a4, 0x000118d6, 0x000118b6,
0x00000580, 0x00000550, 0x00002d15, 0x000010b5,
0x00001f78, 0x00001ff8, 0x0000a767, 0x0000a766,
0x00016e72, 0x00016e52, 0x00002d0a, 0x000010aa,
0x00000061, 0x00000041, 0x0000a759, 0x0000a758,
0x0000ab7a, 0x000013aa, 0x000000f0, 0x000000d0,
0x00001f42, 0x00001f4a, 0x00002c9b, 0x00002c9a,
0x00001e25, 0x00001e24, 0x0000aba1, 0x000013d1,
0x000118c7, 0x000118a7, 0x0000018c, 0x0000018b,
0x00001e4d, 0x00001e4c, 0x000010e4, 0x00001ca4,
0x000118d0, 0x000118b0, 0x00001ea7, 0x00001ea6,
0x00010ceb, 0x00010cab, 0x000010d8, 0x00001c98,
0x0000a64f, 0x0000a64e, 0x0001e929, 0x0001e907,
0x0000011f, 0x0000011e, 0x0000ab94, 0x000013c4,
0x00002d23, 0x000010c3, 0x0001e941, 0x0001e91f,
0x00000345, 0x00000399, 0x0000ab77, 0x000013a7,
0x00001ed1, 0x00001ed0, 0x0001e923, 0x0001e901,
0x00001e1d, 0x00001e1c, 0x0000ab8f, 0x000013bf,
0x00000582, 0x00000552, 0x00001f37, 0x00001f3f,
0x00001fb2, 0x02000124, 0x00000249, 0x00000248,
0x00001ec5, 0x00001ec4, 0x0000ff50, 0x0000ff30,
0x00001e61, 0x00001e60, 0x0000043a, 0x0000041a,
0x00000463, 0x00000462, 0x0000ff55, 0x0000ff35,
0x00000215, 0x00000214, 0x00016e6d, 0x00016e4d,
0x00010cda, 0x00010c9a, 0x00002175, 0x00002165,
0x00001e6f, 0x00001e6e, 0x00000493, 0x00000492,
0x00000587, 0x0200006b, 0x00002d09, 0x000010a9,
0x00001f62, 0x00001f6a, 0x0000017a, 0x00000179,
0x0000abaf, 0x000013df, 0x000118ce, 0x000118ae,
0x000003b2, 0x00000392, 0x00001e0d, 0x00001e0c,
0x000118da, 0x000118ba, 0x00002c3b, 0x00002c0b,
0x00001f60, 0x00001f68, 0x00000117, 0x00000116,
0x00001e3b, 0x00001e3a, 0x00000144, 0x00000143,
0x0000ff5a, 0x0000ff3a, 0x0000029e, 0x0000a7b0,
0x0000021f, 0x0000021e, 0x0000a79f, 0x0000a79e,
0x000024e7, 0x000024cd, 0x000000e5, 0x000000c5,
0x00016e66, 0x00016e46, 0x0000ab79, 0x000013a9,
0x0000fb13, 0x0200006e, 0x00001f87, 0x02000015,
0x0000a733, 0x0000a732, 0x0000fb06, 0x02000068,
0x00002c3e, 0x00002c0e, 0x0001e93c, 0x0001e91a,
0x0000ff53, 0x0000ff33, 0x0000a735, 0x0000a734,
0x00002c42, 0x00002c12, 0x00001fb0, 0x00001fb8,
0x00001e0b, 0x00001e0a, 0x00000577, 0x00000547,
0x000004c2, 0x000004c1, 0x0000a7a3, 0x0000a7a2,
0x000001e7, 0x000001e6, 0x0000044c, 0x0000042c,
0x000010fe, 0x00001cbe, 0x00000229, 0x00000228,
0x00001e93, 0x00001e92, 0x000001cc, 0x000001ca,
0x000010e0, 0x00001ca0, 0x000118c2, 0x000118a2,
0x00000072, 0x00000052, 0x000010f9, 0x00001cb9,
0x00010cc4, 0x00010c84, 0x0000217d, 0x0000216d,
0x000013fb, 0x000013f3, 0x000001bf, 0x000001f7,
0x0000ab7c, 0x000013ac, 0x00001eb9, 0x00001eb8,
0x0000028c, 0x00000245, 0x0000a791, 0x0000a790,
0x000001ff, 0x000001fe, 0x00000459, 0x00000409,
0x0001e936, 0x0001e914, 0x00001e7b, 0x00001e7a,
0x000004e5, 0x000004e4, 0x00002c93, 0x00002c92,
0x00001fe7, 0x030000cc, 0x00000101, 0x00000100,
0x000003d1, 0x00000398, 0x0000abb9, 0x000013e9,
0x0000ff44, 0x0000ff24, 0x00001e4b, 0x00001e4a,
0x00000450, 0x00000400, 0x00010ce2, 0x00010ca2,
0x000118cf, 0x000118af, 0x00001f91, 0x0200001b,
0x00002c97, 0x00002c96, 0x00000564, 0x00000534,
0x000003d6, 0x000003a0, 0x00010439, 0x00010411,
0x00001fbe, 0x00000399, 0x00010cc9, 0x00010c89,
0x000003cc, 0x0000038c, 0x000003dd, 0x000003dc,
0x00002d04, 0x000010a4, 0x0000a72d, 0x0000a72c,
0x0000044e, 0x0000042e, 0x00010442, 0x0001041a,
0x00001f75, 0x00001fcb, 0x00002cd7, 0x00002cd6,
0x00000449, 0x00000429, 0x0000006a, 0x0000004a,
0x000001df, 0x000001de, 0x00000105, 0x00000104,
0x0000abae, 0x000013de, 0x0000a65b, 0x0000a65a,
0x00001ea9, 0x00001ea8, 0x00000445, 0x00000425,
0x0000ab81, 0x000013b1, 0x00000140, 0x0000013f,
0x00001efb, 0x00001efa, 0x00010cee, 0x00010cae,
0x00002c89, 0x00002c88, 0x00000119, 0x00000118,
0x0000a695, 0x0000a694, 0x000004b3, 0x000004b2,
0x00000569, 0x00000539, 0x00002c51, 0x00002c21,
0x00001e47, 0x00001e46, 0x0000015f, 0x0000015e,
0x000001e9, 0x000001e8, 0x000118d2, 0x000118b2,
0x00001f50, 0x0200009a, 0x00001e21, 0x00001e20,
0x00002c34, 0x00002c04, 0x00000069, 0x00000049,
0x0001e93e, 0x0001e91c, 0x00001ef3, 0x00001ef2,
0x00002c59, 0x00002c29, 0x000010e9, 0x00001ca9,
0x00000180, 0x00000243, 0x000001e3, 0x000001e2,
0x00016e67, 0x00016e47, 0x00010ccc, 0x00010c8c,
0x000104e4, 0x000104bc, 0x00000071, 0x00000051,
0x000000f9, 0x000000d9, 0x0000ab9b, 0x000013cb,
0x000003ce, 0x0000038f, 0x00001ee1, 0x00001ee0,
0x0000019e, 0x00000220, 0x000010e7, 0x00001ca7,
0x00002d1e, 0x000010be, 0x00010445, 0x0001041d,
0x00001e35, 0x00001e34, 0x000010f8, 0x00001cb8,
0x00000438, 0x00000418, 0x00001f55, 0x00001f5d,
0x00016e77, 0x00016e57, 0x0000a76b, 0x0000a76a,
0x000004d9, 0x000004d8, 0x00001fbc, 0x0200011b,
0x00001e41, 0x00001e40, 0x00000146, 0x00000145,
0x000010de, 0x00001c9e, 0x00001e89, 0x00001e88,
0x00001e8f, 0x00001e8e, 0x000000e6, 0x000000c6,
0x00010cd4, 0x00010c94, 0x0000022f, 0x0000022e,
0x00001e91, 0x00001e90, 0x00002cbf, 0x00002cbe,
0x0000057a, 0x0000054a, 0x00001ed3, 0x00001ed2,
0x000024d9, 0x000024bf, 0x00001edf, 0x00001ede,
0x0000a7b5, 0x0000a7b4, 0x00002d0b, 0x000010ab,
0x0001e93a, 0x0001e918, 0x00001f95, 0x02000027,
0x00001f41, 0x00001f49, 0x000118c5, 0x000118a5,
0x00000259, 0x0000018f, 0x00016e6a, 0x00016e4a,
0x0000ab76, 0x000013a6, 0x000003f8, 0x000003f7,
0x000104d9, 0x000104b1, 0x000000ec, 0x000000cc,
0x0000a66b, 0x0000a66a, 0x000010d3, 0x00001c93,
0x000104f9, 0x000104d1, 0x00001e17, 0x00001e16,
0x000003b0, 0x03000084, 0x000004ad, 0x000004ac,
0x000003b3, 0x00000393, 0x00000253, 0x00000181,
0x00001c82, 0x0000041e, 0x00010cce, 0x00010c8e,
0x000003b8, 0x00000398, 0x0000a645, 0x0000a644,
0x0000217b, 0x0000216b, 0x000104e7, 0x000104bf,
0x0000044f, 0x0000042f, 0x0001e931, 0x0001e90f,
0x0000013e, 0x0000013d, 0x0000ab99, 0x000013c9,
0x000004c6, 0x000004c5, 0x000001d4, 0x000001d3,
0x00016e61, 0x00016e41, 0x0000a657, 0x0000a656,
0x0000217c, 0x0000216c, 0x000104f6, 0x000104ce,
0x00001e3f, 0x00001e3e, 0x00000070, 0x00000050,
0x000000e7, 0x000000c7, 0x000104e6, 0x000104be,
0x000024e9, 0x000024cf, 0x00010cef, 0x00010caf,
0x000004cf, 0x000004c0, 0x00000131, 0x00000049,
0x00000107, 0x00000106, 0x00002d25, 0x000010c5,
0x0000ab85, 0x000013b5, 0x00001ebb, 0x00001eba,
0x00000271, 0x00002c6e, 0x00016e6c, 0x00016e4c,
0x000000e8, 0x000000c8, 0x0000fb15, 0x02000074,
0x0001e924, 0x0001e902, 0x00000133, 0x00000132,
0x00000373, 0x00000372, 0x00000442, 0x00000422,
0x000001c9, 0x000001c7, 0x00001fb6, 0x020000a9,
0x00000561, 0x00000531, 0x0000ff51, 0x0000ff31,
0x000104ed, 0x000104c5, 0x00001efd, 0x00001efc,
0x00000578, 0x00000548, 0x0000ff46, 0x0000ff26,
0x0000ff47, 0x0000ff27, 0x00001e98, 0x02000091,
0x00002c38, 0x00002c08, 0x000001d0, 0x000001cf,
0x000118d1, 0x000118b1, 0x000024d8, 0x000024be,
0x00002c30, 0x00002c00, 0x00010ce9, 0x00010ca9,
0x00001ebd, 0x00001ebc, 0x00001f31, 0x00001f39,
0x0000010d, 0x0000010c, 0x0000abb1, 0x000013e1,
0x0000aba7, 0x000013d7, 0x0001e93d, 0x0001e91b,
0x0000a743, 0x0000a742, 0x0000ab7f, 0x000013af,
0x00000437, 0x00000417, 0x0000024d, 0x0000024c,
0x0000015b, 0x0000015a, 0x00002d01, 0x000010a1,
0x000013f9, 0x000013f1, 0x00010443, 0x0001041b,
0x00001e55, 0x00001e54, 0x0000a681, 0x0000a680,
0x0000abac, 0x000013dc, 0x00002c83, 0x00002c82,
0x000001f0, 0x02000088, 0x00000448, 0x00000428,
0x00002178, 0x00002168, 0x000118c4, 0x000118a4,
0x000000f8, 0x000000d8, 0x00002c81, 0x00002c80,
0x00010ce4, 0x00010ca4, 0x000003c0, 0x000003a0,
0x0001e92b, 0x0001e909, 0x00002cd5, 0x00002cd4,
0x00002d07, 0x000010a7, 0x0000ab9c, 0x000013cc,
0x000003bd, 0x0000039d, 0x0000a751, 0x0000a750,
0x0000ab74, 0x000013a4, 0x000118c9, 0x000118a9,
0x00001f22, 0x00001f2a, 0x000000ea, 0x000000ca,
0x000004fd, 0x000004fc, 0x00000586, 0x00000556,
0x00001ed9, 0x00001ed8, 0x00001e7f, 0x00001e7e,
0x000118d7, 0x000118b7, 0x00001faa, 0x02000109,
0x0000ff43, 0x0000ff23, 0x000003e5, 0x000003e4,
0x0000043d, 0x0000041d, 0x000104da, 0x000104b2,
0x000104df, 0x000104b7, 0x0000023c, 0x0000023b,
0x00001f64, 0x00001f6c, 0x00010cd3, 0x00010c93,
0x000003cb, 0x000003ab, 0x0001e93f, 0x0001e91d,
0x0000a723, 0x0000a722, 0x0001043c, 0x00010414,
0x0000ab91, 0x000013c1, 0x0001044e, 0x00010426,
0x00000149, 0x0200007d, 0x00001ed7, 0x00001ed6,
0x00001fd6, 0x020000b7, 0x00001f14, 0x00001f1c,
0x0000a7a9, 0x0000a7a8, 0x00016e74, 0x00016e54,
0x00002c49, 0x00002c19, 0x00000111, 0x00000110,
0x00000068, 0x00000048, 0x0000045c, 0x0000040c,
0x000000e3, 0x000000c3, 0x00000205, 0x00000204,
0x000024da, 0x000024c0, 0x00002c5e, 0x00002c2e,
0x000010ea, 0x00001caa, 0x0001044a, 0x00010422,
0x0000029d, 0x0000a7b2, 0x00016e65, 0x00016e45,
0x0000ab70, 0x000013a0, 0x00002171, 0x00002161,
0x000104ea, 0x000104c2, 0x00016e71, 0x00016e51,
0x000010d1, 0x00001c91, 0x00002c91, 0x00002c90,
0x000001cb, 0x000001ca, 0x0000a73b, 0x0000a73a,
0x00001e15, 0x00001e14, 0x00002c5a, 0x00002c2a,
0x000104f1, 0x000104c9, 0x000001bd, 0x000001bc,
0x0000006b, 0x0000004b, 0x00001f9f, 0x02000100,
0x000104f2, 0x000104ca, 0x00001f70, 0x00001fba,
0x0000a64d, 0x0000a64c, 0x00002d22, 0x000010c2,
0x00001f9a, 0x020000f1, 0x000001f5, 0x000001f4,
0x00002c53, 0x00002c23, 0x0000049f, 0x0000049e,
0x00010441, 0x00010419, 0x00000292, 0x000001b7,
0x00000436, 0x00000416, 0x0000052d, 0x0000052c,
0x00001e75, 0x00001e74, 0x00001f79, 0x00001ff9,
0x00016e7a, 0x00016e5a, 0x0000057e, 0x0000054e,
0x00002d11, 0x000010b1, 0x00001f27, 0x00001f2f,
0x00000125, 0x00000124, 0x00010ce8, 0x00010ca8,
0x00002c4f, 0x00002c1f, 0x00001f45, 0x00001f4d,
0x00001e03, 0x00001e02, 0x00002d18, 0x000010b8,
0x0000ab9e, 0x000013ce, 0x0000ff52, 0x0000ff32,
0x00001f65, 0x00001f6d, 0x0000a655, 0x0000a654,
0x0000abb6, 0x000013e6, 0x00001f8f, 0x020000e8,
0x000001f3, 0x000001f1, 0x00002c48, 0x00002c18,
0x0000ab8b, 0x000013bb, 0x00001ee5, 0x00001ee4,
0x000024d6, 0x000024bc, 0x00000203, 0x00000202,
0x000010e2, 0x00001ca2, 0x0000214e, 0x00002132,
0x0000024b, 0x0000024a, 0x00002cee, 0x00002ced,
0x0000ab72, 0x000013a2, 0x00002d24, 0x000010c4,
0x00001e5b, 0x00001e5a, 0x000001b4, 0x000001b3,
0x0000ab86, 0x000013b6, 0x00001fc3, 0x0200004b,
0x000003b1, 0x00000391, 0x00001e1f, 0x00001e1e,
0x00016e78, 0x00016e58, 0x00000481, 0x00000480,
0x00001f61, 0x00001f69, 0x000001a5, 0x000001a4,
0x0000a663, 0x0000a662, 0x0000abab, 0x000013db,
0x00001f7c, 0x00001ffa, 0x00001e9a, 0x02000097,
0x00016e76, 0x00016e56, 0x00010cd6, 0x00010c96,
0x0000ff42, 0x0000ff22, 0x00001ead, 0x00001eac,
0x00010ced, 0x00010cad, 0x00002d12, 0x000010b2,
0x0000ff57, 0x0000ff37, 0x0000a647, 0x0000a646,
0x00001f85, 0x0200000f, 0x0000a76d, 0x0000a76c,
0x00002d16, 0x000010b6, 0x000003b9, 0x00000399,
0x0000a763, 0x0000a762, 0x00000579, 0x00000549,
0x000004e9, 0x000004e8, 0x00001e73, 0x00001e72,
0x00001e39, 0x00001e38, 0x00002c43, 0x00002c13,
0x000004ed, 0x000004ec, 0x00001f99, 0x020000ee,
0x000003f0, 0x0000039a, 0x0000a74f, 0x0000a74e,
0x000010fa, 0x00001cba, 0x00000217, 0x00000216,
0x000024dd, 0x000024c3, 0x0000a683, 0x0000a682,
0x000004b5, 0x000004b4, 0x00002c33, 0x00002c03,
0x00001f80, 0x02000000, 0x000000fe, 0x000000de,
0x0000abb5, 0x000013e5, 0x0000217f, 0x0000216f,
0x0000026c, 0x0000a7ad, 0x0000a769, 0x0000a768,
0x0000abaa, 0x000013da, 0x0000045a, 0x0000040a,
0x00001e71, 0x00001e70, 0x00001f97, 0x0200002d,
0x0000056e, 0x0000053e, 0x00001ee7, 0x00001ee6,
0x000118ca, 0x000118aa, 0x00000529, 0x00000528,
0x00000566, 0x00000536, 0x00002c6c, 0x00002c6b,
0x0000a68d, 0x0000a68c, 0x0000a783, 0x0000a782,
0x000003c6, 0x000003a6, 0x00001edb, 0x00001eda,
0x00001ff6, 0x020000d0, 0x00000209, 0x00000208,
0x00000227, 0x00000226, 0x00000479, 0x00000478,
0x0000ff45, 0x0000ff25, 0x00001f8b, 0x020000dc,
0x000001ce, 0x000001cd, 0x0000057b, 0x0000054b,
0x00001f73, 0x00001fc9, 0x00000261, 0x0000a7ac,
0x00002cdd, 0x00002cdc, 0x0000ab88, 0x000013b8,
0x00002d08, 0x000010a8, 0x0001e933, 0x0001e911,
0x000004eb, 0x000004ea, 0x00000563, 0x00000533,
0x00000435, 0x00000415, 0x00001ec7, 0x00001ec6,
0x0000a797, 0x0000a796, 0x0000021d, 0x0000021c,
0x0000047b, 0x0000047a, 0x00001f83, 0x02000009,
0x000001c6, 0x000001c4, 0x000013f8, 0x000013f0,
0x000118dd, 0x000118bd, 0x00001f56, 0x030000a5,
0x00001f86, 0x02000012, 0x00002c57, 0x00002c27,
0x00002d21, 0x000010c1, 0x000003be, 0x0000039e,
0x00000527, 0x00000526, 0x0000047f, 0x0000047e,
0x0000051f, 0x0000051e, 0x00001ecf, 0x00001ece,
0x00001f04, 0x00001f0c, 0x00016e75, 0x00016e55,
0x00010cd5, 0x00010c95, 0x00000507, 0x00000506,
0x0001e926, 0x0001e904, 0x00001f81, 0x02000003,
0x00002cd9, 0x00002cd8, 0x00000161, 0x00000160,
0x000104fa, 0x000104d2, 0x00001e23, 0x00001e22,
0x000118d4, 0x000118b4, 0x0000aba3, 0x000013d3,
0x00001f51, 0x00001f59, 0x0000a659, 0x0000a658,
0x000118df, 0x000118bf, 0x00002d2d, 0x000010cd,
0x00001fe0, 0x00001fe8, 0x000001e5, 0x000001e4,
0x00002c4c, 0x00002c1c, 0x000010d4, 0x00001c94,
0x0000048d, 0x0000048c, 0x00001eab, 0x00001eaa,
0x000003bb, 0x0000039b, 0x00000565, 0x00000535,
0x000003ac, 0x00000386, 0x000024d7, 0x000024bd,
0x00016e68, 0x00016e48, 0x000001ef, 0x000001ee,
0x00000159, 0x00000158, 0x00001f53, 0x00001f5b,
0x00000188, 0x00000187, 0x00002cc1, 0x00002cc0,
0x00002cd3, 0x00002cd2, 0x0001e935, 0x0001e913,
0x00001fab, 0x0200010c, 0x0000057c, 0x0000054c,
0x0000ab98, 0x000013c8, 0x00010448, 0x00010420,
0x00001f54, 0x030000a1, 0x000004f1, 0x000004f0,
0x000004d7, 0x000004d6, 0x00001fd2, 0x030000af,
0x000003e7, 0x000003e6, 0x00002c76, 0x00002c75,
0x000010ef, 0x00001caf, 0x0000012d, 0x0000012c,
0x00001ef9, 0x00001ef8, 0x00000123, 0x00000122,
0x00002cc9, 0x00002cc8, 0x000003db, 0x000003da,
0x0001e927, 0x0001e905, 0x0000012f, 0x0000012e,
0x00000568, 0x00000538, 0x000003e1, 0x000003e0,
0x0001e930, 0x0001e90e, 0x00000501, 0x00000500,
0x00002c73, 0x00002c72, 0x00000177, 0x00000176,
0x0001e928, 0x0001e906, 0x00001fa0, 0x02000030,
0x000118de, 0x000118be, 0x00002c87, 0x00002c86,
0x0001043f, 0x00010417, 0x000001f9, 0x000001f8,
0x000000fd, 0x000000dd, 0x0000a65f, 0x0000a65e,
0x00000075, 0x00000055, 0x000001dd, 0x0000018e,
0x0000012b, 0x0000012a, 0x000010e8, 0x00001ca8,
0x00000477, 0x00000476, 0x00001ecb, 0x00001eca,
0x00000499, 0x00000498, 0x00000377, 0x00000376,
0x00000103, 0x00000102, 0x0001e925, 0x0001e903,
0x00002c95, 0x00002c94, 0x000010e6, 0x00001ca6,
0x00002d14, 0x000010b4, 0x00001e5d, 0x00001e5c,
0x000104e1, 0x000104b9, 0x00002cab, 0x00002caa,
0x0000050b, 0x0000050a, 0x0000026b, 0x00002c62,
0x00000173, 0x00000172, 0x000118d5, 0x000118b5,
0x000004ce, 0x000004cd, 0x0000ab53, 0x0000a7b3,
0x000001b9, 0x000001b8, 0x00000233, 0x00000232,
0x0000014f, 0x0000014e, 0x00000219, 0x00000218,
0x00000268, 0x00000197, 0x0000047d, 0x0000047c,
0x00010cc0, 0x00010c80, 0x00010444, 0x0001041c,
0x00000231, 0x00000230, 0x00001ec9, 0x00001ec8,
0x00002cb3, 0x00002cb2, 0x00001eaf, 0x00001eae,
0x00000266, 0x0000a7aa, 0x00000523, 0x00000522,
0x00001c83, 0x00000421, 0x00002cb9, 0x00002cb8,
0x0001042d, 0x00010405, 0x0000ff48, 0x0000ff28,
0x00001c87, 0x00000462, 0x00002c4d, 0x00002c1d,
0x00000260, 0x00000193, 0x0000a79b, 0x0000a79a,
0x000004ab, 0x000004aa, 0x000003ef, 0x000003ee,
0x00001f26, 0x00001f2e, 0x00000185, 0x00000184,
0x00000457, 0x00000407, 0x0000ab92, 0x000013c2,
0x00001f34, 0x00001f3c, 0x00001e79, 0x00001e78,
0x0000037b, 0x000003fd, 0x00010cd0, 0x00010c90,
0x00001ff3, 0x0200004e, 0x0001e92f, 0x0001e90d,
0x000010f5, 0x00001cb5, 0x00001f36, 0x00001f3e,
0x000003ba, 0x0000039a, 0x0001e938, 0x0001e916,
0x000000f3, 0x000000d3, 0x0000ab87, 0x000013b7,
0x0000052f, 0x0000052e, 0x00001e01, 0x00001e00,
0x000118c6, 0x000118a6, 0x000118c0, 0x000118a0,
0x00002c58, 0x00002c28, 0x0000fb02, 0x0200005a,
0x0000a78c, 0x0000a78b, 0x0000037d, 0x000003ff,
0x00002cbb, 0x00002cba, 0x000104ef, 0x000104c7,
0x000001a3, 0x000001a2, 0x00000062, 0x00000042,
0x0000abbf, 0x000013ef, 0x000003ca, 0x000003aa,
0x00001eed, 0x00001eec, 0x00002c52, 0x00002c22,
0x000003e9, 0x000003e8, 0x0000019a, 0x0000023d,
0x0000025b, 0x00000190, 0x00001ea1, 0x00001ea0,
0x0000056f, 0x0000053f, 0x00001fa2, 0x02000036,
0x0000022b, 0x0000022a, 0x000004c8, 0x000004c7,
0x00010cd2, 0x00010c92, 0x000003c1, 0x000003a1,
0x0000028a, 0x000001b1, 0x000118d3, 0x000118b3,
0x00002d02, 0x000010a2, 0x00000443, 0x00000423,
0x0001044f, 0x00010427, 0x0000a781, 0x0000a780,
0x00000562, 0x00000532, 0x00002cdb, 0x00002cda,
0x00001fc7, 0x0300013a, 0x00000199, 0x00000198,
0x00001c84, 0x00000422, 0x000004ef, 0x000004ee,
0x00001f40, 0x00001f48, 0x00001f74, 0x00001fca,
0x0000a641, 0x0000a640, 0x000104de, 0x000104b6,
0x00001e67, 0x00001e66, 0x000118d9, 0x000118b9,
0x0000049d, 0x0000049c, 0x000010e3, 0x00001ca3,
0x0000fb03, 0x0300005d, 0x0001e92a, 0x0001e908,
0x000004bd, 0x000004bc, 0x0000ab9f, 0x000013cf,
0x00000519, 0x00000518, 0x000001a8, 0x000001a7,
0x000000f4, 0x000000d4, 0x00000585, 0x00000555,
0x00000454, 0x00000404, 0x00001f24, 0x00001f2c,
0x0000a77a, 0x0000a779, 0x000004f9, 0x000004f8,
0x00002ccd, 0x00002ccc, 0x00001f66, 0x00001f6e,
0x000001da, 0x000001d9, 0x00000065, 0x00000045,
0x0000aba9, 0x000013d9, 0x00001f71, 0x00001fbb,
0x00001ef7, 0x00001ef6, 0x00000157, 0x00000156,
0x0000abb8, 0x000013e8, 0x0000ff4d, 0x0000ff2d,
0x00000252, 0x00002c70, 0x00016e7e, 0x00016e5e,
0x00002d1d, 0x000010bd, 0x00002177, 0x00002167,
0x000024e3, 0x000024c9, 0x0000a64b, 0x0000a64a,
0x00000503, 0x00000502, 0x0000048f, 0x0000048e,
0x000024e0, 0x000024c6, 0x00000153, 0x00000152,
0x00000576, 0x00000546, 0x00002c54, 0x00002c24,
0x00001f89, 0x020000d6, 0x00001f7d, 0x00001ffb,
0x00001e2b, 0x00001e2a, 0x00002170, 0x00002160,
0x00010430, 0x00010408, 0x00001eef, 0x00001eee,
0x000000f2, 0x000000d2, 0x00000491, 0x00000490,
0x0000a7a1, 0x0000a7a0, 0x000024d2, 0x000024b8,
0x00002c68, 0x00002c67, 0x0000abad, 0x000013dd,
0x0000a653, 0x0000a652, 0x0000a667, 0x0000a666,
0x00001e8b, 0x00001e8a, 0x00010cdc, 0x00010c9c,
0x0000ff41, 0x0000ff21, 0x0001e940, 0x0001e91e,
0x00001f9b, 0x020000f4, 0x00001f57, 0x00001f5f,
0x00002d00, 0x000010a0, 0x00001f01, 0x00001f09,
0x00000148, 0x00000147, 0x0000056b, 0x0000053b,
0x0000043e, 0x0000041e, 0x00001f9e, 0x020000fd,
0x00001f72, 0x00001fc8, 0x000004e3, 0x000004e2,
0x00002c61, 0x00002c60, 0x00001fa6, 0x02000042,
0x00001fa7, 0x02000045, 0x0000006d, 0x0000004d,
0x00010ce5, 0x00010ca5, 0x00001fc6, 0x020000ac,
0x00000287, 0x0000a7b1, 0x00002c5d, 0x00002c2d,
0x000010eb, 0x00001cab, 0x000003eb, 0x000003ea,
0x00001f96, 0x0200002a, 0x00001c86, 0x0000042a,
0x00000572, 0x00000542, 0x00000371, 0x00000370,
0x000024d5, 0x000024bb, 0x00002ccb, 0x00002cca,
0x000010d0, 0x00001c90, 0x00000444, 0x00000424,
0x00001f25, 0x00001f2d, 0x00000115, 0x00000114,
0x00001ec1, 0x00001ec0, 0x00002c5b, 0x00002c2b,
0x00010447, 0x0001041f, 0x00001f67, 0x00001f6f,
0x00016e6f, 0x00016e4f, 0x00002ce3, 0x00002ce2,
0x00001fa5, 0x0200003f, 0x00001e31, 0x00001e30,
0x00002c3d, 0x00002c0d, 0x00010cd8, 0x00010c98,
0x0000ff4f, 0x0000ff2f, 0x00001ea5, 0x00001ea4,
0x00000453, 0x00000403, 0x00000497, 0x00000496,
0x0000013c, 0x0000013b, 0x0000a699, 0x0000a698,
0x000010f7, 0x00001cb7, 0x00010cc6, 0x00010c86,
0x00000175, 0x00000174, 0x00001f06, 0x00001f0e,
0x0000010f, 0x0000010e, 0x00002d10, 0x000010b0,
0x00002c39, 0x00002c09, 0x000003f3, 0x0000037f,
0x00001f8c, 0x020000df, 0x00016e7f, 0x00016e5f,
0x0000051b, 0x0000051a, 0x00001f12, 0x00001f1a,
0x0000a785, 0x0000a784, 0x00000525, 0x00000524,
0x0000aba0, 0x000013d0, 0x000104dd, 0x000104b5,
0x000001c8, 0x000001c7, 0x0000056a, 0x0000053a,
0x00010ccf, 0x00010c8f, 0x000104e5, 0x000104bd,
0x00001ea3, 0x00001ea2, 0x00001f76, 0x00001fda,
0x000010d5, 0x00001c95, 0x00000137, 0x00000136,
0x00000265, 0x0000a78d, 0x00002ca3, 0x00002ca2,
0x00001e29, 0x00001e28, 0x0000a75f, 0x0000a75e,
0x00001f63, 0x00001f6b, 0x000004af, 0x000004ae,
0x0000ab71, 0x000013a1, 0x000104e8, 0x000104c0,
0x000003c8, 0x000003a8, 0x0000a77c, 0x0000a77b,
0x0000ab83, 0x000013b3, 0x00002d1c, 0x000010bc,
0x00010435, 0x0001040d, 0x00001e19, 0x00001e18,
0x000004db, 0x000004da, 0x0000ab95, 0x000013c5,
0x00001ff2, 0x02000130, 0x00001e7d, 0x00001e7c,
0x0000011b, 0x0000011a, 0x00010cc2, 0x00010c82,
0x00001fa3, 0x02000039, 0x000001d8, 0x000001d7,
0x000000b5, 0x0000039c, 0x000010dd, 0x00001c9d,
0x00000213, 0x00000212, 0x00000257, 0x0000018a,
0x0000051d, 0x0000051c, 0x00010ce7, 0x00010ca7,
0x000003d9, 0x000003d8, 0x0000020d, 0x0000020c,
0x00002ce1, 0x00002ce0, 0x000104e0, 0x000104b8,
0x00001e99, 0x02000094, 0x000118c1, 0x000118a1,
0x0000016f, 0x0000016e, 0x0000abba, 0x000013ea,
0x00002c65, 0x0000023a, 0x00001f52, 0x0300009d,
0x00001f33, 0x00001f3b, 0x000004dd, 0x000004dc,
0x000000fb, 0x000000db, 0x00001fb4, 0x02000127,
0x00001e1b, 0x00001e1a, 0x0000a66d, 0x0000a66c,
0x00001eeb, 0x00001eea, 0x00002c99, 0x00002c98,
0x000001b0, 0x000001af, 0x00000432, 0x00000412,
0x0000aba8, 0x000013d8, 0x0000a74b, 0x0000a74a,
0x00001e97, 0x0200008e, 0x0000a725, 0x0000a724,
0x000010d7, 0x00001c97, 0x000003b7, 0x00000397,
0x00001f93, 0x02000021, 0x000000ee, 0x000000ce,
0x00001e11, 0x00001e10, 0x00002c5c, 0x00002c2c,
0x00001f23, 0x00001f2b, 0x000004f7, 0x000004f6,
0x0000a73f, 0x0000a73e, 0x000004ff, 0x000004fe,
0x00001f35, 0x00001f3d, 0x0000017e, 0x0000017d,
0x0000050f, 0x0000050e, 0x00000113, 0x00000112,
0x00001ec3, 0x00001ec2, 0x000001f2, 0x000001f1,
0x000000f1, 0x000000d1, 0x00002cd1, 0x00002cd0,
0x0000ff54, 0x0000ff34, 0x00002c8b, 0x00002c8a,
0x000010f6, 0x00001cb6, 0x0000abb3, 0x000013e3,
0x00000390, 0x03000080, 0x000024e1, 0x000024c7,
0x00002c8d, 0x00002c8c, 0x00010cd1, 0x00010c91,
0x00001f98, 0x020000eb, 0x0001e934, 0x0001e912,
0x00001f90, 0x02000018, 0x000118cb, 0x000118ab,
0x00000431, 0x00000411, 0x0001042f, 0x00010407,
0x0000a74d, 0x0000a74c, 0x00001eb1, 0x00001eb0,
0x00002c6a, 0x00002c69, 0x0000fb01, 0x02000057,
0x000001dc, 0x000001db, 0x00001ecd, 0x00001ecc,
0x00000439, 0x00000419, 0x0000045d, 0x0000040d,
0x0000a799, 0x0000a798, 0x00002c41, 0x00002c11,
0x0000ab9d, 0x000013cd, 0x0001043a, 0x00010412,
0x00000067, 0x00000047, 0x0000006f, 0x0000004f,
0x000004c4, 0x000004c3, 0x00002176, 0x00002166,
0x0001e922, 0x0001e900, 0x00001c80, 0x00000412,
0x000010f0, 0x00001cb0, 0x00001f8d, 0x020000e2,
0x0000024f, 0x0000024e, 0x00000127, 0x00000126,
0x000001a1, 0x000001a0, 0x0000043c, 0x0000041c,
0x00001fe4, 0x020000c6, 0x00002d27, 0x000010c7,
0x00000207, 0x00000206, 0x00002c44, 0x00002c14,
0x0000a65d, 0x0000a65c, 0x0000a72b, 0x0000a72a,
0x0000ab7e, 0x000013ae, 0x00000465, 0x00000464,
0x000104d8, 0x000104b0, 0x000001e1, 0x000001e0,
0x00002c36, 0x00002c06, 0x0000abbb, 0x000013eb,
0x000104ec, 0x000104c4, 0x0000ff4b, 0x0000ff2b,
0x0000045e, 0x0000040e, 0x0000ab8c, 0x000013bc,
0x00000289, 0x00000244, 0x00000254, 0x00000186,
0x0000a685, 0x0000a684, 0x000010ed, 0x00001cad,
0x00002172, 0x00002162, 0x00010437, 0x0001040f,
0x0000a77f, 0x0000a77e, 0x00000574, 0x00000544,
0x000003df, 0x000003de, 0x0001042a, 0x00010402,
0x00001c85, 0x00000422, 0x0000a755, 0x0000a754,
0x00000076, 0x00000056, 0x00010440, 0x00010418,
0x00000183, 0x00000182
};
static const unsigned _uccase_lower_g_size = 226;
static const short _uccase_lower_g[] = {
378, 492, 185, 1753, 339, 6625, 945, 16446,
65, 1293, 18, 11220, 1036, 427, 550, 32,
133, 1629, 44, -55, 674, 19, 3949, 999,
2, -1322, 799, 1563, 17679, -1376, 61, 8474,
17, 6429, 7526, 1989, 4806, 2240, 569, 123,
7, 3273, 3641, 1058, 750, 5194, 5, 4168,
348, 515, 1355, 1127, 43, 8505, 14, 6476,
1223, 1245, 1705, 10707, 15, 2869, 33, 1441,
8845, 25, 7125, 2629, 1, -1039, 505, 252,
14983, 1438, 48, 156, 1131, 1079, 1404, 831,
553, 836, 278, 32767, 551, 1351, 14260, 22101,
682, 3477, 2, 18384, 61, 5915, 536, 473,
43, 10714, 20, 612, 536, 3622, 528, 1334,
104, 3202, 23, 437, 5395, 29, 3132, 432,
5, -610, 518, 111, 7221, 857, 40, 4247,
318, 1678, 2930, 24758, 66, 30739, 348, -1000,
3271, 1220, 17653, 14959, 1306, 1059, 209, -102,
219, 2132, 752, 2322, 43, 3295, 6, 10838,
450, 5742, 614, 1121, 48, 5015, 7, 3227,
895, 86, 7694, 5597, 2, 1432, 5512, 77,
3964, 3372, 77, -813, 610, 16149, 1418, 3255,
2, 976, 263, -336, 1806, 3, 5294, 4036,
547, 1524, 1, -33, 40, 8455, 1218, 8552,
368, 889, 2, 1502, 3441, 7654, 80, 10953,
293, 3783, 32, 2996, 525, 68, 1729, 4606,
8, -496, 1483, 51, 6480, 1116, 9, -1339,
3265, 3526, 3995, 356, 1, 4243, 650, 2662,
5467, 1209, 4058, 24424, 374, 610, 216, -125,
3604, 1707
};
static const unsigned _uccase_lower_table_size = 1383;
static const unsigned _uccase_lower_table[] = {
0x000010a9, 0x00002d09, 0x00000130, 0x02000142,
0x00002c1f, 0x00002c4f, 0x000013dc, 0x0000abac,
0x00016e56, 0x00016e76, 0x00000048, 0x00000068,
0x00002cd0, 0x00002cd1, 0x000013d3, 0x0000aba3,
0x00000460, 0x00000461, 0x00001e20, 0x00001e21,
0x00001ee4, 0x00001ee5, 0x00001cb4, 0x000010f4,
0x00002126, 0x000003c9, 0x00001ffc, 0x00001ff3,
0x0000216d, 0x0000217d, 0x00001fba, 0x00001f70,
0x00001f59, 0x00001f51, 0x000013ed, 0x0000abbd,
0x00010c93, 0x00010cd3, 0x00001e68, 0x00001e69,
0x000000d8, 0x000000f8, 0x0000ff28, 0x0000ff48,
0x00000480, 0x00000481, 0x0000040c, 0x0000045c,
0x0000050a, 0x0000050b, 0x00000218, 0x00000219,
0x000104d3, 0x000104fb, 0x00000230, 0x00000231,
0x00001ef8, 0x00001ef9, 0x00010405, 0x0001042d,
0x00000421, 0x00000441, 0x00000393, 0x000003b3,
0x00000512, 0x00000513, 0x000104c8, 0x000104f0,
0x00002c9e, 0x00002c9f, 0x00001fc8, 0x00001f72,
0x00001f2e, 0x00001f26, 0x00010404, 0x0001042c,
0x000010c1, 0x00002d21, 0x00001e46, 0x00001e47,
0x00002c82, 0x00002c83, 0x0000053e, 0x0000056e,
0x00000228, 0x00000229, 0x000024ce, 0x000024e8,
0x000010b0, 0x00002d10, 0x00002cca, 0x00002ccb,
0x00000141, 0x00000142, 0x000010bd, 0x00002d1d,
0x00001f9b, 0x00001f93, 0x000104cb, 0x000104f3,
0x00000472, 0x00000473, 0x000013df, 0x0000abaf,
0x0000a648, 0x0000a649, 0x00016e42, 0x00016e62,
0x00001fe8, 0x00001fe0, 0x00002c07, 0x00002c37,
0x000118a7, 0x000118c7, 0x00002c16, 0x00002c46,
0x000001fa, 0x000001fb, 0x00002c0d, 0x00002c3d,
0x00000184, 0x00000185, 0x0000a66a, 0x0000a66b,
0x000024bb, 0x000024d5, 0x00001f0c, 0x00001f04,
0x000001c8, 0x000001c9, 0x0000a732, 0x0000a733,
0x00001e04, 0x00001e05, 0x00010cab, 0x00010ceb,
0x000001a4, 0x000001a5, 0x00000492, 0x00000493,
0x0000021c, 0x0000021d, 0x00000056, 0x00000076,
0x00002cde, 0x00002cdf, 0x000013c8, 0x0000ab98,
0x0000040b, 0x0000045b, 0x00001c91, 0x000010d1,
0x000024b8, 0x000024d2, 0x00001f3c, 0x00001f34,
0x00000426, 0x00000446, 0x00002c2a, 0x00002c5a,
0x0000a742, 0x0000a743, 0x0000a73c, 0x0000a73d,
0x000000cf, 0x000000ef, 0x00002ca8, 0x00002ca9,
0x00002cbe, 0x00002cbf, 0x000003aa, 0x000003ca,
0x0000048a, 0x0000048b, 0x000013c0, 0x0000ab90,
0x00001ffb, 0x00001f7d, 0x00001e10, 0x00001e11,
0x00002c17, 0x00002c47, 0x00000520, 0x00000521,
0x00000187, 0x00000188, 0x000013da, 0x0000abaa,
0x0000a664, 0x0000a665, 0x0000a73a, 0x0000a73b,
0x00002c9c, 0x00002c9d, 0x000104be, 0x000104e6,
0x00002cbc, 0x00002cbd, 0x00001ca7, 0x000010e7,
0x000001ea, 0x000001eb, 0x00000246, 0x00000247,
0x000104c6, 0x000104ee, 0x00000551, 0x00000581,
0x000024ba, 0x000024d4, 0x00000506, 0x00000507,
0x00002c06, 0x00002c36, 0x0000053d, 0x0000056d,
0x00016e50, 0x00016e70, 0x00001e2c, 0x00001e2d,
0x0000ff32, 0x0000ff52, 0x00001ed2, 0x00001ed3,
0x0000053f, 0x0000056f, 0x00001cae, 0x000010ee,
0x0000015c, 0x0000015d, 0x00010c82, 0x00010cc2,
0x00000476, 0x00000477, 0x0000ff23, 0x0000ff43,
0x0001041a, 0x00010442, 0x0000a728, 0x0000a729,
0x00002c62, 0x0000026b, 0x00001f6f, 0x00001f67,
0x000118bf, 0x000118df, 0x00000403, 0x00000453,
0x00001e3a, 0x00001e3b, 0x000104ca, 0x000104f2,
0x0000052e, 0x0000052f, 0x000004d0, 0x000004d1,
0x0000a652, 0x0000a653, 0x00001ee6, 0x00001ee7,
0x000013bd, 0x0000ab8d, 0x000001b8, 0x000001b9,
0x000004de, 0x000004df, 0x00001e34, 0x00001e35,
0x000104c1, 0x000104e9, 0x0000046a, 0x0000046b,
0x000013c1, 0x0000ab91, 0x0000040d, 0x0000045d,
0x0000ff21, 0x0000ff41, 0x00010421, 0x00010449,
0x000013d4, 0x0000aba4, 0x00001e54, 0x00001e55,
0x00000134, 0x00000135, 0x00002c11, 0x00002c41,
0x0000042f, 0x0000044f, 0x00016e47, 0x00016e67,
0x0000a766, 0x0000a767, 0x0000a79e, 0x0000a79f,
0x00001fd8, 0x00001fd0, 0x000104b3, 0x000104db,
0x00010caa, 0x00010cea, 0x000013ad, 0x0000ab7d,
0x000001f7, 0x000001bf, 0x000003a6, 0x000003c6,
0x0000a660, 0x0000a661, 0x000118b9, 0x000118d9,
0x00002c24, 0x00002c54, 0x000003f4, 0x000003b8,
0x0000051e, 0x0000051f, 0x000118aa, 0x000118ca,
0x000118bc, 0x000118dc, 0x00000415, 0x00000435,
0x000000ca, 0x000000ea, 0x0000022a, 0x0000022b,
0x000004aa, 0x000004ab, 0x000013e1, 0x0000abb1,
0x00001ec4, 0x00001ec5, 0x0000011a, 0x0000011b,
0x00010424, 0x0001044c, 0x00001e0c, 0x00001e0d,
0x0000a696, 0x0000a697, 0x000010bc, 0x00002d1c,
0x0000019c, 0x0000026f, 0x000104bf, 0x000104e7,
0x000118bb, 0x000118db, 0x00010408, 0x00010430,
0x0000024a, 0x0000024b, 0x00000412, 0x00000432,
0x000013e0, 0x0000abb0, 0x00000046, 0x00000066,
0x00002cce, 0x00002ccf, 0x0000051c, 0x0000051d,
0x000013ac, 0x0000ab7c, 0x000010be, 0x00002d1e,
0x00000196, 0x00000269, 0x000010ba, 0x00002d1a,
0x00010ca5, 0x00010ce5, 0x00001fbb, 0x00001f71,
0x0001e90e, 0x0001e930, 0x0000a7b0, 0x0000029e,
0x000010c4, 0x00002d24, 0x00001cb7, 0x000010f7,
0x00016e55, 0x00016e75, 0x00001caa, 0x000010ea,
0x00000172, 0x00000173, 0x00001e14, 0x00001e15,
0x0000041a, 0x0000043a, 0x0001e917, 0x0001e939,
0x00000556, 0x00000586, 0x0000a79a, 0x0000a79b,
0x00002c84, 0x00002c85, 0x0001e909, 0x0001e92b,
0x00001fcb, 0x00001f75, 0x00016e4c, 0x00016e6c,
0x0000ff2b, 0x0000ff4b, 0x00000547, 0x00000577,
0x000013f5, 0x000013fd, 0x000013cc, 0x0000ab9c,
0x00000128, 0x00000129, 0x000013b5, 0x0000ab85,
0x0000ff25, 0x0000ff45, 0x00001f0e, 0x00001f06,
0x00001edc, 0x00001edd, 0x00002cda, 0x00002cdb,
0x00002c6e, 0x00000271, 0x000000d3, 0x000000f3,
0x0000216b, 0x0000217b, 0x000024c8, 0x000024e2,
0x000001fe, 0x000001ff, 0x0000039c, 0x000003bc,
0x000013ab, 0x0000ab7b, 0x00002160, 0x00002170,
0x00001e00, 0x00001e01, 0x00001c9b, 0x000010db,
0x0000048c, 0x0000048d, 0x00010ca0, 0x00010ce0,
0x00010c99, 0x00010cd9, 0x0000a782, 0x0000a783,
0x00001cbd, 0x000010fd, 0x0001e906, 0x0001e928,
0x000004c5, 0x000004c6, 0x000001b2, 0x0000028b,
0x00001f9c, 0x00001f94, 0x000104cf, 0x000104f7,
0x000104b6, 0x000104de, 0x00002c19, 0x00002c49,
0x0000a686, 0x0000a687, 0x00001e6e, 0x00001e6f,
0x00000110, 0x00000111, 0x000013a8, 0x0000ab78,
0x0000012c, 0x0000012d, 0x0000a77d, 0x00001d79,
0x00010c85, 0x00010cc5, 0x0000a76a, 0x0000a76b,
0x00000404, 0x00000454, 0x0001040d, 0x00010435,
0x00001f6d, 0x00001f65, 0x00001c97, 0x000010d7,
0x000013d2, 0x0000aba2, 0x0000a76e, 0x0000a76f,
0x000024bd, 0x000024d7, 0x000013a7, 0x0000ab77,
0x00000392, 0x000003b2, 0x00010c86, 0x00010cc6,
0x00000496, 0x00000497, 0x00002cb0, 0x00002cb1,
0x00001c99, 0x000010d9, 0x000003e2, 0x000003e3,
0x0000004b, 0x0000006b, 0x0000a77e, 0x0000a77f,
0x0000a65e, 0x0000a65f, 0x00001feb, 0x00001f7b,
0x00000145, 0x00000146, 0x000118bd, 0x000118dd,
0x000024c9, 0x000024e3, 0x0000a7a8, 0x0000a7a9,
0x0000038c, 0x000003cc, 0x00000102, 0x00000103,
0x00002c08, 0x00002c38, 0x0000a64e, 0x0000a64f,
0x000003f9, 0x000003f2, 0x0001e920, 0x0001e942,
0x00000544, 0x00000574, 0x000003f7, 0x000003f8,
0x00000241, 0x00000242, 0x00000108, 0x00000109,
0x00001f29, 0x00001f21, 0x00001fab, 0x00001fa3,
0x00010411, 0x00010439, 0x00001e7c, 0x00001e7d,
0x00001cb0, 0x000010f0, 0x00010402, 0x0001042a,
0x000010b4, 0x00002d14, 0x00000132, 0x00000133,
0x000013e5, 0x0000abb5, 0x0000042e, 0x0000044e,
0x00010c8a, 0x00010cca, 0x00001ca8, 0x000010e8,
0x00001e4c, 0x00001e4d, 0x00001fae, 0x00001fa6,
0x00000422, 0x00000442, 0x000003fa, 0x000003fb,
0x00001eb4, 0x00001eb5, 0x0000a7b6, 0x0000a7b7,
0x000001b5, 0x000001b6, 0x000001e0, 0x000001e1,
0x000118b8, 0x000118d8, 0x00000508, 0x00000509,
0x00016e5e, 0x00016e7e, 0x000104c5, 0x000104ed,
0x000013d8, 0x0000aba8, 0x000118ba, 0x000118da,
0x000024ca, 0x000024e4, 0x00001f49, 0x00001f41,
0x00016e41, 0x00016e61, 0x0000010c, 0x0000010d,
0x0000021a, 0x0000021b, 0x0000a7a0, 0x0000a7a1,
0x00001e0a, 0x00001e0b, 0x000004c9, 0x000004ca,
0x00001f99, 0x00001f91, 0x00010415, 0x0001043d,
0x000001c5, 0x000001c6, 0x00001ff9, 0x00001f79,
0x0000053b, 0x0000056b, 0x00001c96, 0x000010d6,
0x00002c70, 0x00000252, 0x00000042, 0x00000062,
0x00000424, 0x00000444, 0x00001f8f, 0x00001f87,
0x00001e60, 0x00001e61, 0x00016e52, 0x00016e72,
0x0000041f, 0x0000043f, 0x00002ca0, 0x00002ca1,
0x0000a668, 0x0000a669, 0x0000014a, 0x0000014b,
0x000013b7, 0x0000ab87, 0x000003a0, 0x000003c0,
0x000004b8, 0x000004b9, 0x00010cb2, 0x00010cf2,
0x000013b3, 0x0000ab83, 0x000001b3, 0x000001b4,
0x00001f3f, 0x00001f37, 0x000013f2, 0x000013fa,
0x000000cb, 0x000000eb, 0x0000015e, 0x0000015f,
0x00000041, 0x00000061, 0x000003fe, 0x0000037c,
0x000104c0, 0x000104e8, 0x000004c3, 0x000004c4,
0x00010c81, 0x00010cc1, 0x0000ff37, 0x0000ff57,
0x00002c29, 0x00002c59, 0x00001fb9, 0x00001fb1,
0x0000a698, 0x0000a699, 0x00002c20, 0x00002c50,
0x0000019d, 0x00000272, 0x00000528, 0x00000529,
0x00010ca8, 0x00010ce8, 0x00000136, 0x00000137,
0x00010c92, 0x00010cd2, 0x0000042d, 0x0000044d,
0x000013e2, 0x0000abb2, 0x00001c92, 0x000010d2,
0x00010cb1, 0x00010cf1, 0x00001cad, 0x000010ed,
0x000000c3, 0x000000e3, 0x0000a748, 0x0000a749,
0x00000402, 0x00000452, 0x000001ee, 0x000001ef,
0x0000a758, 0x0000a759, 0x000013dd, 0x0000abad,
0x000118b1, 0x000118d1, 0x0000013d, 0x0000013e,
0x000010ab, 0x00002d0b, 0x00001cb5, 0x000010f5,
0x000104cd, 0x000104f5, 0x00001ca5, 0x000010e5,
0x0000012a, 0x0000012b, 0x00002c8c, 0x00002c8d,
0x00000429, 0x00000449, 0x000013cf, 0x0000ab9f,
0x000118a6, 0x000118c6, 0x00002c14, 0x00002c44,
0x00000147, 0x00000148, 0x000004f6, 0x000004f7,
0x00002165, 0x00002175, 0x00000118, 0x00000119,
0x0000023e, 0x00002c66, 0x00010c9a, 0x00010cda,
0x00001e5c, 0x00001e5d, 0x000118a9, 0x000118c9,
0x00000222, 0x00000223, 0x00000411, 0x00000431,
0x00001cb3, 0x000010f3, 0x000013e6, 0x0000abb6,
0x00010410, 0x00010438, 0x0000a7b2, 0x0000029d,
0x00002c6d, 0x00000251, 0x00001f5d, 0x00001f55,
0x00016e59, 0x00016e79, 0x0000a762, 0x0000a763,
0x00000413, 0x00000433, 0x000013c7, 0x0000ab97,
0x0000a740, 0x0000a741, 0x0001e908, 0x0001e92a,
0x00002c12, 0x00002c42, 0x00002c92, 0x00002c93,
0x00000395, 0x000003b5, 0x000004e0, 0x000004e1,
0x000010b6, 0x00002d16, 0x00002cd2, 0x00002cd3,
0x0000ff24, 0x0000ff44, 0x0000047e, 0x0000047f,
0x000010b8, 0x00002d18, 0x0000024e, 0x0000024f,
0x000013bb, 0x0000ab8b, 0x000004be, 0x000004bf,
0x000001a9, 0x00000283, 0x000004dc, 0x000004dd,
0x000000d2, 0x000000f2, 0x000010a0, 0x00002d00,
0x000003e8, 0x000003e9, 0x00000536, 0x00000566,
0x00016e5a, 0x00016e7a, 0x0000051a, 0x0000051b,
0x00010425, 0x0001044d, 0x00001f9d, 0x00001f95,
0x00000208, 0x00000209, 0x0000a756, 0x0000a757,
0x00001e26, 0x00001e27, 0x000000d5, 0x000000f5,
0x000013aa, 0x0000ab7a, 0x00010ca1, 0x00010ce1,
0x000024cb, 0x000024e5, 0x00001e80, 0x00001e81,
0x00000394, 0x000003b4, 0x00001f0b, 0x00001f03,
0x000118ae, 0x000118ce, 0x00001e3e, 0x00001e3f,
0x00000408, 0x00000458, 0x000004b2, 0x000004b3,
0x000104c4, 0x000104ec, 0x00010ca2, 0x00010ce2,
0x00001e86, 0x00001e87, 0x0001e918, 0x0001e93a,
0x00016e44, 0x00016e64, 0x000003cf, 0x000003d7,
0x00002c0e, 0x00002c3e, 0x0000a7a6, 0x0000a7a7,
0x0000038a, 0x000003af, 0x000118a0, 0x000118c0,
0x000118ad, 0x000118cd, 0x0000a684, 0x0000a685,
0x00001f98, 0x00001f90, 0x00000468, 0x00000469,
0x000013a2, 0x0000ab72, 0x0000a754, 0x0000a755,
0x0000041d, 0x0000043d, 0x00001fcc, 0x00001fc3,
0x0000212a, 0x0000006b, 0x000001b7, 0x00000292,
0x00010413, 0x0001043b, 0x00001e4e, 0x00001e4f,
0x00001e1e, 0x00001e1f, 0x000001af, 0x000001b0,
0x0000004f, 0x0000006f, 0x0000a680, 0x0000a681,
0x000000d9, 0x000000f9, 0x00000398, 0x000003b8,
0x00002c69, 0x00002c6a, 0x000004ba, 0x000004bb,
0x0000015a, 0x0000015b, 0x00002c88, 0x00002c89,
0x00000427, 0x00000447, 0x000001cb, 0x000001cc,
0x00000216, 0x00000217, 0x00002c26, 0x00002c56,
0x000118a2, 0x000118c2, 0x0001e907, 0x0001e929,
0x000118be, 0x000118de, 0x00001fbc, 0x00001fb3,
0x000004e6, 0x000004e7, 0x00001ed8, 0x00001ed9,
0x000013f3, 0x000013fb, 0x00000498, 0x00000499,
0x000024c5, 0x000024df, 0x000000c4, 0x000000e4,
0x00010c9f, 0x00010cdf, 0x00016e5d, 0x00016e7d,
0x0000013f, 0x00000140, 0x00010caf, 0x00010cef,
0x00001cb2, 0x000010f2, 0x0000050c, 0x0000050d,
0x0000004d, 0x0000006d, 0x00000052, 0x00000072,
0x00001eb8, 0x00001eb9, 0x00001cb8, 0x000010f8,
0x000024cf, 0x000024e9, 0x00001c9a, 0x000010da,
0x00001f0a, 0x00001f02, 0x0000ff3a, 0x0000ff5a,
0x00000397, 0x000003b7, 0x00000524, 0x00000525,
0x00001cab, 0x000010eb, 0x0000a722, 0x0000a723,
0x00002c05, 0x00002c35, 0x00002c6b, 0x00002c6c,
0x0000a650, 0x0000a651, 0x0000004c, 0x0000006c,
0x00001e84, 0x00001e85, 0x00002ca4, 0x00002ca5,
0x00001f9f, 0x00001f97, 0x000118b4, 0x000118d4,
0x00001eea, 0x00001eeb, 0x00000204, 0x00000205,
0x00001f5b, 0x00001f53, 0x000010b1, 0x00002d11,
0x00001ca4, 0x000010e4, 0x00000405, 0x00000455,
0x00001f2a, 0x00001f22, 0x00000114, 0x00000115,
0x000024b7, 0x000024d1, 0x000001cf, 0x000001d0,
0x00000156, 0x00000157, 0x00001ea0, 0x00001ea1,
0x00001c95, 0x000010d5, 0x000010a5, 0x00002d05,
0x00002169, 0x00002179, 0x00001f28, 0x00001f20,
0x000003e4, 0x000003e5, 0x00000526, 0x00000527,
0x00001e70, 0x00001e71, 0x0000a7ae, 0x0000026a,
0x000004c1, 0x000004c2, 0x0000042a, 0x0000044a,
0x00001ede, 0x00001edf, 0x0000a78b, 0x0000a78c,
0x0000a726, 0x0000a727, 0x0000ff39, 0x0000ff59,
0x0000a73e, 0x0000a73f, 0x0000a72e, 0x0000a72f,
0x00010403, 0x0001042b, 0x00010ca7, 0x00010ce7,
0x000003a3, 0x000003c3, 0x000104ce, 0x000104f6,
0x00001efc, 0x00001efd, 0x00002c18, 0x00002c48,
0x00001eb6, 0x00001eb7, 0x0000020e, 0x0000020f,
0x000013ef, 0x0000abbf, 0x000013a3, 0x0000ab73,
0x00000189, 0x00000256, 0x0000ff36, 0x0000ff56,
0x000004ac, 0x000004ad, 0x00002c09, 0x00002c39,
0x00001f1b, 0x00001f13, 0x00002cae, 0x00002caf,
0x0001e904, 0x0001e926, 0x000000c7, 0x000000e7,
0x00000406, 0x00000456, 0x000024bc, 0x000024d6,
0x000010b9, 0x00002d19, 0x00002c90, 0x00002c91,
0x00000478, 0x00000479, 0x00001efa, 0x00001efb,
0x00000139, 0x0000013a, 0x00002c0b, 0x00002c3b,
0x00001caf, 0x000010ef, 0x000004ee, 0x000004ef,
0x00001c98, 0x000010d8, 0x00000178, 0x000000ff,
0x0000a7b1, 0x00000287, 0x00001cbf, 0x000010ff,
0x0001041c, 0x00010444, 0x0000017b, 0x0000017c,
0x00001e74, 0x00001e75, 0x00000399, 0x000003b9,
0x00001f0d, 0x00001f05, 0x000118b7, 0x000118d7,
0x000003a9, 0x000003c9, 0x00001e76, 0x00001e77,
0x000013b8, 0x0000ab88, 0x00016e43, 0x00016e63,
0x00001ca3, 0x000010e3, 0x000001db, 0x000001dc,
0x0001e91c, 0x0001e93e, 0x0000041e, 0x0000043e,
0x0001e90f, 0x0001e931, 0x00000120, 0x00000121,
0x000001e8, 0x000001e9, 0x00000370, 0x00000371,
0x00001ea4, 0x00001ea5, 0x000118ac, 0x000118cc,
0x000024c0, 0x000024da, 0x000010a2, 0x00002d02,
0x000003e0, 0x000003e1, 0x000013a6, 0x0000ab76,
0x0000a7ad, 0x0000026c, 0x00001ec8, 0x00001ec9,
0x000003da, 0x000003db, 0x00000416, 0x00000436,
0x0001e913, 0x0001e935, 0x00001ca2, 0x000010e2,
0x0000a7b8, 0x0000a7b9, 0x000013d0, 0x0000aba0,
0x00010426, 0x0001044e, 0x000013eb, 0x0000abbb,
0x000000d0, 0x000000f0, 0x00002c9a, 0x00002c9b,
0x0000054d, 0x0000057d, 0x0001e901, 0x0001e923,
0x000003a7, 0x000003c7, 0x000001a0, 0x000001a1,
0x00001f3a, 0x00001f32, 0x0000040e, 0x0000045e,
0x000004ea, 0x000004eb, 0x000013e3, 0x0000abb3,
0x00000162, 0x00000163, 0x0000ff35, 0x0000ff55,
0x00002c01, 0x00002c31, 0x0000023d, 0x0000019a,
0x000013cd, 0x0000ab9d, 0x0000a666, 0x0000a667,
0x0000039e, 0x000003be, 0x000004a0, 0x000004a1,
0x000010c5, 0x00002d25, 0x000024c4, 0x000024de,
0x000010a6, 0x00002d06, 0x00010cae, 0x00010cee,
0x00002c2c, 0x00002c5c, 0x00000044, 0x00000064,
0x00002ccc, 0x00002ccd, 0x00001e2e, 0x00001e2f,
0x00002132, 0x0000214e, 0x00016e4f, 0x00016e6f,
0x00000179, 0x0000017a, 0x00001e48, 0x00001e49,
0x00016e58, 0x00016e78, 0x000004a6, 0x000004a7,
0x00001f09, 0x00001f01, 0x00001cb6, 0x000010f6,
0x00016e48, 0x00016e68, 0x0000039a, 0x000003ba,
0x0000041b, 0x0000043b, 0x0000018a, 0x00000257,
0x00000158, 0x00000159, 0x00000462, 0x00000463,
0x0000216a, 0x0000217a, 0x0001e91e, 0x0001e940,
0x000000c0, 0x000000e0, 0x00000176, 0x00000177,
0x000013ce, 0x0000ab9e, 0x00001e52, 0x00001e53,
0x000010bf, 0x00002d1f, 0x00001f38, 0x00001f30,
0x000001f6, 0x00000195, 0x00002cc2, 0x00002cc3,
0x000010b5, 0x00002d15, 0x00000490, 0x00000491,
0x000004bc, 0x000004bd, 0x00010c8d, 0x00010ccd,
0x000013a9, 0x0000ab79, 0x000004fa, 0x000004fb,
0x00000504, 0x00000505, 0x00002cd8, 0x00002cd9,
0x00001ee0, 0x00001ee1, 0x00002166, 0x00002176,
0x00001e6a, 0x00001e6b, 0x00000054, 0x00000074,
0x00002cdc, 0x00002cdd, 0x00001e78, 0x00001e79,
0x00000419, 0x00000439, 0x000118b2, 0x000118d2,
0x0001e903, 0x0001e925, 0x000104c2, 0x000104ea,
0x000001d7, 0x000001d8, 0x00000540, 0x00000570,
0x00002c1b, 0x00002c4b, 0x000003e6, 0x000003e7,
0x000000cc, 0x000000ec, 0x000010c2, 0x00002d22,
0x00002c27, 0x00002c57, 0x0000004a, 0x0000006a,
0x00001eba, 0x00001ebb, 0x0000013b, 0x0000013c,
0x000004b4, 0x000004b5, 0x00001ca1, 0x000010e1,
0x000024c7, 0x000024e1, 0x000013b9, 0x0000ab89,
0x00002161, 0x00002171, 0x000000dd, 0x000000fd,
0x000013d5, 0x0000aba5, 0x000024c3, 0x000024dd,
0x00001e82, 0x00001e83, 0x000001c7, 0x000001c9,
0x00000510, 0x00000511, 0x0000020c, 0x0000020d,
0x00010cad, 0x00010ced, 0x00000248, 0x00000249,
0x0000a7b3, 0x0000ab53, 0x00000417, 0x00000437,
0x00000058, 0x00000078, 0x00002ce0, 0x00002ce1,
0x000013ec, 0x0000abbc, 0x00010c88, 0x00010cc8,
0x00001e22, 0x00001e23, 0x0000a694, 0x0000a695,
0x0000ff2e, 0x0000ff4e, 0x0000038e, 0x000003cd,
0x00000418, 0x00000438, 0x000013c5, 0x0000ab95,
0x00001e94, 0x00001e95, 0x00000116, 0x00000117,
0x00002c86, 0x00002c87, 0x0000a734, 0x0000a735,
0x00010417, 0x0001043f, 0x0000a7a2, 0x0000a7a3,
0x000013ca, 0x0000ab9a, 0x000001a6, 0x00000280,
0x000004f4, 0x000004f5, 0x0000a760, 0x0000a761,
0x00001f18, 0x00001f10, 0x00002c64, 0x0000027d,
0x00000541, 0x00000571, 0x00000049, 0x00000069,
0x00000152, 0x00000153, 0x000003ec, 0x000003ed,
0x0001e914, 0x0001e936, 0x00002c23, 0x00002c53,
0x00001ed0, 0x00001ed1, 0x00001c9e, 0x000010de,
0x00001f1c, 0x00001f14, 0x00001e06, 0x00001e07,
0x00001ef2, 0x00001ef3, 0x00000057, 0x00000077,
0x00000206, 0x00000207, 0x000003d8, 0x000003d9,
0x0000047a, 0x0000047b, 0x00001ffa, 0x00001f7c,
0x00000051, 0x00000071, 0x000013c9, 0x0000ab99,
0x0000a640, 0x0000a641, 0x0001e919, 0x0001e93b,
0x00000053, 0x00000073, 0x0000a7a4, 0x0000a7a5,
0x00001e56, 0x00001e57, 0x00002ced, 0x00002cee,
0x00016e5f, 0x00016e7f, 0x00010416, 0x0001043e,
0x0000a78d, 0x00000265, 0x00010c95, 0x00010cd5,
0x00000546, 0x00000576, 0x00000555, 0x00000585,
0x00001fac, 0x00001fa4, 0x00001f6a, 0x00001f62,
0x000003dc, 0x000003dd, 0x00000548, 0x00000578,
0x00016e54, 0x00016e74, 0x00000552, 0x00000582,
0x0000ff2f, 0x0000ff4f, 0x00001fa9, 0x00001fa1,
0x00010406, 0x0001042e, 0x000013d7, 0x0000aba7,
0x000001e6, 0x000001e7, 0x00010cac, 0x00010cec,
0x00010c8b, 0x00010ccb, 0x00000181, 0x00000253,
0x000024c2, 0x000024dc, 0x00000407, 0x00000457,
0x000001d1, 0x000001d2, 0x00010c83, 0x00010cc3,
0x000104b4, 0x000104dc, 0x00001ecc, 0x00001ecd,
0x000104c3, 0x000104eb, 0x0000042b, 0x0000044b,
0x00002c80, 0x00002c81, 0x00001c9c, 0x000010dc,
0x00001e4a, 0x00001e4b, 0x000013d9, 0x0000aba9,
0x000013e7, 0x0000abb7, 0x00001eda, 0x00001edb,
0x000003ea, 0x000003eb, 0x00001cbe, 0x000010fe,
0x00001e16, 0x00001e17, 0x00010cb0, 0x00010cf0,
0x0000049c, 0x0000049d, 0x0000a654, 0x0000a655,
0x00002cb2, 0x00002cb3, 0x000013af, 0x0000ab7f,
0x0001e910, 0x0001e932, 0x000004ec, 0x000004ed,
0x0000a656, 0x0000a657, 0x000000c6, 0x000000e6,
0x00010423, 0x0001044b, 0x0000021e, 0x0000021f,
0x00010c94, 0x00010cd4, 0x0000a798, 0x0000a799,
0x0001e900, 0x0001e922, 0x00001c9d, 0x000010dd,
0x0000a75e, 0x0000a75f, 0x00010407, 0x0001042f,
0x00002c22, 0x00002c52, 0x00016e4e, 0x00016e6e,
0x0000053c, 0x0000056c, 0x00001efe, 0x00001eff,
0x00002c0c, 0x00002c3c, 0x00001e8e, 0x00001e8f,
0x00000414, 0x00000434, 0x000013ee, 0x0000abbe,
0x00000059, 0x00000079, 0x000004c7, 0x000004c8,
0x00001c9f, 0x000010df, 0x000118a4, 0x000118c4,
0x0000212b, 0x000000e5, 0x000004f8, 0x000004f9,
0x00001eac, 0x00001ead, 0x000003ff, 0x0000037d,
0x00000542, 0x00000572, 0x00002c02, 0x00002c32,
0x000000de, 0x000000fe, 0x00002cb4, 0x00002cb5,
0x00001c93, 0x000010d3, 0x000004cd, 0x000004ce,
0x000010c3, 0x00002d23, 0x00001e2a, 0x00001e2b,
0x0000ff33, 0x0000ff53, 0x00002c1d, 0x00002c4d,
0x0000040f, 0x0000045f, 0x0000a764, 0x0000a765,
0x0000a79c, 0x0000a79d, 0x0000ff26, 0x0000ff46,
0x00001f2d, 0x00001f25, 0x00001e1a, 0x00001e1b,
0x000000d6, 0x000000f6, 0x000013b6, 0x0000ab86,
0x00010420, 0x00010448, 0x00000532, 0x00000562,
0x00000182, 0x00000183, 0x0000a768, 0x0000a769,
0x00001f8c, 0x00001f84, 0x00016e40, 0x00016e60,
0x00002c2d, 0x00002c5d, 0x0001041b, 0x00010443,
0x00001f0f, 0x00001f07, 0x000104bd, 0x000104e5,
0x000004a4, 0x000004a5, 0x0000a72c, 0x0000a72d,
0x0000a646, 0x0000a647, 0x00000401, 0x00000451,
0x000000cd, 0x000000ed, 0x00000533, 0x00000563,
0x0000a74c, 0x0000a74d, 0x00000545, 0x00000575,
0x00000400, 0x00000450, 0x00002168, 0x00002178,
0x000024cd, 0x000024e7, 0x000004d6, 0x000004d7,
0x00001e8a, 0x00001e8b, 0x0000024c, 0x0000024d,
0x00010c9b, 0x00010cdb, 0x000004cb, 0x000004cc,
0x000024bf, 0x000024d9, 0x00001ca0, 0x000010e0,
0x000001d9, 0x000001da, 0x000013de, 0x0000abae,
0x00001eb2, 0x00001eb3, 0x0000a68e, 0x0000a68f,
0x00001e64, 0x00001e65, 0x0000a746, 0x0000a747,
0x000013a4, 0x0000ab74, 0x0000a74e, 0x0000a74f,
0x00000166, 0x00000167, 0x00001fec, 0x00001fe5,
0x00000106, 0x00000107, 0x000104bb, 0x000104e3,
0x0000005a, 0x0000007a, 0x00002ce2, 0x00002ce3,
0x00010c9c, 0x00010cdc, 0x0000014e, 0x0000014f,
0x000118ab, 0x000118cb, 0x00010418, 0x00010440,
0x00001f3e, 0x00001f36, 0x000013bf, 0x0000ab8f,
0x00000543, 0x00000573, 0x00001e66, 0x00001e67,
0x00002cac, 0x00002cad, 0x00000043, 0x00000063,
0x000004b6, 0x000004b7, 0x000004f0, 0x000004f1,
0x0000a752, 0x0000a753, 0x00001eae, 0x00001eaf,
0x00000150, 0x00000151, 0x00010c8e, 0x00010cce,
0x000001a7, 0x000001a8, 0x00000100, 0x00000101,
0x000104c7, 0x000104ef, 0x000001c4, 0x000001c6,
0x000013f0, 0x000013f8, 0x000004da, 0x000004db,
0x0000a692, 0x0000a693, 0x00001fd9, 0x00001fd1,
0x000104b2, 0x000104da, 0x00000531, 0x00000561,
0x00000522, 0x00000523, 0x0000a7ac, 0x00000261,
0x0000054b, 0x0000057b, 0x0000a750, 0x0000a751,
0x0000054f, 0x0000057f, 0x0001041d, 0x00010445,
0x00000200, 0x00000201, 0x0000a786, 0x0000a787,
0x00001f2b, 0x00001f23, 0x00001e5e, 0x00001e5f,
0x0001040a, 0x00010432, 0x000104c9, 0x000104f1,
0x00000122, 0x00000123, 0x000013f4, 0x000013fc,
0x00001ea6, 0x00001ea7, 0x00000174, 0x00000175,
0x00001f9e, 0x00001f96, 0x00001e50, 0x00001e51,
0x00002c2e, 0x00002c5e, 0x0001040e, 0x00010436,
0x000104b9, 0x000104e1, 0x0000039d, 0x000003bd,
0x00002183, 0x00002184, 0x00002c6f, 0x00000250,
0x00000190, 0x0000025b, 0x000010a4, 0x00002d04,
0x0000039f, 0x000003bf, 0x00000389, 0x000003ae,
0x00001e12, 0x00001e13, 0x0000a644, 0x0000a645,
0x00001ec0, 0x00001ec1, 0x00000494, 0x00000495,
0x000104ba, 0x000104e2, 0x00000050, 0x00000070,
0x00001e32, 0x00001e33, 0x0000ff2d, 0x0000ff4d,
0x00000423, 0x00000443, 0x00016e4a, 0x00016e6a,
0x0000004e, 0x0000006e, 0x00010427, 0x0001044f,
0x00002c0f, 0x00002c3f, 0x0000023b, 0x0000023c,
0x00001f1d, 0x00001f15, 0x00001f08, 0x00001f00,
0x00001f4c, 0x00001f44, 0x00010c87, 0x00010cc7,
0x000004f2, 0x000004f3, 0x00001c94, 0x000010d4,
0x0000a7aa, 0x00000266, 0x00001f68, 0x00001f60,
0x0000046e, 0x0000046f, 0x00016e49, 0x00016e69,
0x00001faf, 0x00001fa7, 0x000001cd, 0x000001ce,
0x00000514, 0x00000515, 0x0000046c, 0x0000046d,
0x000118b5, 0x000118d5, 0x00002c1c, 0x00002c4c,
0x00001ea8, 0x00001ea9, 0x000003de, 0x000003df,
0x00002c04, 0x00002c34, 0x00001fa8, 0x00001fa0,
0x00002cb8, 0x00002cb9, 0x00000553, 0x00000583,
0x0000041c, 0x0000043c, 0x00001f5f, 0x00001f57,
0x000010b7, 0x00002d17, 0x00000212, 0x00000213,
0x000013d1, 0x0000aba1, 0x0001041e, 0x00010446,
0x00000243, 0x00000180, 0x0000a690, 0x0000a691,
0x00001cba, 0x000010fa, 0x00000391, 0x000003b1,
0x0001e90b, 0x0001e92d, 0x00001f39, 0x00001f31,
0x00001e7e, 0x00001e7f, 0x00001f69, 0x00001f61,
0x00000516, 0x00000517, 0x00000535, 0x00000565,
0x00010401, 0x00010429, 0x0000a7b4, 0x0000a7b5,
0x000118a8, 0x000118c8, 0x000004a8, 0x000004a9,
0x000010a7, 0x00002d07, 0x000013be, 0x0000ab8e,
0x00001eaa, 0x00001eab, 0x00010ca6, 0x00010ce6,
0x0001e921, 0x0001e943, 0x00010c97, 0x00010cd7,
0x0000a744, 0x0000a745, 0x000013b4, 0x0000ab84,
0x00001e9e, 0x000000df, 0x000010c0, 0x00002d20,
0x000013c4, 0x0000ab94, 0x00001eb0, 0x00001eb1,
0x00001f8e, 0x00001f86, 0x00001f89, 0x00001f81,
0x0001e90d, 0x0001e92f, 0x000003a8, 0x000003c8,
0x00001ece, 0x00001ecf, 0x0000ff2a, 0x0000ff4a,
0x0000a66c, 0x0000a66d, 0x0001e91a, 0x0001e93c,
0x0000010e, 0x0000010f, 0x00002c96, 0x00002c97,
0x0000037f, 0x000003f3, 0x00000534, 0x00000564,
0x0000049e, 0x0000049f, 0x00002cb6, 0x00002cb7,
0x00002c25, 0x00002c55, 0x0000047c, 0x0000047d,
0x000013ea, 0x0000abba, 0x00010414, 0x0001043c,
0x0000a780, 0x0000a781, 0x000001a2, 0x000001a3,
0x0001e915, 0x0001e937, 0x00010400, 0x00010428,
0x000024c6, 0x000024e0, 0x00001e92, 0x00001e93,
0x000001ac, 0x000001ad, 0x00002c15, 0x00002c45,
0x000000c9, 0x000000e9, 0x00002c21, 0x00002c51,
0x00001cb9, 0x000010f9, 0x000001bc, 0x000001bd,
0x00016e4d, 0x00016e6d, 0x00000518, 0x00000519,
0x00002cf2, 0x00002cf3, 0x00001cb1, 0x000010f1,
0x000004ae, 0x000004af, 0x000010b2, 0x00002d12,
0x00002c28, 0x00002c58, 0x000001fc, 0x000001fd,
0x0001e912, 0x0001e934, 0x0000a662, 0x0000a663,
0x000000d1, 0x000000f1, 0x000000d4, 0x000000f4,
0x000013c3, 0x0000ab93, 0x00000186, 0x00000254,
0x00000538, 0x00000568, 0x0000011c, 0x0000011d,
0x00002cba, 0x00002cbb, 0x00001ea2, 0x00001ea3,
0x000104cc, 0x000104f4, 0x00000193, 0x00000260,
0x0001040f, 0x00010437, 0x00000202, 0x00000203,
0x00010c8f, 0x00010ccf, 0x00010c8c, 0x00010ccc,
0x00001e1c, 0x00001e1d, 0x0000a65a, 0x0000a65b,
0x00000550, 0x00000580, 0x00000245, 0x0000028c,
0x00001f19, 0x00001f11, 0x000000c1, 0x000000e1,
0x00001e40, 0x00001e41, 0x00001f2c, 0x00001f24,
0x00000466, 0x00000467, 0x00002cc4, 0x00002cc5,
0x000024b9, 0x000024d3, 0x00001e8c, 0x00001e8d,
0x00001e90, 0x00001e91, 0x000004b0, 0x000004b1,
0x000001b1, 0x0000028a, 0x000003fd, 0x0000037b,
0x000001f2, 0x000001f3, 0x000000c2, 0x000000e2,
0x00000502, 0x00000503, 0x0000022e, 0x0000022f,
0x000013b1, 0x0000ab81, 0x0000017d, 0x0000017e,
0x00010c89, 0x00010cc9, 0x000013a0, 0x0000ab70,
0x00001ca9, 0x000010e9, 0x00000164, 0x00000165,
0x00002c00, 0x00002c30, 0x00001ef4, 0x00001ef5,
0x00002cc0, 0x00002cc1, 0x0000a68c, 0x0000a68d,
0x00001e24, 0x00001e25, 0x00000372, 0x00000373,
0x0000052c, 0x0000052d, 0x000010c7, 0x00002d27,
0x00001e28, 0x00001e29, 0x00001f48, 0x00001f40,
0x000003a4, 0x000003c4, 0x00010c9e, 0x00010cde,
0x00001ca6, 0x000010e6, 0x00001e44, 0x00001e45,
0x0000018b, 0x0000018c, 0x00000047, 0x00000067,
0x00001f6e, 0x00001f66, 0x0000a75c, 0x0000a75d,
0x00001ebe, 0x00001ebf, 0x00001fda, 0x00001f76,
0x00001e62, 0x00001e63, 0x000118a5, 0x000118c5,
0x00002c1a, 0x00002c4a, 0x000010a8, 0x00002d08,
0x00002c7f, 0x00000240, 0x00016e51, 0x00016e71,
0x00001cac, 0x000010ec, 0x000001f1, 0x000001f3,
0x00000554, 0x00000584, 0x00001e0e, 0x00001e0f,
0x000013a1, 0x0000ab71, 0x00000055, 0x00000075,
0x00000154, 0x00000155, 0x00010c90, 0x00010cd0,
0x00002cc8, 0x00002cc9, 0x0000a658, 0x0000a659,
0x0000048e, 0x0000048f, 0x00001e7a, 0x00001e7b,
0x000003a1, 0x000003c1, 0x00001f3d, 0x00001f35,
0x000000c8, 0x000000e8, 0x00002c10, 0x00002c40,
0x00001f4a, 0x00001f42, 0x0000042c, 0x0000044c,
0x00002163, 0x00002173, 0x00016e46, 0x00016e66,
0x00001faa, 0x00001fa2, 0x00000104, 0x00000105,
0x00001ed4, 0x00001ed5, 0x0000a64c, 0x0000a64d,
0x0001041f, 0x00010447, 0x00001e88, 0x00001e89,
0x0000039b, 0x000003bb, 0x000104b0, 0x000104d8,
0x000010ae, 0x00002d0e, 0x0000a64a, 0x0000a64b,
0x00002caa, 0x00002cab, 0x000001e2, 0x000001e3,
0x00016e45, 0x00016e65, 0x000004e8, 0x000004e9,
0x000104d2, 0x000104fa, 0x0000ff38, 0x0000ff58,
0x00001ed6, 0x00001ed7, 0x00000376, 0x00000377,
0x0000a76c, 0x0000a76d, 0x00001e38, 0x00001e39,
0x0000023a, 0x00002c65, 0x00000464, 0x00000465,
0x00000500, 0x00000501, 0x0000a69a, 0x0000a69b,
0x00001f4b, 0x00001f43, 0x000001ca, 0x000001cc,
0x00000539, 0x00000569, 0x00001e6c, 0x00001e6d,
0x00000124, 0x00000125, 0x0001e90c, 0x0001e92e,
0x0000216f, 0x0000217f, 0x0001e91d, 0x0001e93f,
0x00001f1a, 0x00001f12, 0x0000a72a, 0x0000a72b,
0x00001f9a, 0x00001f92, 0x00000470, 0x00000471,
0x00002cc6, 0x00002cc7, 0x00010409, 0x00010431,
0x000013c6, 0x0000ab96, 0x00000388, 0x000003ad,
0x000013e4, 0x0000abb4, 0x000118b3, 0x000118d3,
0x00002c1e, 0x00002c4e, 0x0000054e, 0x0000057e,
0x000104d0, 0x000104f8, 0x0000038f, 0x000003ce,
0x000118b0, 0x000118d0, 0x00001ec2, 0x00001ec3,
0x00000194, 0x00000263, 0x00001ff8, 0x00001f78,
0x0001e902, 0x0001e924, 0x000010ad, 0x00002d0d,
0x00001ec6, 0x00001ec7, 0x00001ee8, 0x00001ee9,
0x000104b8, 0x000104e0, 0x00001f3b, 0x00001f33,
0x0000a77b, 0x0000a77c, 0x00001f88, 0x00001f80,
0x00010c80, 0x00010cc0, 0x000013e9, 0x0000abb9,
0x0001e916, 0x0001e938, 0x0000012e, 0x0000012f,
0x00002c98, 0x00002c99, 0x00002167, 0x00002177,
0x000013f1, 0x000013f9, 0x0001040b, 0x00010433,
0x0000a7ab, 0x0000025c, 0x0000a74a, 0x0000a74b,
0x00002c7e, 0x0000023f, 0x00016e57, 0x00016e77,
0x0000a682, 0x0000a683, 0x00002ca2, 0x00002ca3,
0x0000a736, 0x0000a737, 0x000000c5, 0x000000e5,
0x00002c63, 0x00001d7d, 0x000000dc, 0x000000fc,
0x0000a790, 0x0000a791, 0x00002c67, 0x00002c68,
0x0001e90a, 0x0001e92c, 0x00010422, 0x0001044a,
0x000001e4, 0x000001e5, 0x0000ff22, 0x0000ff42,
0x000104bc, 0x000104e4, 0x00000220, 0x0000019e,
0x000010cd, 0x00002d2d, 0x00001eca, 0x00001ecb,
0x000004c0, 0x000004cf, 0x0001e905, 0x0001e927,
0x00016e4b, 0x00016e6b, 0x000024cc, 0x000024e6,
0x00010ca9, 0x00010ce9, 0x0000010a, 0x0000010b,
0x0000053a, 0x0000056a, 0x00002c0a, 0x00002c3a,
0x00000168, 0x00000169, 0x00001fca, 0x00001f74,
0x00002c75, 0x00002c76, 0x000013c2, 0x0000ab92,
0x00010412, 0x0001043a, 0x000003ee, 0x000003ef,
0x000013ba, 0x0000ab8a, 0x000004d2, 0x000004d3,
0x000004e4, 0x000004e5, 0x0000a688, 0x0000a689,
0x0000016c, 0x0000016d, 0x00000396, 0x000003b6,
0x00001ee2, 0x00001ee3, 0x0000022c, 0x0000022d,
0x00001e42, 0x00001e43, 0x00001f4d, 0x00001f45,
0x0000a779, 0x0000a77a, 0x0000019f, 0x00000275,
0x00001fb8, 0x00001fb0, 0x00001e30, 0x00001e31,
0x00016e5c, 0x00016e7c, 0x00001f6c, 0x00001f64,
0x00002ceb, 0x00002cec, 0x000001ae, 0x00000288,
0x000001f4, 0x000001f5, 0x00000112, 0x00000113,
0x000003ab, 0x000003cb, 0x000118a1, 0x000118c1,
0x000024c1, 0x000024db, 0x000010aa, 0x00002d0a,
0x00010ca3, 0x00010ce3, 0x00002c8e, 0x00002c8f,
0x00001ef0, 0x00001ef1, 0x00001f8d, 0x00001f85,
0x000010af, 0x00002d0f, 0x00000425, 0x00000445,
0x000004e2, 0x000004e3, 0x0000a68a, 0x0000a68b,
0x000004d8, 0x000004d9, 0x00000409, 0x00000459,
0x0000052a, 0x0000052b, 0x0001e911, 0x0001e933,
0x000000ce, 0x000000ee, 0x00001e02, 0x00001e03,
0x000010b3, 0x00002d13, 0x00000143, 0x00000144,
0x000004fc, 0x000004fd, 0x0000016e, 0x0000016f,
0x00001f8a, 0x00001f82, 0x0000216c, 0x0000217c,
0x00016e5b, 0x00016e7b, 0x0000054c, 0x0000057c,
0x00002cd6, 0x00002cd7, 0x000104b7, 0x000104df,
0x00001fc9, 0x00001f73, 0x000118a3, 0x000118c3,
0x00001e08, 0x00001e09, 0x000001f8, 0x000001f9,
0x00010ca4, 0x00010ce4, 0x000013b0, 0x0000ab80,
0x0000a75a, 0x0000a75b, 0x00002c72, 0x00002c73,
0x00000244, 0x00000289, 0x00000420, 0x00000440,
0x00002c03, 0x00002c33, 0x00010c98, 0x00010cd8,
0x0000018e, 0x000001dd, 0x00001eec, 0x00001eed,
0x00000410, 0x00000430, 0x00000226, 0x00000227,
0x000013cb, 0x0000ab9b, 0x00002cd4, 0x00002cd5,
0x00010c9d, 0x00010cdd, 0x00000210, 0x00000211,
0x000010a1, 0x00002d01, 0x00000126, 0x00000127,
0x0000ff2c, 0x0000ff4c, 0x00000428, 0x00000448,
0x0001e91b, 0x0001e93d, 0x000010bb, 0x00002d1b,
0x00000170, 0x00000171, 0x00001ef6, 0x00001ef7,
0x00000474, 0x00000475, 0x000013bc, 0x0000ab8c,
0x00010419, 0x00010441, 0x00001ebc, 0x00001ebd,
0x0000a65c, 0x0000a65d, 0x00001e58, 0x00001e59,
0x000118af, 0x000118cf, 0x000004fe, 0x000004ff,
0x00001e72, 0x00001e73, 0x00010c96, 0x00010cd6,
0x00000537, 0x00000567, 0x00001c90, 0x000010d0,
0x00001e5a, 0x00001e5b, 0x00001fe9, 0x00001fe1,
0x00000197, 0x00000268, 0x00001f8b, 0x00001f83,
0x0000016a, 0x0000016b, 0x000001ec, 0x000001ed,
0x00002c8a, 0x00002c8b, 0x00002164, 0x00002174,
0x0000040a, 0x0000045a, 0x000000da, 0x000000fa,
0x0000a796, 0x0000a797, 0x00002c94, 0x00002c95,
0x000013ae, 0x0000ab7e, 0x00001fad, 0x00001fa5,
0x00000160, 0x00000161, 0x0000ff30, 0x0000ff50,
0x000104b5, 0x000104dd, 0x00000549, 0x00000579,
0x00000191, 0x00000192, 0x0000a784, 0x0000a785,
0x00000232, 0x00000233, 0x00002c13, 0x00002c43,
0x0000ff27, 0x0000ff47, 0x0001040c, 0x00010434,
0x0000a724, 0x0000a725, 0x00000386, 0x000003ac,
0x000013e8, 0x0000abb8, 0x000118b6, 0x000118d6,
0x000024b6, 0x000024d0, 0x00001e36, 0x00001e37,
0x0000ff29, 0x0000ff49, 0x000013d6, 0x0000aba6,
0x0000020a, 0x0000020b, 0x000000db, 0x000000fb,
0x00001fdb, 0x00001f77, 0x0000018f, 0x00000259,
0x000001d3, 0x000001d4, 0x000010a3, 0x00002d03,
0x00001e3c, 0x00001e3d, 0x00001fea, 0x00001f7a,
0x000004a2, 0x000004a3, 0x000003a5, 0x000003c5,
0x000024be, 0x000024d8, 0x000004d4, 0x000004d5,
0x000013db, 0x0000abab, 0x000013b2, 0x0000ab82,
0x00010c91, 0x00010cd1, 0x0000a792, 0x0000a793,
0x0000ff34, 0x0000ff54, 0x00002c2b, 0x00002c5b,
0x0001e91f, 0x0001e941, 0x0000011e, 0x0000011f,
0x0000a738, 0x0000a739, 0x0000216e, 0x0000217e,
0x000013a5, 0x0000ab75, 0x00001eee, 0x00001eef,
0x00001e18, 0x00001e19, 0x0000a642, 0x0000a643,
0x00002ca6, 0x00002ca7, 0x0000054a, 0x0000057a,
0x000001de, 0x000001df, 0x000104b1, 0x000104d9,
0x00000214, 0x00000215, 0x000001d5, 0x000001d6,
0x00016e53, 0x00016e73, 0x00001f6b, 0x00001f63,
0x00002c60, 0x00002c61, 0x0000ff31, 0x0000ff51,
0x000010ac, 0x00002d0c, 0x00000224, 0x00000225,
0x0000014c, 0x0000014d, 0x000104d1, 0x000104f9,
0x00010c84, 0x00010cc4, 0x00000198, 0x00000199,
0x00002162, 0x00002172, 0x00001f2f, 0x00001f27,
0x0000049a, 0x0000049b, 0x00000045, 0x00000065,
0x0000050e, 0x0000050f
};
static const unsigned _uccase_title_g_size = 35;
static const short _uccase_title_g[] = {
-106, -10, 537, 2066, -30, -87, 280, 735,
1417, 32767, -103, 1741, 1318, 7204, -21, -13,
850, 32, 160, 32767, -44, 406, 784, 13403,
-15, -107, 12, 320, 2114, -41, -100, 1643,
1548, 1350, -117
};
static const unsigned _uccase_title_table_size = 135;
static const unsigned _uccase_title_table[] = {
0x00001fbc, 0x00001fbc, 0x000010d6, 0x000010d6,
0x00001f83, 0x00001f8b, 0x000010e8, 0x000010e8,
0x00001f80, 0x00001f88, 0x000010e2, 0x000010e2,
0x00001faf, 0x00001faf, 0x00001f81, 0x00001f89,
0x000001f1, 0x000001f2, 0x000010d8, 0x000010d8,
0x000010f5, 0x000010f5, 0x00001fc2, 0x02000177,
0x000010dc, 0x000010dc, 0x0000fb06, 0x0200015c,
0x00001f90, 0x00001f98, 0x0000fb16, 0x0200016b,
0x00001f98, 0x00001f98, 0x000001c8, 0x000001c8,
0x00001f95, 0x00001f9d, 0x00001f94, 0x00001f9c,
0x000001c9, 0x000001c8, 0x0000fb15, 0x02000168,
0x000010ff, 0x000010ff, 0x00001f9e, 0x00001f9e,
0x00001ff2, 0x0200017d, 0x000010d2, 0x000010d2,
0x000010f1, 0x000010f1, 0x000001c5, 0x000001c5,
0x00001fb4, 0x02000174, 0x000010d7, 0x000010d7,
0x0000fb14, 0x02000165, 0x00001ff3, 0x00001ffc,
0x000010e4, 0x000010e4, 0x00001f92, 0x00001f9a,
0x000010d3, 0x000010d3, 0x00001fb7, 0x03000183,
0x000010db, 0x000010db, 0x00001fb3, 0x00001fbc,
0x00001fb2, 0x02000171, 0x000001c6, 0x000001c5,
0x00001faa, 0x00001faa, 0x0000fb13, 0x02000162,
0x00001f9f, 0x00001f9f, 0x000010f3, 0x000010f3,
0x0000fb03, 0x03000151, 0x00001f82, 0x00001f8a,
0x000010f4, 0x000010f4, 0x00001f8b, 0x00001f8b,
0x000010e1, 0x000010e1, 0x00001f8e, 0x00001f8e,
0x000010f0, 0x000010f0, 0x00001fa1, 0x00001fa9,
0x00001f88, 0x00001f88, 0x000010f6, 0x000010f6,
0x000010df, 0x000010df, 0x00001ff7, 0x0300018b,
0x00001ffc, 0x00001ffc, 0x000010f9, 0x000010f9,
0x000001f3, 0x000001f2, 0x00001f89, 0x00001f89,
0x000010fe, 0x000010fe, 0x00001f91, 0x00001f99,
0x00001fc3, 0x00001fcc, 0x00001fcc, 0x00001fcc,
0x00001f86, 0x00001f8e, 0x00001fc4, 0x0200017a,
0x00000587, 0x0200015f, 0x000010f8, 0x000010f8,
0x000010ed, 0x000010ed, 0x00001fab, 0x00001fab,
0x000010e0, 0x000010e0, 0x000010e3, 0x000010e3,
0x000001cc, 0x000001cb, 0x00001fad, 0x00001fad,
0x000010d0, 0x000010d0, 0x00001f8c, 0x00001f8c,
0x00001fa7, 0x00001faf, 0x000010f2, 0x000010f2,
0x00001f99, 0x00001f99, 0x000001c7, 0x000001c8,
0x00001fa2, 0x00001faa, 0x000010e9, 0x000010e9,
0x00001fa5, 0x00001fad, 0x00001fa4, 0x00001fac,
0x000010fd, 0x000010fd, 0x00001fa3, 0x00001fab,
0x000001c4, 0x000001c5, 0x0000fb05, 0x02000159,
0x000010ec, 0x000010ec, 0x00001f9a, 0x00001f9a,
0x00001fae, 0x00001fae, 0x000010dd, 0x000010dd,
0x00001f8a, 0x00001f8a, 0x000010ef, 0x000010ef,
0x00001f87, 0x00001f8f, 0x00001f9b, 0x00001f9b,
0x00001fa8, 0x00001fa8, 0x00001f8f, 0x00001f8f,
0x000000df, 0x02000145, 0x000010d1, 0x000010d1,
0x0000fb04, 0x03000155, 0x000010e7, 0x000010e7,
0x000010d5, 0x000010d5, 0x0000fb02, 0x0200014e,
0x00001f97, 0x00001f9f, 0x000010f7, 0x000010f7,
0x0000fb01, 0x0200014b, 0x0000fb00, 0x02000148,
0x00001f9c, 0x00001f9c, 0x00001f8d, 0x00001f8d,
0x000010fa, 0x000010fa, 0x00001f96, 0x00001f9e,
0x000001ca, 0x000001cb, 0x000010e6, 0x000010e6,
0x00001f9d, 0x00001f9d, 0x000010ee, 0x000010ee,
0x000010ea, 0x000010ea, 0x0000fb17, 0x0200016e,
0x00001fa6, 0x00001fae, 0x000010de, 0x000010de,
0x00001f85, 0x00001f8d, 0x00001fa0, 0x00001fa8,
0x000010eb, 0x000010eb, 0x00001f84, 0x00001f8c,
0x000010da, 0x000010da, 0x00001fa9, 0x00001fa9,
0x000010d4, 0x000010d4, 0x00001fac, 0x00001fac,
0x00001fc7, 0x03000187, 0x000010d9, 0x000010d9,
0x00001ff4, 0x02000180, 0x000001cb, 0x000001cb,
0x000001f2, 0x000001f2, 0x000010e5, 0x000010e5,
0x00001f93, 0x00001f9b
};
static const unsigned _uccase_fold_g_size = 272;
static const short _uccase_fold_g[] = {
5, 935, 2, -1389, 333, 697, 1, 37,
32767, 4350, 16, 73, 776, -581, -820, 15914,
395, 2544, 2279, 193, 5, 1241, 170, 4107,
16, 4010, 589, 1862, 5283, 5219, 5, 72,
194, 2028, 2, 8007, 293, 32767, 1454, 190,
166, 2400, 201, 1652, 37, 3315, 3553, 8210,
34, 426, 1805, 32767, 1580, 422, 543, 4945,
-405, 32767, 129, 3092, 259, 193, 48, 7089,
9, 937, 3517, 163, 517, 306, -428, 32767,
7, 2061, 2, 4457, 2535, 693, 12, 1605,
-966, 243, 35, 1749, 424, -1422, 4, 967,
178, 32767, 538, 1098, 67, 1623, 32767, 1304,
16, 7261, 2068, -769, 831, 385, 1, 1165,
113, 324, 52, 2846, 538, 154, 2, 5621,
781, 360, 6268, 20557, 7, 4466, 26246, 438,
478, 1029, 53, 5769, 2321, 313, 2, 1687,
180, 1661, 8, 1241, -1276, 5430, 1, 772,
8, 32767, 1072, 1248, 489, 5116, -163, -1362,
1574, 762, 692, 11591, 23, 1869, 1007, -796,
2829, 630, 36, 913, -489, 32767, 2, 898,
274, 792, 4164, 57, 57, 794, 7131, 612,
328, 636, 886, -1319, 55, 1022, 3, -1194,
5351, 201, 90, 589, 32767, 1186, 16, 2432,
1294, -220, 1531, 5978, 5, 3540, 126, 43,
508, 980, 32767, 1797, 3, 17682, 787, -315,
6813, 20635, 10, 8475, 3011, 109, 295, 5917,
614, 8830, 8, 542, 589, 921, 554, 1967,
4, 37, -1057, 15388, 3, 3, 17, 32767,
8479, 632, 276, 6344, 1125, -1350, 16, 3063,
4683, 1305, 115, 2520, 187, 32767, 1665, 617,
760, 2298, -784, 32767, 8, 1978, 1826, 2630,
495, 691, 273, 69, 9638, 53, 48, 2209,
10918, -1282, 1, 118, 140, -1032, 397, 1235,
1, 1558, 32767, 176, 17, 866, 315, 3650
};
static const unsigned _uccase_fold_table_size = 1480;
static const unsigned _uccase_fold_table[] = {
0x000004a8, 0x000004a9, 0x00001fe2, 0x0300028c,
0x0000ff2b, 0x0000ff4b, 0x00001e32, 0x00001e33,
0x000004dc, 0x000004dd, 0x0000aba0, 0x000013d0,
0x00010422, 0x0001044a, 0x0001e913, 0x0001e935,
0x00000538, 0x00000568, 0x00016e46, 0x00016e66,
0x000000c0, 0x000000e0, 0x00016e48, 0x00016e68,
0x0000042c, 0x0000044c, 0x00001e9e, 0x020001b5,
0x00000172, 0x00000173, 0x00001ed2, 0x00001ed3,
0x0000abaa, 0x000013da, 0x00001e82, 0x00001e83,
0x000010ab, 0x00002d0b, 0x0000aba5, 0x000013d5,
0x00002cd6, 0x00002cd7, 0x00002ceb, 0x00002cec,
0x00001fd7, 0x03000288, 0x0000a784, 0x0000a785,
0x000003d8, 0x000003d9, 0x0000a74c, 0x0000a74d,
0x000118bc, 0x000118dc, 0x000024c3, 0x000024dd,
0x00002c26, 0x00002c56, 0x000118b1, 0x000118d1,
0x00001f3e, 0x00001f36, 0x00010c8c, 0x00010ccc,
0x0001e908, 0x0001e92a, 0x00000345, 0x000003b9,
0x000004d2, 0x000004d3, 0x000024bc, 0x000024d6,
0x0000021c, 0x0000021d, 0x000003d1, 0x000003b8,
0x00000510, 0x00000511, 0x0001041f, 0x00010447,
0x0000abbd, 0x000013ed, 0x000003f5, 0x000003b5,
0x00000422, 0x00000442, 0x00001fb4, 0x0200025d,
0x0000016c, 0x0000016d, 0x0001040c, 0x00010434,
0x0000a722, 0x0000a723, 0x000004b4, 0x000004b5,
0x000001c8, 0x000001c9, 0x000104c4, 0x000104ec,
0x00000372, 0x00000373, 0x0000a724, 0x0000a725,
0x00001fb8, 0x00001fb0, 0x0000a780, 0x0000a781,
0x000010b1, 0x00002d11, 0x00010c89, 0x00010cc9,
0x00000118, 0x00000119, 0x00000197, 0x00000268,
0x000004e0, 0x000004e1, 0x00001cb1, 0x000010f1,
0x00001f08, 0x00001f00, 0x00001fe4, 0x02000294,
0x00000196, 0x00000269, 0x0000216b, 0x0000217b,
0x000004da, 0x000004db, 0x000118a4, 0x000118c4,
0x00000212, 0x00000213, 0x0000ff27, 0x0000ff47,
0x00001e58, 0x00001e59, 0x0000a7b4, 0x0000a7b5,
0x00000543, 0x00000573, 0x0000a78b, 0x0000a78c,
0x0000042a, 0x0000044a, 0x00001fa4, 0x02000233,
0x00000162, 0x00000163, 0x00000419, 0x00000439,
0x0000a736, 0x0000a737, 0x00001e84, 0x00001e85,
0x00001e70, 0x00001e71, 0x00001e3e, 0x00001e3f,
0x0000053d, 0x0000056d, 0x000010c1, 0x00002d21,
0x00001fb6, 0x02000260, 0x000003dc, 0x000003dd,
0x0000a686, 0x0000a687, 0x0000042e, 0x0000044e,
0x000003a6, 0x000003c6, 0x00001eee, 0x00001eef,
0x000104b0, 0x000104d8, 0x0000a664, 0x0000a665,
0x00010c8f, 0x00010ccf, 0x00001fec, 0x00001fe5,
0x00000149, 0x02000195, 0x00000389, 0x000003ae,
0x00001e12, 0x00001e13, 0x00001f9e, 0x02000221,
0x0000021a, 0x0000021b, 0x0000ab82, 0x000013b2,
0x00001e56, 0x00001e57, 0x00001f3c, 0x00001f34,
0x0000a73e, 0x0000a73f, 0x000000cd, 0x000000ed,
0x00001fe7, 0x0300029a, 0x0000a796, 0x0000a797,
0x0000016a, 0x0000016b, 0x0000ff33, 0x0000ff53,
0x0000aba6, 0x000013d6, 0x00001e8c, 0x00001e8d,
0x00010c9c, 0x00010cdc, 0x0000021e, 0x0000021f,
0x00001cb2, 0x000010f2, 0x00001ec6, 0x00001ec7,
0x0000ab8d, 0x000013bd, 0x0001e917, 0x0001e939,
0x0000a758, 0x0000a759, 0x0000011c, 0x0000011d,
0x00000470, 0x00000471, 0x0000016e, 0x0000016f,
0x00010c85, 0x00010cc5, 0x00001e16, 0x00001e17,
0x00000542, 0x00000572, 0x00001e60, 0x00001e61,
0x0000019f, 0x00000275, 0x00001c83, 0x00000441,
0x00000520, 0x00000521, 0x00016e5f, 0x00016e7f,
0x000104d1, 0x000104f9, 0x00001eb4, 0x00001eb5,
0x00010c99, 0x00010cd9, 0x00001f2c, 0x00001f24,
0x000024cf, 0x000024e9, 0x00000055, 0x00000075,
0x00000476, 0x00000477, 0x00001e78, 0x00001e79,
0x000010b0, 0x00002d10, 0x00002c1f, 0x00002c4f,
0x00000498, 0x00000499, 0x00002cd0, 0x00002cd1,
0x000010bd, 0x00002d1d, 0x0000fb04, 0x030002be,
0x00002cde, 0x00002cdf, 0x0001e910, 0x0001e932,
0x00001ed6, 0x00001ed7, 0x000000cf, 0x000000ef,
0x00001f4d, 0x00001f45, 0x0000a762, 0x0000a763,
0x00000418, 0x00000438, 0x000104b9, 0x000104e1,
0x00002c2e, 0x00002c5e, 0x00001fd8, 0x00001fd0,
0x00000549, 0x00000579, 0x0000017f, 0x00000073,
0x00001ca3, 0x000010e3, 0x0000fb13, 0x020002c8,
0x0000a786, 0x0000a787, 0x0000216c, 0x0000217c,
0x00002126, 0x000003c9, 0x000104c1, 0x000104e9,
0x00010caf, 0x00010cef, 0x00001ed4, 0x00001ed5,
0x000118a0, 0x000118c0, 0x000004cb, 0x000004cc,
0x00002c0f, 0x00002c3f, 0x00016e5b, 0x00016e7b,
0x00001fa7, 0x0200023c, 0x000104b5, 0x000104dd,
0x000004ae, 0x000004af, 0x00010ca5, 0x00010ce5,
0x00001f6a, 0x00001f62, 0x0000abb3, 0x000013e3,
0x0000ab78, 0x000013a8, 0x000104be, 0x000104e6,
0x00001fc6, 0x02000273, 0x00016e5c, 0x00016e7c,
0x000003fe, 0x0000037c, 0x000004a4, 0x000004a5,
0x00001eba, 0x00001ebb, 0x000010c2, 0x00002d22,
0x000003f7, 0x000003f8, 0x00000051, 0x00000071,
0x00000056, 0x00000076, 0x00001f54, 0x030001bf,
0x00000398, 0x000003b8, 0x00001f0f, 0x00001f07,
0x00001e0a, 0x00001e0b, 0x000024c2, 0x000024dc,
0x0000023b, 0x0000023c, 0x0000ab88, 0x000013b8,
0x00001e66, 0x00001e67, 0x00016e50, 0x00016e70,
0x000001d3, 0x000001d4, 0x000004c0, 0x000004cf,
0x00001feb, 0x00001f7b, 0x0000053e, 0x0000056e,
0x00001f98, 0x0200020f, 0x0000abb1, 0x000013e1,
0x00001f3d, 0x00001f35, 0x00000524, 0x00000525,
0x000001ee, 0x000001ef, 0x00000410, 0x00000430,
0x00001caa, 0x000010ea, 0x0000a680, 0x0000a681,
0x00001ff9, 0x00001f79, 0x0000ab83, 0x000013b3,
0x00001f6d, 0x00001f65, 0x0000a7ae, 0x0000026a,
0x00001e8e, 0x00001e8f, 0x000001e4, 0x000001e5,
0x0001e91c, 0x0001e93e, 0x00001f56, 0x030001c3,
0x00001f49, 0x00001f41, 0x0000ff38, 0x0000ff58,
0x000010a7, 0x00002d07, 0x00000504, 0x00000505,
0x000000d8, 0x000000f8, 0x000118bf, 0x000118df,
0x00000502, 0x00000503, 0x00002c6e, 0x00000271,
0x00010c9f, 0x00010cdf, 0x00002c75, 0x00002c76,
0x00016e5a, 0x00016e7a, 0x00002c0d, 0x00002c3d,
0x00000206, 0x00000207, 0x000000dd, 0x000000fd,
0x000004c1, 0x000004c2, 0x00001f9b, 0x02000218,
0x0000049e, 0x0000049f, 0x00010ca0, 0x00010ce0,
0x00001e90, 0x00001e91, 0x000003a4, 0x000003c4,
0x00010c98, 0x00010cd8, 0x00010cae, 0x00010cee,
0x00001f81, 0x020001ca, 0x0000a744, 0x0000a745,
0x00001f83, 0x020001d0, 0x0000a768, 0x0000a769,
0x000024c6, 0x000024e0, 0x000010c4, 0x00002d24,
0x00001f96, 0x02000209, 0x000001db, 0x000001dc,
0x00001fd9, 0x00001fd1, 0x00001ff2, 0x0200029e,
0x000024cb, 0x000024e5, 0x0001040e, 0x00010436,
0x000004ee, 0x000004ef, 0x00000104, 0x00000105,
0x000104cb, 0x000104f3, 0x00000112, 0x00000113,
0x00000550, 0x00000580, 0x00000116, 0x00000117,
0x00000490, 0x00000491, 0x00001f92, 0x020001fd,
0x0000a650, 0x0000a651, 0x00000194, 0x00000263,
0x00001e36, 0x00001e37, 0x000104c0, 0x000104e8,
0x0000aba8, 0x000013d8, 0x00001e92, 0x00001e93,
0x000001de, 0x000001df, 0x00000545, 0x00000575,
0x0000038e, 0x000003cd, 0x000004de, 0x000004df,
0x00001f69, 0x00001f61, 0x00002c6f, 0x00000250,
0x000003f0, 0x000003ba, 0x0000048e, 0x0000048f,
0x00001eb6, 0x00001eb7, 0x00000053, 0x00000073,
0x0000004d, 0x0000006d, 0x00002163, 0x00002173,
0x00001f2a, 0x00001f22, 0x0000a658, 0x0000a659,
0x0000a652, 0x0000a653, 0x00000041, 0x00000061,
0x00001e06, 0x00001e07, 0x000024c8, 0x000024e2,
0x0000022e, 0x0000022f, 0x0000017d, 0x0000017e,
0x00000552, 0x00000582, 0x00000402, 0x00000452,
0x00000400, 0x00000450, 0x00001c82, 0x0000043e,
0x00010cb1, 0x00010cf1, 0x0000a68c, 0x0000a68d,
0x00000427, 0x00000447, 0x000104c9, 0x000104f1,
0x0000ab73, 0x000013a3, 0x0000ab9b, 0x000013cb,
0x000004b0, 0x000004b1, 0x0000fb01, 0x020002b4,
0x00001ca6, 0x000010e6, 0x0000fb16, 0x020002d1,
0x000000ce, 0x000000ee, 0x0001e915, 0x0001e937,
0x0000aba9, 0x000013d9, 0x00002cb0, 0x00002cb1,
0x00000130, 0x02000192, 0x000104d3, 0x000104fb,
0x00001ffb, 0x00001f7d, 0x000001fc, 0x000001fd,
0x0000a766, 0x0000a767, 0x0000ff34, 0x0000ff54,
0x000010b6, 0x00002d16, 0x00002c00, 0x00002c30,
0x00000049, 0x00000069, 0x00010423, 0x0001044b,
0x00001f4b, 0x00001f43, 0x0000014c, 0x0000014d,
0x00001e6e, 0x00001e6f, 0x00001c93, 0x000010d3,
0x000024b7, 0x000024d1, 0x0001e91e, 0x0001e940,
0x00000492, 0x00000493, 0x00000512, 0x00000513,
0x00001e9b, 0x00001e61, 0x00016e54, 0x00016e74,
0x000118af, 0x000118cf, 0x0000047e, 0x0000047f,
0x000104c6, 0x000104ee, 0x00010c95, 0x00010cd5,
0x00001c95, 0x000010d5, 0x00000462, 0x00000463,
0x000118a8, 0x000118c8, 0x00010409, 0x00010431,
0x00001f8d, 0x020001ee, 0x00002cb6, 0x00002cb7,
0x00000132, 0x00000133, 0x000010be, 0x00002d1e,
0x00001f91, 0x020001fa, 0x000001fe, 0x000001ff,
0x00000059, 0x00000079, 0x00001ff8, 0x00001f78,
0x00002c27, 0x00002c57, 0x00002c06, 0x00002c36,
0x000024bf, 0x000024d9, 0x0000a7b8, 0x0000a7b9,
0x0000015e, 0x0000015f, 0x0000014e, 0x0000014f,
0x000010c5, 0x00002d25, 0x00001f48, 0x00001f40,
0x00001e02, 0x00001e03, 0x000118b2, 0x000118d2,
0x00001fd6, 0x02000285, 0x0000052c, 0x0000052d,
0x0000020e, 0x0000020f, 0x0000216e, 0x0000217e,
0x0000abae, 0x000013de, 0x00001e98, 0x020001ac,
0x000010a6, 0x00002d06, 0x0000fb14, 0x020002cb,
0x00000425, 0x00000445, 0x000003ff, 0x0000037d,
0x00001fe9, 0x00001fe1, 0x000001a2, 0x000001a3,
0x000118be, 0x000118de, 0x000004e4, 0x000004e5,
0x00001cad, 0x000010ed, 0x0000040b, 0x0000045b,
0x000104c7, 0x000104ef, 0x0000a660, 0x0000a661,
0x0000013d, 0x0000013e, 0x000010a0, 0x00002d00,
0x000010bf, 0x00002d1f, 0x00001fc3, 0x0200026d,
0x000004e8, 0x000004e9, 0x00010425, 0x0001044d,
0x000010a5, 0x00002d05, 0x00002c2d, 0x00002c5d,
0x00010c9b, 0x00010cdb, 0x00000042, 0x00000062,
0x00002c03, 0x00002c33, 0x00001c88, 0x0000a64b,
0x00010c88, 0x00010cc8, 0x00000514, 0x00000515,
0x000001d9, 0x000001da, 0x00000421, 0x00000441,
0x00002c80, 0x00002c81, 0x00001eae, 0x00001eaf,
0x00010ca6, 0x00010ce6, 0x000001b5, 0x000001b6,
0x00000388, 0x000003ad, 0x00000464, 0x00000465,
0x000000d5, 0x000000f5, 0x0000013f, 0x00000140,
0x00010c80, 0x00010cc0, 0x00016e42, 0x00016e62,
0x00001ca0, 0x000010e0, 0x00000224, 0x00000225,
0x00000409, 0x00000459, 0x0000a666, 0x0000a667,
0x00002ce0, 0x00002ce1, 0x0000a65e, 0x0000a65f,
0x00010cac, 0x00010cec, 0x00000424, 0x00000444,
0x000004e6, 0x000004e7, 0x00000174, 0x00000175,
0x00000228, 0x00000229, 0x00001c94, 0x000010d4,
0x00010cab, 0x00010ceb, 0x0000053f, 0x0000056f,
0x0001e914, 0x0001e936, 0x00001c9a, 0x000010da,
0x0000a648, 0x0000a649, 0x0000051c, 0x0000051d,
0x00000178, 0x000000ff, 0x00016e59, 0x00016e79,
0x00002c82, 0x00002c83, 0x00000556, 0x00000586,
0x00001f68, 0x00001f60, 0x00000553, 0x00000583,
0x00000386, 0x000003ac, 0x0000046c, 0x0000046d,
0x000000c8, 0x000000e8, 0x000001a4, 0x000001a5,
0x00000395, 0x000003b5, 0x00001ee0, 0x00001ee1,
0x000010a9, 0x00002d09, 0x000104cd, 0x000104f5,
0x00000170, 0x00000171, 0x000024c1, 0x000024db,
0x0000a73a, 0x0000a73b, 0x0000a690, 0x0000a691,
0x00000506, 0x00000507, 0x00001e30, 0x00001e31,
0x00001e08, 0x00001e09, 0x00000164, 0x00000165,
0x00000226, 0x00000227, 0x00002c60, 0x00002c61,
0x00016e53, 0x00016e73, 0x00000044, 0x00000064,
0x0000004f, 0x0000006f, 0x000001cb, 0x000001cc,
0x00001fd2, 0x0300027d, 0x0000050c, 0x0000050d,
0x00000176, 0x00000177, 0x000118ad, 0x000118cd,
0x0000a78d, 0x00000265, 0x00001fdb, 0x00001f77,
0x00001fc8, 0x00001f72, 0x0000abab, 0x000013db,
0x00001ca8, 0x000010e8, 0x000104c5, 0x000104ed,
0x000000c6, 0x000000e6, 0x000001ac, 0x000001ad,
0x00001f59, 0x00001f51, 0x00002cb8, 0x00002cb9,
0x000004b6, 0x000004b7, 0x00001fa0, 0x02000227,
0x000010b2, 0x00002d12, 0x00000230, 0x00000231,
0x00000045, 0x00000065, 0x00002c9c, 0x00002c9d,
0x00002ca4, 0x00002ca5, 0x00002c08, 0x00002c38,
0x000004e2, 0x000004e3, 0x00001ef0, 0x00001ef1,
0x00002c6d, 0x00000251, 0x0000050a, 0x0000050b,
0x00010c97, 0x00010cd7, 0x0000004c, 0x0000006c,
0x000010cd, 0x00002d2d, 0x00001f0d, 0x00001f05,
0x00000460, 0x00000461, 0x00001e40, 0x00001e41,
0x000024cd, 0x000024e7, 0x0000024c, 0x0000024d,
0x0001e921, 0x0001e943, 0x00001f9a, 0x02000215,
0x000010ae, 0x00002d0e, 0x000104ca, 0x000104f2,
0x000003b0, 0x0300019f, 0x0000abb6, 0x000013e6,
0x0000054a, 0x0000057a, 0x00010ca2, 0x00010ce2,
0x0000ab8b, 0x000013bb, 0x00001ee2, 0x00001ee3,
0x00001e96, 0x020001a6, 0x00001fa6, 0x02000239,
0x00001ca9, 0x000010e9, 0x00001f87, 0x020001dc,
0x0000049a, 0x0000049b, 0x00002c9e, 0x00002c9f,
0x00001e00, 0x00001e01, 0x0000053c, 0x0000056c,
0x000004f6, 0x000004f7, 0x00001ef6, 0x00001ef7,
0x00000222, 0x00000223, 0x0000a7a2, 0x0000a7a3,
0x000003ea, 0x000003eb, 0x00016e55, 0x00016e75,
0x00000208, 0x00000209, 0x00001edc, 0x00001edd,
0x0000a68a, 0x0000a68b, 0x00001e46, 0x00001e47,
0x000001a0, 0x000001a1, 0x00000150, 0x00000151,
0x00002c9a, 0x00002c9b, 0x000004f0, 0x000004f1,
0x00001f6e, 0x00001f66, 0x000118a9, 0x000118c9,
0x00000396, 0x000003b6, 0x0000a692, 0x0000a693,
0x000000c2, 0x000000e2, 0x0000a642, 0x0000a643,
0x000024bb, 0x000024d5, 0x00010ca4, 0x00010ce4,
0x0000ab95, 0x000013c5, 0x0000ff24, 0x0000ff44,
0x000004c5, 0x000004c6, 0x0000a668, 0x0000a669,
0x000004aa, 0x000004ab, 0x00000532, 0x00000562,
0x00002c0b, 0x00002c3b, 0x0000a65c, 0x0000a65d,
0x00001e0e, 0x00001e0f, 0x0000ab85, 0x000013b5,
0x0000ff28, 0x0000ff48, 0x00002c19, 0x00002c49,
0x00010c96, 0x00010cd6, 0x00001f1d, 0x00001f15,
0x0000012a, 0x0000012b, 0x00001ede, 0x00001edf,
0x00002c98, 0x00002c99, 0x0000041a, 0x0000043a,
0x00000186, 0x00000254, 0x000024ce, 0x000024e8,
0x00002c28, 0x00002c58, 0x0000050e, 0x0000050f,
0x00001ec8, 0x00001ec9, 0x00010c8b, 0x00010ccb,
0x00001cae, 0x000010ee, 0x0000ab90, 0x000013c0,
0x000000d6, 0x000000f6, 0x00000114, 0x00000115,
0x0000041d, 0x0000043d, 0x00010c86, 0x00010cc6,
0x00001ec0, 0x00001ec1, 0x0001e904, 0x0001e926,
0x00000544, 0x00000574, 0x0000a73c, 0x0000a73d,
0x0000fb03, 0x030002ba, 0x0000ff29, 0x0000ff49,
0x000001ea, 0x000001eb, 0x0000039f, 0x000003bf,
0x0000a7aa, 0x00000266, 0x000000d0, 0x000000f0,
0x0000ff26, 0x0000ff46, 0x000118a7, 0x000118c7,
0x0000a760, 0x0000a761, 0x0000a698, 0x0000a699,
0x00010421, 0x00010449, 0x00001cb6, 0x000010f6,
0x00000401, 0x00000451, 0x00000522, 0x00000523,
0x000003e0, 0x000003e1, 0x00002160, 0x00002170,
0x0001040f, 0x00010437, 0x00001cb9, 0x000010f9,
0x0000004e, 0x0000006e, 0x00001f85, 0x020001d6,
0x0000a64a, 0x0000a64b, 0x00000472, 0x00000473,
0x00000546, 0x00000576, 0x00000551, 0x00000581,
0x00016e4d, 0x00016e6d, 0x00001f8b, 0x020001e8,
0x00001ec2, 0x00001ec3, 0x00001e8a, 0x00001e8b,
0x0000a7b2, 0x0000029d, 0x000003c2, 0x000003c3,
0x00000496, 0x00000497, 0x00002c23, 0x00002c53,
0x00002c13, 0x00002c43, 0x0001e912, 0x0001e934,
0x0000a79a, 0x0000a79b, 0x00002cae, 0x00002caf,
0x00002c67, 0x00002c68, 0x000003a8, 0x000003c8,
0x000003e6, 0x000003e7, 0x00001f50, 0x020001b8,
0x000013f9, 0x000013f1, 0x00016e56, 0x00016e76,
0x000004f8, 0x000004f9, 0x00001fa1, 0x0200022a,
0x00000122, 0x00000123, 0x0001e91b, 0x0001e93d,
0x00000124, 0x00000125, 0x00001ea0, 0x00001ea1,
0x00002c72, 0x00002c73, 0x00010c91, 0x00010cd1,
0x00001e76, 0x00001e77, 0x00001f82, 0x020001cd,
0x00000189, 0x00000256, 0x000001b2, 0x0000028b,
0x0000fb06, 0x020002c5, 0x00010c90, 0x00010cd0,
0x00001c99, 0x000010d9, 0x00001fa8, 0x0200023f,
0x00000191, 0x00000192, 0x0000ab98, 0x000013c8,
0x00001e72, 0x00001e73, 0x00000102, 0x00000103,
0x00001e99, 0x020001af, 0x00001f93, 0x02000200,
0x000004fe, 0x000004ff, 0x00001ef8, 0x00001ef9,
0x0000ff22, 0x0000ff42, 0x00001e22, 0x00001e23,
0x000003d5, 0x000003c6, 0x00000052, 0x00000072,
0x00000126, 0x00000127, 0x00001c90, 0x000010d0,
0x0000ab76, 0x000013a6, 0x00001e48, 0x00001e49,
0x00001fe3, 0x03000290, 0x00001e04, 0x00001e05,
0x00002c2c, 0x00002c5c, 0x000003a7, 0x000003c7,
0x00016e4e, 0x00016e6e, 0x00016e5d, 0x00016e7d,
0x0000039e, 0x000003be, 0x0000a764, 0x0000a765,
0x0000a696, 0x0000a697, 0x00002c62, 0x0000026b,
0x00002132, 0x0000214e, 0x00002ccc, 0x00002ccd,
0x0000042f, 0x0000044f, 0x00001c81, 0x00000434,
0x00001fb3, 0x0200025a, 0x00010411, 0x00010439,
0x0000a646, 0x0000a647, 0x00001ca4, 0x000010e4,
0x000001c5, 0x000001c6, 0x00002c1c, 0x00002c4c,
0x0000017b, 0x0000017c, 0x00001e3a, 0x00001e3b,
0x0000023e, 0x00002c66, 0x00002c70, 0x00000252,
0x0000a7b6, 0x0000a7b7, 0x00001f2e, 0x00001f26,
0x000104c8, 0x000104f0, 0x00010420, 0x00010448,
0x000000cb, 0x000000eb, 0x00000528, 0x00000529,
0x0000018e, 0x000001dd, 0x0001e902, 0x0001e924,
0x000104ba, 0x000104e2, 0x00002c94, 0x00002c95,
0x00001f8a, 0x020001e5, 0x00000243, 0x00000180,
0x000104ce, 0x000104f6, 0x00000478, 0x00000479,
0x000000de, 0x000000fe, 0x000118b3, 0x000118d3,
0x0000fb02, 0x020002b7, 0x0000216f, 0x0000217f,
0x00001eda, 0x00001edb, 0x00010cb2, 0x00010cf2,
0x00002cc0, 0x00002cc1, 0x0000ff36, 0x0000ff56,
0x0000a756, 0x0000a757, 0x000024c4, 0x000024de,
0x000001d7, 0x000001d8, 0x00001ea2, 0x00001ea3,
0x00001e2a, 0x00001e2b, 0x000003a3, 0x000003c3,
0x00002c10, 0x00002c40, 0x000104bd, 0x000104e5,
0x0000a782, 0x0000a783, 0x000104c2, 0x000104ea,
0x00002ca6, 0x00002ca7, 0x00001f90, 0x020001f7,
0x00001f80, 0x020001c7, 0x0000053a, 0x0000056a,
0x00001f88, 0x020001df, 0x0001040d, 0x00010435,
0x0001e918, 0x0001e93a, 0x0000a742, 0x0000a743,
0x00000190, 0x0000025b, 0x0000054b, 0x0000057b,
0x00002165, 0x00002175, 0x0000a72c, 0x0000a72d,
0x00001ed8, 0x00001ed9, 0x000001b8, 0x000001b9,
0x00000415, 0x00000435, 0x00002cca, 0x00002ccb,
0x00001e68, 0x00001e69, 0x000010ad, 0x00002d0d,
0x0000041e, 0x0000043e, 0x000003da, 0x000003db,
0x0000fb00, 0x020002b1, 0x00000108, 0x00000109,
0x0000a68e, 0x0000a68f, 0x00002c1a, 0x00002c4a,
0x00001e1a, 0x00001e1b, 0x00001c9b, 0x000010db,
0x000013fb, 0x000013f3, 0x00002c11, 0x00002c41,
0x00000143, 0x00000144, 0x00000058, 0x00000078,
0x000024b6, 0x000024d0, 0x0000ab8e, 0x000013be,
0x00002c25, 0x00002c55, 0x00000391, 0x000003b1,
0x000001a9, 0x00000283, 0x0000a694, 0x0000a695,
0x00000120, 0x00000121, 0x0000ab81, 0x000013b1,
0x00010c93, 0x00010cd3, 0x0000a7ad, 0x0000026c,
0x000010c7, 0x00002d27, 0x0000abb4, 0x000013e4,
0x00000548, 0x00000578, 0x00002cac, 0x00002cad,
0x00010424, 0x0001044c, 0x00002cd4, 0x00002cd5,
0x0000041c, 0x0000043c, 0x00001ff4, 0x020002a4,
0x00000047, 0x00000067, 0x0000a75a, 0x0000a75b,
0x0000ff31, 0x0000ff51, 0x0000011a, 0x0000011b,
0x000024b8, 0x000024d2, 0x00002c24, 0x00002c54,
0x00000541, 0x00000571, 0x000013fd, 0x000013f5,
0x000118a1, 0x000118c1, 0x00001f5f, 0x00001f57,
0x000003e8, 0x000003e9, 0x000104b2, 0x000104da,
0x000003cf, 0x000003d7, 0x00002c17, 0x00002c47,
0x00001c80, 0x00000432, 0x000013f8, 0x000013f0,
0x00001e26, 0x00001e27, 0x000000d1, 0x000000f1,
0x000003e2, 0x000003e3, 0x000118b5, 0x000118d5,
0x0001e90a, 0x0001e92c, 0x0000abbb, 0x000013eb,
0x0000020c, 0x0000020d, 0x0000a72a, 0x0000a72b,
0x000001f6, 0x00000195, 0x00010c9a, 0x00010cda,
0x00001f19, 0x00001f11, 0x00002cd2, 0x00002cd3,
0x00000468, 0x00000469, 0x00002c8c, 0x00002c8d,
0x00002c09, 0x00002c39, 0x0000a76e, 0x0000a76f,
0x0000ab94, 0x000013c4, 0x00000200, 0x00000201,
0x00001fc9, 0x00001f73, 0x00002c22, 0x00002c52,
0x00001faf, 0x02000254, 0x00002c7f, 0x00000240,
0x00001fe6, 0x02000297, 0x00010419, 0x00010441,
0x0000a69a, 0x0000a69b, 0x000004d0, 0x000004d1,
0x00000128, 0x00000129, 0x00001f97, 0x0200020c,
0x00000158, 0x00000159, 0x00001ff3, 0x020002a1,
0x000001d1, 0x000001d2, 0x00000533, 0x00000563,
0x00002c8e, 0x00002c8f, 0x00000420, 0x00000440,
0x00001f1c, 0x00001f14, 0x00016e58, 0x00016e78,
0x000104b8, 0x000104e0, 0x0000a734, 0x0000a735,
0x00001e86, 0x00001e87, 0x000118a5, 0x000118c5,
0x0000ab77, 0x000013a7, 0x00000370, 0x00000371,
0x00001e6c, 0x00001e6d, 0x00001fbc, 0x02000267,
0x00010408, 0x00010430, 0x0000a684, 0x0000a685,
0x00001f89, 0x020001e2, 0x00000179, 0x0000017a,
0x00010401, 0x00010429, 0x00010c82, 0x00010cc2,
0x00016e57, 0x00016e77, 0x00001f0c, 0x00001f04,
0x000118a6, 0x000118c6, 0x00001fb7, 0x03000263,
0x00010403, 0x0001042b, 0x000004d6, 0x000004d7,
0x000010c3, 0x00002d23, 0x00000210, 0x00000211,
0x00002cdc, 0x00002cdd, 0x00001e5c, 0x00001e5d,
0x00000048, 0x00000068, 0x0001e911, 0x0001e933,
0x000001d5, 0x000001d6, 0x00000426, 0x00000446,
0x00000043, 0x00000063, 0x00000160, 0x00000161,
0x0000216d, 0x0000217d, 0x0000a732, 0x0000a733,
0x0000054e, 0x0000057e, 0x00010c94, 0x00010cd4,
0x0000abad, 0x000013dd, 0x00000376, 0x00000377,
0x00000241, 0x00000242, 0x00002c92, 0x00002c93,
0x0000004b, 0x0000006b, 0x0000a682, 0x0000a683,
0x00000408, 0x00000458, 0x00000202, 0x00000203,
0x000104bb, 0x000104e3, 0x00010413, 0x0001043b,
0x0000ab7f, 0x000013af, 0x0000aba4, 0x000013d4,
0x00001f29, 0x00001f21, 0x0000041b, 0x0000043b,
0x000003ee, 0x000003ef, 0x0000015a, 0x0000015b,
0x0000a65a, 0x0000a65b, 0x00000216, 0x00000217,
0x0000046e, 0x0000046f, 0x00010ca7, 0x00010ce7,
0x00001c97, 0x000010d7, 0x00001c96, 0x000010d6,
0x0000ab89, 0x000013b9, 0x00010407, 0x0001042f,
0x00001e3c, 0x00001e3d, 0x00000166, 0x00000167,
0x00001ee6, 0x00001ee7, 0x000004a6, 0x000004a7,
0x00010ca1, 0x00010ce1, 0x000104b4, 0x000104dc,
0x0000ab75, 0x000013a5, 0x00002cda, 0x00002cdb,
0x0000a7b0, 0x0000029e, 0x00001fba, 0x00001f70,
0x0000ff30, 0x0000ff50, 0x0000039d, 0x000003bd,
0x000004a0, 0x000004a1, 0x00010404, 0x0001042c,
0x00010406, 0x0001042e, 0x00002c2a, 0x00002c5a,
0x00001f9c, 0x0200021b, 0x00001f0a, 0x00001f02,
0x00001fda, 0x00001f76, 0x0001e900, 0x0001e922,
0x000000d9, 0x000000f9, 0x000003d6, 0x000003c0,
0x0000012e, 0x0000012f, 0x00016e4b, 0x00016e6b,
0x0000ab87, 0x000013b7, 0x00001e5a, 0x00001e5b,
0x000001ae, 0x00000288, 0x0000023d, 0x0000019a,
0x00010c8d, 0x00010ccd, 0x00016e4a, 0x00016e6a,
0x00010c84, 0x00010cc4, 0x00000393, 0x000003b3,
0x0000a779, 0x0000a77a, 0x0000abac, 0x000013dc,
0x00010ca3, 0x00010ce3, 0x000001e6, 0x000001e7,
0x0000ab7b, 0x000013ab, 0x0000ab96, 0x000013c6,
0x00001f38, 0x00001f30, 0x00001fc4, 0x02000270,
0x00000539, 0x00000569, 0x00000531, 0x00000561,
0x000004a2, 0x000004a3, 0x00000136, 0x00000137,
0x000001e0, 0x000001e1, 0x00010414, 0x0001043c,
0x00001fe8, 0x00001fe0, 0x00010c9e, 0x00010cde,
0x0000ff3a, 0x0000ff5a, 0x00000139, 0x0000013a,
0x0000a7a6, 0x0000a7a7, 0x00001e14, 0x00001e15,
0x0000ab91, 0x000013c1, 0x00000390, 0x0300019b,
0x0000ab8a, 0x000013ba, 0x00001e64, 0x00001e65,
0x00002c07, 0x00002c37, 0x000104c3, 0x000104eb,
0x00016e47, 0x00016e67, 0x0000a77d, 0x00001d79,
0x00002c90, 0x00002c91, 0x0000ff35, 0x0000ff55,
0x00001eb0, 0x00001eb1, 0x00000480, 0x00000481,
0x00016e44, 0x00016e64, 0x00002c1d, 0x00002c4d,
0x000000b5, 0x000003bc, 0x00001cb4, 0x000010f4,
0x00016e4f, 0x00016e6f, 0x00001fc2, 0x0200026a,
0x0000ff37, 0x0000ff57, 0x000003d0, 0x000003b2,
0x0000ab86, 0x000013b6, 0x00000534, 0x00000564,
0x000001e2, 0x000001e3, 0x000118b0, 0x000118d0,
0x00010c92, 0x00010cd2, 0x00000555, 0x00000585,
0x00001fcb, 0x00001f75, 0x00016e40, 0x00016e60,
0x0000ff23, 0x0000ff43, 0x000004d8, 0x000004d9,
0x000104d2, 0x000104fa, 0x000024ba, 0x000024d4,
0x00001f3b, 0x00001f33, 0x00001e62, 0x00001e63,
0x00001f1b, 0x00001f13, 0x000004bc, 0x000004bd,
0x0000ab80, 0x000013b0, 0x00000428, 0x00000448,
0x0000a79e, 0x0000a79f, 0x0000004a, 0x0000006a,
0x00001e20, 0x00001e21, 0x00002cb4, 0x00002cb5,
0x00001e28, 0x00001e29, 0x0000040c, 0x0000045c,
0x00000414, 0x00000434, 0x00002c64, 0x0000027d,
0x00001ece, 0x00001ecf, 0x00001ffc, 0x020002ae,
0x00001ed0, 0x00001ed1, 0x0000216a, 0x0000217a,
0x0000a76a, 0x0000a76b, 0x00000110, 0x00000111,
0x00001eb2, 0x00001eb3, 0x000104bc, 0x000104e4,
0x00001e1e, 0x00001e1f, 0x00000404, 0x00000454,
0x00000245, 0x0000028c, 0x0000fb15, 0x020002ce,
0x00000220, 0x0000019e, 0x000118ae, 0x000118ce,
0x000024c7, 0x000024e1, 0x00000218, 0x00000219,
0x0000abba, 0x000013ea, 0x0000040f, 0x0000045f,
0x00001fcc, 0x0200027a, 0x000004be, 0x000004bf,
0x0000fb17, 0x020002d4, 0x00002caa, 0x00002cab,
0x00000397, 0x000003b7, 0x00000168, 0x00000169,
0x00002c05, 0x00002c35, 0x0000ab8c, 0x000013bc,
0x000010b5, 0x00002d15, 0x0000040e, 0x0000045e,
0x0000ab9e, 0x000013ce, 0x00002cc4, 0x00002cc5,
0x00001ca2, 0x000010e2, 0x000000c9, 0x000000e9,
0x000104b1, 0x000104d9, 0x00001cbf, 0x000010ff,
0x000004ba, 0x000004bb, 0x00001eaa, 0x00001eab,
0x0000ff39, 0x0000ff59, 0x00002c14, 0x00002c44,
0x000104b3, 0x000104db, 0x0001e90f, 0x0001e931,
0x00010c81, 0x00010cc1, 0x0000053b, 0x0000056b,
0x0000040a, 0x0000045a, 0x000004d4, 0x000004d5,
0x000024ca, 0x000024e4, 0x0000212a, 0x0000006b,
0x00001fc7, 0x03000276, 0x0000a64e, 0x0000a64f,
0x000118b7, 0x000118d7, 0x00002c01, 0x00002c31,
0x0000042b, 0x0000044b, 0x000118a2, 0x000118c2,
0x00002c1b, 0x00002c4b, 0x00001f99, 0x02000212,
0x00001c86, 0x0000044a, 0x0000a7ab, 0x0000025c,
0x00001f86, 0x020001d9, 0x0000ab93, 0x000013c3,
0x0000a7a0, 0x0000a7a1, 0x00001c9e, 0x000010de,
0x0000a7a8, 0x0000a7a9, 0x00001fca, 0x00001f74,
0x0001040b, 0x00010433, 0x000118ba, 0x000118da,
0x0000a75e, 0x0000a75f, 0x00001f8f, 0x020001f4,
0x000001fa, 0x000001fb, 0x00002c04, 0x00002c34,
0x00000403, 0x00000453, 0x00001f1a, 0x00001f12,
0x00001ff7, 0x030002aa, 0x000010bb, 0x00002d1b,
0x00002c12, 0x00002c42, 0x00001e7e, 0x00001e7f,
0x0000014a, 0x0000014b, 0x00000214, 0x00000215,
0x0000037f, 0x000003f3, 0x00001e6a, 0x00001e6b,
0x00001eec, 0x00001eed, 0x0000abb9, 0x000013e9,
0x00001fa5, 0x02000236, 0x0000038f, 0x000003ce,
0x00000535, 0x00000565, 0x00001fd3, 0x03000281,
0x0000ab8f, 0x000013bf, 0x00001c9c, 0x000010dc,
0x00001e97, 0x020001a9, 0x00001f6c, 0x00001f64,
0x00010417, 0x0001043f, 0x00002162, 0x00002172,
0x00002c88, 0x00002c89, 0x00010415, 0x0001043d,
0x000104b6, 0x000104de, 0x00001caf, 0x000010ef,
0x00002cbc, 0x00002cbd, 0x00001ebc, 0x00001ebd,
0x00002c15, 0x00002c45, 0x000001cf, 0x000001d0,
0x00002167, 0x00002177, 0x0000ab9a, 0x000013ca,
0x00001ffa, 0x00001f7c, 0x0000020a, 0x0000020b,
0x00002c0c, 0x00002c3c, 0x00001e0c, 0x00001e0d,
0x000010a8, 0x00002d08, 0x00000147, 0x00000148,
0x0000ff2f, 0x0000ff4f, 0x00001e7c, 0x00001e7d,
0x00001f4a, 0x00001f42, 0x0000a7ac, 0x00000261,
0x00001c87, 0x00000463, 0x00000474, 0x00000475,
0x00000406, 0x00000456, 0x000024cc, 0x000024e6,
0x00001fab, 0x02000248, 0x0001e905, 0x0001e927,
0x00001e9a, 0x020001b2, 0x000010a4, 0x00002d04,
0x0000054d, 0x0000057d, 0x00001cac, 0x000010ec,
0x0000ff25, 0x0000ff45, 0x00001e24, 0x00001e25,
0x00000411, 0x00000431, 0x0000abb5, 0x000013e5,
0x00002cb2, 0x00002cb3, 0x00001ca5, 0x000010e5,
0x000118a3, 0x000118c3, 0x00002164, 0x00002174,
0x000003a1, 0x000003c1, 0x0000a74e, 0x0000a74f,
0x000118b8, 0x000118d8, 0x0000ff2e, 0x0000ff4e,
0x00002c02, 0x00002c32, 0x0000054f, 0x0000057f,
0x00010427, 0x0001044f, 0x0000a740, 0x0000a741,
0x000000c5, 0x000000e5, 0x00001f84, 0x020001d3,
0x000010b9, 0x00002d19, 0x0001e91f, 0x0001e941,
0x000024c9, 0x000024e3, 0x0000013b, 0x0000013c,
0x00000516, 0x00000517, 0x0000a654, 0x0000a655,
0x0000a656, 0x0000a657, 0x00000405, 0x00000455,
0x00002c29, 0x00002c59, 0x000010a2, 0x00002d02,
0x00000540, 0x00000570, 0x000010a3, 0x00002d03,
0x00000466, 0x00000467, 0x00001fb9, 0x00001fb1,
0x00010416, 0x0001043e, 0x0000ab97, 0x000013c7,
0x00002cba, 0x00002cbb, 0x00001ef4, 0x00001ef5,
0x000003e4, 0x000003e5, 0x000004c9, 0x000004ca,
0x0000a66c, 0x0000a66d, 0x00000054, 0x00000074,
0x00000246, 0x00000247, 0x0000ab7a, 0x000013aa,
0x00002c0a, 0x00002c3a, 0x000004ec, 0x000004ed,
0x0001e90e, 0x0001e930, 0x000000d3, 0x000000f3,
0x00001fa9, 0x02000242, 0x00001f2b, 0x00001f23,
0x0000fb05, 0x020002c2, 0x00002c6b, 0x00002c6c,
0x00000537, 0x00000567, 0x000010b7, 0x00002d17,
0x0000a77e, 0x0000a77f, 0x00010cad, 0x00010ced,
0x0000040d, 0x0000045d, 0x00002c0e, 0x00002c3e,
0x00000547, 0x00000577, 0x00001f4c, 0x00001f44,
0x000003a5, 0x000003c5, 0x0000038c, 0x000003cc,
0x00001cb7, 0x000010f7, 0x00001eea, 0x00001eeb,
0x000001a6, 0x00000280, 0x00001fad, 0x0200024e,
0x00002c8a, 0x00002c8b, 0x00000134, 0x00000135,
0x00010418, 0x00010440, 0x00010c87, 0x00010cc7,
0x0000a662, 0x0000a663, 0x000001b3, 0x000001b4,
0x0000015c, 0x0000015d, 0x000118b9, 0x000118d9,
0x00000500, 0x00000501, 0x00010c8a, 0x00010cca,
0x000010ac, 0x00002d0c, 0x0000022c, 0x0000022d,
0x00001fbb, 0x00001f71, 0x00001e54, 0x00001e55,
0x00000046, 0x00000066, 0x00002161, 0x00002171,
0x00001cba, 0x000010fa, 0x0000051a, 0x0000051b,
0x000001e8, 0x000001e9, 0x000118b4, 0x000118d4,
0x00001f0b, 0x00001f03, 0x00001f8c, 0x020001eb,
0x0000ab99, 0x000013c9, 0x00001e74, 0x00001e75,
0x000003a0, 0x000003c0, 0x000010a1, 0x00002d01,
0x00001f5d, 0x00001f55, 0x000000cc, 0x000000ec,
0x0000041f, 0x0000043f, 0x0000aba1, 0x000013d1,
0x00001ee4, 0x00001ee5, 0x00001f28, 0x00001f20,
0x00001fb2, 0x02000257, 0x000000df, 0x0200018f,
0x0000a66a, 0x0000a66b, 0x000010b3, 0x00002d13,
0x0001e90b, 0x0001e92d, 0x00001e2c, 0x00001e2d,
0x00001e34, 0x00001e35, 0x000004ea, 0x000004eb,
0x0001041b, 0x00010443, 0x0000018f, 0x00000259,
0x000001f0, 0x02000198, 0x00001e44, 0x00001e45,
0x00002ca8, 0x00002ca9, 0x00000412, 0x00000432,
0x000000c3, 0x000000e3, 0x0000052e, 0x0000052f,
0x00001e52, 0x00001e53, 0x0000ab9d, 0x000013cd,
0x00002168, 0x00002178, 0x00001f8e, 0x020001f1,
0x00016e51, 0x00016e71, 0x000010aa, 0x00002d0a,
0x000118ab, 0x000118cb, 0x0000038a, 0x000003af,
0x0000aba7, 0x000013d7, 0x00000554, 0x00000584,
0x000001cd, 0x000001ce, 0x00000193, 0x00000260,
0x00000518, 0x00000519, 0x00001f6f, 0x00001f67,
0x00001fac, 0x0200024b, 0x00001c91, 0x000010d1,
0x00010426, 0x0001044e, 0x000001f4, 0x000001f5,
0x00016e41, 0x00016e61, 0x00001e2e, 0x00001e2f,
0x00002c2b, 0x00002c5b, 0x000004f4, 0x000004f5,
0x00001efc, 0x00001efd, 0x0000022a, 0x0000022b,
0x00002cd8, 0x00002cd9, 0x000003f4, 0x000003b8,
0x00001e18, 0x00001e19, 0x000118bd, 0x000118dd,
0x0000abb7, 0x000013e7, 0x000024c5, 0x000024df,
0x00001e4c, 0x00001e4d, 0x000001c4, 0x000001c6,
0x000004cd, 0x000004ce, 0x00002c84, 0x00002c85,
0x00001ea8, 0x00001ea9, 0x000010bc, 0x00002d1c,
0x0000ff2d, 0x0000ff4d, 0x00000394, 0x000003b4,
0x00016e45, 0x00016e65, 0x000000ca, 0x000000ea,
0x00000416, 0x00000436, 0x0001e91a, 0x0001e93c,
0x00001cb8, 0x000010f8, 0x00001cb3, 0x000010f3,
0x00001fa2, 0x0200022d, 0x0000abaf, 0x000013df,
0x00001ca1, 0x000010e1, 0x0000010e, 0x0000010f,
0x00016e43, 0x00016e63, 0x00002ca0, 0x00002ca1,
0x0000ab79, 0x000013a9, 0x000004f2, 0x000004f3,
0x00001ef2, 0x00001ef3, 0x000004ac, 0x000004ad,
0x00000429, 0x00000449, 0x00010c9d, 0x00010cdd,
0x0000a750, 0x0000a751, 0x0001e90d, 0x0001e92f,
0x00001c98, 0x000010d8, 0x00010402, 0x0001042a,
0x00001e42, 0x00001e43, 0x00000184, 0x00000185,
0x00000154, 0x00000155, 0x0000ab84, 0x000013b4,
0x00001e80, 0x00001e81, 0x00001c92, 0x000010d2,
0x0001e90c, 0x0001e92e, 0x00000392, 0x000003b2,
0x00001f2f, 0x00001f27, 0x000000d4, 0x000000f4,
0x00000050, 0x00000070, 0x0001041a, 0x00010442,
0x00000156, 0x00000157, 0x00001fea, 0x00001f7a,
0x00001faa, 0x02000245, 0x00001cb5, 0x000010f5,
0x0000039b, 0x000003bb, 0x0000a738, 0x0000a739,
0x00000100, 0x00000101, 0x0000042d, 0x0000044d,
0x0001040a, 0x00010432, 0x00001f3a, 0x00001f32,
0x00001efa, 0x00001efb, 0x00000232, 0x00000233,
0x00002c7e, 0x0000023f, 0x000001ec, 0x000001ed,
0x00002c69, 0x00002c6a, 0x00010412, 0x0001043a,
0x00001ca7, 0x000010e7, 0x0000047c, 0x0000047d,
0x00001e4a, 0x00001e4b, 0x00000182, 0x00000183,
0x00000423, 0x00000443, 0x000000c7, 0x000000e7,
0x00000526, 0x00000527, 0x00001f09, 0x00001f01,
0x000118b6, 0x000118d6, 0x00001f52, 0x030001bb,
0x000004fc, 0x000004fd, 0x000000d2, 0x000000f2,
0x0000018b, 0x0000018c, 0x000001b1, 0x0000028a,
0x00002cce, 0x00002ccf, 0x00001e4e, 0x00001e4f,
0x00001f18, 0x00001f10, 0x00010410, 0x00010438,
0x00010400, 0x00010428, 0x0000048a, 0x0000048b,
0x000000db, 0x000000fb, 0x00002ca2, 0x00002ca3,
0x00002c1e, 0x00002c4e, 0x00001ea4, 0x00001ea5,
0x00001eca, 0x00001ecb, 0x000004b2, 0x000004b3,
0x0000039c, 0x000003bc, 0x000003de, 0x000003df,
0x00001e88, 0x00001e89, 0x0000abbc, 0x000013ec,
0x0000ff2c, 0x0000ff4c, 0x00002cbe, 0x00002cbf,
0x00001e7a, 0x00001e7b, 0x000001bc, 0x000001bd,
0x00002ce2, 0x00002ce3, 0x00000417, 0x00000437,
0x0000a7b3, 0x0000ab53, 0x00001c85, 0x00000442,
0x0001e920, 0x0001e942, 0x000118ac, 0x000118cc,
0x0000abbe, 0x000013ee, 0x0000046a, 0x0000046b,
0x00001c9d, 0x000010dd, 0x000004c7, 0x000004c8,
0x00002ced, 0x00002cee, 0x0000048c, 0x0000048d,
0x00001ff6, 0x020002a7, 0x000010b4, 0x00002d14,
0x00001f3f, 0x00001f37, 0x00001f5b, 0x00001f53,
0x000024b9, 0x000024d3, 0x000001ca, 0x000001cc,
0x000004b8, 0x000004b9, 0x000004fa, 0x000004fb,
0x00000106, 0x00000107, 0x0000ff2a, 0x0000ff4a,
0x000001a7, 0x000001a8, 0x000001f2, 0x000001f3,
0x000000dc, 0x000000fc, 0x0000011e, 0x0000011f,
0x0000212b, 0x000000e5, 0x0000a688, 0x0000a689,
0x000013fc, 0x000013f4, 0x00010ca8, 0x00010ce8,
0x0001e907, 0x0001e929, 0x00000181, 0x00000253,
0x00001eb8, 0x00001eb9, 0x00002183, 0x00002184,
0x00001ee8, 0x00001ee9, 0x0000039a, 0x000003ba,
0x0000a72e, 0x0000a72f, 0x0000054c, 0x0000057c,
0x000118aa, 0x000118ca, 0x0000a7b1, 0x00000287,
0x00001cbd, 0x000010fd, 0x00000248, 0x00000249,
0x00001e38, 0x00001e39, 0x0000a79c, 0x0000a79d,
0x0000ab7d, 0x000013ad, 0x0000049c, 0x0000049d,
0x000118bb, 0x000118db, 0x000010af, 0x00002d0f,
0x0001e916, 0x0001e938, 0x00002cf2, 0x00002cf3,
0x000001f8, 0x000001f9, 0x0000023a, 0x00002c65,
0x00000587, 0x020001a3, 0x000003ec, 0x000003ed,
0x0000a74a, 0x0000a74b, 0x00002c21, 0x00002c51,
0x0000a640, 0x0000a641, 0x0000ab72, 0x000013a2,
0x0000052a, 0x0000052b, 0x0000018a, 0x00000257,
0x000024bd, 0x000024d7, 0x00010cb0, 0x00010cf0,
0x0000a746, 0x0000a747, 0x00001c9f, 0x000010df,
0x000003fd, 0x0000037b, 0x0000ab71, 0x000013a1,
0x0000047a, 0x0000047b, 0x000000da, 0x000000fa,
0x000001b7, 0x00000292, 0x0001e901, 0x0001e923,
0x00001f9f, 0x02000224, 0x00001ec4, 0x00001ec5,
0x0000ab9c, 0x000013cc, 0x00002166, 0x00002176,
0x00001e50, 0x00001e51, 0x00010caa, 0x00010cea,
0x0000aba2, 0x000013d2, 0x00002c63, 0x00001d7d,
0x0000ab7e, 0x000013ae, 0x0000abbf, 0x000013ef,
0x00001f39, 0x00001f31, 0x00000536, 0x00000566,
0x00001f9d, 0x0200021e, 0x0000a64c, 0x0000a64d,
0x00000057, 0x00000077, 0x0000012c, 0x0000012d,
0x00001cbe, 0x000010fe, 0x00000145, 0x00000146,
0x000013fa, 0x000013f2, 0x0000019c, 0x0000026f,
0x00016e49, 0x00016e69, 0x0000ab92, 0x000013c2,
0x00002169, 0x00002179, 0x0001e903, 0x0001e925,
0x0001e906, 0x0001e928, 0x0000ab9f, 0x000013cf,
0x0000abb0, 0x000013e0, 0x0000024a, 0x0000024b,
0x0000019d, 0x00000272, 0x00000413, 0x00000433,
0x00002cc8, 0x00002cc9, 0x00001e94, 0x00001e95,
0x000010c0, 0x00002d20, 0x00000407, 0x00000457,
0x0000abb8, 0x000013e8, 0x0000a752, 0x0000a753,
0x0000010a, 0x0000010b, 0x000004c3, 0x000004c4,
0x00002c18, 0x00002c48, 0x000003a9, 0x000003c9,
0x00016e4c, 0x00016e6c, 0x0000024e, 0x0000024f,
0x000001c7, 0x000001c9, 0x000003aa, 0x000003ca,
0x0000005a, 0x0000007a, 0x000003f1, 0x000003c1,
0x00001f94, 0x02000203, 0x0000ab74, 0x000013a4,
0x0000051e, 0x0000051f, 0x0000a77b, 0x0000a77c,
0x0001e919, 0x0001e93b, 0x0000ff21, 0x0000ff41,
0x00001ebe, 0x00001ebf, 0x00001eac, 0x00001ead,
0x0000ff32, 0x0000ff52, 0x00001c84, 0x00000442,
0x0000abb2, 0x000013e2, 0x00010c8e, 0x00010cce,
0x000001f1, 0x000001f3, 0x00000508, 0x00000509,
0x00002cc6, 0x00002cc7, 0x00010c83, 0x00010cc3,
0x00001fbe, 0x000003b9, 0x000003ab, 0x000003cb,
0x000003fa, 0x000003fb, 0x0000a76c, 0x0000a76d,
0x00000141, 0x00000142, 0x00016e52, 0x00016e72,
0x00002c16, 0x00002c46, 0x000104b7, 0x000104df,
0x00001f0e, 0x00001f06, 0x0001e909, 0x0001e92b,
0x00016e5e, 0x00016e7e, 0x00001f6b, 0x00001f63,
0x0000a790, 0x0000a791, 0x0001041d, 0x00010445,
0x000104cc, 0x000104f4, 0x0000ab7c, 0x000013ac,
0x00001e5e, 0x00001e5f, 0x00001fae, 0x02000251,
0x000001af, 0x000001b0, 0x00002c86, 0x00002c87,
0x0000a798, 0x0000a799, 0x00001ea6, 0x00001ea7,
0x0001041c, 0x00010444, 0x00001ecc, 0x00001ecd,
0x0000a728, 0x0000a729, 0x00001efe, 0x00001eff,
0x000010ba, 0x00002d1a, 0x000001f7, 0x000001bf,
0x00001e10, 0x00001e11, 0x00002c20, 0x00002c50,
0x00000494, 0x00000495, 0x00001e1c, 0x00001e1d,
0x000104bf, 0x000104e7, 0x0000a754, 0x0000a755,
0x000024be, 0x000024d8, 0x000104cf, 0x000104f7,
0x0000aba3, 0x000013d3, 0x00000198, 0x00000199,
0x00001f2d, 0x00001f25, 0x00000152, 0x00000153,
0x00000187, 0x00000188, 0x0000a748, 0x0000a749,
0x0000a792, 0x0000a793, 0x0000010c, 0x0000010d,
0x00001cb0, 0x000010f0, 0x000000c1, 0x000000e1,
0x00001fa3, 0x02000230, 0x0001e91d, 0x0001e93f,
0x00001f95, 0x02000206, 0x00000244, 0x00000289,
0x00002c96, 0x00002c97, 0x0000a644, 0x0000a645,
0x00000399, 0x000003b9, 0x000104d0, 0x000104f8,
0x0000a726, 0x0000a727, 0x000000c4, 0x000000e4,
0x000024c0, 0x000024da, 0x00010405, 0x0001042d,
0x00002cc2, 0x00002cc3, 0x00001cab, 0x000010eb,
0x00010ca9, 0x00010ce9, 0x000010b8, 0x00002d18,
0x0001041e, 0x00010446, 0x0000a75c, 0x0000a75d,
0x00000204, 0x00000205, 0x000003f9, 0x000003f2,
0x0000ab70, 0x000013a0, 0x0000a7a4, 0x0000a7a5
};
static const unsigned _uccase_extra_table[] = {
0x00001f88, 0x00001f08, 0x00000399, 0x00001f89,
0x00001f09, 0x00000399, 0x00001f8a, 0x00001f0a,
0x00000399, 0x00001f8b, 0x00001f0b, 0x00000399,
0x00001f8c, 0x00001f0c, 0x00000399, 0x00001f8d,
0x00001f0d, 0x00000399, 0x00001f8e, 0x00001f0e,
0x00000399, 0x00001f8f, 0x00001f0f, 0x00000399,
0x00001f98, 0x00001f28, 0x00000399, 0x00001f99,
0x00001f29, 0x00000399, 0x00001f9a, 0x00001f2a,
0x00000399, 0x00001f9b, 0x00001f2b, 0x00000399,
0x00001f9c, 0x00001f2c, 0x00000399, 0x00001f9d,
0x00001f2d, 0x00000399, 0x00001f9e, 0x00001f2e,
0x00000399, 0x00001f9f, 0x00001f2f, 0x00000399,
0x00001fa8, 0x00001f68, 0x00000399, 0x00001fa9,
0x00001f69, 0x00000399, 0x00001faa, 0x00001f6a,
0x00000399, 0x00001fab, 0x00001f6b, 0x00000399,
0x00001fac, 0x00001f6c, 0x00000399, 0x00001fad,
0x00001f6d, 0x00000399, 0x00001fae, 0x00001f6e,
0x00000399, 0x00001faf, 0x00001f6f, 0x00000399,
0x00001fbc, 0x00000391, 0x00000399, 0x00001fcc,
0x00000397, 0x00000399, 0x00001ffc, 0x000003a9,
0x00000399, 0x000000df, 0x00000053, 0x00000053,
0x0000fb00, 0x00000046, 0x00000046, 0x0000fb01,
0x00000046, 0x00000049, 0x0000fb02, 0x00000046,
0x0000004c, 0x0000fb03, 0x00000046, 0x00000046,
0x00000049, 0x0000fb04, 0x00000046, 0x00000046,
0x0000004c, 0x0000fb05, 0x00000053, 0x00000054,
0x0000fb06, 0x00000053, 0x00000054, 0x00000587,
0x00000535, 0x00000552, 0x0000fb13, 0x00000544,
0x00000546, 0x0000fb14, 0x00000544, 0x00000535,
0x0000fb15, 0x00000544, 0x0000053b, 0x0000fb16,
0x0000054e, 0x00000546, 0x0000fb17, 0x00000544,
0x0000053d, 0x00000149, 0x000002bc, 0x0000004e,
0x00000390, 0x00000399, 0x00000308, 0x00000301,
0x000003b0, 0x000003a5, 0x00000308, 0x00000301,
0x000001f0, 0x0000004a, 0x0000030c, 0x00001e96,
0x00000048, 0x00000331, 0x00001e97, 0x00000054,
0x00000308, 0x00001e98, 0x00000057, 0x0000030a,
0x00001e99, 0x00000059, 0x0000030a, 0x00001e9a,
0x00000041, 0x000002be, 0x00001f50, 0x000003a5,
0x00000313, 0x00001f52, 0x000003a5, 0x00000313,
0x00000300, 0x00001f54, 0x000003a5, 0x00000313,
0x00000301, 0x00001f56, 0x000003a5, 0x00000313,
0x00000342, 0x00001fb6, 0x00000391, 0x00000342,
0x00001fc6, 0x00000397, 0x00000342, 0x00001fd2,
0x00000399, 0x00000308, 0x00000300, 0x00001fd3,
0x00000399, 0x00000308, 0x00000301, 0x00001fd6,
0x00000399, 0x00000342, 0x00001fd7, 0x00000399,
0x00000308, 0x00000342, 0x00001fe2, 0x000003a5,
0x00000308, 0x00000300, 0x00001fe3, 0x000003a5,
0x00000308, 0x00000301, 0x00001fe4, 0x000003a1,
0x00000313, 0x00001fe6, 0x000003a5, 0x00000342,
0x00001fe7, 0x000003a5, 0x00000308, 0x00000342,
0x00001ff6, 0x000003a9, 0x00000342, 0x00001f88,
0x00001f08, 0x00000399, 0x00001f89, 0x00001f09,
0x00000399, 0x00001f8a, 0x00001f0a, 0x00000399,
0x00001f8b, 0x00001f0b, 0x00000399, 0x00001f8c,
0x00001f0c, 0x00000399, 0x00001f8d, 0x00001f0d,
0x00000399, 0x00001f8e, 0x00001f0e, 0x00000399,
0x00001f8f, 0x00001f0f, 0x00000399, 0x00001f98,
0x00001f28, 0x00000399, 0x00001f99, 0x00001f29,
0x00000399, 0x00001f9a, 0x00001f2a, 0x00000399,
0x00001f9b, 0x00001f2b, 0x00000399, 0x00001f9c,
0x00001f2c, 0x00000399, 0x00001f9d, 0x00001f2d,
0x00000399, 0x00001f9e, 0x00001f2e, 0x00000399,
0x00001f9f, 0x00001f2f, 0x00000399, 0x00001fa8,
0x00001f68, 0x00000399, 0x00001fa9, 0x00001f69,
0x00000399, 0x00001faa, 0x00001f6a, 0x00000399,
0x00001fab, 0x00001f6b, 0x00000399, 0x00001fac,
0x00001f6c, 0x00000399, 0x00001fad, 0x00001f6d,
0x00000399, 0x00001fae, 0x00001f6e, 0x00000399,
0x00001faf, 0x00001f6f, 0x00000399, 0x00001fbc,
0x00000391, 0x00000399, 0x00001fcc, 0x00000397,
0x00000399, 0x00001ffc, 0x000003a9, 0x00000399,
0x00001fb2, 0x00001fba, 0x00000399, 0x00001fb4,
0x00000386, 0x00000399, 0x00001fc2, 0x00001fca,
0x00000399, 0x00001fc4, 0x00000389, 0x00000399,
0x00001ff2, 0x00001ffa, 0x00000399, 0x00001ff4,
0x0000038f, 0x00000399, 0x00001fb7, 0x00000391,
0x00000342, 0x00000399, 0x00001fc7, 0x00000397,
0x00000342, 0x00000399, 0x00001ff7, 0x000003a9,
0x00000342, 0x00000399, 0x00000069, 0x00000069,
0x00000307, 0x000000df, 0x00000053, 0x00000073,
0x0000fb00, 0x00000046, 0x00000066, 0x0000fb01,
0x00000046, 0x00000069, 0x0000fb02, 0x00000046,
0x0000006c, 0x0000fb03, 0x00000046, 0x00000066,
0x00000069, 0x0000fb04, 0x00000046, 0x00000066,
0x0000006c, 0x0000fb05, 0x00000053, 0x00000074,
0x0000fb06, 0x00000053, 0x00000074, 0x00000587,
0x00000535, 0x00000582, 0x0000fb13, 0x00000544,
0x00000576, 0x0000fb14, 0x00000544, 0x00000565,
0x0000fb15, 0x00000544, 0x0000056b, 0x0000fb16,
0x0000054e, 0x00000576, 0x0000fb17, 0x00000544,
0x0000056d, 0x00001fb2, 0x00001fba, 0x00000345,
0x00001fb4, 0x00000386, 0x00000345, 0x00001fc2,
0x00001fca, 0x00000345, 0x00001fc4, 0x00000389,
0x00000345, 0x00001ff2, 0x00001ffa, 0x00000345,
0x00001ff4, 0x0000038f, 0x00000345, 0x00001fb7,
0x00000391, 0x00000342, 0x00000345, 0x00001fc7,
0x00000397, 0x00000342, 0x00000345, 0x00001ff7,
0x000003a9, 0x00000342, 0x00000345, 0x000000df,
0x00000073, 0x00000073, 0x00000130, 0x00000069,
0x00000307, 0x00000149, 0x000002bc, 0x0000006e,
0x000001f0, 0x0000006a, 0x0000030c, 0x00000390,
0x000003b9, 0x00000308, 0x00000301, 0x000003b0,
0x000003c5, 0x00000308, 0x00000301, 0x00000587,
0x00000565, 0x00000582, 0x00001e96, 0x00000068,
0x00000331, 0x00001e97, 0x00000074, 0x00000308,
0x00001e98, 0x00000077, 0x0000030a, 0x00001e99,
0x00000079, 0x0000030a, 0x00001e9a, 0x00000061,
0x000002be, 0x000000df, 0x00000073, 0x00000073,
0x00001f50, 0x000003c5, 0x00000313, 0x00001f52,
0x000003c5, 0x00000313, 0x00000300, 0x00001f54,
0x000003c5, 0x00000313, 0x00000301, 0x00001f56,
0x000003c5, 0x00000313, 0x00000342, 0x00001f80,
0x00001f00, 0x000003b9, 0x00001f81, 0x00001f01,
0x000003b9, 0x00001f82, 0x00001f02, 0x000003b9,
0x00001f83, 0x00001f03, 0x000003b9, 0x00001f84,
0x00001f04, 0x000003b9, 0x00001f85, 0x00001f05,
0x000003b9, 0x00001f86, 0x00001f06, 0x000003b9,
0x00001f87, 0x00001f07, 0x000003b9, 0x00001f80,
0x00001f00, 0x000003b9, 0x00001f81, 0x00001f01,
0x000003b9, 0x00001f82, 0x00001f02, 0x000003b9,
0x00001f83, 0x00001f03, 0x000003b9, 0x00001f84,
0x00001f04, 0x000003b9, 0x00001f85, 0x00001f05,
0x000003b9, 0x00001f86, 0x00001f06, 0x000003b9,
0x00001f87, 0x00001f07, 0x000003b9, 0x00001f90,
0x00001f20, 0x000003b9, 0x00001f91, 0x00001f21,
0x000003b9, 0x00001f92, 0x00001f22, 0x000003b9,
0x00001f93, 0x00001f23, 0x000003b9, 0x00001f94,
0x00001f24, 0x000003b9, 0x00001f95, 0x00001f25,
0x000003b9, 0x00001f96, 0x00001f26, 0x000003b9,
0x00001f97, 0x00001f27, 0x000003b9, 0x00001f90,
0x00001f20, 0x000003b9, 0x00001f91, 0x00001f21,
0x000003b9, 0x00001f92, 0x00001f22, 0x000003b9,
0x00001f93, 0x00001f23, 0x000003b9, 0x00001f94,
0x00001f24, 0x000003b9, 0x00001f95, 0x00001f25,
0x000003b9, 0x00001f96, 0x00001f26, 0x000003b9,
0x00001f97, 0x00001f27, 0x000003b9, 0x00001fa0,
0x00001f60, 0x000003b9, 0x00001fa1, 0x00001f61,
0x000003b9, 0x00001fa2, 0x00001f62, 0x000003b9,
0x00001fa3, 0x00001f63, 0x000003b9, 0x00001fa4,
0x00001f64, 0x000003b9, 0x00001fa5, 0x00001f65,
0x000003b9, 0x00001fa6, 0x00001f66, 0x000003b9,
0x00001fa7, 0x00001f67, 0x000003b9, 0x00001fa0,
0x00001f60, 0x000003b9, 0x00001fa1, 0x00001f61,
0x000003b9, 0x00001fa2, 0x00001f62, 0x000003b9,
0x00001fa3, 0x00001f63, 0x000003b9, 0x00001fa4,
0x00001f64, 0x000003b9, 0x00001fa5, 0x00001f65,
0x000003b9, 0x00001fa6, 0x00001f66, 0x000003b9,
0x00001fa7, 0x00001f67, 0x000003b9, 0x00001fb2,
0x00001f70, 0x000003b9, 0x00001fb3, 0x000003b1,
0x000003b9, 0x00001fb4, 0x000003ac, 0x000003b9,
0x00001fb6, 0x000003b1, 0x00000342, 0x00001fb7,
0x000003b1, 0x00000342, 0x000003b9, 0x00001fb3,
0x000003b1, 0x000003b9, 0x00001fc2, 0x00001f74,
0x000003b9, 0x00001fc3, 0x000003b7, 0x000003b9,
0x00001fc4, 0x000003ae, 0x000003b9, 0x00001fc6,
0x000003b7, 0x00000342, 0x00001fc7, 0x000003b7,
0x00000342, 0x000003b9, 0x00001fc3, 0x000003b7,
0x000003b9, 0x00001fd2, 0x000003b9, 0x00000308,
0x00000300, 0x00001fd3, 0x000003b9, 0x00000308,
0x00000301, 0x00001fd6, 0x000003b9, 0x00000342,
0x00001fd7, 0x000003b9, 0x00000308, 0x00000342,
0x00001fe2, 0x000003c5, 0x00000308, 0x00000300,
0x00001fe3, 0x000003c5, 0x00000308, 0x00000301,
0x00001fe4, 0x000003c1, 0x00000313, 0x00001fe6,
0x000003c5, 0x00000342, 0x00001fe7, 0x000003c5,
0x00000308, 0x00000342, 0x00001ff2, 0x00001f7c,
0x000003b9, 0x00001ff3, 0x000003c9, 0x000003b9,
0x00001ff4, 0x000003ce, 0x000003b9, 0x00001ff6,
0x000003c9, 0x00000342, 0x00001ff7, 0x000003c9,
0x00000342, 0x000003b9, 0x00001ff3, 0x000003c9,
0x000003b9, 0x0000fb00, 0x00000066, 0x00000066,
0x0000fb01, 0x00000066, 0x00000069, 0x0000fb02,
0x00000066, 0x0000006c, 0x0000fb03, 0x00000066,
0x00000066, 0x00000069, 0x0000fb04, 0x00000066,
0x00000066, 0x0000006c, 0x0000fb05, 0x00000073,
0x00000074, 0x0000fb06, 0x00000073, 0x00000074,
0x0000fb13, 0x00000574, 0x00000576, 0x0000fb14,
0x00000574, 0x00000565, 0x0000fb15, 0x00000574,
0x0000056b, 0x0000fb16, 0x0000057e, 0x00000576,
0x0000fb17, 0x00000574, 0x0000056d
};
| 141,965 |
348 | <reponame>chamberone/Leaflet.PixiOverlay
{"nom":"Damprichard","circ":"3ème circonscription","dpt":"Doubs","inscrits":1328,"abs":817,"votants":511,"blancs":27,"nuls":13,"exp":471,"res":[{"nuance":"REM","nom":"M. <NAME>","voix":270},{"nuance":"LR","nom":"M. <NAME>","voix":201}]} | 114 |
432 | package com.hccake.ballcat.common.swagger;
import cn.hutool.core.util.StrUtil;
import com.hccake.ballcat.common.swagger.builder.DocketBuildHelper;
import com.hccake.ballcat.common.swagger.builder.MultiRequestHandlerSelectors;
import com.hccake.ballcat.common.swagger.property.SwaggerProperties;
import lombok.RequiredArgsConstructor;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import springfox.documentation.spring.web.plugins.ApiSelectorBuilder;
import springfox.documentation.spring.web.plugins.Docket;
/**
* @author Hccake
* @version 1.0
* @date 2019/11/1 19:43
*/
@RequiredArgsConstructor
@EnableConfigurationProperties(SwaggerProperties.class)
public class SwaggerConfiguration {
private final SwaggerProperties swaggerProperties;
@Bean
@ConditionalOnMissingBean
public Docket api() {
DocketBuildHelper helper = new DocketBuildHelper(swaggerProperties);
// @formatter:off
// 1. 文档信息构建
Docket docket = new Docket(swaggerProperties.getDocumentationType().getType())
.host(swaggerProperties.getHost())
.apiInfo(helper.apiInfo())
.groupName(swaggerProperties.getGroupName())
.enable(swaggerProperties.getEnabled());
// 2. 安全配置
docket.securitySchemes(helper.securitySchema())
.securityContexts(helper.securityContext());
// 3. 文档筛选
String basePackage = swaggerProperties.getBasePackage();
ApiSelectorBuilder select = docket.select();
if(StrUtil.isEmpty(basePackage)){
select.apis(MultiRequestHandlerSelectors.any());
}else {
select.apis(MultiRequestHandlerSelectors.basePackage(basePackage));
}
select.paths(helper.paths()).build();
return docket;
// @formatter:on
}
}
| 643 |
874 | <reponame>orenmnero/lambda<filename>src/main/java/com/jnape/palatable/lambda/optics/lenses/MapLens.java
package com.jnape.palatable.lambda.optics.lenses;
import com.jnape.palatable.lambda.adt.Maybe;
import com.jnape.palatable.lambda.adt.hlist.Tuple2;
import com.jnape.palatable.lambda.functions.Fn1;
import com.jnape.palatable.lambda.functions.builtin.fn2.Filter;
import com.jnape.palatable.lambda.io.IO;
import com.jnape.palatable.lambda.optics.Iso;
import com.jnape.palatable.lambda.optics.Lens;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import static com.jnape.palatable.lambda.adt.Maybe.maybe;
import static com.jnape.palatable.lambda.functions.Effect.effect;
import static com.jnape.palatable.lambda.functions.builtin.fn2.Alter.alter;
import static com.jnape.palatable.lambda.functions.builtin.fn2.Map.map;
import static com.jnape.palatable.lambda.functions.builtin.fn2.ToCollection.toCollection;
import static com.jnape.palatable.lambda.functions.builtin.fn2.ToMap.toMap;
import static com.jnape.palatable.lambda.functions.specialized.SideEffect.sideEffect;
import static com.jnape.palatable.lambda.io.IO.io;
import static com.jnape.palatable.lambda.optics.Lens.Simple.adapt;
import static com.jnape.palatable.lambda.optics.Lens.lens;
import static com.jnape.palatable.lambda.optics.Lens.simpleLens;
import static com.jnape.palatable.lambda.optics.functions.View.view;
import static com.jnape.palatable.lambda.optics.lenses.MaybeLens.unLiftA;
import static com.jnape.palatable.lambda.optics.lenses.MaybeLens.unLiftB;
/**
* Lenses that operate on {@link Map}s.
*/
public final class MapLens {
private MapLens() {
}
/**
* A lens that focuses on a copy of a {@link Map} as a subtype <code>M</code>. Useful for composition to avoid
* mutating a map reference.
*
* @param <M> the map subtype
* @param <K> the key type
* @param <V> the value type
* @param copyFn the copy function
* @return a lens that focuses on copies of maps as a specific subtype
*/
public static <M extends Map<K, V>, K, V> Lens<Map<K, V>, M, M, M> asCopy(
Fn1<? super Map<K, V>, ? extends M> copyFn) {
return lens(copyFn, (__, copy) -> copy);
}
/**
* A lens that focuses on a copy of a Map. Useful for composition to avoid mutating a map reference.
*
* @param <K> the key type
* @param <V> the value type
* @return a lens that focuses on copies of maps
*/
public static <K, V> Lens.Simple<Map<K, V>, Map<K, V>> asCopy() {
return adapt(asCopy(HashMap::new));
}
/**
* A lens that focuses on a value at a key in a map, as a {@link Maybe}, and produces a subtype <code>M</code> on
* the way back out.
*
* @param copyFn the copy function
* @param k the key to focus on
* @param <M> the map subtype
* @param <K> the key type
* @param <V> the value type
* @return a lens that focuses on the value at key, as a {@link Maybe}
*/
public static <M extends Map<K, V>, K, V> Lens<Map<K, V>, M, Maybe<V>, Maybe<V>> valueAt(
Fn1<? super Map<K, V>, ? extends M> copyFn, K k) {
return lens(m -> maybe(m.get(k)), (m, maybeV) -> maybeV
.<Fn1<M, IO<M>>>fmap(v -> alter(effect(updated -> io(() -> updated.put(k, v)))))
.orElse(alter(updated -> io(sideEffect(() -> updated.remove(k)))))
.apply(copyFn.apply(m))
.unsafePerformIO());
}
/**
* A lens that focuses on a value at a key in a map, as a {@link Maybe}.
*
* @param <K> the key type
* @param <V> the value type
* @param k the key to focus on
* @return a lens that focuses on the value at key, as a {@link Maybe}
*/
public static <K, V> Lens.Simple<Map<K, V>, Maybe<V>> valueAt(K k) {
return adapt(valueAt(HashMap::new, k));
}
/**
* A lens that focuses on a value at a key in a map, falling back to <code>defaultV</code> if the value is missing.
* <p>
* Note that this lens is NOT lawful, since "putting back what you got changes nothing" fails for any value
* <code>B</code> where <code>S</code> is the empty map
*
* @param k the key to focus on
* @param defaultValue the default value to use in case of a missing value at key
* @param <K> the key type
* @param <V> the value type
* @return a lens that focuses on the value at the key
*/
public static <K, V> Lens.Simple<Map<K, V>, V> valueAt(K k, V defaultValue) {
return adapt(unLiftB(unLiftA(valueAt(k), defaultValue)));
}
/**
* A lens that focuses on the keys of a map.
*
* @param <K> the key type
* @param <V> the value type
* @return a lens that focuses on the keys of a map
*/
public static <K, V> Lens.Simple<Map<K, V>, Set<K>> keys() {
return simpleLens(m -> new HashSet<>(m.keySet()), (m, ks) -> {
HashSet<K> ksCopy = new HashSet<>(ks);
Map<K, V> updated = new HashMap<>(m);
Set<K> keys = updated.keySet();
keys.retainAll(ksCopy);
ksCopy.removeAll(keys);
ksCopy.forEach(k -> updated.put(k, null));
return updated;
});
}
/**
* A lens that focuses on the values of a map. In the case of updating the map, only the entries with a value listed
* in the update collection of values are kept.
* <p>
* Note that this lens is NOT lawful, since "you get back what you put in" fails for all values <code>B</code> that
* represent a non-surjective superset of the existing values in <code>S</code>.
*
* @param <K> the key type
* @param <V> the value type
* @return a lens that focuses on the values of a map
*/
public static <K, V> Lens.Simple<Map<K, V>, Collection<V>> values() {
return simpleLens(m -> new ArrayList<>(m.values()), (m, vs) -> {
Map<K, V> updated = new HashMap<>(m);
Set<V> valueSet = new HashSet<>(vs);
Set<K> matchingKeys = Filter.<Map.Entry<K, V>>filter(kv -> valueSet.contains(kv.getValue()))
.fmap(map(Map.Entry::getKey))
.fmap(toCollection(HashSet::new))
.apply(updated.entrySet());
updated.keySet().retainAll(matchingKeys);
return updated;
});
}
/**
* A lens that focuses on the inverse of a map (keys and values swapped). In the case of multiple equal values
* becoming keys, the last one wins.
* <p>
* Note that this lens is very likely to NOT be lawful, since "you get back what you put in" will fail for any keys
* that map to the same value.
*
* @param <K> the key type
* @param <V> the value type
* @return a lens that focuses on the inverse of a map
*/
public static <K, V> Lens.Simple<Map<K, V>, Map<V, K>> inverted() {
return simpleLens(m -> {
Map<V, K> inverted = new HashMap<>();
m.forEach((key, value) -> inverted.put(value, key));
return inverted;
}, (m, im) -> {
Map<K, V> updated = new HashMap<>(m);
updated.clear();
updated.putAll(view(inverted(), im));
return updated;
});
}
/**
* A lens that focuses on a map while mapping its values with the mapping {@link Iso}.
* <p>
* Note that for this lens to be lawful, <code>iso</code> must be lawful.
*
* @param iso the mapping {@link Iso}
* @param <K> the key type
* @param <V> the unfocused map value type
* @param <V2> the focused map value type
* @return a lens that focuses on a map while mapping its values
*/
public static <K, V, V2> Lens.Simple<Map<K, V>, Map<K, V2>> mappingValues(Iso<V, V, V2, V2> iso) {
return simpleLens(m -> toMap(HashMap::new, map(t -> t.biMapR(view(iso)), map(Tuple2::fromEntry, m.entrySet()))),
(s, b) -> view(mappingValues(iso.mirror()), b));
}
}
| 3,457 |
770 | <reponame>arthurmaciel/cyclone-bootstrap
/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
/*
* Copyright 2012 Couchbase, 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.
*/
#ifndef HASHSET_H
#define HASHSET_H 1
#include <stdlib.h>
#ifdef __cplusplus
extern "C" {
#endif
struct hashset_st {
size_t nbits;
size_t mask;
size_t capacity;
size_t *items;
size_t nitems;
size_t n_deleted_items;
};
typedef struct hashset_st *hashset_t;
/* create hashset instance */
hashset_t hashset_create(void);
/* destroy hashset instance */
void hashset_destroy(hashset_t set);
size_t hashset_num_items(hashset_t set);
/* add item into the hashset.
*
* @note 0 and 1 is special values, meaning nil and deleted items. the
* function will return -1 indicating error.
*
* returns zero if the item already in the set and non-zero otherwise
*/
int hashset_add(hashset_t set, void *item);
/* remove item from the hashset
*
* returns non-zero if the item was removed and zero if the item wasn't
* exist
*/
int hashset_remove(hashset_t set, void *item);
/* check if existence of the item
*
* returns non-zero if the item exists and zero otherwise
*/
int hashset_is_member(hashset_t set, void *item);
void hashset_to_array(hashset_t set, void **items);
#ifdef __cplusplus
}
#endif
#endif
| 752 |
317 | <gh_stars>100-1000
/* -------------------------------------------------------------------------------
Copyright 2000-2006 Adobe Systems Incorporated. All Rights Reserved.
NOTICE: Adobe permits you to use, modify, and distribute this file
in accordance with the terms of the Adobe license agreement accompanying
it. If you have received this file from a source other than Adobe, then
your use, modification, or distribution of it requires the prior written
permission of Adobe.
----------------------------------------------------------------------------------
File: IText.h
Notes: Machine Generated file from script version 1.45
Please don't modify manually!
---------------------------------------------------------------------------------- */
#pragma once
#include "ATESuites.h"
#include "ATEException.h"
#include "SloTextdomTypes.h"
namespace ATE
{
class IApplicationPaint;
class ICompFont;
class ICompFontClass;
class ICompFontClassSet;
class ICompFontComponent;
class ICompFontSet;
class IGlyphRun;
class IGlyphRunsIterator;
class IMojiKumi;
class IMojiKumiSet;
class ITextFrame;
class ITextFramesIterator;
class ITextLine;
class ITextLinesIterator;
class ITextResources;
class IApplicationTextResources;
class IDocumentTextResources;
class IVersionInfo;
class IArrayApplicationPaintRef;
class IArrayReal;
class IArrayBool;
class IArrayInteger;
class IArrayLineCapType;
class IArrayFigureStyle;
class IArrayLineJoinType;
class IArrayWariChuJustification;
class IArrayStyleRunAlignment;
class IArrayAutoKernType;
class IArrayBaselineDirection;
class IArrayLanguage;
class IArrayFontCapsOption;
class IArrayFontBaselineOption;
class IArrayFontOpenTypePositionOption;
class IArrayUnderlinePosition;
class IArrayStrikethroughPosition;
class IArrayParagraphJustification;
class IArrayArrayReal;
class IArrayBurasagariType;
class IArrayPreferredKinsokuOrder;
class IArrayKinsokuRef;
class IArrayMojiKumiRef;
class IArrayMojiKumiSetRef;
class IArrayTabStopsRef;
class IArrayLeadingType;
class IArrayFontRef;
class IArrayGlyphID;
class IArrayRealPoint;
class IArrayRealMatrix;
#if SLO_COMPLEXSCRIPT // Middle Eastern specific features only
class IArrayParagraphDirection;
class IArrayJustificationMethod;
class IArrayKashidaWidth;
class IArrayKashidas;
class IArrayDirOverride;
class IArrayDigitSet;
class IArrayDiacVPos;
#endif
class ICharFeatures;
class ICharInspector;
class ICharStyle;
class ICharStyles;
class ICharStylesIterator;
class IFind;
class IFont;
class IGlyph;
class IGlyphs;
class IGlyphsIterator;
class IKinsoku;
class IKinsokuSet;
class IParaFeatures;
class IParagraph;
class IParagraphsIterator;
class IParaInspector;
class IParaStyle;
class IParaStyles;
class IParaStylesIterator;
class ISpell;
class IStories;
class IStory;
class ITabStop;
class ITabStops;
class ITabStopsIterator;
class ITextRange;
class ITextRanges;
class ITextRangesIterator;
class ITextRunsIterator;
class IWordsIterator;
class IArrayLine;
class IArrayComposerEngine;
//////////////////////////////////////////////
// --IApplicationPaint--
//////////////////////////////////////////////
/** Encapsulates Illustrator-specific painting of
fill and stroke for text, as defined by
the \c #AIATEPaintSuite.
@see \c IArrayApplicationPaintRef */
class IApplicationPaint
{
private:
ApplicationPaintRef fApplicationPaint;
public:
/** Constructor
@return The new object. */
IApplicationPaint();
/** Copy constructor
@param src The object to copy.
@return The new object. */
IApplicationPaint(const IApplicationPaint& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
IApplicationPaint& operator=(const IApplicationPaint& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const IApplicationPaint& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const IApplicationPaint& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param applicationpaint The C object.
@return The new C++ object.
@return The new C++ object. */
explicit IApplicationPaint(ApplicationPaintRef applicationpaint);
/** Destructor */
virtual ~IApplicationPaint();
/** Retrieves a reference to this object.
@return The object reference. */
ApplicationPaintRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
};
//////////////////////////////////////////////
// --ICompFont--
//////////////////////////////////////////////
/** Encapsulates a composite font as a text resource. The methods allow you to
add, access, and manipulate fonts for use with the
Adobe Text Engine (ATE). This font contains \c ICompFontComponent
objects. */
class ICompFont
{
private:
CompFontRef fCompFont;
public:
/** Constructor
@return The new object. */
ICompFont();
/** Copy constructor
@param src The object to copy.
@return The new object. */
ICompFont(const ICompFont& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
ICompFont& operator=(const ICompFont& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const ICompFont& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const ICompFont& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param compfont The C object.
@return The new C++ object. */
explicit ICompFont(CompFontRef compfont);
/** Destructor */
virtual ~ICompFont();
/** Retrieves a reference to this object.
@return The object reference. */
CompFontRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
/** Constructor: Creates a composite font from a text resources object.
@param pResources The text resources object.
@return The new object. */
ICompFont( ITextResources pResources);
// =======================================================================
// PROPERTIES
// =======================================================================
/** Retrieves the platform-specific name of this font.
@param name A buffer in which to return the name string.
@param maxLength The number of characters in the passed buffer. The name is
truncated to this length if necessary.
@return Nothing.
*/
void GetNativeName( ATETextDOM::Unicode* name, ATETextDOM::Int32 maxLength) const;
/** Sets the platform-specific name of this font. The PostScript name is
automatically derived from this name.
@param name The new name string.
@return Nothing.
*/
void SetNativeName( const ATETextDOM::Unicode* name);
/** Retrieves the PostScript name of this font as Unicode.
@param name A Unicode character buffer in which to return the name string.
@param maxLength The number of characters in the passed buffer. The name is
truncated to this length if necessary.
@return Nothing.
*/
void GetPostScriptName( ATETextDOM::Unicode* name, ATETextDOM::Int32 maxLength) const;
/** Retrieves the PostScript name of this font as a C string.
@param name A \c char buffer in which to return the name string.
@param maxLength The number of characters in the passed buffer. The name is
truncated to this length if necessary.
@return Nothing.
*/
void GetPostScriptName( char* name, ATETextDOM::Int32 maxLength) const;
/** Sets the font dictionary for this font.
@param fontDictionary A pointer to the new dictionary.
@return Nothing.
@see \c #AIDictionarySuite
*/
void SetFontDictionary( void* fontDictionary);
/** Retrieves the font dictionary for this font.
@return A pointer to the dictionary..
@see \c #AIDictionarySuite
*/
void* GetFontDictionary( ) const;
// =======================================================================
// METHODS
// =======================================================================
/** Duplicates this font.
@return The new font object.
*/
ICompFont Duplicate( ) const;
/** Reports whether the resource been modified since it became editable.
@return True if the resource has been modified.
*/
bool IsModified( ) const;
/** Reports whether the resource is currently editable.
@return True if the resource is editable.
*/
bool IsEditable( ) const;
/** Reports whether changes to the resource have been committed.
@return True if changes have been committed.
*/
bool IsCommitted( ) const;
/** Reports whether the resource is in a valid state, either editable or committed.
@return True if the resource is in a valid state.
*/
bool VerifyState( ) const;
/** Reports whether the ATC file for the font is currently loaded.
@return True if the font file is loaded.
*/
bool IsATCFileLoaded( ) const;
/** Retrieves the number of components of this font. Use with
\c #GetComponent() to iterate through components.
@return The number of components.
*/
ATETextDOM::Int32 GetComponentCount( ) const;
/** Retrieves a component from this font by index position. Use with
\c #GetComponentCount() to iterate through components.
@param index The 0-based position index.
@return The component object.
*/
ICompFontComponent GetComponent( ATETextDOM::Int32 index) const;
/** Retrieves a specific component from this font.
@param component The component object.
@return The index position of the component, or -1 if the component
is not in this font.
*/
ATETextDOM::Int32 Find( ICompFontComponent component) const;
/** Removes a component from this font.
@param index The 0-based position index of the component to remove.
@return True if a component was successfully removed.
*/
bool RemoveComponent( ATETextDOM::Int32 index);
/** Appends a component to this font.
@param component The component object.
@return The 0-based position index of the successfully
added component, or -1 if the component could not be appended.
*/
ATETextDOM::Int32 AddComponent( ICompFontComponent component);
/** Replaces a component in this font.
@param index The 0-based position index of the component to replace.
@param component The replacement component object.
@return True if a component was successfully replaced.
*/
bool ReplaceComponent( ATETextDOM::Int32 index, ICompFontComponent component);
};
//////////////////////////////////////////////
// --ICompFontClass--
//////////////////////////////////////////////
/** Encapsulates a font character class as a text resource. The methods allow you to
add, access, and manipulate font classes for use with the
Adobe Text Engine (ATE). A font character class contains a collection of Unicode characters.
*/
class ICompFontClass
{
private:
CompFontClassRef fCompFontClass;
public:
/** Constructor
@return The new object. */
ICompFontClass();
/** Copy constructor
@param src The object to copy.
@return The new object. */
ICompFontClass(const ICompFontClass& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
ICompFontClass& operator=(const ICompFontClass& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const ICompFontClass& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const ICompFontClass& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param compfontclass The C object.
@return The new C++ object. */
explicit ICompFontClass(CompFontClassRef compfontclass);
/** Destructor */
virtual ~ICompFontClass();
/** Retrieves a reference to this object.
@return The object reference. */
CompFontClassRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
// =======================================================================
// PROPERTIES
// =======================================================================
/** Retrieves the platform-specific name of this font class.
@param name A buffer in which to return the name string.
@param maxLength The number of characters in the passed buffer. The name is
truncated to this length if necessary.
@return Nothing.
*/
void GetNativeName( ATETextDOM::Unicode* name, ATETextDOM::Int32 maxLength) const;
/** Sets the platform-specific name of this font.
@param name The new name string.
@return Nothing.
*/
void SetNativeName( const ATETextDOM::Unicode* name);
/** Retrieves the Unicode character codes that belong to this class.
@param codes A buffer in which to return the character codes.
@param maxLength The number of characters in the passed buffer. The return
string (including the terminating 0) is truncated to this length if necessary.
@return The number of character codes written to the buffer, including the terminating 0.
*/
ATETextDOM::Int32 GetCodes( ATETextDOM::Unicode* codes, ATETextDOM::Int32 maxLength) const;
/** Sets the Unicode character codes that belong to this class.
@param codes A buffer containing the new Unicode character codes.
@return The character code count, not include the terminating 0.
*/
ATETextDOM::Int32 SetCodes( const ATETextDOM::Unicode* codes);
// =======================================================================
// METHODS
// =======================================================================
/** Duplicates this font class.
@return The new font class object.
*/
ICompFontClass Duplicate( ) const;
/** Retrieves the number of characters in this font class.
@return The number of characters.
*/
ATETextDOM::Int32 GetCharacterCount( ) const;
/** Retrieves the type of this font class.
@return The class type constant.
*/
CompositeFontClassType GetClassType( ) const;
/** Reports whether a Unicode character is in this font class.
@param code The character code.
@return True if the code is part of this class.
*/
bool IsCodeInClass( ATETextDOM::Unicode code) const;
/** Reports whether the resource is currently editable.
@return True if the resource is editable.
@note Predefined classes are never editable.
*/
bool IsEditable( ) const;
/** Reports whether this is a custom override class or predefined class.
@return True if this is a custom override class, false if it is a predefined class.
@note Predefined classes are never editable.
*/
bool IsCustomOverride( ) const;
/** Reports whether the resource been modified since it became editable.
@return True if the resource has been modified.
*/
bool IsModified( ) const;
/** Reports whether the resource is in a valid state, either editable or committed.
@return True if the resource is in a valid state.
*/
bool VerifyState( ) const;
};
//////////////////////////////////////////////
// --ICompFontClassSet--
//////////////////////////////////////////////
/** Encapsulates a font class set as a text resource. The methods allow you to
add, access, and manipulate font class sets for use with the
Adobe Text Engine (ATE). A font class set contains a collection of \c ICompFontClass objects.
*/
class ICompFontClassSet
{
private:
CompFontClassSetRef fCompFontClassSet;
public:
/** Constructor
@return The new object. */
ICompFontClassSet();
/** Copy constructor
@param src The object to copy.
@return The new object. */
ICompFontClassSet(const ICompFontClassSet& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
ICompFontClassSet& operator=(const ICompFontClassSet& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const ICompFontClassSet& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const ICompFontClassSet& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param compfontclassset The C object.
@return The new C++ object. */
explicit ICompFontClassSet(CompFontClassSetRef compfontclassset);
/** Destructor */
virtual ~ICompFontClassSet();
/** Retrieves a reference to this object.
@return The object reference. */
CompFontClassSetRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
// =======================================================================
// PROPERTIES
// =======================================================================
/** Retrieves the number of members of this set.
@return The number of members.
*/
ATETextDOM::Int32 GetSize( ) const;
/** Retrieves the first member of this set.
@return The member object.
*/
ICompFontClass GetFirst( ) const;
/** Retrieves the last member of this set.
@return The member object.
*/
ICompFontClass GetLast( ) const;
// =======================================================================
// METHODS
// =======================================================================
/** Retrieves a member of this set by position index. Use with \c GetSize()
to iterate through members.
@param nIndex The 0-based position index.
@return The member object.
*/
ICompFontClass Item( ATETextDOM::Int32 nIndex) const;
/** Retrieves a specific font class from this set.
@param compFontClass The font class object.
@return The index position of the object in this set, or -1
if the object is not in this set.
*/
ATETextDOM::Int32 Find( ICompFontClass compFontClass) const;
/** Retrieves a specific predefined font class type from this set.
@param predefinedType The font class type.
@return The index position of the type in this set, or -1
if the type is not in this set.
*/
ATETextDOM::Int32 FindPredefined( CompositeFontClassType predefinedType) const;
};
//////////////////////////////////////////////
// --ICompFontComponent--
//////////////////////////////////////////////
/** Encapsulates a font component as a text resource. The methods allow you to
add, access, and manipulate font components for use with the
Adobe Text Engine (ATE). Font components belong to \c ICompFont objects.
See \c ICompFont::GetComponent() */
class ICompFontComponent
{
private:
CompFontComponentRef fCompFontComponent;
public:
/** Constructor
@return The new object. */
ICompFontComponent();
/** Copy constructor
@param src The object to copy.
@return The new object. */
ICompFontComponent(const ICompFontComponent& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
ICompFontComponent& operator=(const ICompFontComponent& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const ICompFontComponent& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const ICompFontComponent& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param compfontcomponent The C object.
@return The new C++ object. */
explicit ICompFontComponent(CompFontComponentRef compfontcomponent);
/** Destructor */
virtual ~ICompFontComponent();
/** Retrieves a reference to this object.
@return The object reference. */
CompFontComponentRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
/** Constructor: Creates a font component from a text resources object.
@param pResources The text resources object.
@return The new object. */
ICompFontComponent( ITextResources pResources);
// =======================================================================
// PROPERTIES
// =======================================================================
/** Retrieves the font class to which this component belongs.
@return The font class object.
*/
ICompFontClass GetClass( ) const;
/** Sets the font character class to which this component belongs.
@param charClass The font character class object.
@return Nothing.
*/
void SetClass( ICompFontClass charClass);
/** Retrieves the font to which this component belongs.
@return The font object.
*/
IFont GetFont( ) const;
/** Sets the font to which this component belongs.
@param font The font object.
@return Nothing.
*/
void SetFont( IFont font);
/** Retrieves the point size of this component.
@return The point size.
*/
ATETextDOM::Real GetSize( ) const;
/** Sets the point size of this component.
@param size The new point size.
*/
void SetSize( ATETextDOM::Real size);
/** Retrieves the baseline value of this component.
@return The baseline value.
*/
ATETextDOM::Real GetBaseline( ) const;
/** Sets the baseline value of this component.
@param baseline The new baseline value.
*/
void SetBaseline( ATETextDOM::Real baseline);
/** Retrieves the horizontal scaling factor of this component.
@return The horizontal scaling factor.
*/
ATETextDOM::Real GetHorizontalScale( ) const;
/** Sets the horizontal scaling factor of this component.
@param horizontalScale The new horizontal scaling factor.
*/
void SetHorizontalScale( ATETextDOM::Real horizontalScale);
/** Retrieves the vertical scaling factor of this component.
@return The vertical scaling factor.
*/
ATETextDOM::Real GetVerticalScale( ) const;
/** Sets the vertical scaling factor of this component.
@param verticalScale The new vertical scaling factor.
*/
void SetVerticalScale( ATETextDOM::Real verticalScale);
/** Reports the centering state of this component.
@return True if centering is on.
*/
bool GetCenterGlyph( ) const;
/** Sets the centering state of this component.
@param centerglyph True to turn centering on, false to turn it off
@return Nothing
*/
void SetCenterGlyph( bool centerglyph);
// =======================================================================
// METHODS
// =======================================================================
/** Reports whether the resource been modified since it became editable.
@return True if the resource has been modified.
*/
bool IsModified( ) const;
};
//////////////////////////////////////////////
// --ICompFontSet--
//////////////////////////////////////////////
/** Encapsulates a composite font set as a text resource. The methods allow you to
add, access, and manipulate font sets for use with the
Adobe Text Engine (ATE). A font set contains a collection of \c ICompFont objects.
*/
class ICompFontSet
{
private:
CompFontSetRef fCompFontSet;
public:
/** Constructor
@return The new object. */
ICompFontSet();
/** Copy constructor
@param src The object to copy.
@return The new object. */
ICompFontSet(const ICompFontSet& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
ICompFontSet& operator=(const ICompFontSet& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const ICompFontSet& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const ICompFontSet& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param compfontset The C object.
@return The new C++ object. */
explicit ICompFontSet(CompFontSetRef compfontset);
/** Destructor */
virtual ~ICompFontSet();
/** Retrieves a reference to this object.
@return The object reference. */
CompFontSetRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
// =======================================================================
// PROPERTIES
// =======================================================================
/** Retrieves the number of members of this set.
@return The number of members.
*/
ATETextDOM::Int32 GetSize( ) const;
/** Retrieves the first member of this set.
@return The member object.
*/
ICompFont GetFirst( ) const;
/** Retrieves the last member of this set.
@return The member object.
*/
ICompFont GetLast( ) const;
// =======================================================================
// METHODS
// =======================================================================
/** Retrieves a member of this set by position index. Use with \c GetSize()
to iterate through members.
@param nIndex The 0-based position index.
@return The member object.
*/
ICompFont Item( ATETextDOM::Int32 nIndex) const;
/** Retrieves a specific font from this set.
@param font The font object.
@return The index position of the object in this set, or -1
if the object is not in this set.
*/
ATETextDOM::Int32 Find( ICompFont font) const;
/** Removes a member font from this font set.
@param nIndex The 0-based position index of the font to remove.
@return True if a font was successfully removed.
*/
bool Remove( ATETextDOM::Int32 nIndex);
/** Appends a font to this font set.
@param font The font object.
@return The 0-based position index of the successfully
added font, or -1 if the font could not be appended.
*/
ATETextDOM::Int32 Add( ICompFont font);
/** Replaces a font in this set.
@param nIndex The 0-based position index of the font to replace.
@param newFont The replacement font object.
@return True if a font was successfully replaced.
*/
bool Replace( ATETextDOM::Int32 nIndex, ICompFont newFont);
/** Updates this font set to reflect what is currently in the
document font resource's font set. This can invalidate
previously saved font indices.
@return Nothing.
*/
void Update( ) const;
};
//////////////////////////////////////////////
// --IGlyphRun--
//////////////////////////////////////////////
/** Encapsulates a glyph run as a text resource. The methods allow you to
add, access, and manipulate glyph runs for use with the
Adobe Text Engine (ATE). A glyph run belongs to a \c ITextLine object.
It contains a string of characters, along with drawing information
for them.
*/
class IGlyphRun
{
private:
GlyphRunRef fGlyphRun;
public:
/** Constructor
@return The new object. */
IGlyphRun();
/** Copy constructor
@param src The object to copy.
@return The new object. */
IGlyphRun(const IGlyphRun& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
IGlyphRun& operator=(const IGlyphRun& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const IGlyphRun& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const IGlyphRun& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param glyphrun The C object.
@return The new C++ object. */
explicit IGlyphRun(GlyphRunRef glyphrun);
/** Destructor */
virtual ~IGlyphRun();
/** Retrieves a reference to this object.
@return The object reference. */
GlyphRunRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
// =======================================================================
// METHODS
// =======================================================================
/** Retrieves the text-line parent of this glyph run.
@return The text-line object.
*/
ITextLine GetTextLine( ) const;
/** Retrieves the number of glyphs in this run.
The number of the glyphs can be different from number of characters returned
by \c #GetCharacterCount(), because of factors such ligature and hyphenation.
@return The number of glyphs.
*/
ATETextDOM::Int32 GetSize( ) const;
/** Retrieves the number of characters in this run. Use to determine
the size of buffer to pass to \c #GetContents().
@return The number of characters.
@see \c #GetSize()
*/
ATETextDOM::Int32 GetCharacterCount( ) const;
/** Retrieves the origin points of each glyph in this run.
@return The array of origin points.
*/
IArrayRealPoint GetOrigins( ) const;
/** Retrieves the unique identifiers of each glyph in this run.
@return The array of identifiers.
*/
IArrayGlyphID GetGlyphIDs( ) const;
/** Retrieves the transformation matrix of this run, which
specifies the full transformation. To get the location of
an individual glyph, you must transform the origin by the value
in the \c #GetOrigins() array, then concatinate this matrix with
the text frame matrix, returned by \c ITextFrame::GetMatrix().
@return The transformation matrix.
*/
ATETextDOM::RealMatrix GetMatrix( ) const;
/** Retrieves the character features of this run.
Only the following members are defined:
<br>\c Font
<br>\c FontSize
<br>\c HorizontalScale
<br>\c VerticalScale
<br>\c Tracking
<br>\c BaselineShift
<br>\c FillColor
<br>\c StrokeColor
<br>\c fBlend
<br>\c Fill
<br>\c Stroke
<br>\c FillFirst
<br>\c FillOverPrint
<br>\c StrokeOverPrint
<br>\c FillBackgroundColor
<br>\c FillBackground
<br>\c LineCap
<br>\c LineJoin
<br>\c LineWidth
<br>\c MiterLimit
<br>\c LineDashOffset
<br>\c LineDashArray
@return The character features object.
*/
ICharFeatures GetCharFeatures( ) const;
/** Retrieves the glyph orientation of this run.
@return The orientation constant.
*/
GlyphOrientation GetGlyphOrientation( ) const;
/** Retrieves the ascent of this run.
@return The ascent value, in document points.
*/
ATETextDOM::Real GetAscent( ) const;
/** Retrieves the descent of this run.
@return The descent value, in document points.
*/
ATETextDOM::Real GetDescent( ) const;
/** Retrieves the tracking (space between each character) of this run,
@return The tracking value, in document points.
*/
ATETextDOM::Real GetTracking( ) const;
/** Retrieves the width of the space glyph in the font for this run.
@return The width value, in document points.
*/
ATETextDOM::Real GetSpaceGlyphWidth( ) const;
/** Retrieves the distance to the baseline in the font for this run.
@return The distance value, in document points.
*/
ATETextDOM::Real GetDistanceToBaseline( ) const;
/** Retrieves the underline position in the font for this run.
@return The position value, in document points.
*/
ATETextDOM::Real GetUnderlinePosition( ) const;
/** Retrieves the underline thickness in the font for this run.
@return The thickness value, in document points.
*/
ATETextDOM::Real GetUnderlineThickness( ) const;
/** Retrieves the maximum height for capital letters in the font for this run.
@return The height value, in document points.
*/
ATETextDOM::Real GetMaxCapHeight( ) const;
/** Retrieves the minimum height for capital letters in the font for this run.
@return The height value, in document points.
*/
ATETextDOM::Real GetMinCapHeight( ) const;
/** Retrieves the component font for this run if the character-feature font is
a composite font, otherwise retrieves the character-feature font.
@return The font object.
*/
IFont GetFlattenedFont( ) const;
/** Retrieves the contents of this run as a Unicode string.
@param text [out] A buffer in which to return the string.
@param maxLength The number of characters in the buffer.
Use \c #GetCharacterCount() to determine what size is needed.
@return The number of characters written to the text buffer.
*/
ATETextDOM::Int32 GetContents( ATETextDOM::Unicode* text, ATETextDOM::Int32 maxLength) const;
/** Retrieves the contents of this run as a C string.
@param text [out] A buffer in which to return the string.
@param maxLength The number of characters in the buffer.
Use \c #GetCharacterCount() to determine what size is needed.
@return The number of characters written to the text buffer.
*/
ATETextDOM::Int32 GetContents( char* text, ATETextDOM::Int32 maxLength) const;
};
//////////////////////////////////////////////
// --IGlyphRunsIterator--
//////////////////////////////////////////////
/** This object enables you to iterate through the set of
glyph runs in the current document.
@see \c IGlyphRun.
*/
class IGlyphRunsIterator
{
private:
GlyphRunsIteratorRef fGlyphRunsIterator;
public:
/** Constructor
@return The new object. */
IGlyphRunsIterator();
/** Copy constructor
@param src The object to copy.
@return The new object. */
IGlyphRunsIterator(const IGlyphRunsIterator& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
IGlyphRunsIterator& operator=(const IGlyphRunsIterator& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const IGlyphRunsIterator& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const IGlyphRunsIterator& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param glyphrunsiterator The C object.
@return The new C++ object. */
explicit IGlyphRunsIterator(GlyphRunsIteratorRef glyphrunsiterator);
/** Destructor */
virtual ~IGlyphRunsIterator();
/** Retrieves a reference to this object.
@return The object reference. */
GlyphRunsIteratorRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
// =======================================================================
// METHODS
// =====================================================================
/** Reports whether the end of the set has been reached.
@return True if more members remain in the set. */
bool IsNotDone( ) const;
/** Reports whether the end of the set has been reached.
@return True if no more members remain in the set. */
bool IsDone( ) const;
/** Increments the current position in the set in the iterator's current direction.
@return Nothing. */
void Next( );
/** Retrieves the current glyph run.
@return The glyph run object. */
IGlyphRun Item( ) const;
};
//////////////////////////////////////////////
// --IMojiKumi--
//////////////////////////////////////////////
/** Encapsulates the MojiKumi characteristics of a character as a text resource.
The methods allow you to add, access, and manipulate MojiKumi for use with the
Adobe Text Engine (ATE). These objects are collected in an \c IMojiKumiSet.
*/
class IMojiKumi
{
private:
MojiKumiRef fMojiKumi;
public:
/** Constructor
@return The new object. */
IMojiKumi();
/** Copy constructor
@param src The object to copy.
@return The new object. */
IMojiKumi(const IMojiKumi& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
IMojiKumi& operator=(const IMojiKumi& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const IMojiKumi& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const IMojiKumi& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param mojikumi The C object.
@return The new C++ object. */
explicit IMojiKumi(MojiKumiRef mojikumi);
/** Destructor */
virtual ~IMojiKumi();
/** Retrieves a reference to this object.
@return The object reference. */
MojiKumiRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
// =======================================================================
// PROPERTIES
// =======================================================================
/** Retrieves the name of this object.
@param name [out] A Unicode string in which to return the name.
@param maxLength The number of characters in the buffer.
Use \c #GetNameSize() to determine the size needed.
@return The number of characters written to the buffer.
*/
ATETextDOM::Int32 GetName( ATETextDOM::Unicode * name, ATETextDOM::Int32 maxLength) const;
/** Retrieves the number of characters in the name of this object. Use to
determine the size of buffer to pass to \c #GetName().
@return The number of characters in the name.
*/
ATETextDOM::Int32 GetNameSize( ) const;
/** Sets the name of this object.
@param name A Unicode string containing the new name.
@return Nothing.
*/
void SetName( const ATETextDOM::Unicode * name);
/** Reports whether this object matches a predefined tag in the
MojiKumi table.
@param tag The tag object.
@return True if this object matches the tag.
*/
bool MatchesPredefinedResourceTag( ATE::MojikumiTablePredefinedTag tag) const;
/** Retrieves a MojiKumi table entry from this object.
@param index The 0-based position index for the entry.
@param minExpansion [out] A buffer in which to return the maximum expansion value.
@param maxExpansion [out] A buffer in which to return the minimum expansion value.
@param desiredExpansion [out] A buffer in which to return the desired expansion value.
@return Nothing.
*/
void GetEntry( ATETextDOM::Int32 index, ATETextDOM::Float * minExpansion, ATETextDOM::Float * maxExpansion, ATETextDOM::Float * desiredExpansion) const;
/** Sets a MojiKumi table entry from this object.
@param index The 0-based position index for the entry.
@param minExpansion The new maximum expansion value.
@param maxExpansion The new minimum expansion value.
@param desiredExpansion The new desired expansion value.
@return Nothing.
*/
void SetEntry( ATETextDOM::Int32 index, ATETextDOM::Real minExpansion, ATETextDOM::Real maxExpansion, ATETextDOM::Real desiredExpansion);
// =======================================================================
// METHODS
// =======================================================================
/** Reports whether this object is equivalent to another MojiKumi object.
@param rhsMojiKumi The other MojiKumi object.
@return True if the objects are equivalent.
*/
bool IsEquivalent( IMojiKumi rhsMojiKumi) const;
/** Reports whether the resource been modified since it became editable.
@return True if the resource has been modified.
*/
bool IsModified( ) const;
/** Reports whether this is a predefined MojiKumi.
@return True if the MojiKumi is predefined, false if it is customized.
*/
bool IsPredefined( ) const;
/** Creates a new object by duplicating the information in this one.
@return The new object
*/
IMojiKumi Duplicate( ) const;
};
//////////////////////////////////////////////
// --IMojiKumiSet--
//////////////////////////////////////////////
/** Encapsulates a MojiKumi set as a text resource. The methods allow you to
add, access, and manipulate MojiKumi sets for use with the
Adobe Text Engine (ATE). The set contains \c IMojiKumi objects.
*/
class IMojiKumiSet
{
private:
MojiKumiSetRef fMojiKumiSet;
public:
/** Constructor
@return The new object. */
IMojiKumiSet();
/** Copy constructor
@param src The object to copy.
@return The new object. */
IMojiKumiSet(const IMojiKumiSet& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
IMojiKumiSet& operator=(const IMojiKumiSet& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const IMojiKumiSet& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const IMojiKumiSet& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param mojikumiset The C object.
@return The new C++ object. */
explicit IMojiKumiSet(MojiKumiSetRef mojikumiset);
/** Destructor */
virtual ~IMojiKumiSet();
/** Retrieves a reference to this object.
@return The object reference. */
MojiKumiSetRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
// =======================================================================
// PROPERTIES
// =======================================================================
/** Retrieves the number of members of this set.
@return The number of members. */
ATETextDOM::Int32 GetSize( );
/** Retrieves the first member of this set.
@return The member object. */
IMojiKumi GetFirst( );
/** Retrieves the last member of this set.
@return The member object. */
IMojiKumi GetLast( );
// =======================================================================
// METHODS
// =======================================================================
/** Retrieves a member of this set by position index. Use with \c GetSize()
to iterate through members.
@param nIndex The 0-based position index.
@return The member object.
*/
IMojiKumi Item( ATETextDOM::Int32 nIndex) const;
/** Retrieves a specific MojiKumi object from this set, matching name and data.
@param mojiKumi The MojiKumi object.
@return The index position of the object in this set, or -1
if the object is not in this set.
*/
ATETextDOM::Int32 Find( const IMojiKumi mojiKumi);
/** Retrieves a specific MojiKumi object from this set, matching only the name.
@param name The object name.
@return The index position of the object in this set, or -1
if the object is not in this set.
*/
ATETextDOM::Int32 Find( const ATETextDOM::Unicode* name);
/** Retrieves a specific MojiKumi object from this set, matching a tag.
@param tag The tag. Use \c #kUserDefinedMojikumiTableTag to get the first
customized (not predefined) MojiKumi.
@return The index position of the object in this set, or -1
if the object is not in this set.
*/
ATETextDOM::Int32 Find( MojikumiTablePredefinedTag tag);
/** Removes a member MojiKumi from this set.
@param nIndex The 0-based position index of the MojiKumi to remove.
@return True if a MojiKumi was successfully removed.
*/
bool Remove( ATETextDOM::Int32 nIndex);
/** Appends a MojiKumi to this set.
@param mojiKumi The MojiKumi object.
@return The 0-based position index of the successfully
added object, or the current index of this object
if it is already in the set, or -1 if the object
was not in the set and could not be appended.
*/
ATETextDOM::Int32 Add( IMojiKumi mojiKumi);
/** Replaces a MojiKumi in this set.
@param nIndex The 0-based position index of the MojiKumi to replace.
@param mojiKumi The replacement MojiKumi object.
@return True if an object was successfully replaced.
*/
bool Replace( ATETextDOM::Int32 nIndex, IMojiKumi mojiKumi);
/** Creates a new, empty MojiKumi object and appends it to this set.
@param name The name of the new object.
@param nIndex [out] A buffer in which to return the
0-based position index of the successfully
added object, or -1 if it could not be added.
@return The new object, or a \c NULL object
if the MojiKumi could not be created.
*/
IMojiKumi CreateNewMojiKumi( const ATETextDOM::Unicode* name, ATETextDOM::Int32* nIndex);
};
//////////////////////////////////////////////
// --ITextFrame--
//////////////////////////////////////////////
/** This class encapsulates a text frame, which manages the layout
of a text range into rows and columns. The methods allow you to
add, access, and manipulate text frames for use with the
Adobe Text Engine (ATE). The frame is associated with an \c ITextRange,
and contains \c ITextLine objects representing rows of text, which you can
access through an \c ITextLinesIterator. A text frame can be part
of an \c IStory. */
class ITextFrame
{
private:
TextFrameRef fTextFrame;
public:
/** Constructor
@return The new object. */
ITextFrame();
/** Copy constructor
@param src The object to copy.
@return The new object. */
ITextFrame(const ITextFrame& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
ITextFrame& operator=(const ITextFrame& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const ITextFrame& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const ITextFrame& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param textframe The C object.
@return The new C++ object. */
explicit ITextFrame(TextFrameRef textframe);
/** Destructor */
virtual ~ITextFrame();
/** Retrieves a reference to this object.
@return The object reference. */
TextFrameRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
// =======================================================================
// METHODS
// =====================================================================
/** Retrieves the parent story of this text frame.
@return The story object.
*/
IStory GetStory( ) const;
/** Retrieves the text range of this frame.
@param bIncludeOverflow Optional. When true (the default), if
the frame is the last one in its story, the range includes any
overflow text. When false, overflow text is not included.
@return The text range object.
*/
ITextRange GetTextRange( bool bIncludeOverflow = true) const;
/** Retrieves a text-line iterator with which you can access
the text lines of this text frame.
@return The text-line iterator object.
*/
ITextLinesIterator GetTextLinesIterator( ) const;
/** Retrieves the type of this text frame.
@return The type constant.
*/
FrameType GetType( ) const;
/** Retrieves the line orientation of this text frame.
@return The line orientation constant.
*/
LineOrientation GetLineOrientation( ) const;
/** Reports whether this frame is selected. Use the \c #AIArtSuite
to set the selection.
@return True if the text frame is selected.
*/
bool GetSelected( ) const;
/** Retrieves the transformation matrix of this text frame.
@return The transformation matrix.
*/
ATETextDOM::RealMatrix GetMatrix( ) const;
/** Retrieves the number of rows for this text frame.
@return The number of rows.
*/
ATETextDOM::Int32 GetRowCount( ) const;
/** Retrieves the number of columns for this text frame.
@return The number of columns.
*/
ATETextDOM::Int32 GetColumnCount( ) const;
/** Reports whether the text range is arranged in row-major order.
@return True if the text frame is in row-major order.
*/
bool GetRowMajorOrder( ) const;
/** Retrieves the row gutter value for this text frame.
@return The row gutter value, in document points.
*/
ATETextDOM::Real GetRowGutter( ) const;
/** Retrieves the column gutter value for this text frame.
@return The column gutter value, in document points.
*/
ATETextDOM::Real GetColumnGutter( ) const;
/** Retrieves the line spacing value for this text frame.
@return The line spacing value, in document points.
*/
ATETextDOM::Real GetSpacing( ) const;
/** Reports whether optical alignment is on for this text frame
@return True if optical alignment is on.
*/
bool GetOpticalAlignment( ) const;
#if SLO_COMPLEXSCRIPT // Middle Eastern specific features only
/** Retrieves the paragraph direction for this text frame.
@return The paragraph direction object.
*/
ParagraphDirection GetStoryDirection( ) const;
#endif
/** Sets the number of rows for this text frame.
@param rowCount The number of rows.
@return Nothing.
*/
void SetRowCount( ATETextDOM::Int32 rowCount);
/** Sets the number of columns for this text frame.
@param columnCount The number of columns.
@return Nothing.
*/
void SetColumnCount( ATETextDOM::Int32 columnCount);
/** Turns row-major order on or off for this text frame.
@param isRowMajor True to turn row-major order on,
false to turn it off.
@return Nothing.
*/
void SetRowMajorOrder( bool isRowMajor);
/** Sets the row gutter value for this text frame.
@param gutter The new row-gutter value in document points.
@return Nothing.
*/
void SetRowGutter( ATETextDOM::Real gutter);
/** Sets the column gutter value for this text frame.
@param gutter The new column-gutter value in document points.
@return Nothing.
*/
void SetColumnGutter( ATETextDOM::Real gutter);
/** Sets the line spacing value for this text frame.
@param spacing The new line spacing value in document points.
@return Nothing.
*/
void SetSpacing( ATETextDOM::Real spacing);
/** Turns optical alignment on or off for this text frame.
@param isActive True to turn optical alignment on,
false to turn it off.
@return Nothing.
*/
void SetOpticalAlignment( bool isActive);
/** Sets the line orientation value for this text frame.
@param lineOrientation The new line orientation constant.
@return Nothing.
*/
void SetLineOrientation( LineOrientation lineOrientation);
#if SLO_COMPLEXSCRIPT // Middle Eastern specific features only
/** Sets the paragragh direction for this text frame.
@param direction The paragraph direction.
@return Nothing.
*/
void SetStoryDirection( ParagraphDirection direction);
#endif
};
//////////////////////////////////////////////
// --ITextFramesIterator--
//////////////////////////////////////////////
/** This object enables you to iterate through the set of
text frames in the current document.
@see \c ITextFrame. */
class ITextFramesIterator
{
private:
TextFramesIteratorRef fTextFramesIterator;
public:
/** Constructor
@return The new object. */
ITextFramesIterator();
/** Copy constructor
@param src The object to copy.
@return The new object. */
ITextFramesIterator(const ITextFramesIterator& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
ITextFramesIterator& operator=(const ITextFramesIterator& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const ITextFramesIterator& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const ITextFramesIterator& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param textframesiterator The C object.
@return The new C++ object. */
explicit ITextFramesIterator(TextFramesIteratorRef textframesiterator);
/** Destructor */
virtual ~ITextFramesIterator();
/** Retrieves a reference to this object.
@return The object reference. */
TextFramesIteratorRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
/** Constructor. Creates an iterator for the text frames
contained in a text range.
@param range The text range object.
@return The new iterator object.
*/
ITextFramesIterator( const ITextRange& range);
// =======================================================================
// METHODS
// =====================================================================
/** Reports whether the end of the set has been reached.
@return True if more members remain in the set. */
bool IsNotDone( ) const;
/** Reports whether the end of the set has been reached.
@return True if no more members remain in the set. */
bool IsDone( ) const;
/** Reports whether the set is empty.
@return True if the set is empty. */
bool IsEmpty( ) const;
/** Increments the current position in the set in the iterator's current direction.
@return Nothing. */
void Next( );
/** Decrements the current position in the set.
@return Nothing. */
void Previous( );
/** Retrieves the current text frame.
@return The text frame object. */
ITextFrame Item( ) const;
};
//////////////////////////////////////////////
// --ITextLine--
//////////////////////////////////////////////
/** This class encapsulates a line of text in a text frame.
The line is part of an \c ITextFrame, contains \c IGlyphRun
objects that you can access with an \c IGlyphRunIterator,
and is associated with an \c ITextRange.
@see \c ITextFrame::GetTextLinesIterator() */
class ITextLine
{
private:
TextLineRef fTextLine;
public:
/** Constructor
@return The new object. */
ITextLine();
/** Copy constructor
@param src The object to copy.
@return The new object. */
ITextLine(const ITextLine& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
ITextLine& operator=(const ITextLine& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const ITextLine& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const ITextLine& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param textline The C object.
@return The new C++ object. */
explicit ITextLine(TextLineRef textline);
/** Destructor */
virtual ~ITextLine();
/** Retrieves a reference to this object.
@return The object reference. */
TextLineRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
// =======================================================================
// METHODS
// =======================================================================
/** Retrieves a glyph-run iterator with which you can access
the glyph runs of this line.
@return The glyph-run iterator object.
@see GetVisualGlyphRunsIterator()
*/
IGlyphRunsIterator GetGlyphRunsIterator( ) const;
/** Retrieves a glyph-run iterator with which you can access
the glyph runs of this line, handling the special case of text that
contains a mixture of left-to-right (LTR) and right-to-left (RTL)
text. If this case is not expected, use \c #GetGlyphRunsIterator().
@return The glyph-run iterator object.
@see GetGlyphRunsIterator() */
IGlyphRunsIterator GetVisualGlyphRunsIterator( ) const;
/** Retrieves the parent text frame of this line.
@return The text frame object.
*/
ITextFrame GetTextFrame( ) const;
/** Retrieves the text range for this line.
@return The text range object.
*/
ITextRange GetTextRange( ) const;
/** Retrieves an array of baselines (IArrayLine) specified by a
start and end point in the coordinate space of the containing text frame.
An array is required since each composed line can contain several segments
due to intrusions such as text wraps and Japanese features such as warichu.
@return The array of baselines.
*/
IArrayLine GetBaselines() const;
};
//////////////////////////////////////////////
// --ITextLinesIterator--
//////////////////////////////////////////////
/** This object enables you to iterate through the set of
text lines in a text frame.
@see \c ITextFrame::GetTextLinesIterator() */
class ITextLinesIterator
{
private:
TextLinesIteratorRef fTextLinesIterator;
public:
/** Constructor
@return The new object. */
ITextLinesIterator();
/** Copy constructor
@param src The object to copy.
@return The new object. */
ITextLinesIterator(const ITextLinesIterator& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
ITextLinesIterator& operator=(const ITextLinesIterator& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const ITextLinesIterator& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const ITextLinesIterator& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param textlinesiterator The C object.
@return The new C++ object. */
explicit ITextLinesIterator(TextLinesIteratorRef textlinesiterator);
/** Destructor */
virtual ~ITextLinesIterator();
/** Retrieves a reference to this object.
@return The object reference. */
TextLinesIteratorRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
// =======================================================================
// METHODS
// =======================================================================
/** Reports whether the end of the set has been reached.
@return True if more members remain in the set. */
bool IsNotDone( ) const;
/** Reports whether the end of the set has been reached.
@return True if no more members remain in the set. */
bool IsDone( ) const;
/** Reports whether the set is empty.
@return True if the set is empty. */
bool IsEmpty( ) const;
/** Increments the current position in the set in the iterator's current direction.
@return Nothing. */
void Next( );
/** Decrements the current position in the set.
@return Nothing. */
void Previous( );
/** Retrieves the current text line.
@return The text line object. */
ITextLine Item( ) const;
};
//////////////////////////////////////////////
// --ITextResources--
//////////////////////////////////////////////
/** Parent class for \c IApplicationTextResources
and \c IDocumentTextResources */
class ITextResources
{
private:
TextResourcesRef fTextResources;
public:
ITextResources();
ITextResources(const ITextResources& src);
ITextResources& operator=(const ITextResources& rhs);
bool operator==(const ITextResources& rhs) const;
bool operator!=(const ITextResources& rhs) const;
explicit ITextResources(TextResourcesRef textresources);
virtual ~ITextResources();
TextResourcesRef GetRef() const;
bool IsNull() const;
ITextResources GetTextResources( );
};
//////////////////////////////////////////////
// --IApplicationTextResources--
//////////////////////////////////////////////
/** Parent class for \c IDocumentTextResources */
class IApplicationTextResources
{
private:
ApplicationTextResourcesRef fApplicationTextResources;
public:
/** Constructor
@return The new object. */
IApplicationTextResources();
/** Copy constructor
@param src The object to copy.
@return The new object. */
IApplicationTextResources(const IApplicationTextResources& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
IApplicationTextResources& operator=(const IApplicationTextResources& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const IApplicationTextResources& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const IApplicationTextResources& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param applicationtextresources The C object.
@return The new C++ object. */
explicit IApplicationTextResources(ApplicationTextResourcesRef applicationtextresources);
/** Destructor */
virtual ~IApplicationTextResources();
/** Retrieves a reference to this object.
@return The object reference. */
ApplicationTextResourcesRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
// From parent class...
ITextResources GetTextResources( );
// =======================================================================
// PROPERTIES
// =======================================================================
IKinsokuSet GetKinsokuSet( ) const;
IMojiKumiSet GetMojiKumiSet( ) const;
ICompFontClassSet GetCompFontClassSet( ) const;
ICompFontSet GetCompFontSet( ) const;
};
//////////////////////////////////////////////
// --IDocumentTextResources--
//////////////////////////////////////////////
/** This object encapsulates the text resources of a document.
Text resources include fonts, character and paragraph styles,
and various text preferences. */
class IDocumentTextResources
{
private:
DocumentTextResourcesRef fDocumentTextResources;
public:
/** Constructor
@return The new object. */
IDocumentTextResources();
/** Copy constructor
@param src The object to copy.
@return The new object. */
IDocumentTextResources(const IDocumentTextResources& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
IDocumentTextResources& operator=(const IDocumentTextResources& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const IDocumentTextResources& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const IDocumentTextResources& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param documenttextresources The C object.
@return The new C++ object. */
explicit IDocumentTextResources(DocumentTextResourcesRef documenttextresources);
/** Destructor */
virtual ~IDocumentTextResources();
/** Retrieves a reference to this object.
@return The object reference. */
DocumentTextResourcesRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
// From parent class...
/** Retrieves the Kinsoku set for the document.
@return The Kinsoku set object.
*/
IKinsokuSet GetKinsokuSet( ) const;
/** Retrieves the MojiKumi set for the document.
@return The MojiKumi set object.
*/
IMojiKumiSet GetMojiKumiSet( ) const;
/** Retrieves the composite font class set for the document.
@return The composite font class set object.
*/
ICompFontClassSet GetCompFontClassSet( ) const;
/** Retrieves the composite font set for the document.
@return The composite font set object.
*/
ICompFontSet GetCompFontSet( ) const;
/** Retrieves the text resources for the document.
@return The text resources object.
*/
ITextResources GetTextResources( );
/** Retrieves the search object for the document.
@return The search object.
*/
IFind GetFind( );
/** Retrieves the spell-check object for the document.
@return The spell-check object.
*/
ISpell GetSpell( );
/** Retrieves the glyph for the document.
@return The glyph object.
*/
IGlyph GetGlyphAndAlternates( ) const;
/** Retrieves the alternate glyph for the document.
@return The glyph object.
*/
IGlyph GetAlternateGlyph( ) const;
/** Inserts a new alternate glyph.
@param theCharacters The characters for which this glyph is an alternate.
@param glyphID The glyph identifier.
@param otFeatureArray An array of features.
@param otFeatureCount The size of the feature array.
@param otFeatureIndexArray A mapping of the glyph-feature array to the character features.
@param leaveSelected True to leave the character in the selected state.
@return Nothing.
*/
void InsertAlternateGlyph( const ATETextDOM::Unicode* theCharacters, const ATEGlyphID glyphID, const char* otFeatureArray, ATETextDOM::Int32 otFeatureCount, const ATETextDOM::Int32* otFeatureIndexArray, bool leaveSelected);
/** Retrieves the alternate glyphs for the document that are available
for selection.
@return The array of alternate glyphs. */
IArrayInteger GetAlternatesAvailableThroughoutSelection( ) const;
/** Retrieves the Japanese alternate-feature value for the document selection.
@param isFeature [out] A buffer in which to return true if the alternate is found.
@return The feature constant.
*/
JapaneseAlternateFeature GetJapaneseAlternateFeatureInSelection( bool* isFeature) const;
/** Sets the Japanese alternate-feature value for the document selection.
@param feature The feature constant.
@return Nothing.
*/
void SetJapaneseAlternateFeatureInSelection( JapaneseAlternateFeature feature);
/** Retrieves the character style set for the document.
@return The character style set object.
*/
ICharStyles GetCharStylesInDocument( ) const;
/** Retrieves the paragraph style set for the document.
@return The paragraph style set object.
*/
IParaStyles GetParaStylesInDocument( ) const;
/** Retrieves a specific character style from the style set for the document.
@param pName The style name.
@return The character style object.
*/
ICharStyle GetCharStyle( const ATETextDOM::Unicode* pName) const;
/** Retrieves a specific paragraph style from the style set for the document.
@param pName The style name.
@return The paragraph style object.
*/
IParaStyle GetParaStyle( const ATETextDOM::Unicode* pName) const;
/** Retrieves the normal character style for the document.
@return The character style object.
*/
ICharStyle GetNormalCharStyle( ) const;
/** Retrieves the normal paragraph style for the document.
@return The paragraph style object.
*/
IParaStyle GetNormalParaStyle( ) const;
/** Sets the normal character style for the document to the
application default.
@return Nothing.
*/
void ResetNormalCharStyle( );
/** Sets the normal paragraph style for the document to the
application default.
@return Nothing.
*/
void ResetNormalParaStyle( );
/** Creates a new, empty character style and adds it to the style set for the document.
@param pName The style name.
@return The character style object, or a null object if a style with
this name already exists, or if the name is an empty string. If
no style is created, the document style set remains unchanged.
*/
ICharStyle CreateCharStyle( const ATETextDOM::Unicode* pName);
/** Creates a new, empty paragraph style and adds it to the style set for the document.
@param pName The style name.
@return The paragraph style object, or a null object if a style with
this name already exists, or if the name is an empty string. If
no style is created, the document style set remains unchanged.
*/
IParaStyle CreateParaStyle( const ATETextDOM::Unicode* pName);
/** Creates a new character style with specified features
and adds it to the style set for the document.
@param pName The style name.
@param pFeatures The feature set for the new style.
@return The character style object, or a null object if a style with
this name already exists, or if the name is an empty string. If
no style is created, the document style set remains unchanged.
*/
ICharStyle CreateCharStyleWithFeatures( const ATETextDOM::Unicode* pName, ICharFeatures pFeatures);
/** Creates a new paragraph style with specified features
and adds it to the style set for the document.
@param pName The style name.
@param pFeatures The feature set for the new style.
@return The paragraph style object, or a null object if a style with
this name already exists, or if the name is an empty string. If
no style is created, the document style set remains unchanged.
*/
IParaStyle CreateParaStyleWithFeatures( const ATETextDOM::Unicode* pName, IParaFeatures pFeatures);
/** Removes a character style from the style set for the document.
@param pName The style name.
@return True if a style with this name is removed, false if no style
with this name is in the document, or if the name is an empty string.
*/
bool RemoveCharStyle( const ATETextDOM::Unicode* pName);
/** Removes a paragraph style from the style set for the document.
@param pName The style name.
@return True if a style with this name is removed, false if no style
with this name is in the document, or if the name is an empty string.
*/
bool RemoveParaStyle( const ATETextDOM::Unicode* pName);
/** Imports a set of character styles into this document
from another resource set.
@param pSrcResources The source text-resources object.
@return Nothing.
*/
void ImportCharStyles( ITextResources pSrcResources);
/** Imports a set of paragraph styles into this document
from another resource set.
@param pSrcResources The source text-resources object.
@return Nothing.
*/
void ImportParaStyles( ITextResources pSrcResources);
/** Turns smart-quotes on or off for this document.
@param smartQuotesAreOn True to turn smart-quotes on, false to turn them off.
@return Nothing
*/
void SetUseSmartQuotes( bool smartQuotesAreOn);
/** Sets the smart-quotes double-quote character codes for a specific language.
@param openQuote The code to use for opening double-quote.
@param closeQuote The code to use for opening double-quote.
@param language The language in which to use these codes.
@return Nothing
*/
void SetSmartDoubleQuoteCharacters( ATETextDOM::Unicode openQuote, ATETextDOM::Unicode closeQuote, Language language);
/** Sets the smart-quotes single-quote character codes for a specific language.
@param openQuote The code to use for opening single-quote.
@param closeQuote The code to use for opening single-quote.
@param language The language in which to use these codes.
@return Nothing
*/
void SetSmartSingleQuoteCharacters( ATETextDOM::Unicode openQuote, ATETextDOM::Unicode closeQuote, Language language);
/** Reports whether smart-quotes are on for this document.
@return True if smart-quotes are on.
*/
bool UseSmartQuotes( );
/** Retrieves the smart-quotes double-quote character codes for a specific language.
@param openQuote [out] A buffer in which to return the code used for opening double-quote.
@param closeQuote [out] A buffer in which to return the code used for opening double-quote.
@param language The language for which to get codes.
@return Nothing
*/
void GetSmartDoubleQuoteCharacters( ATETextDOM::Unicode* openQuote, ATETextDOM::Unicode* closeQuote, Language language);
/** Retrieves the smart-quotes single-quote character codes for a specific language.
@param openQuote [out] A buffer in which to return the code used for opening single-quote.
@param closeQuote [out] A buffer in which to return the code used for opening single-quote.
@param language The language for which to get codes.
@return Nothing
*/
void GetSmartSingleQuoteCharacters( ATETextDOM::Unicode* openQuote, ATETextDOM::Unicode* closeQuote, Language language);
/** Retrieves the local overrides (character features) from the insertion
attributes, saved from the most recent text selection or attribute change to text.
@return The character features object.
*/
ICharFeatures GetInsertionCharFeatures( ) const;
/** Retrieves the character style from the insertion
attributes, saved from the most recent text selection or attribute change to text.
@return The character style object.
*/
ICharStyle GetInsertionCharStyle( ) const;
/** Sets the character features and style for the current insertion attributes.
@param pFeatures The new character features object.
@param pStyleName The new style name.
@return Nothing
*/
void SetInsertionFeaturesAndStyle( const ICharFeatures& pFeatures, const ATETextDOM::Unicode* pStyleName);
/** Retrieves the superscript size.
@return The size in document points.
*/
ATETextDOM::Real GetSuperscriptSize( ) const;
/** Sets the superscript size.
@param value The new size in document points.
@return Nothing
*/
void SetSuperscriptSize( ATETextDOM::Real value);
/** Retrieves the superscript position.
@return The position in document points and page coordinates.
*/
ATETextDOM::Real GetSuperscriptPosition( ) const;
/** Sets the superscript position.
@param value The new position in document points and page coordinates.
@return Nothing
*/
void SetSuperscriptPosition( ATETextDOM::Real value);
/** Retrieves the subscript size.
@return The size in document points.
*/
ATETextDOM::Real GetSubscriptSize( ) const;
/** Sets the supbscript size.
@param value The new size in document points.
@return Nothing
*/
void SetSubscriptSize( ATETextDOM::Real value);
/** Retrieves the subscript position.
@return The position in document points and page coordinates.
*/
ATETextDOM::Real GetSubscriptPosition( ) const;
/** Sets the subscript position.
@param value The new position in document points and page coordinates.Text that does not fit is truncated
@return Nothing
*/
void SetSubscriptPosition( ATETextDOM::Real value);
/** Retrieves the small-cap size.
@return The size in document points.
*/
ATETextDOM::Real GetSmallCapSize( ) const;
/** Sets the small-cap size.
@param value The new size in document points.
@return Nothing
*/
void SetSmallCapSize( ATETextDOM::Real value);
/** Reports whether hidden characters are shown.
@return True if hidden characters are shown.
*/
bool GetShowHiddenCharacters( ) const;
/** Turns show hidden characters on or off.
@param value True to show hidden characters, false to hide them.
*/
void SetShowHiddenCharacters( bool value);
/** Retrieves the greeking threshhold.
@return The greeking threshhold in document points.
*/
ATETextDOM::Int32 GetGreekingSize( ) const;
/** Sets the greeking threshhold.
@param value The new threshhold in document points.
@return Nothing
*/
void SetGreekingSize( ATETextDOM::Int32 value);
/** Reports whether substitute fonts are highlighted.
@return True if substitute fonts are highlighted.
*/
bool GetHighlightSubstituteFonts( ) const;
/** Turns highlighting of substitute fonts on or off.
@param value True to highlight substitute fonts, false to turn highlighting off.
*/
void SetHighlightSubstituteFonts( bool value);
/** Reports whether alternate glyphs are highlighted.
@return True if alternate glyphs are highlighted.
*/
bool GetHighlightAlternateGlyphs( ) const;
/** Turns highlighting of alternate glyphs on or off.
@param value True to highligh alternate glyphs, false to turn highlighting off.
*/
void SetHighlightAlternateGlyphs( bool value);
};
//////////////////////////////////////////////
// --IVersionInfo--
//////////////////////////////////////////////
/** This object encapsulates version information for
the Adobe Text Engine (ATE).
*/
class IVersionInfo
{
private:
VersionInfoRef fVersionInfo;
public:
/** Constructor
@return The new object. */
IVersionInfo();
/** Copy constructor
@param src The object to copy.
@return The new object. */
IVersionInfo(const IVersionInfo& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
IVersionInfo& operator=(const IVersionInfo& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const IVersionInfo& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const IVersionInfo& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param versioninfo The C object.
@return The new C++ object. */
explicit IVersionInfo(VersionInfoRef versioninfo);
/** Destructor */
virtual ~IVersionInfo();
/** Retrieves a reference to this object.
@return The object reference. */
VersionInfoRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
/** Retrieves the major version portion of the version number.
@return The major version value. */
int GetMajorVersion( );
/** Retrieves the minor version portion of the version number.
@return The minor version value. */
int GetMinorVersion( );
/** Retrieves the sub-minor version (patch) portion of the version number.
@return The sub-minor version value. */
int GetSubMinorVersion( );
/** Retrieves the version number as a string of UTF-16 characters.
For example:
@code
ASUTF16 versionString[256];
GetVersionAsUTF16(versionString , 256);
@endcode
@param versionString [out] A buffer in which to return the string.
@param maxLength The number of characters in the buffer.
*/
int GetVersionAsUTF16( ASUTF16* versionString, int maxLength);
};
//////////////////////////////////////////////
// --IArrayApplicationPaintRef--
//////////////////////////////////////////////
/** Provides access to an ordered collection of application paint
objects, which encapsulate Illustrator-specific painting
of fill and stroke for text, as defined by the \c #AIATEPaintSuite.
@see \c IApplicationPaint
*/
class IArrayApplicationPaintRef
{
private:
ArrayApplicationPaintRefRef fArrayApplicationPaintRef;
public:
/** Constructor
@return The new object. */
IArrayApplicationPaintRef();
/** Copy constructor
@param src The object to copy.
@return The new object. */
IArrayApplicationPaintRef(const IArrayApplicationPaintRef& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
IArrayApplicationPaintRef& operator=(const IArrayApplicationPaintRef& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const IArrayApplicationPaintRef& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const IArrayApplicationPaintRef& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param arrayapplicationpaintref The C object.
@return The new C++ object. */
explicit IArrayApplicationPaintRef(ArrayApplicationPaintRefRef arrayapplicationpaintref);
/** Destructor */
virtual ~IArrayApplicationPaintRef();
/** Retrieves a reference to this object.
@return The object reference. */
ArrayApplicationPaintRefRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
// ========================================================================
// PROPERTIES
// ========================================================================
/** Retrieves the number of members of this set.
@return The number of members. */
ATETextDOM::Int32 GetSize( ) const;
/** Retrieves the first member of this set.
@return The member object. */
IApplicationPaint GetFirst( ) const;
/** Retrieves the last member of this set.
@return The member object. */
IApplicationPaint GetLast( ) const;
// ========================================================================
// METHODS
// ========================================================================
/** Retrieves a member of this set by position index. Use with \c GetSize()
to iterate through members.
@param index The 0-based position index.
@return The member object.
*/
IApplicationPaint Item( ATETextDOM::Int32 index) const;
};
//////////////////////////////////////////////
// --IArrayReal--
//////////////////////////////////////////////
/** Provides access to an ordered collection of real-number values. */
class IArrayReal
{
private:
ArrayRealRef fArrayReal;
public:
/** Constructor
@return The new object. */
IArrayReal();
/** Copy constructor
@param src The object to copy.
@return The new object. */
IArrayReal(const IArrayReal& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
IArrayReal& operator=(const IArrayReal& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const IArrayReal& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const IArrayReal& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param arrayreal The C object.
@return The new C++ object. */
explicit IArrayReal(ArrayRealRef arrayreal);
/** Destructor */
virtual ~IArrayReal();
/** Retrieves a reference to this object.
@return The object reference. */
ArrayRealRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
// ========================================================================
// PROPERTIES
// ========================================================================
/** Retrieves the number of members of this set.
@return The number of members. */
ATETextDOM::Int32 GetSize( ) const;
/** Retrieves the first member of this set.
@return The member value. */
ATETextDOM::Real GetFirst( ) const;
/** Retrieves the last member of this set.
@return The member value. */
ATETextDOM::Real GetLast( ) const;
// ========================================================================
// METHODS
// ========================================================================
/** Retrieves a member of this set by position index. Use with \c GetSize()
to iterate through members.
@param index The 0-based position index.
@return The member value.
*/
ATETextDOM::Real Item( ATETextDOM::Int32 index) const;
};
//////////////////////////////////////////////
// --IArrayBool--
//////////////////////////////////////////////
/** Provides access to an ordered collection of boolean values. */
class IArrayBool
{
private:
ArrayBoolRef fArrayBool;
public:
/** Constructor
@return The new object. */
IArrayBool();
/** Copy constructor
@param src The object to copy.
@return The new object. */
IArrayBool(const IArrayBool& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
IArrayBool& operator=(const IArrayBool& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const IArrayBool& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const IArrayBool& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param arraybool The C object.
@return The new C++ object. */
explicit IArrayBool(ArrayBoolRef arraybool);
/** Destructor */
virtual ~IArrayBool();
/** Retrieves a reference to this object.
@return The object reference. */
ArrayBoolRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
// ========================================================================
// PROPERTIES
// ========================================================================
/** Retrieves the number of members of this set.
@return The number of members. */
ATETextDOM::Int32 GetSize( ) const;
/** Retrieves the first member of this set.
@return The member value. */
bool GetFirst( ) const;
/** Retrieves the last member of this set.
@return The member value. */
bool GetLast( ) const;
// ========================================================================
// METHODS
// ========================================================================
/** Retrieves a member of this set by position index. Use with \c GetSize()
to iterate through members.
@param index The 0-based position index.
@return The member value.
*/
bool Item( ATETextDOM::Int32 index) const;
};
//////////////////////////////////////////////
// --IArrayInteger--
//////////////////////////////////////////////
/** Provides access to an ordered collection of integer values. */
class IArrayInteger
{
private:
ArrayIntegerRef fArrayInteger;
public:
/** Constructor
@return The new object. */
IArrayInteger();
/** Copy constructor
@param src The object to copy.
@return The new object. */
IArrayInteger(const IArrayInteger& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
IArrayInteger& operator=(const IArrayInteger& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const IArrayInteger& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const IArrayInteger& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param arrayinteger The C object.
@return The new C++ object. */
explicit IArrayInteger(ArrayIntegerRef arrayinteger);
/** Destructor */
virtual ~IArrayInteger();
/** Retrieves a reference to this object.
@return The object reference. */
ArrayIntegerRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
// ========================================================================
// PROPERTIES
// ========================================================================
/** Retrieves the number of members of this set.
@return The number of members. */
ATETextDOM::Int32 GetSize( ) const;
/** Retrieves the first member of this set.
@return The member value. */
ATETextDOM::Int32 GetFirst( ) const;
/** Retrieves the last member of this set.
@return The member value. */
ATETextDOM::Int32 GetLast( ) const;
// ========================================================================
// METHODS
// ========================================================================
/** Retrieves a member of this set by position index. Use with \c GetSize()
to iterate through members.
@param index The 0-based position index.
@return The member value.
*/
ATETextDOM::Int32 Item( ATETextDOM::Int32 index) const;
};
//////////////////////////////////////////////
// --IArrayLineCapType--
//////////////////////////////////////////////
/** Provides access to an ordered collection of line-cap type values.
See \c #LineCapType. */
class IArrayLineCapType
{
private:
ArrayLineCapTypeRef fArrayLineCapType;
public:
/** Constructor
@return The new object. */
IArrayLineCapType();
/** Copy constructor
@param src The object to copy.
@return The new object. */
IArrayLineCapType(const IArrayLineCapType& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
IArrayLineCapType& operator=(const IArrayLineCapType& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const IArrayLineCapType& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const IArrayLineCapType& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param arraylinecaptype The C object.
@return The new C++ object. */
explicit IArrayLineCapType(ArrayLineCapTypeRef arraylinecaptype);
/** Destructor */
virtual ~IArrayLineCapType();
/** Retrieves a reference to this object.
@return The object reference. */
ArrayLineCapTypeRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
// ========================================================================
// PROPERTIES
// ========================================================================
/** Retrieves the number of members of this set.
@return The number of members. */
ATETextDOM::Int32 GetSize( ) const;
/** Retrieves the first member of this set.
@return The member value. */
LineCapType GetFirst( ) const;
/** Retrieves the last member of this set.
@return The member value. */
LineCapType GetLast( ) const;
// ========================================================================
// METHODS
// ========================================================================
/** Retrieves a member of this set by position index. Use with \c GetSize()
to iterate through members.
@param index The 0-based position index.
@return The member value.
*/
LineCapType Item( ATETextDOM::Int32 index) const;
};
//////////////////////////////////////////////
// --IArrayFigureStyle--
//////////////////////////////////////////////
/** Provides access to an ordered collection of figure style values.
See \c #FigureStyle. */
class IArrayFigureStyle
{
private:
ArrayFigureStyleRef fArrayFigureStyle;
public:
/** Constructor
@return The new object. */
IArrayFigureStyle();
/** Copy constructor
@param src The object to copy.
@return The new object. */
IArrayFigureStyle(const IArrayFigureStyle& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
IArrayFigureStyle& operator=(const IArrayFigureStyle& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const IArrayFigureStyle& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const IArrayFigureStyle& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param arrayfigurestyle The C object.
@return The new C++ object. */
explicit IArrayFigureStyle(ArrayFigureStyleRef arrayfigurestyle);
/** Destructor */
virtual ~IArrayFigureStyle();
/** Retrieves a reference to this object.
@return The object reference. */
ArrayFigureStyleRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
// ========================================================================
// PROPERTIES
// ========================================================================
/** Retrieves the number of members of this set.
@return The number of members. */
ATETextDOM::Int32 GetSize( ) const;
/** Retrieves the first member of this set.
@return The member value. */
FigureStyle GetFirst( ) const;
/** Retrieves the last member of this set.
@return The member value. */
FigureStyle GetLast( ) const;
// ========================================================================
// METHODS
// ========================================================================
/** Retrieves a member of this set by position index. Use with \c GetSize()
to iterate through members.
@param index The 0-based position index.
@return The member value.
*/
FigureStyle Item( ATETextDOM::Int32 index) const;
};
//////////////////////////////////////////////
// --IArrayLineJoinType--
//////////////////////////////////////////////
/** Provides access to an ordered collection of line-join type values.
See \c #LineJoinType. */
class IArrayLineJoinType
{
private:
ArrayLineJoinTypeRef fArrayLineJoinType;
public:
/** Constructor
@return The new object. */
IArrayLineJoinType();
/** Copy constructor
@param src The object to copy.
@return The new object. */
IArrayLineJoinType(const IArrayLineJoinType& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
IArrayLineJoinType& operator=(const IArrayLineJoinType& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const IArrayLineJoinType& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const IArrayLineJoinType& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param arraylinejointype The C object.
@return The new C++ object. */
explicit IArrayLineJoinType(ArrayLineJoinTypeRef arraylinejointype);
/** Destructor */
virtual ~IArrayLineJoinType();
/** Retrieves a reference to this object.
@return The object reference. */
ArrayLineJoinTypeRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
// ========================================================================
// PROPERTIES
// ========================================================================
/** Retrieves the number of members of this set.
@return The number of members. */
ATETextDOM::Int32 GetSize( ) const;
/** Retrieves the first member of this set.
@return The member value. */
LineJoinType GetFirst( ) const;
/** Retrieves the last member of this set.
@return The member value. */
LineJoinType GetLast( ) const;
// ========================================================================
// METHODS
// ========================================================================
/** Retrieves a member of this set by position index. Use with \c GetSize()
to iterate through members.
@param index The 0-based position index.
@return The member value.
*/
LineJoinType Item( ATETextDOM::Int32 index) const;
};
//////////////////////////////////////////////
// --IArrayWariChuJustification--
//////////////////////////////////////////////
/** Provides access to an ordered collection of WariChu justification values.
See \c #WariChuJustification. */
class IArrayWariChuJustification
{
private:
ArrayWariChuJustificationRef fArrayWariChuJustification;
public:
/** Constructor
@return The new object. */
IArrayWariChuJustification();
/** Copy constructor
@param src The object to copy.
@return The new object. */
IArrayWariChuJustification(const IArrayWariChuJustification& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
IArrayWariChuJustification& operator=(const IArrayWariChuJustification& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const IArrayWariChuJustification& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const IArrayWariChuJustification& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param arraywarichujustification The C object.
@return The new C++ object. */
explicit IArrayWariChuJustification(ArrayWariChuJustificationRef arraywarichujustification);
/** Destructor */
virtual ~IArrayWariChuJustification();
/** Retrieves a reference to this object.
@return The object reference. */
ArrayWariChuJustificationRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
// ========================================================================
// PROPERTIES
// ========================================================================
/** Retrieves the number of members of this set.
@return The number of members. */
ATETextDOM::Int32 GetSize( ) const;
/** Retrieves the first member of this set.
@return The member value. */
WariChuJustification GetFirst( ) const;
/** Retrieves the last member of this set.
@return The member value. */
WariChuJustification GetLast( ) const;
// ========================================================================
// METHODS
// ========================================================================
/** Retrieves a member of this set by position index. Use with \c GetSize()
to iterate through members.
@param index The 0-based position index.
@return The member value.
*/
WariChuJustification Item( ATETextDOM::Int32 index) const;
};
//////////////////////////////////////////////
// --IArrayStyleRunAlignment--
//////////////////////////////////////////////
/** Provides access to an ordered collection of style-run alignment values.
See \c #StyleRunAlignment. */
class IArrayStyleRunAlignment
{
private:
ArrayStyleRunAlignmentRef fArrayStyleRunAlignment;
public:
/** Constructor
@return The new object. */
IArrayStyleRunAlignment();
/** Copy constructor
@param src The object to copy.
@return The new object. */
IArrayStyleRunAlignment(const IArrayStyleRunAlignment& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
IArrayStyleRunAlignment& operator=(const IArrayStyleRunAlignment& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const IArrayStyleRunAlignment& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const IArrayStyleRunAlignment& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param arraystylerunalignment The C object.
@return The new C++ object. */
explicit IArrayStyleRunAlignment(ArrayStyleRunAlignmentRef arraystylerunalignment);
/** Destructor */
virtual ~IArrayStyleRunAlignment();
/** Retrieves a reference to this object.
@return The object reference. */
ArrayStyleRunAlignmentRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
// ========================================================================
// PROPERTIES
// ========================================================================
/** Retrieves the number of members of this set.
@return The number of members. */
ATETextDOM::Int32 GetSize( ) const;
/** Retrieves the first member of this set.
@return The member value. */
StyleRunAlignment GetFirst( ) const;
/** Retrieves the last member of this set.
@return The member value. */
StyleRunAlignment GetLast( ) const;
// ========================================================================
// METHODS
// ========================================================================
/** Retrieves a member of this set by position index. Use with \c GetSize()
to iterate through members.
@param index The 0-based position index.
@return The member value.
*/
StyleRunAlignment Item( ATETextDOM::Int32 index) const;
};
//////////////////////////////////////////////
// --IArrayAutoKernType--
//////////////////////////////////////////////
/** Provides access to an ordered collection of automatic kern type values.
See \c #AutoKernType. */
class IArrayAutoKernType
{
private:
ArrayAutoKernTypeRef fArrayAutoKernType;
public:
/** Constructor
@return The new object. */
IArrayAutoKernType();
/** Copy constructor
@param src The object to copy.
@return The new object. */
IArrayAutoKernType(const IArrayAutoKernType& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
IArrayAutoKernType& operator=(const IArrayAutoKernType& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const IArrayAutoKernType& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const IArrayAutoKernType& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param arrayautokerntype The C object.
@return The new C++ object. */
explicit IArrayAutoKernType(ArrayAutoKernTypeRef arrayautokerntype);
/** Destructor */
virtual ~IArrayAutoKernType();
/** Retrieves a reference to this object.
@return The object reference. */
ArrayAutoKernTypeRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
// ========================================================================
// PROPERTIES
// ========================================================================
/** Retrieves the number of members of this set.
@return The number of members. */
ATETextDOM::Int32 GetSize( ) const;
/** Retrieves the first member of this set.
@return The member value. */
AutoKernType GetFirst( ) const;
/** Retrieves the last member of this set.
@return The member value. */
AutoKernType GetLast( ) const;
// ========================================================================
// METHODS
// ========================================================================
/** Retrieves a member of this set by position index. Use with \c GetSize()
to iterate through members.
@param index The 0-based position index.
@return The member value.
*/
AutoKernType Item( ATETextDOM::Int32 index) const;
};
//////////////////////////////////////////////
// --IArrayBaselineDirection--
//////////////////////////////////////////////
/** Provides access to an ordered collection of baseline direction values.
See \c #BaselineDirection. */
class IArrayBaselineDirection
{
private:
ArrayBaselineDirectionRef fArrayBaselineDirection;
public:
/** Constructor
@return The new object. */
IArrayBaselineDirection();
/** Copy constructor
@param src The object to copy.
@return The new object. */
IArrayBaselineDirection(const IArrayBaselineDirection& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
IArrayBaselineDirection& operator=(const IArrayBaselineDirection& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const IArrayBaselineDirection& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const IArrayBaselineDirection& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param arraybaselinedirection The C object.
@return The new C++ object. */
explicit IArrayBaselineDirection(ArrayBaselineDirectionRef arraybaselinedirection);
/** Destructor */
virtual ~IArrayBaselineDirection();
/** Retrieves a reference to this object.
@return The object reference. */
ArrayBaselineDirectionRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
// ========================================================================
// PROPERTIES
// ========================================================================
/** Retrieves the number of members of this set.
@return The number of members. */
ATETextDOM::Int32 GetSize( ) const;
/** Retrieves the first member of this set.
@return The member value. */
BaselineDirection GetFirst( ) const;
/** Retrieves the last member of this set.
@return The member value. */
BaselineDirection GetLast( ) const;
// ========================================================================
// METHODS
// ========================================================================
/** Retrieves a member of this set by position index. Use with \c GetSize()
to iterate through members.
@param index The 0-based position index.
@return The member value.
*/
BaselineDirection Item( ATETextDOM::Int32 index) const;
};
//////////////////////////////////////////////
// --IArrayLanguage--
//////////////////////////////////////////////
/** Provides access to an ordered collection of language values.
See \c #Language. */
class IArrayLanguage
{
private:
ArrayLanguageRef fArrayLanguage;
public:
/** Constructor
@return The new object. */
IArrayLanguage();
/** Copy constructor
@param src The object to copy.
@return The new object. */
IArrayLanguage(const IArrayLanguage& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
IArrayLanguage& operator=(const IArrayLanguage& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const IArrayLanguage& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const IArrayLanguage& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param arraylanguage The C object.
@return The new C++ object. */
explicit IArrayLanguage(ArrayLanguageRef arraylanguage);
/** Destructor */
virtual ~IArrayLanguage();
/** Retrieves a reference to this object.
@return The object reference. */
ArrayLanguageRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
// ========================================================================
// PROPERTIES
// ========================================================================
/** Retrieves the number of members of this set.
@return The number of members. */
ATETextDOM::Int32 GetSize( ) const;
/** Retrieves the first member of this set.
@return The member value. */
Language GetFirst( ) const;
/** Retrieves the last member of this set.
@return The member value. */
Language GetLast( ) const;
// ========================================================================
// METHODS
// ========================================================================
/** Retrieves a member of this set by position index. Use with \c GetSize()
to iterate through members.
@param index The 0-based position index.
@return The member value.
*/
Language Item( ATETextDOM::Int32 index) const;
};
//////////////////////////////////////////////
// --IArrayFontCapsOption--
//////////////////////////////////////////////
/** Provides access to an ordered collection of font caps option values.
See \c #FontCapsOption. */
class IArrayFontCapsOption
{
private:
ArrayFontCapsOptionRef fArrayFontCapsOption;
public:
/** Constructor
@return The new object. */
IArrayFontCapsOption();
/** Copy constructor
@param src The object to copy.
@return The new object. */
IArrayFontCapsOption(const IArrayFontCapsOption& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
IArrayFontCapsOption& operator=(const IArrayFontCapsOption& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const IArrayFontCapsOption& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const IArrayFontCapsOption& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param arrayfontcapsoption The C object.
@return The new C++ object. */
explicit IArrayFontCapsOption(ArrayFontCapsOptionRef arrayfontcapsoption);
/** Destructor */
virtual ~IArrayFontCapsOption();
/** Retrieves a reference to this object.
@return The object reference. */
ArrayFontCapsOptionRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
// ========================================================================
// PROPERTIES
// ========================================================================
/** Retrieves the number of members of this set.
@return The number of members. */
ATETextDOM::Int32 GetSize( ) const;
/** Retrieves the first member of this set.
@return The member value. */
FontCapsOption GetFirst( ) const;
/** Retrieves the last member of this set.
@return The member value. */
FontCapsOption GetLast( ) const;
// ========================================================================
// METHODS
// ========================================================================
/** Retrieves a member of this set by position index. Use with \c GetSize()
to iterate through members.
@param index The 0-based position index.
@return The member value.
*/
FontCapsOption Item( ATETextDOM::Int32 index) const;
};
//////////////////////////////////////////////
// --IArrayFontBaselineOption--
//////////////////////////////////////////////
/** Provides access to an ordered collection of font baseline option values.
See \c #FontBaselineOption. */
class IArrayFontBaselineOption
{
private:
ArrayFontBaselineOptionRef fArrayFontBaselineOption;
public:
/** Constructor
@return The new object. */
IArrayFontBaselineOption();
/** Copy constructor
@param src The object to copy.
@return The new object. */
IArrayFontBaselineOption(const IArrayFontBaselineOption& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
IArrayFontBaselineOption& operator=(const IArrayFontBaselineOption& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const IArrayFontBaselineOption& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const IArrayFontBaselineOption& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param arrayfontbaselineoption The C object.
@return The new C++ object. */
explicit IArrayFontBaselineOption(ArrayFontBaselineOptionRef arrayfontbaselineoption);
/** Destructor */
virtual ~IArrayFontBaselineOption();
/** Retrieves a reference to this object.
@return The object reference. */
ArrayFontBaselineOptionRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
// ========================================================================
// PROPERTIES
// ========================================================================
/** Retrieves the number of members of this set.
@return The number of members. */
ATETextDOM::Int32 GetSize( ) const;
/** Retrieves the first member of this set.
@return The member value. */
FontBaselineOption GetFirst( ) const;
/** Retrieves the last member of this set.
@return The member value. */
FontBaselineOption GetLast( ) const;
// ========================================================================
// METHODS
// ========================================================================
/** Retrieves a member of this set by position index. Use with \c GetSize()
to iterate through members.
@param index The 0-based position index.
@return The member value.
*/
FontBaselineOption Item( ATETextDOM::Int32 index) const;
};
//////////////////////////////////////////////
// --IArrayFontOpenTypePositionOption--
//////////////////////////////////////////////
/** Provides access to an ordered collection of font OpenType position option values.
See \c #FontOpenTypePositionOption. */
class IArrayFontOpenTypePositionOption
{
private:
ArrayFontOpenTypePositionOptionRef fArrayFontOpenTypePositionOption;
public:
/** Constructor
@return The new object. */
IArrayFontOpenTypePositionOption();
/** Copy constructor
@param src The object to copy.
@return The new object. */
IArrayFontOpenTypePositionOption(const IArrayFontOpenTypePositionOption& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
IArrayFontOpenTypePositionOption& operator=(const IArrayFontOpenTypePositionOption& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const IArrayFontOpenTypePositionOption& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const IArrayFontOpenTypePositionOption& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param arrayfontopentypepositionoption The C object.
@return The new C++ object. */
explicit IArrayFontOpenTypePositionOption(ArrayFontOpenTypePositionOptionRef arrayfontopentypepositionoption);
/** Destructor */
virtual ~IArrayFontOpenTypePositionOption();
/** Retrieves a reference to this object.
@return The object reference. */
ArrayFontOpenTypePositionOptionRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
// ========================================================================
// PROPERTIES
// ========================================================================
/** Retrieves the number of members of this set.
@return The number of members. */
ATETextDOM::Int32 GetSize( ) const;
/** Retrieves the first member of this set.
@return The member value. */
FontOpenTypePositionOption GetFirst( ) const;
/** Retrieves the last member of this set.
@return The member value. */
FontOpenTypePositionOption GetLast( ) const;
// ========================================================================
// METHODS
// ========================================================================
/** Retrieves a member of this set by position index. Use with \c GetSize()
to iterate through members.
@param index The 0-based position index.
@return The member value.
*/
FontOpenTypePositionOption Item( ATETextDOM::Int32 index) const;
};
//////////////////////////////////////////////
// --IArrayUnderlinePosition--
//////////////////////////////////////////////
/** Provides access to an ordered collection of underline position values.
See \c #UnderlinePosition. */
class IArrayUnderlinePosition
{
private:
ArrayUnderlinePositionRef fArrayUnderlinePosition;
public:
/** Constructor
@return The new object. */
IArrayUnderlinePosition();
/** Copy constructor
@param src The object to copy.
@return The new object. */
IArrayUnderlinePosition(const IArrayUnderlinePosition& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
IArrayUnderlinePosition& operator=(const IArrayUnderlinePosition& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const IArrayUnderlinePosition& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const IArrayUnderlinePosition& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param arrayunderlineposition The C object.
@return The new C++ object. */
explicit IArrayUnderlinePosition(ArrayUnderlinePositionRef arrayunderlineposition);
/** Destructor */
virtual ~IArrayUnderlinePosition();
/** Retrieves a reference to this object.
@return The object reference. */
ArrayUnderlinePositionRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
// ========================================================================
// PROPERTIES
// ========================================================================
/** Retrieves the number of members of this set.
@return The number of members. */
ATETextDOM::Int32 GetSize( ) const;
/** Retrieves the first member of this set.
@return The member value. */
UnderlinePosition GetFirst( ) const;
/** Retrieves the last member of this set.
@return The member value. */
UnderlinePosition GetLast( ) const;
// ========================================================================
// METHODS
// ========================================================================
/** Retrieves a member of this set by position index. Use with \c GetSize()
to iterate through members.
@param index The 0-based position index.
@return The member value.
*/
UnderlinePosition Item( ATETextDOM::Int32 index) const;
};
//////////////////////////////////////////////
// --IArrayStrikethroughPosition--
//////////////////////////////////////////////
/** Provides access to an ordered collection of strikethrough position values.
See \c #StrikethroughPosition. */
class IArrayStrikethroughPosition
{
private:
ArrayStrikethroughPositionRef fArrayStrikethroughPosition;
public:
/** Constructor
@return The new object. */
IArrayStrikethroughPosition();
/** Copy constructor
@param src The object to copy.
@return The new object. */
IArrayStrikethroughPosition(const IArrayStrikethroughPosition& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
IArrayStrikethroughPosition& operator=(const IArrayStrikethroughPosition& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const IArrayStrikethroughPosition& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const IArrayStrikethroughPosition& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param arraystrikethroughposition The C object.
@return The new C++ object. */
explicit IArrayStrikethroughPosition(ArrayStrikethroughPositionRef arraystrikethroughposition);
/** Destructor */
virtual ~IArrayStrikethroughPosition();
/** Retrieves a reference to this object.
@return The object reference. */
ArrayStrikethroughPositionRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
// ========================================================================
// PROPERTIES
// ========================================================================
/** Retrieves the number of members of this set.
@return The number of members. */
ATETextDOM::Int32 GetSize( ) const;
/** Retrieves the first member of this set.
@return The member value. */
StrikethroughPosition GetFirst( ) const;
/** Retrieves the last member of this set.
@return The member value. */
StrikethroughPosition GetLast( ) const;
// ========================================================================
// METHODS
// ========================================================================
/** Retrieves a member of this set by position index. Use with \c GetSize()
to iterate through members.
@param index The 0-based position index.
@return The member value.
*/
StrikethroughPosition Item( ATETextDOM::Int32 index) const;
};
//////////////////////////////////////////////
// --IArrayParagraphJustification--
//////////////////////////////////////////////
/** Provides access to an ordered collection of paragraph justification values.
See \c #ParagraphJustification. */
class IArrayParagraphJustification
{
private:
ArrayParagraphJustificationRef fArrayParagraphJustification;
public:
/** Constructor
@return The new object. */
IArrayParagraphJustification();
/** Copy constructor
@param src The object to copy.
@return The new object. */
IArrayParagraphJustification(const IArrayParagraphJustification& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
IArrayParagraphJustification& operator=(const IArrayParagraphJustification& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const IArrayParagraphJustification& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const IArrayParagraphJustification& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param arrayparagraphjustification The C object.
@return The new C++ object. */
explicit IArrayParagraphJustification(ArrayParagraphJustificationRef arrayparagraphjustification);
/** Destructor */
virtual ~IArrayParagraphJustification();
/** Retrieves a reference to this object.
@return The object reference. */
ArrayParagraphJustificationRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
// ========================================================================
// PROPERTIES
// ========================================================================
/** Retrieves the number of members of this set.
@return The number of members. */
ATETextDOM::Int32 GetSize( ) const;
/** Retrieves the first member of this set.
@return The member value. */
ParagraphJustification GetFirst( ) const;
/** Retrieves the last member of this set.
@return The member value. */
ParagraphJustification GetLast( ) const;
// ========================================================================
// METHODS
// ========================================================================
/** Retrieves a member of this set by position index. Use with \c GetSize()
to iterate through members.
@param index The 0-based position index.
@return The member value.
*/
ParagraphJustification Item( ATETextDOM::Int32 index) const;
};
//////////////////////////////////////////////
// --IArrayArrayReal--
//////////////////////////////////////////////
/** Provides access to an ordered collection of arrays of real-number values. */
class IArrayArrayReal
{
private:
ArrayArrayRealRef fArrayArrayReal;
public:
/** Constructor
@return The new object. */
IArrayArrayReal();
/** Copy constructor
@param src The object to copy.
@return The new object. */
IArrayArrayReal(const IArrayArrayReal& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
IArrayArrayReal& operator=(const IArrayArrayReal& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const IArrayArrayReal& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const IArrayArrayReal& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param arrayarrayreal The C object.
@return The new C++ object. */
explicit IArrayArrayReal(ArrayArrayRealRef arrayarrayreal);
/** Destructor */
virtual ~IArrayArrayReal();
/** Retrieves a reference to this object.
@return The object reference. */
ArrayArrayRealRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
// ========================================================================
// PROPERTIES
// ========================================================================
/** Retrieves the number of members of this set.
@return The number of member arrays. */
ATETextDOM::Int32 GetSize( ) const;
/** Retrieves the first member of this set.
@return The member array value. */
IArrayReal GetFirst( ) const;
/** Retrieves the last member of this set.
@return The member array value. */
IArrayReal GetLast( ) const;
// ========================================================================
// METHODS
// ========================================================================
/** Retrieves a member of this set by position index. Use with \c GetSize()
to iterate through members.
@param index The 0-based position index.
@return The member array value.
*/
IArrayReal Item( ATETextDOM::Int32 index) const;
};
//////////////////////////////////////////////
// --IArrayBurasagariType--
//////////////////////////////////////////////
/** Provides access to an ordered collection of Burasagari type values.
See \c #BurasagariType. */
class IArrayBurasagariType
{
private:
ArrayBurasagariTypeRef fArrayBurasagariType;
public:
/** Constructor
@return The new object. */
IArrayBurasagariType();
/** Copy constructor
@param src The object to copy.
@return The new object. */
IArrayBurasagariType(const IArrayBurasagariType& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
IArrayBurasagariType& operator=(const IArrayBurasagariType& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const IArrayBurasagariType& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const IArrayBurasagariType& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param arrayburasagaritype The C object.
@return The new C++ object. */
explicit IArrayBurasagariType(ArrayBurasagariTypeRef arrayburasagaritype);
/** Destructor */
virtual ~IArrayBurasagariType();
/** Retrieves a reference to this object.
@return The object reference. */
ArrayBurasagariTypeRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
// ========================================================================
// PROPERTIES
// ========================================================================
/** Retrieves the number of members of this set.
@return The number of members. */
ATETextDOM::Int32 GetSize( ) const;
/** Retrieves the first member of this set.
@return The member value. */
BurasagariType GetFirst( ) const;
/** Retrieves the last member of this set.
@return The member value. */
BurasagariType GetLast( ) const;
// ========================================================================
// METHODS
// ========================================================================
/** Retrieves a member of this set by position index. Use with \c GetSize()
to iterate through members.
@param index The 0-based position index.
@return The member value.
*/
BurasagariType Item( ATETextDOM::Int32 index) const;
};
//////////////////////////////////////////////
// --IArrayPreferredKinsokuOrder--
//////////////////////////////////////////////
/** Provides access to an ordered collection of preferred Kinsoku order values.
See \c #PreferredKinsokuOrder. */
class IArrayPreferredKinsokuOrder
{
private:
ArrayPreferredKinsokuOrderRef fArrayPreferredKinsokuOrder;
public:
/** Constructor
@return The new object. */
IArrayPreferredKinsokuOrder();
/** Copy constructor
@param src The object to copy.
@return The new object. */
IArrayPreferredKinsokuOrder(const IArrayPreferredKinsokuOrder& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
IArrayPreferredKinsokuOrder& operator=(const IArrayPreferredKinsokuOrder& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const IArrayPreferredKinsokuOrder& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const IArrayPreferredKinsokuOrder& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param arraypreferredkinsokuorder The C object.
@return The new C++ object. */
explicit IArrayPreferredKinsokuOrder(ArrayPreferredKinsokuOrderRef arraypreferredkinsokuorder);
/** Destructor */
virtual ~IArrayPreferredKinsokuOrder();
/** Retrieves a reference to this object.
@return The object reference. */
ArrayPreferredKinsokuOrderRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
// ========================================================================
// PROPERTIES
// ========================================================================
/** Retrieves the number of members of this set.
@return The number of members. */
ATETextDOM::Int32 GetSize( ) const;
/** Retrieves the first member of this set.
@return The member value. */
PreferredKinsokuOrder GetFirst( ) const;
/** Retrieves the last member of this set.
@return The member value. */
PreferredKinsokuOrder GetLast( ) const;
// ========================================================================
// METHODS
// ========================================================================
/** Retrieves a member of this set by position index. Use with \c GetSize()
to iterate through members.
@param index The 0-based position index.
@return The member value.
*/
PreferredKinsokuOrder Item( ATETextDOM::Int32 index) const;
};
//////////////////////////////////////////////
// --IArrayKinsokuRef--
//////////////////////////////////////////////
/** Provides access to an ordered collection of Kinsoku objects. */
class IArrayKinsokuRef
{
private:
ArrayKinsokuRefRef fArrayKinsokuRef;
public:
/** Constructor
@return The new object. */
IArrayKinsokuRef();
/** Copy constructor
@param src The object to copy.
@return The new object. */
IArrayKinsokuRef(const IArrayKinsokuRef& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
IArrayKinsokuRef& operator=(const IArrayKinsokuRef& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const IArrayKinsokuRef& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const IArrayKinsokuRef& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param arraykinsokuref The C object.
@return The new C++ object. */
explicit IArrayKinsokuRef(ArrayKinsokuRefRef arraykinsokuref);
/** Destructor */
virtual ~IArrayKinsokuRef();
/** Retrieves a reference to this object.
@return The object reference. */
ArrayKinsokuRefRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
// ========================================================================
// PROPERTIES
// ========================================================================
/** Retrieves the number of members of this set.
@return The number of members. */
ATETextDOM::Int32 GetSize( ) const;
/** Retrieves the first member of this set.
@return The member object. */
IKinsoku GetFirst( ) const;
/** Retrieves the last member of this set.
@return The member object. */
IKinsoku GetLast( ) const;
// ========================================================================
// METHODS
// ========================================================================
/** Retrieves a member of this set by position index. Use with \c GetSize()
to iterate through members.
@param index The 0-based position index.
@return The member object.
*/
IKinsoku Item( ATETextDOM::Int32 index) const;
};
//////////////////////////////////////////////
// --IArrayMojiKumiRef--
//////////////////////////////////////////////
/** Provides access to an ordered collection of MojiKumi objects. */
class IArrayMojiKumiRef
{
private:
ArrayMojiKumiRefRef fArrayMojiKumiRef;
public:
/** Constructor
@return The new object. */
IArrayMojiKumiRef();
/** Copy constructor
@param src The object to copy.
@return The new object. */
IArrayMojiKumiRef(const IArrayMojiKumiRef& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
IArrayMojiKumiRef& operator=(const IArrayMojiKumiRef& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const IArrayMojiKumiRef& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const IArrayMojiKumiRef& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param arraymojikumiref The C object.
@return The new C++ object. */
explicit IArrayMojiKumiRef(ArrayMojiKumiRefRef arraymojikumiref);
/** Destructor */
virtual ~IArrayMojiKumiRef();
/** Retrieves a reference to this object.
@return The object reference. */
ArrayMojiKumiRefRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
// ========================================================================
// PROPERTIES
// ========================================================================
/** Retrieves the number of members of this set.
@return The number of members. */
ATETextDOM::Int32 GetSize( ) const;
/** Retrieves the first member of this set.
@return The member object. */
IMojiKumi GetFirst( ) const;
/** Retrieves the last member of this set.
@return The member object. */
IMojiKumi GetLast( ) const;
// ========================================================================
// METHODS
// ========================================================================
/** Retrieves a member of this set by position index. Use with \c GetSize()
to iterate through members.
@param index The 0-based position index.
@return The member object.
*/
IMojiKumi Item( ATETextDOM::Int32 index) const;
};
//////////////////////////////////////////////
// --IArrayMojiKumiSetRef--
//////////////////////////////////////////////
/** Provides access to an ordered collection of MojiKumi set objects. */
class IArrayMojiKumiSetRef
{
private:
ArrayMojiKumiSetRefRef fArrayMojiKumiSetRef;
public:
/** Constructor
@return The new object. */
IArrayMojiKumiSetRef();
/** Copy constructor
@param src The object to copy.
@return The new object. */
IArrayMojiKumiSetRef(const IArrayMojiKumiSetRef& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
IArrayMojiKumiSetRef& operator=(const IArrayMojiKumiSetRef& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const IArrayMojiKumiSetRef& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const IArrayMojiKumiSetRef& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param arraymojikumisetref The C object.
@return The new C++ object. */
explicit IArrayMojiKumiSetRef(ArrayMojiKumiSetRefRef arraymojikumisetref);
/** Destructor */
virtual ~IArrayMojiKumiSetRef();
/** Retrieves a reference to this object.
@return The object reference. */
ArrayMojiKumiSetRefRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
// ========================================================================
// PROPERTIES
// ========================================================================
/** Retrieves the number of members of this set.
@return The number of members. */
ATETextDOM::Int32 GetSize( ) const;
/** Retrieves the first member of this set.
@return The member object. */
IMojiKumiSet GetFirst( ) const;
/** Retrieves the last member of this set.
@return The member object. */
IMojiKumiSet GetLast( ) const;
// ========================================================================
// METHODS
// ========================================================================
/** Retrieves a member of this set by position index. Use with \c GetSize()
to iterate through members.
@param index The 0-based position index.
@return The member object.
*/
IMojiKumiSet Item( ATETextDOM::Int32 index) const;
};
//////////////////////////////////////////////
// --IArrayTabStopsRef--
//////////////////////////////////////////////
/** Provides access to an ordered collection of tab-stops objects. */
class IArrayTabStopsRef
{
private:
ArrayTabStopsRefRef fArrayTabStopsRef;
public:
/** Constructor
@return The new object. */
IArrayTabStopsRef();
/** Copy constructor
@param src The object to copy.
@return The new object. */
IArrayTabStopsRef(const IArrayTabStopsRef& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
IArrayTabStopsRef& operator=(const IArrayTabStopsRef& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const IArrayTabStopsRef& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const IArrayTabStopsRef& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param arraytabstopsref The C object.
@return The new C++ object. */
explicit IArrayTabStopsRef(ArrayTabStopsRefRef arraytabstopsref);
/** Destructor */
virtual ~IArrayTabStopsRef();
/** Retrieves a reference to this object.
@return The object reference. */
ArrayTabStopsRefRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
// ========================================================================
// PROPERTIES
// ========================================================================
/** Retrieves the number of members of this set.
@return The number of members. */
ATETextDOM::Int32 GetSize( ) const;
/** Retrieves the first member of this set.
@return The member object. */
ITabStops GetFirst( ) const;
/** Retrieves the last member of this set.
@return The member object. */
ITabStops GetLast( ) const;
// ========================================================================
// METHODS
// ========================================================================
/** Retrieves a member of this set by position index. Use with \c GetSize()
to iterate through members.
@param index The 0-based position index.
@return The member object.
*/
ITabStops Item( ATETextDOM::Int32 index) const;
};
//////////////////////////////////////////////
// --IArrayLeadingType--
//////////////////////////////////////////////
/** Provides access to an ordered collection of preferred leading type values.
See \c #LeadingType. */
class IArrayLeadingType
{
private:
ArrayLeadingTypeRef fArrayLeadingType;
public:
/** Constructor
@return The new object. */
IArrayLeadingType();
/** Copy constructor
@param src The object to copy.
@return The new object. */
IArrayLeadingType(const IArrayLeadingType& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
IArrayLeadingType& operator=(const IArrayLeadingType& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const IArrayLeadingType& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const IArrayLeadingType& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param arrayleadingtype The C object.
@return The new C++ object. */
explicit IArrayLeadingType(ArrayLeadingTypeRef arrayleadingtype);
/** Destructor */
virtual ~IArrayLeadingType();
/** Retrieves a reference to this object.
@return The object reference. */
ArrayLeadingTypeRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
// ========================================================================
// PROPERTIES
// ========================================================================
/** Retrieves the number of members of this set.
@return The number of members. */
ATETextDOM::Int32 GetSize( ) const;
/** Retrieves the first member of this set.
@return The member value. */
LeadingType GetFirst( ) const;
/** Retrieves the last member of this set.
@return The member value. */
LeadingType GetLast( ) const;
// ========================================================================
// METHODS
// ========================================================================
/** Retrieves a member of this set by position index. Use with \c GetSize()
to iterate through members.
@param index The 0-based position index.
@return The member value.
*/
LeadingType Item( ATETextDOM::Int32 index) const;
};
//////////////////////////////////////////////
// --IArrayFontRef--
//////////////////////////////////////////////
/** Provides access to an ordered collection of font objects. */
class IArrayFontRef
{
private:
ArrayFontRefRef fArrayFontRef;
public:
/** Constructor
@return The new object. */
IArrayFontRef();
/** Copy constructor
@param src The object to copy.
@return The new object. */
IArrayFontRef(const IArrayFontRef& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
IArrayFontRef& operator=(const IArrayFontRef& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const IArrayFontRef& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const IArrayFontRef& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param arrayfontref The C object.
@return The new C++ object. */
explicit IArrayFontRef(ArrayFontRefRef arrayfontref);
/** Destructor */
virtual ~IArrayFontRef();
/** Retrieves a reference to this object.
@return The object reference. */
ArrayFontRefRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
// ========================================================================
// PROPERTIES
// ========================================================================
/** Retrieves the number of members of this set.
@return The number of members. */
ATETextDOM::Int32 GetSize( ) const;
/** Retrieves the first member of this set.
@return The member object. */
IFont GetFirst( ) const;
/** Retrieves the last member of this set.
@return The member object. */
IFont GetLast( ) const;
// ========================================================================
// METHODS
// ========================================================================
/** Retrieves a member of this set by position index. Use with \c GetSize()
to iterate through members.
@param index The 0-based position index.
@return The member object.
*/
IFont Item( ATETextDOM::Int32 index) const;
};
//////////////////////////////////////////////
// --IArrayGlyphID--
//////////////////////////////////////////////
/** Provides access to an ordered collection of glyph identifier objects. */
class IArrayGlyphID
{
private:
ArrayGlyphIDRef fArrayGlyphID;
public:
/** Constructor
@return The new object. */
IArrayGlyphID();
/** Copy constructor
@param src The object to copy.
@return The new object. */
IArrayGlyphID(const IArrayGlyphID& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
IArrayGlyphID& operator=(const IArrayGlyphID& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const IArrayGlyphID& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const IArrayGlyphID& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param arrayglyphid The C object.
@return The new C++ object. */
explicit IArrayGlyphID(ArrayGlyphIDRef arrayglyphid);
/** Destructor */
virtual ~IArrayGlyphID();
/** Retrieves a reference to this object.
@return The object reference. */
ArrayGlyphIDRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
// ========================================================================
// PROPERTIES
// ========================================================================
/** Retrieves the number of members of this set.
@return The number of members. */
ATETextDOM::Int32 GetSize( ) const;
/** Retrieves the first member of this set.
@return The member object. */
ATEGlyphID GetFirst( ) const;
/** Retrieves the last member of this set.
@return The member object. */
ATEGlyphID GetLast( ) const;
// ========================================================================
// METHODS
// ========================================================================
/** Retrieves a member of this set by position index. Use with \c GetSize()
to iterate through members.
@param index The 0-based position index.
@return The member object.
*/
ATEGlyphID Item( ATETextDOM::Int32 index) const;
};
//////////////////////////////////////////////
// --IArrayRealPoint--
//////////////////////////////////////////////
/** Provides access to an ordered collection of point position values
with real-number coordinates. */
class IArrayRealPoint
{
private:
ArrayRealPointRef fArrayRealPoint;
public:
/** Constructor
@return The new object. */
IArrayRealPoint();
/** Copy constructor
@param src The object to copy.
@return The new object. */
IArrayRealPoint(const IArrayRealPoint& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
IArrayRealPoint& operator=(const IArrayRealPoint& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const IArrayRealPoint& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const IArrayRealPoint& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param arrayrealpoint The C object.
@return The new C++ object. */
explicit IArrayRealPoint(ArrayRealPointRef arrayrealpoint);
/** Destructor */
virtual ~IArrayRealPoint();
/** Retrieves a reference to this object.
@return The object reference. */
ArrayRealPointRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
// ========================================================================
// PROPERTIES
// ========================================================================
/** Retrieves the number of members of this set.
@return The number of members. */
ATETextDOM::Int32 GetSize( ) const;
/** Retrieves the first member of this set.
@return The member value. */
ATETextDOM::RealPoint GetFirst( ) const;
/** Retrieves the last member of this set.
@return The member value. */
ATETextDOM::RealPoint GetLast( ) const;
// ========================================================================
// METHODS
// ========================================================================
/** Retrieves a member of this set by position index. Use with \c GetSize()
to iterate through members.
@param index The 0-based position index.
@return The member value.
*/
ATETextDOM::RealPoint Item( ATETextDOM::Int32 index) const;
};
//////////////////////////////////////////////
// --IArrayRealMatrix--
//////////////////////////////////////////////
/** Provides access to an ordered collection of transformation matrix values. */
class IArrayRealMatrix
{
private:
ArrayRealMatrixRef fArrayRealMatrix;
public:
/** Constructor
@return The new object. */
IArrayRealMatrix();
/** Copy constructor
@param src The object to copy.
@return The new object. */
IArrayRealMatrix(const IArrayRealMatrix& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
IArrayRealMatrix& operator=(const IArrayRealMatrix& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const IArrayRealMatrix& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const IArrayRealMatrix& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param arrayrealmatrix The C object.
@return The new C++ object. */
explicit IArrayRealMatrix(ArrayRealMatrixRef arrayrealmatrix);
/** Destructor */
virtual ~IArrayRealMatrix();
/** Retrieves a reference to this object.
@return The object reference. */
ArrayRealMatrixRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
// ========================================================================
// PROPERTIES
// ========================================================================
/** Retrieves the number of members of this set.
@return The number of members. */
ATETextDOM::Int32 GetSize( ) const;
/** Retrieves the first member of this set.
@return The member value. */
ATETextDOM::RealMatrix GetFirst( ) const;
/** Retrieves the last member of this set.
@return The member value. */
ATETextDOM::RealMatrix GetLast( ) const;
// ========================================================================
// METHODS
// ========================================================================
/** Retrieves a member of this set by position index. Use with \c GetSize()
to iterate through members.
@param index The 0-based position index.
@return The member value.
*/
ATETextDOM::RealMatrix Item( ATETextDOM::Int32 index) const;
};
//////////////////////////////////////////////
// --IArrayLine--
//////////////////////////////////////////////
/** Provides access to an ordered collection of line objects
where each entry is the start and end point of a 2D line.
*/
class IArrayLine
{
private:
ArrayLineRef fArrayLine;
public:
/** Constructor.
@return The new object. */
IArrayLine();
/** Copy constructor
@param src The object to copy.
@return The new object. */
IArrayLine(const IArrayLine& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
IArrayLine& operator=(const IArrayLine& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const IArrayLine& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const IArrayLine& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param ArrayLineRef The C object.
@return The new C++ object. */
explicit IArrayLine(ArrayLineRef ArrayLineRef);
/** Destructor */
virtual ~IArrayLine();
/** Retrieves a reference to this object.
@return The object reference. */
ArrayLineRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
// ========================================================================
// PROPERTIES
// ========================================================================
/** Retrieves the number of members of this set.
@return The number of members. */
ATETextDOM::Int32 GetSize( ) const;
// ========================================================================
// METHODS
// ========================================================================
/** Retrieves the line start and end points of a 2Dline in this set by position index. Use with \c GetSize()
to iterate through members.
@param index The 0-based position index.
@param lineStart [out] the ATETextDOM::RealPoint object defining the start of the line.
@param lineEnd [out] the ATETextDOM::RealPoint object defining the end of the line.
@return Nothing.
*/
void Item( ATETextDOM::Int32 index, ATETextDOM::FloatPoint* lineStart, ATETextDOM::FloatPoint* lineEnd) const;
};
//////////////////////////////////////////////
// --IArrayComposerEngine--
//////////////////////////////////////////////
/** Provides access to an ordered collection of composer engine objects.
*/
class IArrayComposerEngine
{
private:
ArrayComposerEngineRef fArrayComposerEngine;
public:
/** Constructor.
@return The new object. */
IArrayComposerEngine();
/** Copy constructor
@param src The object to copy.
@return The new object. */
IArrayComposerEngine(const IArrayComposerEngine& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
IArrayComposerEngine& operator=(const IArrayComposerEngine& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const IArrayComposerEngine& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const IArrayComposerEngine& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param arraycomposerengine The C object.
@return The new C++ object. */
explicit IArrayComposerEngine(ArrayComposerEngineRef arraycomposerengine);
/** Destructor */
virtual ~IArrayComposerEngine();
/** Retrieves a reference to this object.
@return The object reference. */
ArrayComposerEngineRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
// ========================================================================
// PROPERTIES
// ========================================================================
/** Retrieves the number of members of this set.
@return The number of members. */
ATETextDOM::Int32 GetSize( ) const;
/** Retrieves the first member of this set.
@return The member value. */
ComposerEngine GetFirst( ) const;
/** Retrieves the last member of this set.
@return The member value. */
ComposerEngine GetLast( ) const;
// ========================================================================
// METHODS
// ========================================================================
/** Retrieves a member of this set by position index. Use with \c GetSize()
to iterate through members.
@param index The 0-based position index.
@return The member value.
*/
ComposerEngine Item( ATETextDOM::Int32 index) const;
};
#if SLO_COMPLEXSCRIPT // Middle Eastern specific features only
//////////////////////////////////////////////
// --IArrayParagraphDirection--
//////////////////////////////////////////////
/** Provides access to an ordered collection of paragraph direction objects.
*/
class IArrayParagraphDirection
{
private:
ArrayParagraphDirectionRef fArrayParagraphDirection;
public:
/** Constructor
@return The new object. */
IArrayParagraphDirection();
/** Copy constructor
@param src The object to copy.
@return The new object. */
IArrayParagraphDirection(const IArrayParagraphDirection& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
IArrayParagraphDirection& operator=(const IArrayParagraphDirection& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const IArrayParagraphDirection& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const IArrayParagraphDirection& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param arrayparagraphdirection The C object.
@return The new C++ object. */
explicit IArrayParagraphDirection(ArrayParagraphDirectionRef arrayparagraphdirection);
/** Destructor */
virtual ~IArrayParagraphDirection();
/** Retrieves a reference to this object.
@return The object reference. */
ArrayParagraphDirectionRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
// ========================================================================
// PROPERTIES
// ========================================================================
/** Retrieves the number of members of this set.
@return The number of members. */
ATETextDOM::Int32 GetSize( ) const;
/** Retrieves the first member of this set.
@return The member value. */
ParagraphDirection GetFirst( ) const;
/** Retrieves the last member of this set.
@return The member value. */
ParagraphDirection GetLast( ) const;
// ========================================================================
// METHODS
// ========================================================================
/** Retrieves a member of this set by position index. Use with \c GetSize()
to iterate through members.
@param index The 0-based position index.
@return The member value.
*/
ParagraphDirection Item( ATETextDOM::Int32 index) const;
};
//////////////////////////////////////////////
// --IArrayJustificationMethod--
//////////////////////////////////////////////
/** Provides access to an ordered collection of justification method objects.
*/
class IArrayJustificationMethod
{
private:
ArrayJustificationMethodRef fArrayJustificationMethod;
public:
/** Constructor
@return The new object. */
IArrayJustificationMethod();
/** Copy constructor
@param src The object to copy.
@return The new object. */
IArrayJustificationMethod(const IArrayJustificationMethod& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
IArrayJustificationMethod& operator=(const IArrayJustificationMethod& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const IArrayJustificationMethod& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const IArrayJustificationMethod& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param arrayjustificationmethod The C object.
@return The new C++ object. */
explicit IArrayJustificationMethod(ArrayJustificationMethodRef arrayjustificationmethod);
/** Destructor */
virtual ~IArrayJustificationMethod();
/** Retrieves a reference to this object.
@return The object reference. */
ArrayJustificationMethodRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
// ========================================================================
// PROPERTIES
// ========================================================================
/** Retrieves the number of members of this set.
@return The number of members. */
ATETextDOM::Int32 GetSize( ) const;
/** Retrieves the first member of this set.
@return The member value. */
JustificationMethod GetFirst( ) const;
/** Retrieves the last member of this set.
@return The member value. */
JustificationMethod GetLast( ) const;
// ========================================================================
// METHODS
// ========================================================================
/** Retrieves a member of this set by position index. Use with \c GetSize()
to iterate through members.
@param index The 0-based position index.
@return The member value.
*/
JustificationMethod Item( ATETextDOM::Int32 index) const;
};
//////////////////////////////////////////////
// --IArrayKashidaWidth--
//////////////////////////////////////////////
/** Provides access to an ordered collection of justification method objects.
*/
class IArrayKashidaWidth
{
private:
ArrayKashidaWidthRef fArrayKashidaWidth;
public:
/** Constructor
@return The new object. */
IArrayKashidaWidth();
/** Copy constructor
@param src The object to copy.
@return The new object. */
IArrayKashidaWidth(const IArrayKashidaWidth& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
IArrayKashidaWidth& operator=(const IArrayKashidaWidth& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const IArrayKashidaWidth& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const IArrayKashidaWidth& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param arraykashidawidth The C object.
@return The new C++ object. */
explicit IArrayKashidaWidth(ArrayKashidaWidthRef arraykashidawidth);
/** Destructor */
virtual ~IArrayKashidaWidth();
/** Retrieves a reference to this object.
@return The object reference. */
ArrayKashidaWidthRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
// ========================================================================
// PROPERTIES
// ========================================================================
/** Retrieves the number of members of this set.
@return The number of members. */
ATETextDOM::Int32 GetSize( ) const;
/** Retrieves the first member of this set.
@return The member value. */
KashidaWidth GetFirst( ) const;
/** Retrieves the last member of this set.
@return The member value. */
KashidaWidth GetLast( ) const;
// ========================================================================
// METHODS
// ========================================================================
/** Retrieves a member of this set by position index. Use with \c GetSize()
to iterate through members.
@param index The 0-based position index.
@return The member value.
*/
KashidaWidth Item( ATETextDOM::Int32 index) const;
};
//////////////////////////////////////////////
// --IArrayKashidas--
//////////////////////////////////////////////
/** Provides access to an ordered collection of kashidas objects.
*/
class IArrayKashidas
{
private:
ArrayKashidasRef fArrayKashidas;
public:
/** Constructor
@return The new object. */
IArrayKashidas();
/** Copy constructor
@param src The object to copy.
@return The new object. */
IArrayKashidas(const IArrayKashidas& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
IArrayKashidas& operator=(const IArrayKashidas& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const IArrayKashidas& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const IArrayKashidas& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param arraykashidas The C object.
@return The new C++ object. */
explicit IArrayKashidas(ArrayKashidasRef arraykashidas);
/** Destructor */
virtual ~IArrayKashidas();
/** Retrieves a reference to this object.
@return The object reference. */
ArrayKashidasRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
// ========================================================================
// PROPERTIES
// ========================================================================
/** Retrieves the number of members of this set.
@return The number of members. */
ATETextDOM::Int32 GetSize( ) const;
/** Retrieves the first member of this set.
@return The member value. */
Kashidas GetFirst( ) const;
/** Retrieves the last member of this set.
@return The member value. */
Kashidas GetLast( ) const;
// ========================================================================
// METHODS
// ========================================================================
/** Retrieves a member of this set by position index. Use with \c GetSize()
to iterate through members.
@param index The 0-based position index.
@return The member value.
*/
Kashidas Item( ATETextDOM::Int32 index) const;
};
//////////////////////////////////////////////
// --IArrayDirOverride--
//////////////////////////////////////////////
/** Provides access to an ordered collection of writing direction override objects.
*/
class IArrayDirOverride
{
private:
ArrayDirOverrideRef fArrayDirOverride;
public:
/** Constructor
@return The new object. */
IArrayDirOverride();
/** Copy constructor
@param src The object to copy.
@return The new object. */
IArrayDirOverride(const IArrayDirOverride& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
IArrayDirOverride& operator=(const IArrayDirOverride& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const IArrayDirOverride& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const IArrayDirOverride& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param arraydiroverride The C object.
@return The new C++ object. */
explicit IArrayDirOverride(ArrayDirOverrideRef arraydiroverride);
/** Destructor */
virtual ~IArrayDirOverride();
/** Retrieves a reference to this object.
@return The object reference. */
ArrayDirOverrideRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
// ========================================================================
// PROPERTIES
// ========================================================================
/** Retrieves the number of members of this set.
@return The number of members. */
ATETextDOM::Int32 GetSize( ) const;
/** Retrieves the first member of this set.
@return The member value. */
DirOverride GetFirst( ) const;
/** Retrieves the last member of this set.
@return The member value. */
DirOverride GetLast( ) const;
// ========================================================================
// METHODS
// ========================================================================
/** Retrieves a member of this set by position index. Use with \c GetSize()
to iterate through members.
@param index The 0-based position index.
@return The member value.
*/
DirOverride Item( ATETextDOM::Int32 index) const;
};
//////////////////////////////////////////////
// --IArrayDigitSet--
//////////////////////////////////////////////
/** Provides access to an ordered collection of digit set objects.
*/
class IArrayDigitSet
{
private:
ArrayDigitSetRef fArrayDigitSet;
public:
/** Constructor
@return The new object. */
IArrayDigitSet();
/** Copy constructor
@param src The object to copy.
@return The new object. */
IArrayDigitSet(const IArrayDigitSet& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
IArrayDigitSet& operator=(const IArrayDigitSet& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const IArrayDigitSet& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const IArrayDigitSet& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param arraydigitset The C object.
@return The new C++ object. */
explicit IArrayDigitSet(ArrayDigitSetRef arraydigitset);
/** Destructor */
virtual ~IArrayDigitSet();
/** Retrieves a reference to this object.
@return The object reference. */
ArrayDigitSetRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
// ========================================================================
// PROPERTIES
// ========================================================================
/** Retrieves the number of members of this set.
@return The number of members. */
ATETextDOM::Int32 GetSize( ) const;
/** Retrieves the first member of this set.
@return The member value. */
DigitSet GetFirst( ) const;
/** Retrieves the last member of this set.
@return The member value. */
DigitSet GetLast( ) const;
// ========================================================================
// METHODS
// ========================================================================
/** Retrieves a member of this set by position index. Use with \c GetSize()
to iterate through members.
@param index The 0-based position index.
@return The member value.
*/
DigitSet Item( ATETextDOM::Int32 index) const;
};
//////////////////////////////////////////////
// --IArrayDiacVPos--
//////////////////////////////////////////////
/** Provides access to an ordered collection of diacritics positioning objects.
*/
class IArrayDiacVPos
{
private:
ArrayDiacVPosRef fArrayDiacVPos;
public:
/** Constructor
@return The new object. */
IArrayDiacVPos();
/** Copy constructor
@param src The object to copy.
@return The new object. */
IArrayDiacVPos(const IArrayDiacVPos& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
IArrayDiacVPos& operator=(const IArrayDiacVPos& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const IArrayDiacVPos& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const IArrayDiacVPos& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param arraydiacvpos The C object.
@return The new C++ object. */
explicit IArrayDiacVPos(ArrayDiacVPosRef arraydiacvpos);
/** Destructor */
virtual ~IArrayDiacVPos();
/** Retrieves a reference to this object.
@return The object reference. */
ArrayDiacVPosRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
// ========================================================================
// PROPERTIES
// ========================================================================
/** Retrieves the number of members of this set.
@return The number of members. */
ATETextDOM::Int32 GetSize( ) const;
/** Retrieves the first member of this set.
@return The member value. */
DiacVPos GetFirst( ) const;
/** Retrieves the last member of this set.
@return The member value. */
DiacVPos GetLast( ) const;
// ========================================================================
// METHODS
// ========================================================================
/** Retrieves a member of this set by position index. Use with \c GetSize()
to iterate through members.
@param index The 0-based position index.
@return The member value.
*/
DiacVPos Item( ATETextDOM::Int32 index) const;
};
#endif
//////////////////////////////////////////////
// --ICharFeatures--
//////////////////////////////////////////////
/** This class encapsulates the complete set of character attributes that
can be applied to text. An object of this type is contained in an
\c ICharStyle object, and is returned from various methods that
query character features of text runs and text ranges. A paragraph
style can also have a default set of character features; see
\c IParaFeatures::GetDefaultCharFeatures().
Attribute values are inherited from the Normal style, and can be overridden
in a named style associated with the character, or at the local character level.
A style or character can partially define attributes. Only those values
that are assigned override the inherited values. The constructor creates
an empty object, in which all attribute values are unassigned.
Setting a value causes it to be assigned, and clearing it causes
it to be unassigned. When you retrieve an attribute value, a boolean
return value, \c isAssigned, reports whether that attribute has a local
value in the queried object.
@see \c ICharInspector
*/
class ICharFeatures
{
private:
CharFeaturesRef fCharFeatures;
public:
/** Constructor. The object is empty; that is, all
attribute values are unassigned.
@return The new object. */
ICharFeatures();
/** Copy constructor
@param src The object to copy.
@return The new object. */
ICharFeatures(const ICharFeatures& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
ICharFeatures& operator=(const ICharFeatures& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const ICharFeatures& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const ICharFeatures& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param charfeatures The C object.
@return The new C++ object. */
explicit ICharFeatures(CharFeaturesRef charfeatures);
/** Destructor */
virtual ~ICharFeatures();
/** Retrieves a reference to this object.
@return The object reference. */
CharFeaturesRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
/** Creates a duplicate of this object.
@return The new object. */
ICharFeatures Clone( ) const;
///////////////////////////////////////////////////////////////////////
// GET PROPERTIES
///////////////////////////////////////////////////////////////////////
/** Retrieves the font attribute of this character.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The font object. */
IFont GetFont( bool* isAssigned) const;
/** Retrieves the font size attribute of this character.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The font size in dcoument points. */
ATETextDOM::Real GetFontSize( bool* isAssigned) const;
/** Retrieves the horizontal scale attribute of this character.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The scale value, where 1 is 100% */
ATETextDOM::Real GetHorizontalScale( bool* isAssigned) const;
/** Retrieves the vertical scale attribute of this character.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The scale value, where 1 is 100%. */
ATETextDOM::Real GetVerticalScale( bool* isAssigned) const;
/** Retrieves the automatic leading attribute of this character.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return True if automatic leading is on, false if it is off. */
bool GetAutoLeading( bool* isAssigned) const;
/** Retrieves the leading attribute of this character.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The leading value in document points. */
ATETextDOM::Real GetLeading( bool* isAssigned) const;
/** Retrieves the tracking attribute of this character.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The tracking value in document points. */
ATETextDOM::Int32 GetTracking( bool* isAssigned) const;
/** Retrieves the baseline shift attribute of this character.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The baseline shift value in document points. */
ATETextDOM::Real GetBaselineShift( bool* isAssigned) const;
/** Retrieves the character rotation attribute of this character.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The character rotation value in degrees. */
ATETextDOM::Real GetCharacterRotation( bool* isAssigned) const;
/** Retrieves the automatic kerning type attribute of this character.
(The actual kerning value applies to character pairs rather than
individual characters, so is available through the \c ICharStyle.)
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The automatic kerning type constant.
@note Use \c IStory::GetKern( ) to get the kerning
value for a text range. */
AutoKernType GetAutoKernType( bool* isAssigned) const;
/** Retrieves the font caps option attribute of this character.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The font caps option constant. */
FontCapsOption GetFontCapsOption( bool* isAssigned) const;
/** Retrieves the font baseline option attribute of this character.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The font baseline option constant. */
FontBaselineOption GetFontBaselineOption( bool* isAssigned) const;
/** Retrieves the font OpenType position option attribute of this character.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The font OpenType position option constant. */
FontOpenTypePositionOption GetFontOpenTypePositionOption( bool* isAssigned) const;
/** Retrieves the strikethrough position attribute of this character.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The strikethrough position constant. */
StrikethroughPosition GetStrikethroughPosition( bool* isAssigned) const;
/** Retrieves the underline position attribute of this character.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The underline position constant. */
UnderlinePosition GetUnderlinePosition( bool* isAssigned) const;
/** Retrieves the underline offset attribute of this character.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The underline offset value, in document points. */
ATETextDOM::Real GetUnderlineOffset( bool* isAssigned) const;
// ------------------------------------------------------------------
// OpenType settings
// ------------------------------------------------------------------
/** Retrieves the OpenType ligature attribute of this character.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return True if ligature is on, false if it is off. */
bool GetLigature( bool* isAssigned) const;
/** Retrieves the OpenType discretionary ligatures attribute of this character.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return True if discretionary ligatures are on, false if they are off. */
bool GetDiscretionaryLigatures( bool* isAssigned) const;
/** Retrieves the OpenType context ligatures attribute of this character.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return True if context ligatures are on, false if they are off. */
bool GetContextualLigatures( bool* isAssigned) const;
/** Retrieves the OpenType alternate ligatures attribute of this character.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return True if alternate ligatures are on, false if they are off. */
bool GetAlternateLigatures( bool* isAssigned) const;
/** Retrieves the OpenType old-style attribute of this character.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return True if the character is old-style, false if it is not. */
bool GetOldStyle( bool* isAssigned) const;
/** Retrieves the OpenType fractions attribute of this character.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return True if fractions are on, false if they are off. */
bool GetFractions( bool* isAssigned) const;
/** Retrieves the OpenType ordinals attribute of this character.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return True if ordinals are on, false if they are off. */
bool GetOrdinals( bool* isAssigned) const;
/** Retrieves the OpenType swash attribute of this character.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return True if swash is on, false if it is off. */
bool GetSwash( bool* isAssigned) const;
/** Retrieves the OpenType titling attribute of this character.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return True if titling is on, false if it is off. */
bool GetTitling( bool* isAssigned) const;
/** Retrieves the OpenType connection forms attribute of this character.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return True if connection forms are on, false if they are off. */
bool GetConnectionForms( bool* isAssigned) const;
/** Retrieves the OpenType stylistic alternates attribute of this character.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return True if stylistic alternates are on, false if they are off. */
bool GetStylisticAlternates( bool* isAssigned) const;
/** Retrieves the OpenType stylistic sets attribute of this character.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value. */
ATETextDOM::Int32 GetStylisticSets(bool* isAssigned) const;
/** Retrieves the OpenType ornaments attribute of this character.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return True if ornaments are on, false if they are off. */
bool GetOrnaments( bool* isAssigned) const;
/** Retrieves the OpenType figure style attribute of this character.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The figure style constant. */
FigureStyle GetFigureStyle( bool* isAssigned) const;
// ------------------------------------------------------------------
// Japanese OpenType settings
// ------------------------------------------------------------------
/** Retrieves the Japanese OpenType proportional metrics attribute of this character.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return True if proportional metrics are on, false if they are off. */
bool GetProportionalMetrics( bool* isAssigned) const;
/** Retrieves the Japanese OpenType Kana attribute of this character.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return True if Kana is on, false if it is off. */
bool GetKana( bool* isAssigned) const;
/** Retrieves the Japanese OpenType Ruby attribute of this character.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return True if Ruby is on, false if it is off. */
bool GetRuby( bool* isAssigned) const;
/** Retrieves the Japanese OpenType italics attribute of this character.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return True if italics is on, false if it is off. */
bool GetItalics( bool* isAssigned) const;
/** Retrieves the Japanese OpenType baseline direction attribute of this character.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The baseline direction constant. */
BaselineDirection GetBaselineDirection( bool* isAssigned) const;
/** Retrieves the Japanese OpenType language attribute of this character.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The language constant. */
Language GetLanguage( bool* isAssigned) const;
/** Retrieves the Japanese OpenType alternate feature attribute of this character.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The Japanese alternate feature constant. */
JapaneseAlternateFeature GetJapaneseAlternateFeature( bool* isAssigned) const;
/** Retrieves the Japanese OpenType Tsume attribute of this character style.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The Tsume value, in document points. */
ATETextDOM::Real GetTsume( bool* isAssigned) const;
/** Retrieves the Japanese OpenType style run alignment attribute of this character.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The style run alignment constant. */
StyleRunAlignment GetStyleRunAlignment( bool* isAssigned) const;
// ------------------------------------------------------------------
// WariChu settings
// ------------------------------------------------------------------
/** Retrieves the WariChu-enabled attribute of this character.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return True if WariChu is on, false if it is off. */
bool GetWariChuEnabled( bool* isAssigned) const;
/** Retrieves the WariChu line count attribute of this character style.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The WariChu line count value. */
ATETextDOM::Int32 GetWariChuLineCount( bool* isAssigned) const;
/** Retrieves the WariChu line gap attribute of this character style.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The WariChu line gap value. */
ATETextDOM::Int32 GetWariChuLineGap( bool* isAssigned) const;
/** Retrieves the WariChu scale attribute of this character style.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The WariChu scale factor, where 1 is 100% */
ATETextDOM::Real GetWariChuScale( bool* isAssigned) const;
/** Retrieves the WariChu size attribute of this character style.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The WariChu size in document points. */
ATETextDOM::Real GetWariChuSize( bool* isAssigned) const;
/** Retrieves the WariChu widow amount attribute of this character style.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The WariChu widow amount value. */
ATETextDOM::Int32 GetWariChuWidowAmount( bool* isAssigned) const;
/** Retrieves the WariChu orphan amount attribute of this character style.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The WariChu orphan amount value. */
ATETextDOM::Int32 GetWariChuOrphanAmount( bool* isAssigned) const;
/** Retrieves the WariChu justification attribute of this character.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The WariChu justification constant. */
WariChuJustification GetWariChuJustification( bool* isAssigned) const;
/** Retrieves the Tate Chu Yoko up-down adjustment attribute of this character style.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The up-down adjustment value. */
ATETextDOM::Int32 GetTCYUpDownAdjustment( bool* isAssigned) const;
/** Retrieves the Tate Chu Yoko right-left adjustment attribute of this character style.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The right-left adjustment value. */
ATETextDOM::Int32 GetTCYLeftRightAdjustment( bool* isAssigned) const;
/** Retrieves the left Aki attribute of this character.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The left Aki value. */
ATETextDOM::Real GetLeftAki( bool* isAssigned) const;
/** Retrieves the right Aki attribute of this character.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The right Aki value. */
ATETextDOM::Real GetRightAki( bool* isAssigned) const;
//---------------------------------------------------------------
// General settings
//---------------------------------------------------------------
/** Retrieves the no-break attribute of this character.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return True if no-break is on, false if it is off. */
bool GetNoBreak( bool* isAssigned) const;
/** Retrieves the fill color attribute of this character.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The paint object containing the fill color. */
IApplicationPaint GetFillColor( bool* isAssigned) const;
/** Retrieves the stroke color attribute of this character.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The paint object containing the stroke color. */
IApplicationPaint GetStrokeColor( bool* isAssigned) const;
/** Retrieves the fill attribute of this character.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return True if fill is on, false if it is off. */
bool GetFill( bool* isAssigned) const;
/** Retrieves the fill visibilty attribute of this character.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return True if fill is visible, false if it is not. */
bool GetFillVisible( bool* isAssigned) const;
/** Retrieves the stroke attribute of this character.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return True if stroke is on, false if it is off. */
bool GetStroke( bool* isAssigned) const;
/** Retrieves the stroke visibility attribute of this character.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return True if stroke is visible, false if it is not. */
bool GetStrokeVisible( bool* isAssigned) const;
/** Retrieves the fill-first attribute of this character.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return True if fill-first is on, false if it is off. */
bool GetFillFirst( bool* isAssigned) const;
/** Retrieves the fill overprint attribute of this character.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return True if fill overprint is on, false if it is off. */
bool GetFillOverPrint( bool* isAssigned) const;
/** Retrieves the stroke overprint attribute of this character.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return True if stroke overprint is on, false if it is off. */
bool GetStrokeOverPrint( bool* isAssigned) const;
/** Retrieves the fill background color attribute of this character.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The paint object containing the fill color. */
IApplicationPaint GetFillBackgroundColor( bool* isAssigned) const;
/** Retrieves the fill background attribute of this character.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return True if fill is on, false if it is off. */
bool GetFillBackground( bool* isAssigned) const;
/** Retrieves the line cap attribute of this character.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The line cap type constant. */
LineCapType GetLineCap( bool* isAssigned) const;
/** Retrieves the line join attribute of this character.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The line join type constant. */
LineJoinType GetLineJoin( bool* isAssigned) const;
/** Retrieves the line width attribute of this character.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The line width value in document points. */
ATETextDOM::Real GetLineWidth( bool* isAssigned) const;
/** Retrieves the miter limit attribute of this character.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The miter limit value in document points. */
ATETextDOM::Real GetMiterLimit( bool* isAssigned) const;
/** Retrieves the line dash offset attribute of this character.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The line dash offset value in document points. */
ATETextDOM::Real GetLineDashOffset( bool* isAssigned) const;
/** Retrieves the line dash array attribute of this character.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The line dash array object. */
IArrayReal GetLineDashArray( bool* isAssigned) const;
#if SLO_COMPLEXSCRIPT // Middle Eastern specific features only
// ------------------------------------------------------------------
// Complex Script Settings
// ------------------------------------------------------------------
/** Retrieves the kashidas attribute of this character.
@param isAssigned [out] a buffer in which to return
true if this attribute has a local value.
@return The kashidas object.
*/
Kashidas GetKashidas( bool* isAssigned) const;
/** Retrieves the direction override attribute of this character.
@param isAssigned [out] a buffer in which to return
true if this attribute has a local value.
@return The direction override object.
*/
DirOverride GetDirOverride( bool* isAssigned) const;
/** Retrieves the digit set attribute of this character.
@param isAssigned [out] a buffer in which to return
true if this attribute has a local value.
@return The digit set object.
*/
DigitSet GetDigitSet( bool* isAssigned) const;
/** Retrieves the diacritics positioning attribute of this
character.
@param isAssigned [out] a buffer in which to return
true if this attribute has a local value.
@return The diacritics positioning object.
*/
DiacVPos GetDiacVPos( bool* isAssigned) const;
/** Retrieves the diacritics x offset attribute of this
character as a real number.
@param isAssigned [out] a buffer in which to return
true if this attribute has a local value.
@return diacritics x offset as a real number.
*/
ATETextDOM::Real GetDiacXOffset( bool* isAssigned) const;
/** Retrieves the diacritics y offset attribute of this
character as a real number.
@param isAssigned [out] a buffer in which to return
true if this attribute has a local value.
@return diacritics y offset as a real number.
*/
ATETextDOM::Real GetDiacYOffset( bool* isAssigned) const;
/** Retrieves the automatic diacritics y distance from baseline attribute of this character.
@param isAssigned [out] a buffer in which to return
true if this attribute has a local value.
@return True if automatic diacritics y distance from baseline is on, false if it is off.
*/
bool GetAutoMydfb( bool* isAssigned) const;
/** Retrieves the diacritics y distance from baseline attribute
of this character as a real number.
@param isAssigned [out] a buffer in which to return
true if this attribute has a local value.
@return diacritics y distance from baseline as a real number.
*/
ATETextDOM::Real GetMarkYDistFromBaseline( bool* isAssigned) const;
/** Retrieves the OpenType overlap swash attribute of
this character.
@param isAssigned [out] a buffer in which to return
true if this attribute has a local value.
@return True if overlap swash is on, false if it is off.
*/
bool GetOverlapSwash( bool* isAssigned) const;
/** Retrieves the justification alternates attribute of
this character.
@param isAssigned [out] a buffer in which to return
true if this attribute has a local value.
@return True if justification alternates is on, false if it is off.
*/
bool GetJustificationAlternates( bool* isAssigned) const;
/** Retrieves the stretched alternates attribute of this character.
@param isAssigned [out] a buffer in which to return
true if this attribute has a local value.
@return True if stretched alternates is on, false if it is off.
*/
bool GetStretchedAlternates( bool* isAssigned) const;
#endif
///////////////////////////////////////////////////////////////////
// SET PROPERTIES
////////////////////////////////////////////////////////////////
/** Sets the local font attribute for this character.
@param newVal The new font object.
@return Nothing.
*/
void SetFont( IFont newVal);
/** Sets the local font size attribute for this character.
@param newVal The new value, in the range [0.1..1296].
@return Nothing.
*/
void SetFontSize( ATETextDOM::Real newVal);
/** Sets the local horizontal scale attribute for this character.
@param newVal The new scaling factor, in the range [0.1..100], where 1 is 100%.
@return Nothing.
*/
void SetHorizontalScale( ATETextDOM::Real newVal);
/** Sets the local vertical scale attribute for this character.
@param newVal The new scaling factor, in the range [0.1..100], where 1 is 100%.
@return Nothing.
*/
void SetVerticalScale( ATETextDOM::Real newVal);
/** Sets the local automatic leading attribute for this character.
@param newVal True to turn automatic leading on, false to turn it off.
@return Nothing.
*/
void SetAutoLeading( bool newVal);
/** Sets the local leading attribute for this character.
@param newVal The new leading value in document points.
@return Nothing.
*/
void SetLeading( ATETextDOM::Real newVal);
/** Sets the local tracking attribute for this character.
@param newVal The new tracking value in document points.
@return Nothing.
*/
void SetTracking( ATETextDOM::Int32 newVal);
/** Sets the local baseline shift attribute for this character.
@param newVal The new baseline shift value in document points.
@return Nothing.
*/
void SetBaselineShift( ATETextDOM::Real newVal);
/** Sets the local character rotation attribute for this character.
@param newVal The new rotation value in degrees.
@return Nothing.
*/
void SetCharacterRotation( ATETextDOM::Real newVal);
/** Sets the local automatic kerning type attribute for this character style.
This is not available for individual characters.
@param newVal The new automatic kerning type constant.
@return Nothing.
*/
void SetAutoKernType( AutoKernType newVal);
/** Sets the local font caps option attribute for this character style.
@param newVal The new font caps option constant.
@return Nothing.
*/
void SetFontCapsOption( FontCapsOption newVal);
/** Sets the local font baseline option attribute for this character style.
@param newVal The new font baseline option constant.
@return Nothing.
*/
void SetFontBaselineOption( FontBaselineOption newVal);
/** Sets the local font OpenType position option attribute for this character style.
@param newVal The new font OpenType position option constant.
@return Nothing.
*/
void SetFontOpenTypePositionOption( FontOpenTypePositionOption newVal);
/** Sets the local strikethrough position attribute for this character style.
@param newVal The new strikethrough position constant.
@return Nothing.
*/
void SetStrikethroughPosition( StrikethroughPosition newVal);
/** Sets the local underline position attribute for this character style.
@param newVal The new underline position constant.
@return Nothing.
*/
void SetUnderlinePosition( UnderlinePosition newVal);
/** Sets the local underline offset attribute for this character style.
@param newVal The new underline offset value, in document points.
@return Nothing.
*/
void SetUnderlineOffset( ATETextDOM::Real newVal);
// ------------------------------------------------------------------
// OpenType settings
// ------------------------------------------------------------------
/** Sets the local OpenType ligature attribute for this character style.
@param newVal The new underline offset value, in document points.
@return Nothing.
*/
void SetLigature( bool newVal);
/** Sets the local OpenType discretionary ligatures attribute for this character style.
@param newVal True to turn discretionary ligatures on, false to turn it off.
@return Nothing.
*/
void SetDiscretionaryLigatures( bool newVal);
/** Sets the local OpenType contextual ligatures attribute for this character style.
@param newVal True to turn contextual ligatures on, false to turn it off.
@return Nothing.
*/
void SetContextualLigatures( bool newVal);
/** Sets the local OpenType alternate ligatures attribute for this character style.
@param newVal True to turn alternate ligatures on, false to turn it off.
@return Nothing.
*/
void SetAlternateLigatures( bool newVal);
/** Sets the local OpenType old-style attribute for this character style.
@param newVal True to turn old-style on, false to turn it off.
@return Nothing.
*/
void SetOldStyle( bool newVal);
/** Sets the local OpenType fractions attribute for this character style.
@param newVal True to turn fractions on, false to turn it off.
@return Nothing.
*/
void SetFractions( bool newVal);
/** Sets the local OpenType ordinals attribute for this character style.
@param newVal True to turn ordinals on, false to turn it off.
@return Nothing.
*/
void SetOrdinals( bool newVal);
/** Sets the local OpenType swash attribute for this character style.
@param newVal True to turn swash on, false to turn it off.
@return Nothing.
*/
void SetSwash( bool newVal);
/** Sets the local OpenType titling attribute for this character style.
@param newVal True to turn titling on, false to turn it off.
@return Nothing.
*/
void SetTitling( bool newVal);
/** Sets the local OpenType connection forms attribute for this character style.
@param newVal True to turn connection forms on, false to turn it off.
@return Nothing.
*/
void SetConnectionForms( bool newVal);
/** Sets the local OpenType stylistic alternates attribute for this character style.
@param newVal True to turn stylistic alternates on, false to turn it off.
@return Nothing.
*/
void SetStylisticAlternates( bool newVal);
/** Sets the local OpenType stylistic sets attributes for this character style.
*/
void SetStylisticSets(ATETextDOM::Int32 newVal);
/** Sets the local OpenType ornaments attribute for this character style.
@param newVal True to turn ornaments on, false to turn it off.
@return Nothing.
*/
void SetOrnaments( bool newVal);
/** Sets the local OpenType figure style attribute for this character style.
@param newVal The new figure style constant.
@return Nothing.
*/
void SetFigureStyle( FigureStyle newVal);
// ------------------------------------------------------------------
// Japanese OpenType settings
// ------------------------------------------------------------------
/** Sets the local Japanese OpenType proportional metrics attribute of this character.
@param newVal True to turn proportional metrics on, false to turn it off.
@return Nothing. */
void SetProportionalMetrics( bool newVal);
/** Sets the local Japanese OpenType Kana attribute of this character.
@param newVal True to turn Kana on, false to turn it off.
@return Nothing. */
void SetKana( bool newVal);
/** Sets the local Japanese OpenType italics attribute of this character.
@param newVal True to turn italics on, false to turn it off.
@return Nothing. */
void SetItalics( bool newVal);
/** Sets the local Japanese OpenType Ruby attribute of this character.
@param newVal True to turn Ruby on, false to turn it off.
@return Nothing. */
void SetRuby( bool newVal);
/** Sets the local Japanese OpenType baseline direction attribute of this character.
@param newVal The new baseline direction constant.
@return Nothing. */
void SetBaselineDirection( BaselineDirection newVal);
/** Sets the local Japanese OpenType language attribute of this character.
@param newVal The new language constant.
@return Nothing. */
void SetLanguage( Language newVal);
/** Sets the local Japanese OpenType Japanese alternate feature attribute of this character.
@param newVal The new Japanese alternate feature constant.
@return Nothing. */
void SetJapaneseAlternateFeature( JapaneseAlternateFeature newVal);
/** Sets the local Japanese OpenType Tsume attribute of this character.
@param newVal The new Tsume value in document points.
@return Nothing. */
void SetTsume( ATETextDOM::Real newVal);
/** Sets the local Japanese OpenType style run alignment attribute of this character.
@param newVal The new style run alignment constant.
@return Nothing. */
void SetStyleRunAlignment( StyleRunAlignment newVal);
// ------------------------------------------------------------------
// WariChu settings
// ------------------------------------------------------------------
/** Sets the local WariChu enabled attribute of this character.
@param newVal True to turn enabling on, false to turn it off.
@return Nothing. */
void SetWariChuEnabled( bool newVal);
/** Sets the local WariChu line count attribute of this character.
@param newVal The new line count value.
@return Nothing. */
void SetWariChuLineCount( ATETextDOM::Int32 newVal);
/** Sets the local WariChu line gap attribute of this character.
@param newVal The new line gap value.
@return Nothing. */
void SetWariChuLineGap( ATETextDOM::Int32 newVal);
/** Sets the local WariChu scale attribute of this character.
@param newVal The new scaling factor, where 1 is 100%.
@return Nothing. */
void SetWariChuScale( ATETextDOM::Real newVal);
/** Sets the local WariChu size attribute of this character.
@param newVal The new size value in document points.
@return Nothing. */
void SetWariChuSize( ATETextDOM::Real newVal);
/** Sets the local WariChu widow amount attribute of this character.
@param newVal The new widow amount value.
@return Nothing. */
void SetWariChuWidowAmount( ATETextDOM::Int32 newVal);
/** Sets the local WariChu orphan amount attribute of this character.
@param newVal The new orphan amount value.
@return Nothing. */
void SetWariChuOrphanAmount( ATETextDOM::Int32 newVal);
/** Sets the local WariChu justification attribute of this character.
@param newVal The new justification constant.
@return Nothing. */
void SetWariChuJustification( WariChuJustification newVal);
/** Sets the local Tate Chu Yoko up-down adjustment attribute of this character.
@param newVal The new adjustment value.
@return Nothing. */
void SetTCYUpDownAdjustment( ATETextDOM::Int32 newVal);
/** Sets the local Tate Chu Yoko right-left adjustment attribute of this character.
@param newVal The new adjustment value.
@return Nothing. */
void SetTCYLeftRightAdjustment( ATETextDOM::Int32 newVal);
/** Sets the local left Aki attribute of this character.
@param newVal The new left Aki value.
@return Nothing. */
void SetLeftAki( ATETextDOM::Real newVal);
/** Sets the local right Aki attribute of this character.
@param newVal The new right Aki value.
@return Nothing. */
void SetRightAki( ATETextDOM::Real newVal);
//------------------------------------------------
// General settings
//------------------------------------------------
/** Sets the local no-break attribute of this character.
@param newVal True to turn no-break on, false to turn it off.
@return Nothing. */
void SetNoBreak( bool newVal);
/** Sets the local fill color attribute of this character.
@param newVal The paint object containing the new fill color value.
@return Nothing. */
void SetFillColor( IApplicationPaint newVal);
/** Sets the local stroke color attribute of this character.
@param newVal The paint object containing the new stroke color value.
@return Nothing. */
void SetStrokeColor( IApplicationPaint newVal);
/** Sets the local fill attribute of this character.
@param newVal True to turn fill on, false to turn it off.
@return Nothing. */
void SetFill( bool newVal);
/** Sets the local fill visibilty attribute of this character.
@param newVal True to turn fill visibility on, false to turn it off.
@return Nothing. */
void SetFillVisible( bool newVal);
/** Sets the local stroke attribute of this character.
@param newVal True to turn stroke on, false to turn it off.
@return Nothing. */
void SetStroke( bool newVal);
/** Sets the local stroke visibility attribute of this character.
@param newVal True to turn stroke visibility on, false to turn it off.
@return Nothing. */
void SetStrokeVisible( bool newVal);
/** Sets the local fill-first attribute of this character.
@param newVal True to turn fill-first on, false to turn it off.
@return Nothing. */
void SetFillFirst( bool newVal);
/** Sets the local fill overprint attribute of this character.
@param newVal True to turn fill overprint on, false to turn it off.
@return Nothing. */
void SetFillOverPrint( bool newVal);
/** Sets the local stroke overprint attribute of this character.
@param newVal True to turn stroke overprint on, false to turn it off.
@return Nothing. */
void SetStrokeOverPrint( bool newVal);
/** Sets the local fill background color attribute of this character.
@param newVal The paint object containing the new fill color value.
@return Nothing. */
void SetFillBackgroundColor( IApplicationPaint newVal);
/** Sets the local fill background attribute of this character.
@param newVal True to turn fill on, false to turn it off.
@return Nothing. */
void SetFillBackground( bool newVal);
/** Sets the local line cap attribute of this character.
@param newVal The new line cap type constant.
@return Nothing. */
void SetLineCap( LineCapType newVal);
/** Sets the local line join attribute of this character.
@param newVal The new line join type constant.
@return Nothing. */
void SetLineJoin( LineJoinType newVal);
/** Sets the local line width attribute of this character.
@param newVal The new line width value in document points.
@return Nothing. */
void SetLineWidth( ATETextDOM::Real newVal);
/** Sets the local miter limit attribute of this character.
@param newVal The new miter limit value in document points.
@return Nothing. */
void SetMiterLimit( ATETextDOM::Real newVal);
/** Sets the local line dash offset attribute of this character.
@param newVal The new line dash offset value in document points.
@return Nothing. */
void SetLineDashOffset( ATETextDOM::Real newVal);
/** Sets the local line dash array attribute of this character.
@param newVal The new line dash array object.
@return Nothing. */
void SetLineDashArray( IArrayReal newVal);
#if SLO_COMPLEXSCRIPT // Middle Eastern specific features only
// ------------------------------------------------------------------
// Complex Script Settings
// ------------------------------------------------------------------
/** Sets the kashidas attribute of this character.
@param newVal The new kashidas object.
@return Nothing.
*/
void SetKashidas( Kashidas newVal);
/** Sets the direction override attribute of this character.
@param newVal The new direction override object.
@return Nothing.
*/
void SetDirOverride( DirOverride newVal);
/** Sets the digit set attribute of this character.
@param newVal The new digit set object.
@return Nothing.
*/
void SetDigitSet( DigitSet newVal);
/** Sets the diacritics positioning attribute of this character.
@param newVal The diacritics positioning object.
@return Nothing.
*/
void SetDiacVPos( DiacVPos newVal);
/** Sets the diacritics x offset attribute of this character.
@param newVal The new diacritics x offset in document points.
@return Nothing.
*/
void SetDiacXOffset( ATETextDOM::Real newVal);
/** Sets the diacritics y offset attribute of this character.
@param newVal The new diacritics y offset in document points.
@return Nothing.
*/
void SetDiacYOffset( ATETextDOM::Real newVal);
/** Sets the automatic diacritics y distance from baseline attribute of this character.
@param newVal True to turn automatic diacritics y distance from baseline on, false to turn it off.
@return Nothing.
*/
void SetAutoMydfb( bool newVal);
/** Sets the diacritics y distance from baseline attribute of this character.
@param newVal The new diacritics y distance from baseline in document points.
@return Nothing.
*/
void SetMarkYDistFromBaseline( ATETextDOM::Real newVal);
/** Sets the overlap swash attribute of this character.
@param newVal True to turn overlap swash on, false to turn it off.
@return Nothing.
*/
void SetOverlapSwash( bool newVal);
/** Sets the justification alternates attribute of this character.
@param newVal True to turn justification alternates on, false to turn it off.
@return Nothing.
*/
void SetJustificationAlternates( bool newVal);
/** Sets the stretched alternates attribute of this character.
@param newVal Trues to turn stretched alternates on, false to turn it off.
@return Nothing.
*/
void SetStretchedAlternates( bool newVal);
#endif
// ======================================================================
// CLEAR PROPERTIES
// ======================================================================
/** Removes the local font attribute value of this character.
@return Nothing. */
void ClearFont( );
/** Removes the local font size attribute value of this character.
@return Nothing. */
void ClearFontSize( );
/** Removes the local horizontal scale attribute value of this character.
@return Nothing. */
void ClearHorizontalScale( );
/** Removes the local vertical scale attribute value of this character.
@return Nothing. */
void ClearVerticalScale( );
/** Removes the local automatic leading attribute value of this character.
@return Nothing. */
void ClearAutoLeading( );
/** Removes the local leading attribute value of this character.
@return Nothing. */
void ClearLeading( );
/** Removes the local tracking attribute value of this character.
@return Nothing. */
void ClearTracking( );
/** Removes the local baseline shift attribute value of this character.
@return Nothing. */
void ClearBaselineShift( );
/** Removes the local character rotation attribute value of this character.
@return Nothing. */
void ClearCharacterRotation( );
/** Removes the local automatic kerning attribute value of this character style.
This is not available for individual characters.
@return Nothing. */
void ClearAutoKernType( );
/** Removes the local font caps option attribute value of this character.
@return Nothing. */
void ClearFontCapsOption( );
/** Removes the local font baseline option attribute value of this character.
@return Nothing. */
void ClearFontBaselineOption( );
/** Removes the local font OpenType position option attribute value of this character.
@return Nothing. */
void ClearFontOpenTypePositionOption( );
/** Removes the local strikethrough position attribute value of this character.
@return Nothing. */
void ClearStrikethroughPosition( );
/** Removes the local underline position attribute value of this character.
@return Nothing. */
void ClearUnderlinePosition( );
/** Removes the local underline offset attribute value of this character.
@return Nothing. */
void ClearUnderlineOffset( );
// ------------------------------------------------------------------
// OpenType settings
// ------------------------------------------------------------------
/** Removes the local OpenType ligature attribute value of this character.
@return Nothing. */
void ClearLigature( );
/** Removes the local OpenType discretionary ligature attribute value of this character.
@return Nothing. */
void ClearDiscretionaryLigatures( );
/** Removes the local OpenType contextual ligature attribute value of this character.
@return Nothing. */
void ClearContextualLigatures( );
/** Removes the local OpenType alternate ligature attribute value of this character.
@return Nothing. */
void ClearAlternateLigatures( );
/** Removes the local OpenType old-style attribute value of this character.
@return Nothing. */
void ClearOldStyle( );
/** Removes the local OpenType fractions attribute value of this character.
@return Nothing. */
void ClearFractions( );
/** Removes the local OpenType ordinals attribute value of this character.
@return Nothing. */
void ClearOrdinals( );
/** Removes the local OpenType swash attribute value of this character.
@return Nothing. */
void ClearSwash( );
/** Removes the local OpenType titling attribute value of this character.
@return Nothing. */
void ClearTitling( );
/** Removes the local OpenType connection forms attribute value of this character.
@return Nothing. */
void ClearConnectionForms( );
/** Removes the local OpenType stylistic alternates attribute value of this character.
@return Nothing. */
void ClearStylisticAlternates( );
/** Removes the local OpenType stylistic sets attribute value of this character.
@return Nothing. */
void ClearStylisticSets();
/** Removes the local OpenType ornaments attribute value of this character.
@return Nothing. */
void ClearOrnaments( );
/** Removes the local OpenType figure style attribute value of this character.
@return Nothing. */
void ClearFigureStyle( );
// ------------------------------------------------------------------
// Japanese OpenType settings
// ------------------------------------------------------------------
/** Removes the local Japanese OpenType proportional metrics attribute value of this character.
@return Nothing. */
void ClearProportionalMetrics( );
/** Removes the local Japanese OpenType Kana attribute value of this character.
@return Nothing. */
void ClearKana( );
/** Removes the local Japanese OpenType italics attribute value of this character.
@return Nothing. */
void ClearItalics( );
/** Removes the local Japanese OpenType Ruby attribute value of this character.
@return Nothing. */
void ClearRuby( );
/** Removes the local Japanese OpenType baseline direction attribute value of this character.
@return Nothing. */
void ClearBaselineDirection( );
/** Removes the local Japanese OpenType language attribute value of this character.
@return Nothing. */
void ClearLanguage( );
/** Removes the local Japanese OpenType Japanese alternate feature attribute value of this character.
@return Nothing. */
void ClearJapaneseAlternateFeature( );
/** Removes the local Japanese OpenType Tsume attribute value of this character.
@return Nothing. */
void ClearTsume( );
/** Removes the local Japanese OpenType style-run alignment attribute value of this character.
@return Nothing. */
void ClearStyleRunAlignment( );
// ------------------------------------------------------------------
// WariChu settings
// ------------------------------------------------------------------
/** Removes the local WariChu enabled attribute value of this character.
@return Nothing. */
void ClearWariChuEnabled( );
/** Removes the local WariChu line count attribute value of this character.
@return Nothing. */
void ClearWariChuLineCount( );
/** Removes the local WariChu line gap attribute value of this character.
@return Nothing. */
void ClearWariChuLineGap( );
/** Removes the local WariChu sub-line amount attribute value of this character.
@return Nothing. */
void ClearWariChuSubLineAmount( );
/** Removes the local WariChu widow amount attribute value of this character.
@return Nothing. */
void ClearWariChuWidowAmount( );
/** Removes the local WariChu orphan amount attribute value of this character.
@return Nothing. */
void ClearWariChuOrphanAmount( );
/** Removes the local WariChu justification attribute value of this character.
@return Nothing. */
void ClearWariChuJustification( );
/** Removes the local Tate Chu Yoko up-down adjustment attribute value of this character.
@return Nothing. */
void ClearTCYUpDownAdjustment( );
/** Removes the local Tate Chu Yoko right-left adjustment attribute value of this character.
@return Nothing. */
void ClearTCYLeftRightAdjustment( );
/** Removes the local left Aki attribute value of this character.
@return Nothing. */
void ClearLeftAki( );
/** Removes the local right Aki attribute value of this character.
@return Nothing. */
void ClearRightAki( );
// ------------------------------------------------------------------
// General settings
// ------------------------------------------------------------------
/** Removes the local no-break attribute value of this character.
@return Nothing. */
void ClearNoBreak( );
/** Removes the local fill color attribute value of this character.
@return Nothing. */
void ClearFillColor( );
/** Removes the local stroke color attribute value of this character.
@return Nothing. */
void ClearStrokeColor( );
/** Removes the local fill attribute value of this character.
@return Nothing. */
void ClearFill( );
/** Removes the local fill visibility attribute value of this character.
@return Nothing. */
void ClearFillVisible( );
/** Removes the local stroke attribute value of this character.
@return Nothing. */
void ClearStroke( );
/** Removes the local stroke visibility attribute value of this character.
@return Nothing. */
void ClearStrokeVisible( );
/** Removes the local fill-first attribute value of this character.
@return Nothing. */
void ClearFillFirst( );
/** Removes the local fill overprint attribute value of this character.
@return Nothing. */
void ClearFillOverPrint( );
/** Removes the local stroke overprint attribute value of this character.
@return Nothing. */
void ClearStrokeOverPrint( );
/** Removes the local fill background color attribute value of this character.
@return Nothing. */
void ClearFillBackgroundColor( );
/** Removes the local fill background attribute value of this character.
@return Nothing. */
void ClearFillBackground( );
/** Removes the local line cap attribute value of this character.
@return Nothing. */
void ClearLineCap( );
/** Removes the local line join attribute value of this character.
@return Nothing. */
void ClearLineJoin( );
/** Removes the local line width attribute value of this character.
@return Nothing. */
void ClearLineWidth( );
/** Removes the local miter limit attribute value of this character.
@return Nothing. */
void ClearMiterLimit( );
/** Removes the local line dash offset attribute value of this character.
@return Nothing. */
void ClearLineDashOffset( );
/** Removes the local line dash array attribute value of this character.
@return Nothing. */
void ClearLineDashArray( );
#if SLO_COMPLEXSCRIPT // Middle Eastern specific features only
// ------------------------------------------------------------------
// Complex Script Settings
// ------------------------------------------------------------------
/** Removes the kashidas attribute value of this character.
@return Nothing.
*/
void ClearKashidas( );
/** Removes the direction override attribute value of this character.
@return Nothing.
*/
void ClearDirOverride( );
/** Removes the digit set attribute value of this character.
@return Nothing.
*/
void ClearDigitSet( );
/** Removes the diacritics positioning attribute value of this character.
@return Nothing.
*/
void ClearDiacVPos( );
/** Removes the diacritics x offset attribute value of this character.
@return Nothing.
*/
void ClearDiacXOffset( );
/** Removes the diacritics y offset attribute value of this character.
@return Nothing.
*/
void ClearDiacYOffset( );
/** Removes the automatic diacritics y distance from baseline attribute value of this character.
@return Nothing.
*/
void ClearAutoMydfb( );
/** Removes the diacritics y distance from baseline attribute value of this character.
@return Nothing.
*/
void ClearMarkYDistFromBaseline( );
/** Removes the overlap swash attribute value of this character.
@return Nothing.
*/
void ClearOverlapSwash( );
/** Removes the justification alternates attribute value of this character.
@return Nothing.
*/
void ClearJustificationAlternates( );
/** Removes the stretched alternates attribute value of this character.
@return Nothing.
*/
void ClearStretchedAlternates( );
#endif
////////////////////////////////////////////////////////////////////////////
// ALGEBRA METHODS
////////////////////////////////////////////////////////////////////////////
/** Clears any attributes in this object whose values are
not the same as or are unassigned in the comparison object.
The only values that remain are those that match
the corresponding value in the comparison object.
@param rhs Right-hand side of comparison.
@return True if changes were made. */
bool IntersectFeatures( ICharFeatures rhs);
/** Sets any attributes in this object whose values are
assigned in the comparison object to those values.
@param rhs Right-hand side of comparison.
@return True if changes were made. */
bool ReplaceOrAddFeatures( ICharFeatures rhs);
/** Clears any attributes in this object whose values are the
same as in the comparison object.
@param rhs Right-hand side of comparison.
@return True if changes were made. */
bool UnassignEachIfEqual( ICharFeatures rhs);
/** Reports whether all attributes of this object are unassigned.
@return True if no attributes have local values. */
bool IsEachNotAssigned( ) const;
/** Reports whether all attributes of this object are assigned.
@return True if all attributes have local values. */
bool IsEachAssigned( ) const;
};
//////////////////////////////////////////////
// --ICharInspector--
//////////////////////////////////////////////
/** This class allows you to retrieve the
character features that apply to the characters in a text range,
after considering all inherited style values and local overrides.
Obtain an \c ICharInspector object from a text range or set of text
ranges. See \c ITextRange::GetCharInspector().
The methods collect the values of a particular attribute into
an array whose order is the same as the order of characters in the text.
*/
class ICharInspector
{
private:
CharInspectorRef fCharInspector;
public:
/** Constructor. The object is empty; that is, all
attribute values are unassigned.
@return The new object. */
ICharInspector();
/** Copy constructor
@param src The object to copy.
@return The new object. */
ICharInspector(const ICharInspector& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
ICharInspector& operator=(const ICharInspector& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const ICharInspector& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const ICharInspector& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param charinspector The C object.
@return The new C++ object. */
explicit ICharInspector(CharInspectorRef charinspector);
/** Destructor */
virtual ~ICharInspector();
/** Retrieves a reference to this object.
@return The object reference. */
CharInspectorRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
//------------------------------------------------------------
// Properties
//------------------------------------------------------------
/** Retrieves the font values from the character set.
@return The array object containing the values. */
IArrayFontRef GetFont( ) const;
/** Retrieves the font size values from the character set.
@return The array object containing the values. */
IArrayReal GetFontSize( ) const;
/** Retrieves the horizontal scale values from the character set.
@return The array object containing the values. */
IArrayReal GetHorizontalScale( ) const;
/** Retrieves the vertical scale values from the character set.
@return The array object. */
IArrayReal GetVerticalScale( ) const;
/** Retrieves the synthetic bold values from the character set.
@return The array object containing the values. */
IArrayBool GetSyntheticBold( ) const;
/** Retrieves the synthetic italic values from the character set.
@return The array object containing the values. */
IArrayBool GetSyntheticItalic( ) const;
/** Retrieves the automatic leading values from the character set.
@return The array object containing the values. */
IArrayBool GetAutoLeading( ) const;
/** Retrieves the leading values from the character set.
@return The array object containing the values. */
IArrayReal GetLeading( ) const;
/** Retrieves the tracking values from the character set.
@return The array object containing the values. */
IArrayInteger GetTracking( ) const;
/** Retrieves the baseline shift values from the character set.
@return The array object containing the values. */
IArrayReal GetBaselineShift( ) const;
/** Retrieves the character rotation values from the character set.
@return The array object containing the values. */
IArrayReal GetCharacterRotation( ) const;
/** Retrieves the font caps option values from the character set.
@return The array object containing the values. */
IArrayFontCapsOption GetFontCapsOption( ) const;
/** Retrieves the font baseline option values from the character set.
@return The array object containing the values. */
IArrayFontBaselineOption GetFontBaselineOption( ) const;
/** Retrieves the font OpenType position option values from the character set.
@return The array object containing the values. */
IArrayFontOpenTypePositionOption GetFontOpenTypePositionOption( ) const;
/** Retrieves the strikethrough position values from the character set.
@return The array object containing the values. */
IArrayStrikethroughPosition GetStrikethroughPosition( ) const;
/** Retrieves the underline position values from the character set.
@return The array object containing the values. */
IArrayUnderlinePosition GetUnderlinePosition( ) const;
/** Retrieves the underline offset values from the character set.
@return The array object containing the values. */
IArrayReal GetUnderlineOffset( ) const;
// ------------------------------------------------------------------
// OpenType settings
// ------------------------------------------------------------------
/** Retrieves the OpenType ligature values from the character set.
@return The array object containing the values. */
IArrayBool GetLigature( ) const;
/** Retrieves the OpenType discretionary ligature values from the character set.
@return The array object containing the values. */
IArrayBool GetDiscretionaryLigatures( ) const;
/** Retrieves the OpenType contextual ligature values from the character set.
@return The array object containing the values. */
IArrayBool GetContextualLigatures( ) const;
/** Retrieves the OpenType alternate ligature values from the character set.
@return The array object containing the values. */
IArrayBool GetAlternateLigatures( ) const;
/** Retrieves the OpenType old-style values from the character set.
@return The array object containing the values. */
IArrayBool GetOldStyle( ) const;
/** Retrieves the OpenType fractions values from the character set.
@return The array object containing the values. */
IArrayBool GetFractions( ) const;
/** Retrieves the OpenType ordinals values from the character set.
@return The array object containing the values. */
IArrayBool GetOrdinals( ) const;
/** Retrieves the OpenType swash values from the character set.
@return The array object containing the values. */
IArrayBool GetSwash( ) const;
/** Retrieves the OpenType titling values from the character set.
@return The array object containing the values. */
IArrayBool GetTitling( ) const;
/** Retrieves the OpenType connection forms values from the character set.
@return The array object containing the values. */
IArrayBool GetConnectionForms( ) const;
/** Retrieves the OpenType stylistic alternates values from the character set.
@return The array object containing the values. */
IArrayBool GetStylisticAlternates( ) const;
/** Retrieves the OpenType stylistic set values from the character set.
@return The array object containing the values. */
IArrayInteger GetStylisticSets( ) const;
/** Retrieves the OpenType ornaments values from the character set.
@return The array object containing the values. */
IArrayBool GetOrnaments( ) const;
/** Retrieves the OpenType figure style values from the character set.
@return The array object containing the values. */
IArrayFigureStyle GetFigureStyle( ) const;
// ------------------------------------------------------------------
// Japanese OpenType settings
// ------------------------------------------------------------------
/** Retrieves the Japanese OpenType proportional metrics values from the character set.
@return The array object containing the values. */
IArrayBool GetProportionalMetrics( ) const;
/** Retrieves the Japanese OpenType Kana values from the character set.
@return The array object containing the values. */
IArrayBool GetKana( ) const;
/** Retrieves the Japanese OpenType italics values from the character set.
@return The array object containing the values. */
IArrayBool GetItalics( ) const;
/** Retrieves the Japanese OpenType Ruby values from the character set.
@return The array object containing the values. */
IArrayBool GetRuby( ) const;
/** Retrieves the Japanese OpenType baseline direction values from the character set.
@return The array object containing the values. */
IArrayBaselineDirection GetBaselineDirection( ) const;
/** Retrieves the Japanese OpenType language values from the character set.
@return The array object containing the values. */
IArrayLanguage GetLanguage( ) const;
/** Retrieves the Japanese OpenType Tsume values from the character set.
@return The array object containing the values. */
IArrayReal GetTsume( ) const;
/** Retrieves the Japanese OpenType style-run alignment values from the character set.
@return The array object containing the values. */
IArrayStyleRunAlignment GetStyleRunAlignment( ) const;
// ------------------------------------------------------------------
// WariChu settings
// ------------------------------------------------------------------
/** Retrieves the WariChu line count values from the character set.
@return The array object containing the values. */
IArrayInteger GetWariChuLineCount( ) const;
/** Retrieves the WariChu line gap values from the character set.
@return The array object containing the values. */
IArrayInteger GetWariChuLineGap( ) const;
/** Retrieves the WariChu scale values from the character set.
@return The array object containing the values. */
IArrayReal GetWariChuScale( ) const;
/** Retrieves the WariChu size values from the character set.
@return The array object containing the values. */
IArrayReal GetWariChuSize( ) const;
/** Retrieves the WariChu widow amount values from the character set.
@return The array object containing the values. */
IArrayInteger GetWariChuWidowAmount( ) const;
/** Retrieves the WariChu orphan amount values from the character set.
@return The array object containing the values. */
IArrayInteger GetWariChuOrphanAmount( ) const;
/** Retrieves the WariChu justification values from the character set.
@return The array object containing the values. */
IArrayWariChuJustification GetWariChuJustification( ) const;
/** Retrieves the WariChu enabled values from the character set.
@return The array object containing the values. */
IArrayBool GetWariChuEnabled( ) const;
/** Retrieves the Tate Chu Yoko up-down adjustment values from the character set.
@return The array object containing the values. */
IArrayInteger GetTCYUpDownAdjustment( ) const;
/** Retrieves the Tate Chu Yoko right-left adjustment values from the character set.
@return The array object containing the values. */
IArrayInteger GetTCYLeftRightAdjustment( ) const;
/** Retrieves the left Aki values from the character set.
@return The array object containing the values. */
IArrayReal GetLeftAki( ) const;
/** Retrieves the right Aki values from the character set.
@return The array object containing the values. */
IArrayReal GetRightAki( ) const;
// ------------------------------------------------------------------
// General settings
// ------------------------------------------------------------------
/** Retrieves the no-break values from the character set.
@return The array object containing the values. */
IArrayBool GetNoBreak( ) const;
/** Retrieves the fill color values from the character set.
@return The array object containing the values. */
IArrayApplicationPaintRef GetFillColor( ) const;
/** Retrieves the stroke color values from the character set.
@return The array object containing the values. */
IArrayApplicationPaintRef GetStrokeColor( ) const;
/** Retrieves the fill values from the character set.
@return The array object containing the values. */
IArrayBool GetFill( ) const;
/** Retrieves the fill visibility values from the character set.
@return The array object containing the values. */
IArrayBool GetFillVisible( ) const;
/** Retrieves the stroke values from the character set.
@return The array object containing the values. */
IArrayBool GetStroke( ) const;
/** Retrieves the stroke visibility values from the character set.
@return The array object containing the values. */
IArrayBool GetStrokeVisible( ) const;
/** Retrieves the fill-first values from the character set.
@return The array object containing the values. */
IArrayBool GetFillFirst( ) const;
/** Retrieves the fill overprint values from the character set.
@return The array object containing the values. */
IArrayBool GetFillOverPrint( ) const;
/** Retrieves the stroke overprint values from the character set.
@return The array object containing the values. */
IArrayBool GetStrokeOverPrint( ) const;
/** Retrieves the fill background color values from the character set.
@return The array object containing the values. */
IArrayApplicationPaintRef GetFillBackgroundColor( ) const;
/** Retrieves the fill background values from the character set.
@return The array object containing the values. */
IArrayBool GetFillBackground( ) const;
/** Retrieves the line cap values from the character set.
@return The array object containing the values. */
IArrayLineCapType GetLineCap( ) const;
/** Retrieves the line join values from the character set.
@return The array object containing the values. */
IArrayLineJoinType GetLineJoin( ) const;
/** Retrieves the line width values from the character set.
@return The array object containing the values. */
IArrayReal GetLineWidth( ) const;
/** Retrieves the miter limit values from the character set.
@return The array object containing the values. */
IArrayReal GetMiterLimit( ) const;
/** Retrieves the line dash offset values from the character set.
@return The array object containing the values. */
IArrayReal GetLineDashOffset( ) const;
/** Retrieves the line dash array values from the character set.
@return The array object containing the values. */
IArrayArrayReal GetLineDashArray( ) const;
#if SLO_COMPLEXSCRIPT // Middle Eastern specific features only
// ------------------------------------------------------------------
// Complex Script Settings
// ------------------------------------------------------------------
/** Retrieves the kashidas values from the character set.
@return The array object containing the values.
*/
IArrayKashidas GetKashidas( ) const;
/** Retrieves the direction override values from the character set.
@return The array object containing the values.
*/
IArrayDirOverride GetDirOverride( ) const;
/** Retrieves the digit set values from the character set.
@return The array object containing the values.
*/
IArrayDigitSet GetDigitSet( ) const;
/** Retrieves the diacritics positioning values from the character set.
@return The array object containing the values.
*/
IArrayDiacVPos GetDiacVPos( ) const;
/** Retrieves the diacritics x offset values from the character set.
@return The array object containing the values.
*/
IArrayReal GetDiacXOffset( ) const;
/** Retrieves the diacritics y offset values from the character set.
@return The array object containing the values.
*/
IArrayReal GetDiacYOffset( ) const;
/** Retrieves the automatic diacritics y offset from baseline values from the character set.
@return The array object containing the values.
*/
IArrayBool GetAutoMydfb( ) const;
/** Retrieves the diacritics y offset from baseline values from the character set.
@return The array object containing the values.
*/
IArrayReal GetMarkYDistFromBaseline( ) const;
/** Retrieves the overlap swash values from the character set.
@return The array object containing the values.
*/
IArrayBool GetOverlapSwash( ) const;
/** Retrieves the justification alternate values from the character set.
@return The array object containing the values.
*/
IArrayBool GetJustificationAlternates( ) const;
/** Retrieves the stretched alternates values from the character set.
@return The array object containing the values.
*/
IArrayBool GetStretchedAlternates( ) const;
#endif
};
//////////////////////////////////////////////
// --ICharStyle--
//////////////////////////////////////////////
/** This class encapsulates a named character style, which can be
applied to a set of characters. It contains an \c ICharFeatures
object, which defines the character attributes for this style.
Attribute values are inherited from the Normal style, and can be overridden
in a named style associated with a text run or text range, or at the
local character level.
A style or character can partially define attributes. Only those values
that are assigned override the inherited values. The constructor creates
an empty object, in which all attribute values are unassigned.
Setting a value causes it to be assigned, and clearing it causes
it to be unassigned. When you retrieve an attribute value, a boolean
return value, \c isAssigned, reports whether that attribute has a local
value in the queried object.
*/
class ICharStyle
{
private:
CharStyleRef fCharStyle;
public:
/** Constructor. The object is empty; that is, all
attribute values are unassigned.
@return The new object. */
ICharStyle();
/** Copy constructor
@param src The object to copy.
@return The new object. */
ICharStyle(const ICharStyle& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
ICharStyle& operator=(const ICharStyle& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const ICharStyle& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const ICharStyle& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param charstyle The C object.
@return The new C++ object. */
explicit ICharStyle(CharStyleRef charstyle);
/** Destructor */
virtual ~ICharStyle();
/** Retrieves a reference to this object.
@return The object reference. */
CharStyleRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
//-------------------------------------------------
// Properties
//-------------------------------------------------
/** Retrieves the name of this style.
@param pName [out] A buffer in which to return the name string.
@param maxLength [in, out] The number of characters in the buffer.
@return The length of the returned string, or 0 if an error occurred.
*/
ATETextDOM::Int32 GetName( ATETextDOM::Unicode* pName, ATETextDOM::Int32 maxLength) const;
/** Sets the name of this style.
@param pName The new, \c NULL terminated name string.
@return True if the name was set successfully, false if a style
already has the specified name or if the name string is empty.
*/
bool SetName( const ATETextDOM::Unicode* pName);
/** Retrieves the parent style of this style.
@return The style object, or a \c NULL object for the Normal (root) style.
*/
ICharStyle GetParent( ) const;
/** Sets the parent style of this style.
@param pStyle The new parent style object,
@return True if the parent was set successfully, false if
this is the Normal (root) style.
*/
bool SetParent( const ICharStyle pStyle);
/** Reports whether this style has a parent.
@return True if this style has a parent, false if this is the Normal (root) style.
*/
bool HasParent( ) const;
/** Retrieves the features defined for this style.
@return The character features object.
*/
ICharFeatures GetFeatures( ) const;
/** Sets the features defined for this style. For the Normal (root) style,
this is the same as \c #ReplaceOrAddFeatures(). For all other
styles, the new feature set completely replaces the old feature set.
@param pFeatures The new character features object.
@return Nothing.
*/
void SetFeatures( ICharFeatures pFeatures);
/** Sets attribute values of this style's feature set to those values that
are specifically assigned in the replacement feature set. Those values
that are unassigned in the replacement set remain unchanged in this
style.
@param pFeatures The replacement character features object.
@return Nothing.
*/
void ReplaceOrAddFeatures( ICharFeatures pFeatures);
};
//////////////////////////////////////////////
// --ICharStyles--
//////////////////////////////////////////////
/** Encapsulates a set of character styles as a text resource.
A style set contains a collection of \c ICharStyle objects.
Use an \c ICharStylesIterator object to iterate through the set.
*/
class ICharStyles
{
private:
CharStylesRef fCharStyles;
public:
/** Constructor.
@return The new object. */
ICharStyles();
/** Copy constructor
@param src The object to copy.
@return The new object. */
ICharStyles(const ICharStyles& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
ICharStyles& operator=(const ICharStyles& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const ICharStyles& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const ICharStyles& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param charstyles The C object.
@return The new C++ object. */
explicit ICharStyles(CharStylesRef charstyles);
/** Destructor */
virtual ~ICharStyles();
/** Retrieves a reference to this object.
@return The object reference. */
CharStylesRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
//-----------------------------------------------------------
// METHODS
//-----------------------------------------------------------
/** Reports whether this is set is empty.
@return True if this set contains no style objects. */
bool IsEmpty( ) const;
/** Retrieves the number of members of this set.
@return The number of members. */
ATETextDOM::Int32 GetSize( ) const;
/** Shows all styles.
@return Nothing.
@see \c #ShowOnlyUnreferencedStyles(), \c #ShowOnlyStylesReferencedIn()
*/
void ShowAllStyles( ) const;
/** Shows only styles to which there are not references in text.
@return Nothing.
@see \c #ShowAllStyles(), \c #ShowOnlyStylesReferencedIn()
*/
void ShowOnlyUnreferencedStyles( ) const;
/** Shows only styles that are used in a text range.
@param pRange The text range object.
@return Nothing.
@see \c #ShowAllStyles(), \c #ShowOnlyUnreferencedStyles()
*/
void ShowOnlyStylesReferencedIn( ITextRange pRange) const;
/** Reorders styles in this set by moving a style to a given position.
@param pStyle The style object.
@param position The new 0-based position index.
@return Nothing.
*/
void MoveStyleTo( ICharStyle pStyle, ATETextDOM::Int32 position);
};
//////////////////////////////////////////////
// --ICharStylesIterator--
//////////////////////////////////////////////
/** This class enables you to iterate through a set of
character styles.
@see \c ICharStyles */
class ICharStylesIterator
{
private:
CharStylesIteratorRef fCharStylesIterator;
public:
/** Constructor.
@return The new object. */
ICharStylesIterator();
/** Copy constructor
@param src The object to copy.
@return The new object. */
ICharStylesIterator(const ICharStylesIterator& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
ICharStylesIterator& operator=(const ICharStylesIterator& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const ICharStylesIterator& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const ICharStylesIterator& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param charstylesiterator The C object.
@return The new C++ object. */
explicit ICharStylesIterator(CharStylesIteratorRef charstylesiterator);
/** Destructor */
virtual ~ICharStylesIterator();
/** Retrieves a reference to this object.
@return The object reference. */
CharStylesIteratorRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
/** Constructor. Creates an iterator for a specific style set
that is ordered first-to-last or last-to-first.
@param pStyles The style set object.
@param direction Optional. The order of iteration. Default is first to last.
@return The new iterator object.
*/
ICharStylesIterator( ICharStyles pStyles, Direction direction = kForward);
//------------------------------------------------------
// Methods
//------------------------------------------------------
/** Reports whether the end of the set has been reached.
@return True if more members remain in the set. */
bool IsNotDone( ) const;
/** Reports whether the end of the set has been reached.
@return True if more members remain in the set. */
bool IsDone( ) const;
/** Reports whether the set is empty.
@return True if the set is empty. */
bool IsEmpty( ) const;
/** Sets the current position to the first member in the set.
@return Nothing. */
void MoveToFirst( );
/** Sets the current position to the last member in the set.
@return Nothing. */
void MoveToLast( );
/** Increments the current position in the set in the iterator's current direction.
@return Nothing. */
void Next( );
/** Decrements the current position in the set.
@return Nothing. */
void Previous( );
/** Retrieves the current character style.
@return The character style object. */
ICharStyle Item( ) const;
};
//////////////////////////////////////////////
// --IFind--
//////////////////////////////////////////////
/** This class encapsulates a search through text. The
methods allow you to find and replace text in a document
using various kinds of character matching.
To find or replace all matches in the search scope, do the following:
\li Save the text object you are currently working with.
\li Retrieve the current search position markers with \c #GetPreReplaceAllSettings()
and save them.
\li Implement a loop through all text objects, using
\c #FindMatch(), \c #FindNextMatch(), and \c #ReplaceMatch()
to find or replace all occurances of your match string.
<br>Keep track of how many matches or replacements were found,
to report back to the user.
\li Restore the previous search position markers with \c #RestorePreReplaceAllSettings()
\li Restore the working text object with \c #SetSearchRange().
*/
class IFind
{
private:
FindRef fFind;
public:
/** Constructor.
@return The new object. */
IFind();
/** Copy constructor
@param src The object to copy.
@return The new object. */
IFind(const IFind& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
IFind& operator=(const IFind& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const IFind& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const IFind& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param find The C object.
@return The new C++ object. */
explicit IFind(FindRef find);
/** Destructor */
virtual ~IFind();
/** Retrieves a reference to this object.
@return The object reference. */
FindRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
//------------------------------------------------------
// Options
//------------------------------------------------------
/** Retrieves the direction of search, front-to-back or
back-to-front.
@return The direction constant.
*/
Direction GetSearchDirection( ) const;
/** Reports whether searching is case-sensitive.
@return True if the search is set to ignore case, false if
it is case-sensitive.
*/
bool GetIgnoreCase( ) const;
/** Reports whether searching matches whole words.
@return True if the search is set to match whole words.
*/
bool GetWholeWord( ) const;
/** Reports whether searching wraps.
@return True if the search is set to wrap.
*/
bool GetWrap( ) const;
/** Reports whether searching should continue beyond selected text.
@return True if the search is set to go out-of-bounds.
*/
bool GetFindWordsOutOfBounds( ) const;
#if SLO_COMPLEXSCRIPT // Middle Eastern specific features only
/** Reports whether accents are to be ignored during the find.
@return True if accents are to be ignored, false if they are not.
*/
bool GetIgnoreAccents( ) const;
/** Reports whether kashidas are to be ignored during the find.
@return True if kashidas are to be ignored, false if they are not.
*/
bool GetIgnoreKashidas( ) const;
#endif
/** Sets the direction of search, front-to-back or back-to-front.
@param newValue The direction constant.
@return Nothing.
*/
void SetSearchDirection( Direction newValue);
/** Sets whether searching is case-sensitive.
@param newValue True to set the search to ignore case,
false to make it case-sensitive.
@return Nothing.
*/
void SetIgnoreCase( bool newValue);
/** Sets whether searching matches whole words.
@param newValue True to turn whole-word matching on,
false to turn it off.
@return Nothing.
*/
void SetWholeWord( bool newValue);
/** Sets whether searching wraps, ignoring line breaks.
@param newValue True to turn wrapping on,
false to turn it off.
@return Nothing.
*/
void SetWrap( bool newValue);
/** Sets whether searching matches words that are out-of-bounds.
@param newValue True to turn out-of-bounds matching on,
false to turn it off.
@return Nothing.
*/
void SetFindWordsOutOfBounds( bool newValue);
#if SLO_COMPLEXSCRIPT // Middle Eastern specific features only
/** Sets whether accents should be ignored during the find.
@param newValue True to ignore accents.
@return Nothing.
*/
void SetIgnoreAccents( bool newValue);
/** Sets whether kashidas are to be ignored during the find.
@param newValue True to ignore kashidas.
@return Nothing.
*/
void SetIgnoreKashidas( bool newValue);
#endif
/** Retrieves the scope of the search, the entire document or the current \c IStory.
The default scope is the entire document.
@return The search-scope constant.
*/
SearchScope GetSearchScope( ) const;
/** Sets the scope of the search to be the entire document or the current \c IStory.
The default scope is the entire document.
@param searchScope The search-scope constant.
@return Nothing.
*/
void SetSearchScope( SearchScope searchScope);
/** Sets the range of this search to a specific text range. Use to restore
the range after a global search or replace operation.
@param pRange The text range object.
@return Nothing.
@see Class description of \c IFind.
*/
void SetSearchRange( ITextRange pRange);
/** Sets the character string that this search tries to match
within the range and scope.
@param pSearchChars The search string.
@return Nothing.
*/
void SetSearchChars( ATETextDOM::Unicode* pSearchChars);
/** Retrieves the character string that this search tries to match.
@param pSearchChars [out] A buffer in which to return the search string.
@param length The number of characters in the buffer. Only this much of
the search string is returned.
@return Nothing.
*/
void GetSearchChars( ATETextDOM::Unicode* pSearchChars, ATETextDOM::Int32 length) const;
/** Sets the character string that this search uses to replace
matches found within the range and scope.
@param pSearchChars The replacement string.
@return Nothing.
*/
void SetReplaceChars( ATETextDOM::Unicode* pSearchChars);
/** Retrieves the character string that this search uses to replace
matches found within the range and scope.
@param pSearchChars [out] A buffer in which to return the replacement string.
@param length The number of characters in the buffer. Only this much of
the replacement string is returned.
@return Nothing.
*/
void GetReplaceChars( ATETextDOM::Unicode* pSearchChars, ATETextDOM::Int32 length) const;
// Temporary way to reset the engine for modeless operation
void Reset( );
//------------------------------------------------------
// Methods
//------------------------------------------------------
// Searches current user selection.
/** Searches for the match string in the specified text range.
@param pTextRange The text range within which to search.
@return True if a match is found, false otherwise.
@see SetSearchChars()
*/
bool FindMatch( ITextRange pTextRange);
// Skips the current user selection.
/** Searches for the match string starting at the end of the current selection in the
specified text range.
@param pTextRange The text range object.
@return True if a match is found, false otherwise.
@see \c #SetSearchChars()
*/
bool FindNextMatch( ITextRange pTextRange);
/** Searches for the match string in specified text range and replaces it, if found,
with the replacement string.
@param pTextRange The text range object.
@param findNext When true, searches in the current selection. When
false, begins searching at the end of the current selection.
@return If findNext parameter is true this function will return true if there is
another occurance found after the one just replaced,
and will return false if there is no other occurance found.
If findNext is false this function will always return false.
@see \c #SetSearchChars(), \c #SetReplaceChars()
*/
bool ReplaceMatch( ITextRange pTextRange, bool findNext);
/** @deprecated Do not use. See class description of \c IFind. */
bool FindAndReplaceAllMatches( ATETextDOM::Int32* pReplaceCount);
/** Retrieves the current position markers in this object, so that they
can be saved before a global search or replacement operation.
@param pCurrentPoint A buffer in which to return the
0-based index to the current position.
@param pStartPoint A buffer in which to return the
0-based index to the starting position.
@return Nothing.
@see Class description of \c IFind.
*/
void GetPreReplaceAllSettings( ATETextDOM::Int32* pCurrentPoint, ATETextDOM::Int32* pStartPoint) const;
/** Restores the current position markers in this object after a global
search or replacement operation.
@param currentPoint The saved 0-based index to the current position.
@param startPoint The saved 0-based index to the starting position.
@return Nothing.
@see Class description of \c IFind.
*/
void RestorePreReplaceAllSettings( const ATETextDOM::Int32 currentPoint, const ATETextDOM::Int32 startPoint);
};
//////////////////////////////////////////////
// --IFont--
//////////////////////////////////////////////
/** Encapsulates a font as a text resource. The methods allow you to
add, access, and manipulate fonts for use with the
Adobe Text Engine (ATE). */
class IFont
{
private:
FontRef fFont;
public:
/** Constructor.
@return The new object. */
IFont();
/** Copy constructor
@param src The object to copy.
@return The new object. */
IFont(const IFont& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
IFont& operator=(const IFont& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const IFont& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const IFont& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param font The C object.
@return The new C++ object. */
explicit IFont(FontRef font);
/** Destructor */
virtual ~IFont();
/** Retrieves a reference to this object.
@return The object reference. */
FontRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
//-----------------------------------------------
// METHODS
//-----------------------------------------------
/** Reports whether this is a CoolType font.
@return True if this is a CoolType font.
*/
bool IsCoolTypeTechnology( ) const;
/** Reports whether Roman glyphs in this font are sideways by default for a specified character alignment.
@param withItalics True to report the default for italics.
@param characterAlignment The style-run alignment constant for which to get the default.
@return True if the default for Roman glyphs is sideways.
*/
bool IsVerticalRomanGlyphsOnSideByDefault( bool withItalics, StyleRunAlignment characterAlignment) const;
/** Retrieves a pointer to the CT font dictionary for this font.
@return A pointer to the dictionary. */
void* GetCTFontDict( );
};
//////////////////////////////////////////////
// --IGlyph--
//////////////////////////////////////////////
/** Encapsulates a glyph as a text resource. The methods allow you to
add, access, and manipulate glyphs for use with the
Adobe Text Engine (ATE). */
class IGlyph
{
private:
GlyphRef fGlyph;
public:
/** Constructor.
@return The new object. */
IGlyph();
/** Copy constructor
@param src The object to copy.
@return The new object. */
IGlyph(const IGlyph& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
IGlyph& operator=(const IGlyph& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const IGlyph& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const IGlyph& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param glyph The C object.
@return The new C++ object. */
explicit IGlyph(GlyphRef glyph);
/** Destructor */
virtual ~IGlyph();
/** Retrieves a reference to this object.
@return The object reference. */
GlyphRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
// ========================================================================
// PROPERTIES
// ========================================================================
/** Retrieves the unique identifier for this glyph.
@return The identifier. */
ATEGlyphID GetGlyphID( ) const;
/** Retrieves the set of alternates for this glyph.
@return The alternate glyph set. */
IGlyphs GetAlternateGlyphs( ) const;
/** Retrieves the OpenType feature of this glyph.
@param otFeatures [out] A buffer in which to return the features string.
@param otFeatureCount [out] A buffer in which to return the number of features.
@param otFeatureIndex [out] A buffer in which to return the index into the feature string.
@return Nothing. */
void GetOTFeatures( char** otFeatures, ATETextDOM::Int32* otFeatureCount, ATETextDOM::Int32** otFeatureIndex);
// RealMatrix GetTransformation();
};
//////////////////////////////////////////////
// --IGlyphs--
//////////////////////////////////////////////
/** Encapsulates a set of glyphs as a text resource.
A glyph set contains a collection of \c IGlyph objects.
Use an \c IGlyphsIterator object to iterate through the set.
*/
class IGlyphs
{
private:
GlyphsRef fGlyphs;
public:
/** Constructor.
@return The new object. */
IGlyphs();
/** Copy constructor
@param src The object to copy.
@return The new object. */
IGlyphs(const IGlyphs& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
IGlyphs& operator=(const IGlyphs& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const IGlyphs& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const IGlyphs& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param glyphs The C object.
@return The new C++ object. */
explicit IGlyphs(GlyphsRef glyphs);
/** Destructor */
virtual ~IGlyphs();
/** Retrieves a reference to this object.
@return The object reference. */
GlyphsRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
// ========================================================================
// PROPERTIES
// ========================================================================
/** Retrieves the number of members of this set.
@return The number of members. */
ATETextDOM::Int32 GetSize( );
/** Retrieves the first member of this set.
@return The member value. */
IGlyph GetFirst( );
/** Retrieves the last member of this set.
@return The member value. */
IGlyph GetLast( );
// navigation objects.
/** Retrieves the set of text ranges that use this glyph set.
@return The text ranges set objet. */
ITextRanges GetTextRanges( ) const;
/** Retrieves the set of selected text ranges that use this glyph set.
@return The text ranges set objet. */
ITextRanges GetTextSelection( ) const;
/** Creates an iterator object for all paragraphs in the current document
that use this glyph set.
@return The iterator object. */
IParagraphsIterator GetParagraphsIterator( ) const;
/** Creates an iterator object for all text runs in the current document
that use this glyph set.
@return The iterator object. */
ITextRunsIterator GetTextRunsIterator( ) const;
/** Creates an iterator object for all words in the current document
that use this glyph set.
@return The iterator object. */
IWordsIterator GetWordsIterator( ) const;
// ========================================================================
// METHODS
// ========================================================================
/** Appends a glyph to this set.
@param glyph The glyph object.
@return The 0-based position index of the successfully
added object, or the current index of this object
if it is already in the set, or -1 if the object
was not in the set and could not be appended.
*/
void Add( const IGlyph& glyph);
/** Retrieves a member of this set by position index. Use with \c GetSize()
to iterate through members.
@param nIndex The 0-based position index.
@return The member object.
*/
IGlyph Item( ATETextDOM::Int32 nIndex) const;
/** Removes all members from the set.
@return Nothing. */
void RemoveAll( );
/** Removes a member from the set.
@param nIndex The 0-based position index of the member to remove.
@return Nothing. */
void Remove( ATETextDOM::Int32 nIndex);
};
//////////////////////////////////////////////
// --IGlyphsIterator--
//////////////////////////////////////////////
/** This class enables you to iterate through a set of.glyphs
@see \c IGlyphs */
class IGlyphsIterator
{
private:
GlyphsIteratorRef fGlyphsIterator;
public:
/** Constructor.
@return The new object. */
IGlyphsIterator();
/** Copy constructor
@param src The object to copy.
@return The new object. */
IGlyphsIterator(const IGlyphsIterator& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
IGlyphsIterator& operator=(const IGlyphsIterator& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const IGlyphsIterator& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const IGlyphsIterator& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param glyphsiterator The C object.
@return The new C++ object. */
explicit IGlyphsIterator(GlyphsIteratorRef glyphsiterator);
/** Destructor */
virtual ~IGlyphsIterator();
/** Retrieves a reference to this object.
@return The object reference. */
GlyphsIteratorRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
/** Constructor. Creates an iterator for a specific glyph set
that is ordered first-to-last or last-to-first.
@param glyphs The glyph set object.
@param direction Optional. The order of iteration. Default is first-to-last.
@return The new iterator object.
*/
IGlyphsIterator( IGlyphs glyphs, Direction direction = kForward);
//------------------------------------------------------
// Methods
//------------------------------------------------------
/** Reports whether the end of the set has been reached.
@return True if more members remain in the set. */
bool IsNotDone( ) const;
/** Reports whether the end of the set has been reached.
@return True if more members remain in the set. */
bool IsDone( ) const;
/** Reports whether the set is empty.
@return True if the set is empty. */
bool IsEmpty( ) const;
/** Retrieves the first member in this set.
@return The glyph object. */
IGlyph GetFirst( );
/** Retrieves the last member in this set.
@return The glyph object. */
IGlyph GetLast( );
/** Retrieves the next member in this set in the iterator's current direction.
@return The glyph object. */
IGlyph GetNext( );
/** Retrieves the current glyph.
@return The glyph object. */
IGlyph Item( ) const;
/** Increments the current position in this set in the iterator's current direction.
@return Nothing. */
void Next( );
/** Decrements the current position in this set.
@return Nothing. */
void Previous( );
};
//////////////////////////////////////////////
// --IKinsoku--
//////////////////////////////////////////////
/** Encapsulates a Kinsoku as a text resource. The methods allow you to
add, access, and manipulate Kinsoku for use with the
Adobe Text Engine (ATE). The \c IKinsokuSet collects \c IKinsoku objects.
*/
class IKinsoku
{
private:
KinsokuRef fKinsoku;
public:
/** Constructor. Constructs an empty Kinsoku.
@return The new object. */
IKinsoku();
/** Copy constructor
@param src The object to copy.
@return The new object. */
IKinsoku(const IKinsoku& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
IKinsoku& operator=(const IKinsoku& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const IKinsoku& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const IKinsoku& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param kinsoku The C object.
@return The new C++ object. */
explicit IKinsoku(KinsokuRef kinsoku);
/** Destructor */
virtual ~IKinsoku();
/** Retrieves a reference to this object.
@return The object reference. */
KinsokuRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
//========================================================================
// PROPERTIES
// =======================================================================
/** Retrieves the name of this Kinsoku.
@param name [out] A buffer in which to return the name string.
@param maxLength The number of characters in the buffer.
@return The number of characters in the returned string. */
ATETextDOM::Int32 GetName( ATETextDOM::Unicode* name, ATETextDOM::Int32 maxLength) const;
/** Retrieves the number of characters in the name of this Kinsoku.
@return The number of characters needed in the buffer to get the name. */
ATETextDOM::Int32 GetNameSize( ) const;
/** Sets the name of this Kinsoku.
@param name The name string.
@return Nothing. */
void SetName( const ATETextDOM::Unicode* name);
/** Reports whether this object matches a predefined tag.
@param tag The tag object.
@return True if this object matches the tag.
*/
bool MatchesPredefinedResourceTag( ATE::KinsokuPredefinedTag tag) const;
/** Retrieves the characters that cannot be used to start this Kinsoku.
@param noStartCharSet [out] A buffer in which to return the no-start character string.
@param maxLength The number of characters in the buffer.
@return The number of characters in the returned string. */
ATETextDOM::Int32 GetNoStartCharSet( ATETextDOM::Unicode* noStartCharSet, ATETextDOM::Int32 maxLength) const;
/** Retrieves the number of characters in the no-start character set of this Kinsoku.
@return The number of characters needed in the buffer to get the no-start set. */
ATETextDOM::Int32 GetNoStartCharSetSize( ) const;
/** Sets the characters that cannot be used to start this Kinsoku.
@param noStartCharSet The string containing the characters.
@return Nothing. */
void SetNoStartCharSet( const ATETextDOM::Unicode* noStartCharSet);
/** Retrieves the characters that cannot be used to end this Kinsoku.
@param noEndCharSet [out] A buffer in which to return the no-end character string.
@param maxLength The number of characters in the buffer.
@return The number of characters in the returned string. */
ATETextDOM::Int32 GetNoEndCharSet( ATETextDOM::Unicode* noEndCharSet, ATETextDOM::Int32 maxLength) const;
/** Retrieves the number of characters in the no-end character set of this Kinsoku.
@return The number of characters needed in the buffer to get the no-end set. */
ATETextDOM::Int32 GetNoEndCharSetSize( ) const;
/** Sets the characters that cannot be used to end this Kinsoku.
@param noEndCharSet The string containing the characters.
@return Nothing. */
void SetNoEndCharSet( const ATETextDOM::Unicode* noEndCharSet);
/** Retrieves the characters that cannot be used at a break in this Kinsoku.
@param noBreakCharSet [out] A buffer in which to return the no-break character string.
@param maxLength The number of characters in the buffer.
@return The number of characters in the returned string. */
ATETextDOM::Int32 GetNoBreakCharSet( ATETextDOM::Unicode* noBreakCharSet, ATETextDOM::Int32 maxLength) const;
/** Retrieves the number of characters in the no-break character set of this Kinsoku.
@return The number of characters needed in the buffer to get the no-break set. */
ATETextDOM::Int32 GetNoBreakCharSetSize( ) const;
/** Sets the characters that cannot be used at a break in this Kinsoku.
@param noBreakCharSet The string containing the characters.
@return Nothing. */
void SetNoBreakCharSet( const ATETextDOM::Unicode* noBreakCharSet);
/** Retrieves the characters that can be left hanging in this Kinsoku.
@param hangingCharSet [out] A buffer in which to return the hanging character string.
@param maxLength The number of characters in the buffer.
@return The number of characters in the returned string. */
ATETextDOM::Int32 GetHangingCharSet( ATETextDOM::Unicode* hangingCharSet, ATETextDOM::Int32 maxLength) const;
/** Retrieves the number of characters in the hanging character set of this Kinsoku.
@return The number of characters needed in the buffer to get the hanging set. */
ATETextDOM::Int32 GetHangingCharSetSize( ) const;
/** Sets the characters that can be left hanging in this Kinsoku.
@param hangingCharSet The string containing the characters.
@return Nothing. */
void SetHangingCharSet( const ATETextDOM::Unicode* hangingCharSet);
// =======================================================================
// METHODS
// =======================================================================
/** Reports whether a character is in the no-start set of this Kinsoku.
@param character The character.
@return True if this character is in the set. */
bool IsNoStartChar( ATETextDOM::Unicode character) const;
/** Reports whether a character is in the no-end set of this Kinsoku.
@param character The character.
@return True if this character is in the set. */
bool IsNoEndChar( ATETextDOM::Unicode character) const;
/** Reports whether a character is in the no-break set of this Kinsoku.
@param character The character.
@return True if this character is in the set. */
bool IsNoBreakChar( ATETextDOM::Unicode character) const;
/** Reports whether a character is in the hanging set of this Kinsoku.
@param character The character.
@return True if this character is in the set. */
bool IsHangingChar( ATETextDOM::Unicode character) const;
/// Does a shallow equivalency test
/// Does a deep equivalency test
/** Reports whether this object represents the same Kinsoku as another Kinsoku object.
@param rhsKinsoku The comparison object.
@return True if the two objects are the same. */
bool IsEquivalent( IKinsoku rhsKinsoku) const;
/** Reports whether the resource been modified since it became editable.
@return True if the resource has been modified. */
bool IsModified( ) const;
/** Reports whether this is a predefined Kinsoku.
@return True if the Kinsoku is predefined, false if it is customized. */
bool IsPredefined( ) const;
/** Creates a new object by duplicating the information in this one.
@return The new object */
IKinsoku Duplicate( ) const;
};
//////////////////////////////////////////////
// --IKinsokuSet--
//////////////////////////////////////////////
/** Encapsulates a set of Kinsoku as a text resource.
A Kinsoku set contains a collection of \c IKinsoku objects. */
class IKinsokuSet
{
private:
KinsokuSetRef fKinsokuSet;
public:
/** Constructor.
@return The new object. */
IKinsokuSet();
/** Copy constructor
@param src The object to copy.
@return The new object. */
IKinsokuSet(const IKinsokuSet& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
IKinsokuSet& operator=(const IKinsokuSet& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const IKinsokuSet& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const IKinsokuSet& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param kinsokuset The C object.
@return The new C++ object. */
explicit IKinsokuSet(KinsokuSetRef kinsokuset);
/** Destructor */
virtual ~IKinsokuSet();
/** Retrieves a reference to this object.
@return The object reference. */
KinsokuSetRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
// =======================================================================
// PROPERTIES
// =======================================================================
/** Retrieves the number of members of this set.
@return The number of members. */
ATETextDOM::Int32 GetSize( );
/** Retrieves the first member of this set.
@return The member object. */
IKinsoku GetFirst( );
/** Retrieves the last member of this set.
@return The member object. */
IKinsoku GetLast( );
// =======================================================================
// METHODS
// =======================================================================
/** Retrieves a member of this set by position index. Use with \c GetSize()
to iterate through members.
@param nIndex The 0-based position index.
@return The member object.
*/
IKinsoku Item( ATETextDOM::Int32 nIndex) const;
/** Retrieves a specific Kinsoku object from this set, matching name and data.
@param kinsoku The Kinsoku object.
@return The index position of the object in this set, or -1
if the object is not in this set.
*/
ATETextDOM::Int32 Find( IKinsoku kinsoku);
/** Retrieves a specific Kinsoku object from this set, matching only the name.
@param name The name string.
@return The index position of the object in this set, or -1
if the object is not in this set.
*/
ATETextDOM::Int32 Find( const ATETextDOM::Unicode* name);
/** Retrieves a specific Kinsoku object from this set, matching a tag.
@param tag The tag. Use \c #kUserDefinedKinsokuTag to get the first
customized (not predefined) Kinsoku.
@return The index position of the object in this set, or -1
if the object is not in this set.
*/
ATETextDOM::Int32 Find( KinsokuPredefinedTag tag);
/** Removes a member from the set.
@param nIndex The 0-based position index of the member to remove.
@return True if a member was successfully removed. */
bool Remove( ATETextDOM::Int32 nIndex);
/** Appends a Kinsoku to this set.
@param kinsoku The Kinsoku object.
@return The 0-based position index of the successfully
added object, or the current index of this object
if it is already in the set, or -1 if the object
was not in the set and could not be appended.
*/
ATETextDOM::Int32 Add( IKinsoku kinsoku);
/** Replaces a Kinsoku in this set.
@param nIndex The 0-based position index of the MojiKumi to replace.
@param kinsoku The replacement Kinsoku object.
@return True if an object was successfully replaced.
*/
bool Replace( ATETextDOM::Int32 nIndex, IKinsoku kinsoku);
};
//////////////////////////////////////////////
// --IParaFeatures--
//////////////////////////////////////////////
/** This class encapsulates the complete set of paragraph attributes that
can be applied to text. An object of this type is contained in an
\c IParaStyle object, and can be associated with a \c ITextRange.
Attribute values are inherited from the Normal style, and can be overridden
in a named style associated with the text, or at the local text level.
A style or text range can partially define attributes. Only those values
that are assigned override the inherited values. The constructor creates
an empty object, in which all attribute values are unassigned.
Setting a value causes it to be assigned, and clearing it causes
it to be unassigned. When you retrieve an attribute value, a boolean
return value, \c isAssigned, reports whether that attribute has a local
value in the queried object.
*/
class IParaFeatures
{
private:
ParaFeaturesRef fParaFeatures;
public:
/** Constructor. Creates an empty object, in which all attributes
are undefined.
@return The new object. */
IParaFeatures();
/** Copy constructor
@param src The object to copy.
@return The new object. */
IParaFeatures(const IParaFeatures& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
IParaFeatures& operator=(const IParaFeatures& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const IParaFeatures& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const IParaFeatures& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param parafeatures The C object.
@return The new C++ object. */
explicit IParaFeatures(ParaFeaturesRef parafeatures);
/** Destructor */
virtual ~IParaFeatures();
/** Retrieves a reference to this object.
@return The object reference. */
ParaFeaturesRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
/** Creates a duplicate of this object.
@return The new object. */
IParaFeatures Clone( ) const;
// ------------------------------------------------------------------
// Justification
// ------------------------------------------------------------------
/** Retrieves the justification attribute of this paragraph.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The justification constant. */
ParagraphJustification GetJustification( bool* isAssigned) const;
/** Retrieves the first-line indent attribute of this paragraph.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The first-line indent value in document points. */
ATETextDOM::Real GetFirstLineIndent( bool* isAssigned) const;
/** Retrieves the paragraph start indent attribute of this paragraph.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The start indent value in document points. */
ATETextDOM::Real GetStartIndent( bool* isAssigned) const;
/** Retrieves the paragraph end indent attribute of this paragraph.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The end indent value in document points. */
ATETextDOM::Real GetEndIndent( bool* isAssigned) const;
/** Retrieves the line space before attribute of this paragraph.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The line space before value in document points. */
ATETextDOM::Real GetSpaceBefore( bool* isAssigned) const;
/** Retrieves the line space after attribute of this paragraph.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The line space after value in document points. */
ATETextDOM::Real GetSpaceAfter( bool* isAssigned) const;
// ------------------------------------------------------------------
// Hyphenation
// ------------------------------------------------------------------
/** Retrieves the automatic hyphenation attribute of this paragraph.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return True if automatic hyphenation is on, false if it is off. */
bool GetAutoHyphenate( bool* isAssigned) const;
/** Retrieves the hyphenation word size attribute of this paragraph.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The hyphenation word size value (number of characters). */
ATETextDOM::Int32 GetHyphenatedWordSize( bool* isAssigned) const;
/** Retrieves the pre-hyphen size attribute of this paragraph.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The pre-hyphen size value (number of characters). */
ATETextDOM::Int32 GetPreHyphenSize( bool* isAssigned) const;
/** Retrieves the post-hyphen size attribute of this paragraph.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The post-hyphen size value (number of characters). */
ATETextDOM::Int32 GetPostHyphenSize( bool* isAssigned) const;
/** Retrieves the consecutive hyphen limit attribute of this paragraph.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The consecutive hyphen limit value (number of hyphens). */
ATETextDOM::Int32 GetConsecutiveHyphenLimit( bool* isAssigned) const;
/** Retrieves the hyphenation zone attribute of this paragraph.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The hyphenation zone value in document points. */
ATETextDOM::Real GetHyphenationZone( bool* isAssigned) const;
/** Retrieves the hyphenation capitalization attribute of this paragraph.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return True if hyphenation capitalization is on, false if it is off. */
bool GetHyphenateCapitalized( bool* isAssigned) const;
/** Retrieves the hyphenation preference attribute of this paragraph.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The hyphenation preference value. */
ATETextDOM::Real GetHyphenationPreference( bool* isAssigned) const;
// ------------------------------------------------------------------
// Justification Features
// ------------------------------------------------------------------
/** Retrieves the desired word spacing attribute of this paragraph.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The desired word spacing value, in document points. */
ATETextDOM::Real GetDesiredWordSpacing( bool* isAssigned) const;
/** Retrieves the maximum word spacing attribute of this paragraph.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The maximum word spacing value, in document points. */
ATETextDOM::Real GetMaxWordSpacing( bool* isAssigned) const;
/** Retrieves the minimum word spacing attribute of this paragraph.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The minimum word spacing value, in document points. */
ATETextDOM::Real GetMinWordSpacing( bool* isAssigned) const;
/** Retrieves the desired letter spacing attribute of this paragraph.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The desired letter spacing value, in document points. */
ATETextDOM::Real GetDesiredLetterSpacing( bool* isAssigned) const;
/** Retrieves the maximum letter spacing attribute of this paragraph.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The maximum letter spacing value, in document points. */
ATETextDOM::Real GetMaxLetterSpacing( bool* isAssigned) const;
/** Retrieves the minimum letter spacing attribute of this paragraph.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The minimum letter spacing value, in document points. */
ATETextDOM::Real GetMinLetterSpacing( bool* isAssigned) const;
/** Retrieves the desired glyph scaling attribute of this paragraph.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The desired glyph scaling value, where 1 is 100%. */
ATETextDOM::Real GetDesiredGlyphScaling( bool* isAssigned) const;
/** Retrieves the maximum glyph scaling attribute of this paragraph.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The maximum glyph scaling value, where 1 is 100%. */
ATETextDOM::Real GetMaxGlyphScaling( bool* isAssigned) const;
/** Retrieves the minimum glyph scaling attribute of this paragraph.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The minimum glyph scaling value, where 1 is 100%. */
ATETextDOM::Real GetMinGlyphScaling( bool* isAssigned) const;
/** Retrieves the single-word justification attribute of this paragraph.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The single-word justification type constant. */
ParagraphJustification GetSingleWordJustification( bool* isAssigned) const;
/** Retrieves the automatic leading percentage attribute of this paragraph.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return Theautomatic leading percentage value, where 1 is 100%. */
ATETextDOM::Real GetAutoLeadingPercentage( bool* isAssigned) const;
/** Retrieves the leading type attribute of this paragraph.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The leading type constant. */
LeadingType GetLeadingType( bool* isAssigned) const;
/** Retrieves the tab stops attribute of this paragraph.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The tab stops object. */
ITabStops GetTabStops( bool* isAssigned) const;
/** Retrieves the default tab width attribute of this paragraph.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The default tab width value, in document points. */
ATETextDOM::Real GetDefaultTabWidth( bool* isAssigned) const;
// ------------------------------------------------------------------
// Japanese Features
// ------------------------------------------------------------------
/** Retrieves the Japanese hanging Roman attribute of this paragraph.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return True if hanging Roman is on, false if it is off. */
bool GetHangingRoman( bool* isAssigned) const;
/** Retrieves the Japanese automatic Tate Chu Yoko attribute of this paragraph.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The automatic Tate Chu Yoko value. */
ATETextDOM::Int32 GetAutoTCY( bool* isAssigned) const;
/** Retrieves the Japanese Bunri Kinshi attribute of this paragraph.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return True if Bunri Kinshi is on, false if it is off. */
bool GetBunriKinshi( bool* isAssigned) const;
/** Retrieves the Japanese Burasagari type attribute of this paragraph.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The Burasagari type constant. */
BurasagariType GetBurasagariType( bool* isAssigned) const;
/** Retrieves the Japanese preferred Kinsoku order attribute of this paragraph.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The preferred Kinsoku order constant. */
PreferredKinsokuOrder GetPreferredKinsokuOrder( bool* isAssigned) const;
/** Retrieves the Japanese Kurikaeshi Moji Shori attribute of this paragraph.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return True if Kurikaeshi Moji Shori is on, false if it is off. */
bool GetKurikaeshiMojiShori( bool* isAssigned) const;
/** Retrieves the Kinsoku attribute of this paragraph.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The Kinsoku object, or a \c NULL object if Kinsoku is not used. */
IKinsoku GetKinsoku( bool* isAssigned) const;
/** Retrieves the MojiKumi attribute of this paragraph.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The MojiKumi object, or a \c NULL object if MojiKumi is not used. */
IMojiKumi GetMojiKumi( bool* isAssigned) const;
// ------------------------------------------------------------------
// Other Features
// ------------------------------------------------------------------
/** Retrieves the every-line composer attribute of this paragraph.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return True if every-line composer is on, false if it is off. */
bool GetEveryLineComposer( bool* isAssigned) const;
/** Retrieves the default character features attribute of this paragraph.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The character features object. */
ICharFeatures GetDefaultCharFeatures( bool* isAssigned) const;
#if SLO_COMPLEXSCRIPT // Middle Eastern specific features only
// ------------------------------------------------------------------
// Complex Script Features
// ------------------------------------------------------------------
/** Retrieves the main writing direction attribute of this paragraph.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The paragragh direction object.
*/
ATE::ParagraphDirection GetParagraphDirection( bool* isAssigned) const;
/** Retrieves the justification method attribute of this paragraph.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The justification method object.
*/
ATE::JustificationMethod GetJustificationMethod( bool* isAssigned) const;
/** Retrieves the Kashida Width attribute of this paragraph.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The Kashida Width object.
*/
ATE::KashidaWidth GetKashidaWidth( bool* isAssigned) const;
#endif
/** Retrieves the composer engine attribute of this paragraph.
@param isAssigned [out] A buffer in which to return
true if this attribute has a local value.
@return The composer engine object.
*/
ATE::ComposerEngine GetComposerEngine( bool* isAssigned ) const;
// ======================================================================
// SET PROPERTIES
// ======================================================================
// ------------------------------------------------------------------
// Justification
// ------------------------------------------------------------------
/** Sets the local justification attribute of this paragraph.
@param newVal The new justification constant.
@return Nothing. */
void SetJustification( ParagraphJustification newVal);
/** Sets the local first-line indent attribute of this paragraph.
@param newVal The new first-line indent value, in document points.
@return Nothing. */
void SetFirstLineIndent( ATETextDOM::Real newVal);
/** Sets the local start indent attribute of this paragraph.
@param newVal The new start indent value, in document points.
@return Nothing. */
void SetStartIndent( ATETextDOM::Real newVal);
/** Sets the local end indent attribute of this paragraph.
@param newVal The new end indent value, in document points.
@return Nothing. */
void SetEndIndent( ATETextDOM::Real newVal);
/** Sets the local line space before attribute of this paragraph.
@param newVal The new line space before value, in document points.
@return Nothing. */
void SetSpaceBefore( ATETextDOM::Real newVal);
/** Sets the local line space after attribute of this paragraph.
@param newVal The new line space after value, in document points.
@return Nothing. */
void SetSpaceAfter( ATETextDOM::Real newVal);
// ------------------------------------------------------------------
// Hyphenation
// ------------------------------------------------------------------
/** Sets the local automatic hyphenation attribute of this paragraph.
@param newVal True to turn automatic hyphenation on, false to turn it off.
@return Nothing. */
void SetAutoHyphenate( bool newVal);
/** Sets the local hyphenated word size attribute of this paragraph.
@param newVal The new hyphenated word size value, in characters.
@return Nothing. */
void SetHyphenatedWordSize( ATETextDOM::Int32 newVal);
/** Sets the local pre-hyphen size attribute of this paragraph.
@param newVal The new pre-hyphen size value, in characters.
@return Nothing. */
void SetPreHyphenSize( ATETextDOM::Int32 newVal);
/** Sets the local post-hyphen size attribute of this paragraph.
@param newVal The new post-hyphen size value, in characters.
@return Nothing. */
void SetPostHyphenSize( ATETextDOM::Int32 newVal);
/** Sets the local consecutive hyphen limit attribute of this paragraph.
@param newVal The new consecutive hyphen limit value, a number of hyphens.
@return Nothing. */
void SetConsecutiveHyphenLimit( ATETextDOM::Int32 newVal);
/** Sets the local hyphenation zone attribute of this paragraph.
@param newVal The new hyphenation zone value, in document points.
@return Nothing. */
void SetHyphenationZone( ATETextDOM::Real newVal);
/** Sets the local hyphenation capitalized attribute of this paragraph.
@param newVal True to turn hyphenation capitalized on, false to turn it off.
@return Nothing. */
void SetHyphenateCapitalized( bool newVal);
/** Sets the local hyphenation preference attribute of this paragraph.
@param newVal The new hyphenation preference value.
@return Nothing. */
void SetHyphenationPreference( ATETextDOM::Real newVal);
// ------------------------------------------------------------------
// Justification Features
// ------------------------------------------------------------------
/** Sets the local desired word spacing attribute of this paragraph.
@param newVal The new desired word spacing value, in document points.
@return Nothing. */
void SetDesiredWordSpacing( ATETextDOM::Real newVal);
/** Sets the local maximum word spacing attribute of this paragraph.
@param newVal The new maximum word spacing value, in document points.
@return Nothing. */
void SetMaxWordSpacing( ATETextDOM::Real newVal);
/** Sets the local minimum word spacing attribute of this paragraph.
@param newVal The new minimum word spacing value, in document points.
@return Nothing. */
void SetMinWordSpacing( ATETextDOM::Real newVal);
/** Sets the local desired letter spacing attribute of this paragraph.
@param newVal The new desired letter spacing value, in document points.
@return Nothing. */
void SetDesiredLetterSpacing( ATETextDOM::Real newVal);
/** Sets the local maximum letter spacing attribute of this paragraph.
@param newVal The new maximum letter spacing value, in document points.
@return Nothing. */
void SetMaxLetterSpacing( ATETextDOM::Real newVal);
/** Sets the local minimum letter spacing attribute of this paragraph.
@param newVal The new minimum letter spacing value, in document points.
@return Nothing. */
void SetMinLetterSpacing( ATETextDOM::Real newVal);
/** Sets the local desired glyph scaling attribute of this paragraph.
@param newVal The new desired glyph scaling value, where 1 is 100%.
@return Nothing. */
void SetDesiredGlyphScaling( ATETextDOM::Real newVal);
/** Sets the local maximum glyph scaling attribute of this paragraph.
@param newVal The new maximum glyph scaling value, where 1 is 100%.
@return Nothing. */
void SetMaxGlyphScaling( ATETextDOM::Real newVal);
/** Sets the local minimum glyph scaling attribute of this paragraph.
@param newVal The new minimum glyph scaling value, where 1 is 100%.
@return Nothing. */
void SetMinGlyphScaling( ATETextDOM::Real newVal);
/** Sets the local single-word justification attribute of this paragraph.
@param newVal The new single-word justification type constant.
@return Nothing. */
void SetSingleWordJustification( ParagraphJustification newVal);
/** Sets the local automatic leading percentage attribute of this paragraph.
@param newVal The new automatic leading percentage value, where 1 is 100%.
@return Nothing. */
void SetAutoLeadingPercentage( ATETextDOM::Real newVal);
/** Sets the local leading type attribute of this paragraph.
@param newVal The new leading type constant.
@return Nothing. */
void SetLeadingType( LeadingType newVal);
/** Sets the local tab stops attribute of this paragraph.
@param newVal The new tab stops object.
@return Nothing. */
void SetTabStops( ITabStops newVal);
/** Sets the local default tab width attribute of this paragraph.
@param newVal The new default tab width value, in document points.
@return Nothing. */
void SetDefaultTabWidth( ATETextDOM::Real newVal);
// ------------------------------------------------------------------
// Japanese Features
// ------------------------------------------------------------------
/** Sets the local Japanese hanging Roman attribute of this paragraph.
@param newVal True to turn hanging Roman on, false to turn it off.
@return Nothing. */
void SetHangingRoman( bool newVal);
/** Sets the local automatic Tate Chu Yoko attribute of this paragraph.
@param newVal The new automatic Tate Chu Yoko value.
@return Nothing. */
void SetAutoTCY( ATETextDOM::Int32 newVal);
/** Sets the local Bunri Kinshi attribute of this paragraph.
@param newVal True to turn Bunri Kinshi on, false to turn it off.
@return Nothing. */
void SetBunriKinshi( bool newVal);
/** Sets the local Burasagari type attribute of this paragraph.
@param newVal The new Burasagari type constant.
@return Nothing. */
void SetBurasagariType( BurasagariType newVal);
/** Sets the local preferred Kinsoku order attribute of this paragraph.
@param newVal The new preferred Kinsoku order constant.
@return Nothing. */
void SetPreferredKinsokuOrder( PreferredKinsokuOrder newVal);
/** Sets the local Kurikaeshi Moji Shori attribute of this paragraph.
@param newVal True to turn Kurikaeshi Moji Shori on, false to turn it off.
@return Nothing. */
void SetKurikaeshiMojiShori( bool newVal);
/** Sets the local Kinsoku attribute of this paragraph.
@param newVal The new Kinsoku object.
@return Nothing. */
void SetKinsoku( IKinsoku newVal);
/** Sets the local Moji Kumi attribute of this paragraph.
@param newVal The new Moji Kumi object.
@return Nothing. */
void SetMojiKumi( IMojiKumi newVal);
// ------------------------------------------------------------------
// Other Features
// ------------------------------------------------------------------
/** Sets the local every-line composer attribute of this paragraph.
@param newVal True to turn every-line composer on, false to turn it off.
@return Nothing. */
void SetEveryLineComposer( bool newVal);
/** Sets the local default character features attribute of this paragraph.
@param newVal The new default character features object.
@return Nothing. */
void SetDefaultCharFeatures( ICharFeatures newVal);
#if SLO_COMPLEXSCRIPT // Middle Eastern specific features only
// ------------------------------------------------------------------
// Complex Script Features
// ------------------------------------------------------------------
/** Sets the main writing direction attribute of this paragraph.
@param newVal The new paragraph direction object.
@return Nothing.
*/
void SetParagraphDirection( ATE::ParagraphDirection newVal);
/** Sets the justification method attribute of this paragraph.
@param newVal The new justification method object.
@return Nothing.
*/
void SetJustificationMethod( ATE::JustificationMethod newVal);
/** Sets the Kashida Width attribute of this paragraph.
@param newVal The new kashida width object.
@return Nothing.
*/
void SetKashidaWidth( ATE::KashidaWidth newVal);
#endif
/** Sets the composer engine attribute of this paragraph.
@param newVal The new composer engine object.
@return Nothing.
*/
void SetComposerEngine( ATE::ComposerEngine newVal);
// ======================================================================
// CLEAR PROPERTIES
// ======================================================================
// ------------------------------------------------------------------
// Justification
// ------------------------------------------------------------------
/** Removes the local justification attribute value of this paragraph.
@return Nothing. */
void ClearJustification( );
/** Removes the local first-line indent attribute value of this paragraph.
@return Nothing. */
void ClearFirstLineIndent( );
/** Removes the local start indent attribute value of this paragraph.
@return Nothing. */
void ClearStartIndent( );
/** Removes the local end indent attribute value of this paragraph.
@return Nothing. */
void ClearEndIndent( );
/** Removes the local line space before attribute value of this paragraph.
@return Nothing. */
void ClearSpaceBefore( );
/** Removes the local line space after attribute value of this paragraph.
@return Nothing. */
void ClearSpaceAfter( );
// ------------------------------------------------------------------
// Hyphenation
// ------------------------------------------------------------------
/** Removes the local automatic hyphenation attribute value of this paragraph.
@return Nothing. */
void ClearAutoHyphenate( );
/** Removes the local hyphenation word size attribute value of this paragraph.
@return Nothing. */
void ClearHyphenatedWordSize( );
/** Removes the local pre-hyphen size attribute value of this paragraph.
@return Nothing. */
void ClearPreHyphenSize( );
/** Removes the local post-hyphen size attribute value of this paragraph.
@return Nothing. */
void ClearPostHyphenSize( );
/** Removes the local consecutive hyphen limit attribute value of this paragraph.
@return Nothing. */
void ClearConsecutiveHyphenLimit( );
/** Removes the local hyphenation zone attribute value of this paragraph.
@return Nothing. */
void ClearHyphenationZone( );
/** Removes the local hyphenate capitalized attribute value of this paragraph.
@return Nothing. */
void ClearHyphenateCapitalized( );
/** Removes the local hyphenation preference attribute value of this paragraph.
@return Nothing. */
void ClearHyphenationPreference( );
// ------------------------------------------------------------------
// Justification Features
// ------------------------------------------------------------------
/** Removes all of the local word spacing attribute values of this paragraph.
@return Nothing. */
void ClearWordSpacing( );
/** Removes all of the local letter spacing attribute values of this paragraph.
@return Nothing. */
void ClearLetterSpacing( );
/** Removes all of the local glyph scaling attribute values of this paragraph.
@return Nothing. */
void ClearGlyphScaling( );
/** Removes the local single-word justification attribute value of this paragraph.
@return Nothing. */
void ClearSingleWordJustification( );
/** Removes the local automatic leading percentage attribute value of this paragraph.
@return Nothing. */
void ClearAutoLeadingPercentage( );
/** Removes the local leading type attribute value of this paragraph.
@return Nothing. */
void ClearLeadingType( );
/** Removes the local tab stops attribute value of this paragraph.
@return Nothing. */
void ClearTabStops( );
// ------------------------------------------------------------------
// Japanese Features
// ------------------------------------------------------------------
/** Removes the local Japanese hanging Roman attribute value of this paragraph.
@return Nothing. */
void ClearHangingRoman( );
/** Removes the local automatic Tate Chu Yoko attribute value of this paragraph.
@return Nothing. */
void ClearAutoTCY( );
/** Removes the local Bunri Kinshi attribute value of this paragraph.
@return Nothing. */
void ClearBunriKinshi( );
/** Removes the local Burasagari type attribute value of this paragraph.
@return Nothing. */
void ClearBurasagariType( );
/** Removes the local preferred Kinsoku order attribute value of this paragraph.
@return Nothing. */
void ClearPreferredKinsokuOrder( );
/** Removes the local Kurikaeshi Moji Shori attribute value of this paragraph.
@return Nothing. */
void ClearKurikaeshiMojiShori( );
/** Removes the local Kinsoku attribute value of this paragraph.
@return Nothing. */
void ClearKinsoku( );
/** Removes the local Moji Kumi attribute value of this paragraph.
@return Nothing. */
void ClearMojiKumi( );
// ------------------------------------------------------------------
// Other Features
// ------------------------------------------------------------------
/** Removes the local every-line composer attribute value of this paragraph.
@return Nothing. */
void ClearEveryLineComposer( );
/** Removes the local default character features attribute value of this paragraph.
@return Nothing. */
void ClearDefaultCharFeatures( );
#if SLO_COMPLEXSCRIPT // Available for use in Middle Eastern versions of the product only.
// ------------------------------------------------------------------
// Complex Script Features
// ------------------------------------------------------------------
/** Removes the main writing direction attribute value of this paragraph.
@return Nothing.
*/
void ClearParagraphDirection( );
/** Removes the justification method attribute value of this paragraph.
@return Nothing.
*/
void ClearJustificationMethod( );
/** Removes the kashida width attribute value of this paragraph.
@return Nothing.
*/
void ClearKashidaWidth( );
#endif
/** Removes the composer engine attribute value of this paragraph.
@return Nothing.
*/
void ClearComposerEngine( );
////////////////////////////////////////////////////////////////////////////
// ALGEBRA METHODS
////////////////////////////////////////////////////////////////////////////
/** Clears any attributes in this object whose values are
not the same as or are unassigned in the comparison object.
The only values that remain are those that match
the corresponding value in the comparison object.
@param rhs Right-hand side of comparison.
@return True if changes were made. */
bool IntersectFeatures( IParaFeatures rhs);
/** Sets any attributes in this object whose values are
assigned in the comparison object to those values.
@param rhs Right-hand side of comparison.
@return True if changes were made. */
bool ReplaceOrAddFeatures( IParaFeatures rhs);
/** Clears any attributes in this object whose values are the
same as in the comparison object.
@param rhs Right-hand side of comparison.
@return True if changes were made. */
bool UnassignEachIfEqual( const IParaFeatures rhs);
/** Reports whether all attributes of this object are unassigned.
@return True if no attributes have local values. */
bool IsEachNotAssigned( ) const;
/** Reports whether all attributes of this object are assigned.
@return True if all attributes have local values. */
bool IsEachAssigned( ) const;
};
//////////////////////////////////////////////
// --IParagraph--
//////////////////////////////////////////////
/** This class encapsulates a paragraph of text, to which a
paragraph style (\c IParaStyle) can be applied.
Paragraphs are contained in stories.
Use an \c IParagraphsIterator object to iterate through
paragraphs in a set of stories.
Use an \c IParaInspector object to retrieve the
paragraph features that apply to a specific paragraph,
after considering all inherited style values and local overrides.
*/
class IParagraph
{
private:
ParagraphRef fParagraph;
public:
/** Constructor.
@return The new object. */
IParagraph();
/** Copy constructor
@param src The object to copy.
@return The new object. */
IParagraph(const IParagraph& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
IParagraph& operator=(const IParagraph& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const IParagraph& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const IParagraph& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param paragraph The C object.
@return The new C++ object. */
explicit IParagraph(ParagraphRef paragraph);
/** Destructor */
virtual ~IParagraph();
/** Retrieves a reference to this object.
@return The object reference. */
ParagraphRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
// ========================================================================
// PROPERTIES
// ========================================================================
/** Retrieves the length of this paragraph.
@return The number of characters in this paragraph. */
ATETextDOM::Int32 GetLength( );
// navigation objects.
/** Retrieves the story that contains this paragraph
@return The story object. */
IStory GetStory( );
/** Retrieves the text range corresponding to this paragraph
@return The text range object. */
ITextRange GetTextRange( );
/** Retrieves the set of text ranges corresponding to this paragraph
@return The text ranges object. */
ITextRanges GetTextRanges( );
/** Retrieves the text selection in this paragraph.
@return The text range set object. */
ITextRanges GetTextSelection( );
/** Creates an iteration object with which to access the words in this paragraph.
@return The word iterator object. */
IWordsIterator GetWordsIterator( );
// ========================================================================
// METHODS
// ========================================================================
/** Retrieves the paragraph after this one in the containing story.
@return The paragraph object. */
IParagraph GetNext( );
/** Retrieves the paragraph before this one in the containing story.
@return The paragraph object. */
IParagraph GetPrev( );
/** Retrieves the text contents of this paragraph as a Unicode string.
@param text [out] A buffer in which to return the string.
@param maxLength The number of characters in the buffer.
*/
ATETextDOM::ATETextDomErr GetContents( ATETextDOM::Unicode* text, ATETextDOM::Int32 maxLength);
/** Retrieves the text contents of this paragraph as a C string.
@param text [out] A buffer in which to return the string.
@param maxLength The number of characters in the buffer.
*/
ATETextDOM::ATETextDomErr GetContents( char* text, ATETextDOM::Int32 maxLength);
};
//////////////////////////////////////////////
// --IParagraphsIterator--
//////////////////////////////////////////////
/** This class allows you to iterate through a set of paragraphs contained in
a set of story objects or text ranges. Retrieve the iteration object
with \c IStories::GetParagraphsIterator(), or create one
from a set of text ranges (\c ITextRanges). Use it to access
the \c IParagraph objects in the document's text.
*/
class IParagraphsIterator
{
private:
ParagraphsIteratorRef fParagraphsIterator;
public:
/** Constructor.
@return The new object. */
IParagraphsIterator();
/** Copy constructor
@param src The object to copy.
@return The new object. */
IParagraphsIterator(const IParagraphsIterator& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
IParagraphsIterator& operator=(const IParagraphsIterator& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const IParagraphsIterator& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const IParagraphsIterator& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param paragraphsiterator The C object.
@return The new C++ object. */
explicit IParagraphsIterator(ParagraphsIteratorRef paragraphsiterator);
/** Destructor */
virtual ~IParagraphsIterator();
/** Retrieves a reference to this object.
@return The object reference. */
ParagraphsIteratorRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
/** Constructor. Creates a paragraph iterator for a specific text-range set
that is ordered first-to-last or last-to-first.
@param ranges The text-range set object.
@param direction Optional. The order of iteration. Default is first-to-last.
@return The new iterator object.
*/
IParagraphsIterator( ITextRanges ranges, Direction direction = kForward);
//------------------------------------------------------
// Methods
//------------------------------------------------------
/** Reports whether the end of the set has been reached.
@return True if more members remain in the set. */
bool IsDone( ) const;
/** Reports whether the end of the set has been reached.
@return True if no more members remain in the set. */
bool IsNotDone( ) const;
/** Reports whether the set is empty.
@return True if the set is empty. */
bool IsEmpty( ) const;
/** Sets the current position to the first member of this set.
@return Nothing. */
void MoveToFirst( );
/** Sets the current position to the last member of this set.
@return Nothing. */
void MoveToLast( );
/** Increments the current position in this set in the iterator's current direction.
@return Nothing. */
void Next( );
/** Retrieves the current paragraph.
@return The paragraph object. */
IParagraph Item( );
};
//////////////////////////////////////////////
// --IParaInspector--
//////////////////////////////////////////////
/** This class allows you to retrieve the
paragraph features that apply to a specific paragraph,
after considering all inherited style values and local overrides.
Obtain an \c IParaInspector object from a text range or set of text
ranges. See \c ITextRange::GetParaInspector().
The methods collect the values of a particular attribute into
an array whose order is the same as the order of paragraphs in the text.
*/
class IParaInspector
{
private:
ParaInspectorRef fParaInspector;
public:
/** Constructor.
@return The new object. */
IParaInspector();
/** Copy constructor
@param src The object to copy.
@return The new object. */
IParaInspector(const IParaInspector& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
IParaInspector& operator=(const IParaInspector& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const IParaInspector& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const IParaInspector& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param parainspector The C object.
@return The new C++ object. */
explicit IParaInspector(ParaInspectorRef parainspector);
/** Destructor */
virtual ~IParaInspector();
/** Retrieves a reference to this object.
@return The object reference. */
ParaInspectorRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
// ------------------------------------------------------------------
// Justification
// ------------------------------------------------------------------
/** Retrieves the justification values from the paragraph set.
@return The array object containing the values. */
IArrayParagraphJustification GetJustification( ) const;
/** Retrieves the first-line indent values from the paragraph set.
@return The array object containing the values. */
IArrayReal GetFirstLineIndent( ) const;
/** Retrieves the start indent values from the paragraph set.
@return The array object containing the values. */
IArrayReal GetStartIndent( ) const;
/** Retrieves the end indent values from the paragraph set.
@return The array object containing the values. */
IArrayReal GetEndIndent( ) const;
/** Retrieves the line space before values from the paragraph set.
@return The array object containing the values. */
IArrayReal GetSpaceBefore( ) const;
/** Retrieves the line space after values from the paragraph set.
@return The array object containing the values. */
IArrayReal GetSpaceAfter( ) const;
// ------------------------------------------------------------------
// Hyphenation
// ------------------------------------------------------------------
/** Retrieves the automatic hyphenation values from the paragraph set.
@return The array object containing the values. */
IArrayBool GetAutoHyphenate( ) const;
/** Retrieves the hyphenated word size values from the paragraph set.
@return The array object containing the values. */
IArrayInteger GetHyphenatedWordSize( ) const;
/** Retrieves the pre-hyphen size values from the paragraph set.
@return The array object containing the values. */
IArrayInteger GetPreHyphenSize( ) const;
/** Retrieves the post-hyphen size values from the paragraph set.
@return The array object containing the values. */
IArrayInteger GetPostHyphenSize( ) const;
/** Retrieves the consecutive hyphen limit values from the paragraph set.
@return The array object containing the values. */
IArrayInteger GetConsecutiveHyphenLimit( ) const;
/** Retrieves the hyphenation zone values from the paragraph set.
@return The array object containing the values. */
IArrayReal GetHyphenationZone( ) const;
/** Retrieves the hyphenate capitalized values from the paragraph set.
@return The array object containing the values. */
IArrayBool GetHyphenateCapitalized( ) const;
/** Retrieves the hyphenation preference values from the paragraph set.
@return The array object containing the values. */
IArrayReal GetHyphenationPreference( ) const;
// ------------------------------------------------------------------
// Justification Features
// ------------------------------------------------------------------
/** Retrieves the desired word spacing values from the paragraph set.
@return The array object containing the values. */
IArrayReal GetDesiredWordSpacing( ) const;
/** Retrieves the maximum word spacing values from the paragraph set.
@return The array object containing the values. */
IArrayReal GetMaxWordSpacing( ) const;
/** Retrieves the minimum word spacing values from the paragraph set.
@return The array object containing the values. */
IArrayReal GetMinWordSpacing( ) const;
/** Retrieves the desired letter spacing values from the paragraph set.
@return The array object containing the values. */
IArrayReal GetDesiredLetterSpacing( ) const;
/** Retrieves the maximum letter spacing values from the paragraph set.
@return The array object containing the values. */
IArrayReal GetMaxLetterSpacing( ) const;
/** Retrieves the minimum letter spacing values from the paragraph set.
@return The array object containing the values. */
IArrayReal GetMinLetterSpacing( ) const;
/** Retrieves the desired glyph scaling values from the paragraph set.
@return The array object containing the values. */
IArrayReal GetDesiredGlyphScaling( ) const;
/** Retrieves the maximum glyph scaling values from the paragraph set.
@return The array object containing the values. */
IArrayReal GetMaxGlyphScaling( ) const;
/** Retrieves the minimum glyph scaling values from the paragraph set.
@return The array object containing the values. */
IArrayReal GetMinGlyphScaling( ) const;
/** Retrieves the single-word justification values from the paragraph set.
@return The array object containing the values. */
IArrayParagraphJustification GetSingleWordJustification( ) const;
/** Retrieves the automatic leading percentage values from the paragraph set.
@return The array object containing the values. */
IArrayReal GetAutoLeadingPercentage( ) const;
/** Retrieves the leading type values from the paragraph set.
@return The array object containing the values. */
IArrayLeadingType GetLeadingType( ) const;
/** Retrieves the tab stops values from the paragraph set.
@return The array object containing the values. */
IArrayTabStopsRef GetTabStops( ) const;
/** Retrieves the tab width values from the paragraph set.
@return The array object containing the values. */
IArrayReal GetDefaultTabWidth( ) const;
// ------------------------------------------------------------------
// Japanese Features
// ------------------------------------------------------------------
/** Retrieves the Japanese hanging Roman values from the paragraph set.
@return The array object containing the values. */
IArrayBool GetHangingRoman( ) const;
/** Retrieves the automatic Tate Chu Yoko values from the paragraph set.
@return The array object containing the values. */
IArrayInteger GetAutoTCY( ) const;
/** Retrieves the Bunri Kinshi values from the paragraph set.
@return The array object containing the values. */
IArrayBool GetBunriKinshi( ) const;
/** Retrieves the Burasagari type values from the paragraph set.
@return The array object containing the values. */
IArrayBurasagariType GetBurasagariType( ) const;
/** Retrieves the preferred Kinsoku order values from the paragraph set.
@return The array object containing the values. */
IArrayPreferredKinsokuOrder GetPreferredKinsokuOrder( ) const;
/** Retrieves the Kurikaeshi Moji Shori values from the paragraph set.
@return The array object containing the values. */
IArrayBool GetKurikaeshiMojiShori( ) const;
/** Retrieves the Kinsoku values from the paragraph set.
@return The array object containing the values. */
IArrayKinsokuRef GetKinsoku( ) const;
/** Retrieves the Moji Kumi values from the paragraph set.
@return The array object containing the values. */
IArrayMojiKumiRef GetMojiKumi( ) const;
// ------------------------------------------------------------------
// Other Features
// ------------------------------------------------------------------
/** Retrieves the every-line composer values from the paragraph set.
@return The array object containing the values. */
IArrayBool GetEveryLineComposer( ) const;
#if SLO_COMPLEXSCRIPT // Middle Eastern specific features only
// ------------------------------------------------------------------
// Complex Script Features
// ------------------------------------------------------------------
/** Retrieves the main writing direction values from the paragraph set.
@return The array object containing the values.
*/
IArrayParagraphDirection GetParagraphDirection( ) const;
/** Retrieves the justification method values from the paragraph set.
@return The array object containing the values.
*/
IArrayJustificationMethod GetJustificationMethod( ) const;
/** Retrieves the Kashida Width values from the paragraph set.
@return The array object containing the values.
*/
IArrayKashidaWidth GetKashidaWidth( ) const;
#endif
/** Retrieves the composer engine values from the paragraph set.
@return The array object containing the values.
*/
IArrayComposerEngine GetComposerEngine( ) const;
};
//////////////////////////////////////////////
// --IParaStyle--
//////////////////////////////////////////////
/** This class encapsulates a named paragraph style, which can be
applied to a paragraph or set of paragraphs. It contains an \c IParaFeatures
object, which defines the paragraph attributes for this style.
Attribute values are inherited from the Normal style, and can be overridden
in a named style associated with a story or text range, or at the
local paragraph level.
A style or paragraph can partially define attributes. Only those values
that are assigned override the inherited values. The constructor creates
an empty object, in which all attribute values are unassigned.
Setting a value causes it to be assigned, and clearing it causes
it to be unassigned. When you retrieve an attribute value, a boolean
return value, \c isAssigned, reports whether that attribute has a local
value in the queried object.
*/
class IParaStyle
{
private:
ParaStyleRef fParaStyle;
public:
/** Constructor.
@return The new object. */
IParaStyle();
/** Copy constructor
@param src The object to copy.
@return The new object. */
IParaStyle(const IParaStyle& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
IParaStyle& operator=(const IParaStyle& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const IParaStyle& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const IParaStyle& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param parastyle The C object.
@return The new C++ object. */
explicit IParaStyle(ParaStyleRef parastyle);
/** Destructor */
virtual ~IParaStyle();
/** Retrieves a reference to this object.
@return The object reference. */
ParaStyleRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
/** Retrieves the name of this style.
@param pName [out] A buffer in which to return the name string.
@param maxLength [in, out] The number of characters in the buffer.
@return The length of the returned string, or 0 if an error occurred.
*/
ATETextDOM::Int32 GetName( ATETextDOM::Unicode* pName, ATETextDOM::Int32 maxLength) const;
/** Sets the name of this style.
@param pName The new, \c NULL terminated name string.
@return True if the name was set successfully, false if a style
already has the specified name or if the name string is empty.
*/
bool SetName( const ATETextDOM::Unicode* pName);
/** Retrieves the parent style of this style.
@return The style object, or a \c NULL object for the Normal (root) style.
*/
IParaStyle GetParent( ) const;
/** Sets the parent style of this style.
@param pStyle The new parent style object,
@return True if the parent was set successfully, false if
this is the Normal (root) style.
*/
bool SetParent( const IParaStyle pStyle);
/** Reports whether this style has a parent.
@return True if this style has a parent, false if this is the Normal (root) style.
*/
bool HasParent( ) const;
/** Retrieves the features defined for this style.
@return The paragraph features object.
*/
IParaFeatures GetFeatures( ) const;
/** Sets the features defined for this style. For the Normal (root) style,
this is the same as \c #ReplaceOrAddFeatures(). For all other
styles, the new feature set completely replaces the old feature set.
@param pFeatures The new paragraph features object.
@return Nothing.
*/
void SetFeatures( IParaFeatures pFeatures);
/** Sets attribute values of this style's feature set to those values that
are specifically assigned in the replacement feature set. Those values
that are unassigned in the replacement set remain unchanged in this
style.
@param pFeatures The replacement paragraph features object.
@return Nothing.
*/
void ReplaceOrAddFeatures( IParaFeatures pFeatures);
};
//////////////////////////////////////////////
// --IParaStyles--
//////////////////////////////////////////////
/** Encapsulates a set of paragraph styles as a text resource.
A style set contains a collection of \c IParaStyle objects.
Use an \c IParaStylesIterator object to iterate through the set.
*/
class IParaStyles
{
private:
ParaStylesRef fParaStyles;
public:
/** Constructor.
@return The new object. */
IParaStyles();
/** Copy constructor
@param src The object to copy.
@return The new object. */
IParaStyles(const IParaStyles& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
IParaStyles& operator=(const IParaStyles& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const IParaStyles& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const IParaStyles& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param parastyles The C object.
@return The new C++ object. */
explicit IParaStyles(ParaStylesRef parastyles);
/** Destructor */
virtual ~IParaStyles();
/** Retrieves a reference to this object.
@return The object reference. */
ParaStylesRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
//------------------------------------------------------
// Methods
//------------------------------------------------------
/** Reports whether the set is empty.
@return True if the set is empty. */
bool IsEmpty( ) const;
/** Retrieves the number of members of this set.
@return The number of members. */
ATETextDOM::Int32 GetSize( ) const;
/** Shows all styles.
@return Nothing.
@see \c #ShowOnlyUnreferencedStyles(), \c #ShowOnlyStylesReferencedIn()
*/
void ShowAllStyles( ) const;
/** Shows only styles to which there are not references in text.
@return Nothing.
@see \c #ShowAllStyles(), \c #ShowOnlyStylesReferencedIn()
*/
void ShowOnlyUnreferencedStyles( ) const;
/** Shows only styles that are used in a text range.
@param pRange The text range object.
@return Nothing.
@see \c #ShowAllStyles(), \c #ShowOnlyUnreferencedStyles()
*/
void ShowOnlyStylesReferencedIn( ITextRange pRange) const;
/** Reorders styles in this set by moving a style to a given position.
@param pStyle The style object.
@param position The new 0-based position index.
@return Nothing.
*/
void MoveStyleTo( IParaStyle pStyle, ATETextDOM::Int32 position);
};
//////////////////////////////////////////////
// --IParaStylesIterator--
//////////////////////////////////////////////
/** This class allows you to iterate through a set of paragraph styles.
Create the iterator object from a \c IParaStyles object.
Use it to access the \c IParaStyle objects in the collection.
*/
class IParaStylesIterator
{
private:
ParaStylesIteratorRef fParaStylesIterator;
public:
/** Constructor.
@return The new object. */
IParaStylesIterator();
/** Copy constructor
@param src The object to copy.
@return The new object. */
IParaStylesIterator(const IParaStylesIterator& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
IParaStylesIterator& operator=(const IParaStylesIterator& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const IParaStylesIterator& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const IParaStylesIterator& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param parastylesiterator The C object.
@return The new C++ object. */
explicit IParaStylesIterator(ParaStylesIteratorRef parastylesiterator);
/** Destructor */
virtual ~IParaStylesIterator();
/** Retrieves a reference to this object.
@return The object reference. */
ParaStylesIteratorRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
/** Constructor. Creates an iterator object for a specific paragraph style set
that is ordered first-to-last or last-to-first.
@param paraStyles The paragraph style set object.
@param direction Optional. The order of iteration. Default is first-to-last.
@return The new iterator object.
*/
IParaStylesIterator( IParaStyles paraStyles, Direction direction = kForward);
//------------------------------------------------------
// Methods
//------------------------------------------------------
/** Reports whether the end of the set has been reached.
@return True if more members remain in the set. */
bool IsNotDone( ) const;
/** Reports whether the end of the set has been reached.
@return True if no more members remain in the set. */
bool IsDone( ) const;
/** Reports whether the set is empty.
@return True if the set is empty. */
bool IsEmpty( ) const;
/** Sets the current position to the first member of this set.
@return Nothing. */
void MoveToFirst( );
/** Sets the current position to the last member of this set.
@return Nothing. */
void MoveToLast( );
/** Increments the current position in this set in the iterator's current direction.
@return Nothing. */
void Next( );
/** Decrements the current position in this set.
@return Nothing. */
void Previous( );
/** Retrieves the current paragraph style.
@return The paragraph style object. */
IParaStyle Item( ) const;
};
//////////////////////////////////////////////
// --ISpell--
//////////////////////////////////////////////
/** This class allows you to configure and execute spell-checks
within a document, story, or text range. Use the object to
perform searches for unknown words, replace them with corrected words,
and maintain associated dictionaries and word lists.
To implement a replace-all operation,
\li Save the current text object and search state, using
\c #GetSearchRange() and \c #GetPreReplaceAllSettings().
\li Loop through the text objects, and use \c #FindReplaceAllWord() to find all instances
of the target word in the current text object. Keep calling until the method
returns false, making sure to set the \c firstTimeInThisObject flag as needed.
When the method returns a text range, select it and call \c #ReplaceSelected().
\li When the operation is complete, restore the text object using \c #SetSearchRange(),
then restore the position and sentence-end flag using \c #RestorePreReplaceAllSettings().
You must do it in this order, because \c #SetSearchRange() resets the flag.
*/
class ISpell
{
private:
SpellRef fSpell;
public:
/** Constructor.
@return The new object. */
ISpell();
/** Copy constructor
@param src The object to copy.
@return The new object. */
ISpell(const ISpell& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
ISpell& operator=(const ISpell& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const ISpell& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const ISpell& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param spell The C object.
@return The new C++ object. */
explicit ISpell(SpellRef spell);
/** Destructor */
virtual ~ISpell();
/** Retrieves a reference to this object.
@return The object reference. */
SpellRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
// ========================================================================
// Options
// ========================================================================
/** Initializes this spell-check object with a directory.
@return Nothing*/
void Initialize( );
/** Reports whether this spell-check object has been initialized.
@return True if this object has been initialized. */
bool IsInitialized( );
/** Reports whether this spell-check ignores words that are all uppercase.
@return True if this spell-check ignores words that are all uppercase. */
bool GetIgnoreWordsInAllUppercase( ) const;
/** Reports whether this spell-check ignores words that contain numbers.
@return True if this spell-check ignores words that contain numbers. */
bool GetIgnoreWordsWithNumbers( ) const;
/** Reports whether this spell-check ignores roman numerals.
@return True if this spell-check ignores roman numerals. */
bool GetIgnoreRomanNumerals( ) const;
/** Reports whether this spell-check ignores repeated words.
@return True if this spell-check ignores repeated words. */
bool GetIgnoreRepeatedWords( ) const;
/** Reports whether this spell-check ignores the uncapitalized first word of a sentence.
@return True if this spell-check ignores the uncapitalized first word of a sentence. */
bool GetIgnoreUncapitalizedStartOfSentence( ) const;
#if SLO_COMPLEXSCRIPT // Middle Eastern specific features only
/** Reports whether strict Yeh characters are considered during the spell check.
@return True if strict Yeh characters are considered, false if they are not.
*/
bool GetStrictYeh( ) const;
/** Reports whether strict Alef characters are considered during the spell check.
@return True if strict Alef characters are considered, false if they are not.
*/
bool GetStrictAlef( ) const;
#endif
/** Sets whether this spell-check ignores words that are all uppercase.
@param newValue True to ignore words that are all uppercase,
false to report as a spelling error. */
void SetIgnoreWordsInAllUppercase( bool newValue);
/** Sets whether this spell-check ignores words that contain numbers.
@param newValue True to ignore words that contain numbers,
false to report as a spelling error. */
void SetIgnoreWordsWithNumbers( bool newValue);
/** Sets whether this spell-check ignores roman numerals.
@param newValue True to ignore roman numerals,
false to report as a spelling error. */
void SetIgnoreRomanNumerals( bool newValue);
/** Sets whether this spell-check ignores repeated word.
@param newValue True to ignore repeated words,
false to report as a spelling error. */
void SetIgnoreRepeatedWords( bool newValue);
/** Sets whether this spell-check ignores uncapitalized first words of sentences.
@param newValue True to ignore uncapitalized first words of sentences,
false to report as a spelling error. */
void SetIgnoreUncapitalizedStartOfSentence( bool newValue);
#if SLO_COMPLEXSCRIPT // Middle Eastern specific features only
/** Sets whether to consider strict Yeh characters during the spell check.
@param newValue True to consider strict Yeh characters, false to not.
@return Nothing.
*/
void SetStrictYeh( bool newValue);
/** Sets whether to consider strict Alef characters during the spell check.
@param newValue True to consider strict Alef characters, false to not.
@return Nothing.
*/
void SetStrictAlef( bool newValue);
#endif
/** Reports the scope of search for this spell-check, the entire document or
a story. The default scope is the entire document.
@return The search-scope constant. */
SearchScope GetSearchScope( ) const;
/** Sets the scope of search for this spell-check, the entire document or
a story. The default scope is the entire document.
@param searchScope The search-scope constant. */
void SetSearchScope( SearchScope searchScope);
/** Sets the range of search for this spell-check, limiting the search
to a specific text range within the scope.
@param pRange The text range object.
@param resetEndOfSentence Optional, whether to reset the end-of-sentence marker.
Default is true.
@param resetCurPos Optional, whether to reset the cursor position after the search.
Default is true.
*/
void SetSearchRange( const ITextRange& pRange, const bool resetEndOfSentence = true, const bool resetCurPos = true);
/** Resets the search temporarily, for a modeless search.
@return Nothing. */
void Reset( );
/** Resumes this search from a given point.
Use this if the user has changed
the text significantly enough that you need to reset, but you are fairly
certain that the text has not been changed before the given point.
@param resumePoint A number of characters, the 0-based offset
into the text at which to resume.
@return Nothing. */
void ResumeFrom( const ATETextDOM::Int32 resumePoint);
// Use this to resume from the current insertion point.
/** Resumes this search from the current insertion point.
@return Nothing. */
void ResumeFromInsertionPoint( );
// ========================================================================
// Methods
// ========================================================================
/** Searches from the start of the range for the first occurrance of an unknown word.
If a word is found, fills a word list with suggested corrections. To retrieve this
list, use \c #GetWordListSize() and GetWordListContents().
@param pResult [out] A buffer in which to return the first unknown word found.
@param pRange [out] A buffer in which to return the text range that contains the returned word.
@param pLanguage [out] Optional. A buffer in which to return the language.
@return True if an unknown word was found and returned, false if the search reached
the end of the range without finding an unknown word. */
bool FindOneMisspelledWord( SpellCheckingResult* pResult, ITextRange pRange, Language* pLanguage = NULL);
/** Retrieves the number of characters in the list of suggested corrections
for an unknown word found by \c #FindOneMisspelledWord().
Use to create a string buffer for \c #GetWordListContents().
@return The number of characters in the list.*/
ATETextDOM::Int32 GetWordListSize( );
/** Retrieves the list of suggested corrections for an unknown word
found by \c #FindOneMisspelledWord().
@param pWordListBuffer [out] A buffer in which to return the word list. Use \c #GetWordListSize()
to allocate sufficient space for the string.
@param sizeOfBuffer The number of characters in the passed buffer.
@param pNumberOfWords [out] A buffer in which to return the number of
NULL-terminated words in the returned word list.
@return Nothing. */
void GetWordListContents( ATETextDOM::Unicode* pWordListBuffer, ATETextDOM::Int32 sizeOfBuffer, ATETextDOM::Int32* pNumberOfWords);
/** Replaces a text range with new text.
@param pRange The destination text range object.
@param pCorrection A string containing the replacement text.
@return Nothing. */
void Replace( ITextRange pRange, const ATETextDOM::Unicode* pCorrection);
// Use this to add an entry to a pair dictionary, binding the selected word to rCorrection.
/** Adds the selected text to the replace-all dictionary
associating it with a given correction string.
@param pCorrection The correction string.
@return Nothing. */
void AddSelectedToReplaceAllDict( const ATETextDOM::Unicode* pCorrection);
/** @deprecated Obsolete, do not use. See \c ISpell class description
for information on implementing a replace-all operation. */
bool DoReplaceAll( );
/** Stores search positions before a replace-all operation that you implement
using \c #FindReplaceAllWord(). Use \c #RestorePreReplaceAllSettings() to
restore the positions after the operation.
You must also save the text object you are currently working with,
and use \c #SetSearchRange() to restore it.
See \c ISpell class description for information on implementing a replace-all operation.
@param pCurrentPoint [out] A buffer in which to save the current search offset.
@param pFoundSentenceEnd [out] A buffer in which to save the current sentence-end flag.
@return Nothing.
*/
void GetPreReplaceAllSettings( ATETextDOM::Int32* pCurrentPoint, bool* pFoundSentenceEnd) const;
// Implement a loop to go through all the text objects you want to replace all with.
// Use this to find all instances of the target word in the current text object.
// Keep calling it until it returns false, making sure to set firstTimeInThisObject as needed.
// It will return the text range to select and call ReplaceSelected( ) with.
/** Searches for the current target word in a text range object. Use to implement
a replace-all operation, by finding all instances of the target word in all text objects
in the range. See \c ISpell class description.
@param pRange The text range object.
@param firstTimeInThisObject True to indicate that that search is
being done in a new text object in your loop.
@return True if the target word is found in the text range.
*/
bool FindReplaceAllWord( ITextRange pRange, const bool firstTimeInThisObject);
/** Restores search positions after a replace-all operation that you implement using \c #FindReplaceAllWord().
Use \c #GetPreReplaceAllSettings() to store the positions before the operation.
You must also save the text object you are currently working with, and use \c #SetSearchRange()
to restore it. See \c ISpell class description for information on implementing a replace-all operation.
@param currentPoint The buffer containing the saved search offset.
@param foundSentenceEnd The buffer containing the saved sentence-end flag.
@return Nothing.
*/
void RestorePreReplaceAllSettings( const ATETextDOM::Int32 currentPoint, const bool foundSentenceEnd);
/// Manage spell-check dictionaries
/** Removes all pairs from the pair dictionary associated with this spell-checker.
The dictionary is never cleared automatically.
@return Nothing. */
void ClearPairDictionary( );
/** Adds the currently selected word to the dictionary associated with this spell-checker.
@return Nothing. */
void AddSelectedToUserDict( );
/** Copies the known-word dictionary for this spell-checker
to the internal word list. Use \c #GetWordListSize() and
\c #GetWordListContents() to examine the result.
@return Nothing. */
void GetUserDictionaryContents( );
/** Adds a word to the known-word dictionary for this spell-checker.
@param pWord A string containing the word.
@return True if the addition was successful, false if the string contains
spaces (multiple words) and no word was added. */
bool AddToUserDictionary( const ATETextDOM::Unicode* pWord);
/** Removes a word from the known-word dictionary for this spell-checker.
@param pWord A string containing the word.
@return Nothing. */
void DeleteFromUserDictionary( const ATETextDOM::Unicode* pWord);
/** Reports whether a word is contained in the known-word dictionary for this spell-checker.
@param pWord A string containing the word.
@return True if the word is in the dictionary. */
bool WordExistsInUserDictionary( const ATETextDOM::Unicode* pWord);
/** Adds the currently selected word to the list of words to be
ignored by this spell-checker.
@return Nothing. */
void AddSelectedToIgnoreList( );
/** Removes all words from the list of words to be ignored by this spell-checker.
The list is never cleared automatically.
@return Nothing. */
void ClearIgnoreList( );
/** Retrieves the language of the most recent missing dictionary.
@return The language constant. */
Language GetLanguageOfLastMissingDictionary( );
//param @out : the size of the length of the path
// @in : the memory where the path is to be stored
ATETextDOM::Int32 GetSpellingDictionaryPath(ATETextDOM::Unicode* path);
};
//////////////////////////////////////////////
// --IStories--
//////////////////////////////////////////////
/** Encapsulates a set of stories. Contains a collection of \c IStory objects.
Use to access the text and input focus of the member stories, and to
temporarily suspend reflow calculations for efficiency when altering the text. */
class IStories
{
private:
StoriesRef fStories;
public:
/** Constructor.
@return The new object. */
IStories();
/** Copy constructor
@param src The object to copy.
@return The new object. */
IStories(const IStories& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
IStories& operator=(const IStories& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const IStories& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const IStories& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param stories The C object.
@return The new C++ object. */
explicit IStories(StoriesRef stories);
/** Destructor */
virtual ~IStories();
/** Retrieves a reference to this object.
@return The object reference. */
StoriesRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
/** Retrieves the number of members of this set.
@return The number of members. */
ATETextDOM::Int32 GetSize( ) const;
/** Retrieves the first member of this set.
@return The member object. */
IStory GetFirst( );
/** Retrieves the last member of this set.
@return The member object. */
IStory GetLast( );
// Focus methods
/** Reports whether a member story has the input focus.
@return True if a story in this collection is currently being edited.
@note Only one story can have the focus. It can lose focus if
the user selects text outside it, or clicks outside the
text of the story. */
bool HasFocus( ) const;
/** Retrieves the member story that has input focus.
@return The story currently being edited, or a \c NULL oject if no text is being edited. */
IStory GetFocus( ) const;
/** Sets the input focus to a member story, deselecting everything in the document.
@param story The story object.
@return Nothing. */
void SetFocus( const IStory& story);
/** Removes input focus from the story currently being edited,
deselecting everything in the document.
@return Nothing. */
void LoseFocus( );
// Navigation objects.
/** Retrieves the set of text ranges in these stories.
@return The text range set object. */
ITextRanges GetTextRanges( ) const;
/** Retrieves the set of text ranges for selected text in these stories.
@return The text range set object. */
ITextRanges GetTextSelection( ) const;
/** Creates an iterator object for the set of paragraphs in these stories.
@return The paragraph iterator object. */
IParagraphsIterator GetParagraphsIterator( ) const;
/** Creates an iterator object for the set of words in these stories.
@return The word iterator object. */
IWordsIterator GetWordsIterator( ) const;
/** Creates an iterator object for the set of text runs in these stories.
@return The text run iterator object. */
ITextRunsIterator GetTextRunsIterator( ) const;
/** Retrieves the document text resources for these stories.
@return The document text resources object. */
IDocumentTextResources GetDocumentTextResources( ) const;
// ========================================================================
// METHODS
// ========================================================================
/** Retrieves a member of this set by position index. Use with \c GetSize()
to iterate through members.
@param nIndex The 0-based position index.
@return The member object.
*/
IStory Item( ATETextDOM::Int32 nIndex) const;
/** Suspends reflow calculation for these stories. Speeds up calls that cause reflow,
such as \c ITextRange insertion methods. Use \c #ResumeReflow()
to restore normal reflow calculation.
@return Nothing. */
void SuspendReflow( );
/** Resumes normal reflow calculation after a call to \c #SuspendReflow().
@return Nothing. */
void ResumeReflow( );
};
//////////////////////////////////////////////
// --IStory--
//////////////////////////////////////////////
/** This class represents a text flow. A story contains
paragraphs, words, text runs, and text frames. You can
get a text range for any arbitrary subset of the text,
or for the selected text.
<<need some discussion of how this is organized, why you
access text at different levels>>
Kerning is managed at the story level.
A set of stories is collected in an \c IStories object.
*/
class IStory
{
private:
StoryRef fStory;
public:
/** Constructor.
@return The new object. */
IStory();
/** Copy constructor
@param src The object to copy.
@return The new object. */
IStory(const IStory& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
IStory& operator=(const IStory& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const IStory& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const IStory& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param story The C object.
@return The new C++ object. */
explicit IStory(StoryRef story);
/** Destructor */
virtual ~IStory();
/** Retrieves a reference to this object.
@return The object reference. */
StoryRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
// ========================================================================
// PROPERTIES
// ========================================================================
/** Retrieves the index position of this story in its \c IStories collection.
@return The 0-based index. */
ATETextDOM::Int32 GetIndex( ) const;
/** Retrieves the number of characters in this story.
@return The number of characters. */
ATETextDOM::Int32 GetSize( ) const;
/// navigation objects.
/** Retrieves the story collection that contains this story.
@return The story collection object. */
IStories GetStories( ) const;
/** Retrieves the text range that contains the entire text of this story.
@return The text range object. */
ITextRange GetTextRange( ) const;
/** Retrieves the set of text ranges that contains the selected text of this story.
@return The text range set object. */
ITextRanges GetTextSelection( ) const;
/** Creates an iterator object for the set of paragraphs in this story.
@return The paragraph iterator object. */
IParagraphsIterator GetParagraphsIterator( ) const;
/** Creates an iterator object for the set of words in this story.
@return The word iterator object. */
IWordsIterator GetWordsIterator( ) const;
/** Creates an iterator object for the set of text runs in this story.
@return The text run iterator object. */
ITextRunsIterator GetTextRunsIterator( ) const;
/** Creates an iterator object for the set of text frames in this story.
@return The text frame iterator object. */
ITextFramesIterator GetTextFramesIterator( ) const;
/** Retrieves a text frame from this story.
@param frameIndex The 0-based position index.
@return The text frame object. */
ITextFrame GetFrame( ATETextDOM::Int32 frameIndex) const;
/// Kerning management
/// for auto or optical kerns
/** Sets automatic or optical kerning for a text range in this story.
@param textRange The text range.
@param autoKernType The kerning type constant.
@return Nothing. */
void SetKernForSelection( const ITextRange& textRange, AutoKernType autoKernType);
/// for manual kerns
/** Sets a specific kern value in this story.
@param charIndex The 0-based position index of the character to kern.
@param value The kerning value.
@return Nothing. */
void SetKernAtChar( ATETextDOM::Int32 charIndex, ATETextDOM::Int32 value);
/** Retrieves the kerning type and value for a text range in this story.
@param textRange The text range object.
@param pAutoKernType [out] A buffer in which to return the kerning type constant.
@param value [out] A buffer in which to return the kerning value.
@return Nothing. */
void GetKern( const ITextRange& textRange, AutoKernType* pAutoKernType, ATETextDOM::Int32* value) const;
/** Retrieves the kerning type and value for a character in this story.
@param charIndex The 0-based position index of the character.
@param pManualKernValue [out] A buffer in which to return the kerning value.
@return The kerning type constant that applies to this character. */
AutoKernType GetModelKernAtChar( ATETextDOM::Int32 charIndex, ATETextDOM::Int32* pManualKernValue) const;
// ========================================================================
// METHODS
// ========================================================================
/** Retrieves an arbitrary text range from this story.
@param start The 0-based position index of the first character in the range.
If negative, 0 is used.
@param end The 0-based position index of the last character in the range.
If greater than the size of the story, the last character of the story is used.
@return The text range object. */
ITextRange GetTextRange( ATETextDOM::Int32 start, ATETextDOM::Int32 end) const;
/** Creates a new story that is a copy of this one.
@return The story object. */
IStory Duplicate( );
/** Suspends reflow calculation for this story. Speeds up calls that cause reflow,
such as \c ITextRange insertion methods. Use \c #ResumeReflow()
to restore normal reflow calculation.
@return Nothing. */
void SuspendReflow( );
/** Resumes normal reflow calculation after a call to \c #SuspendReflow().
@return Nothing. */
void ResumeReflow( );
};
//////////////////////////////////////////////
// --ITabStop--
//////////////////////////////////////////////
/** Encapsulates a tab stop in a paragraph. Tab stops are collected
in an \c ITabStops object, which you can retrieve from
a paragraph using \c IParaFeatures::GetTabStops.
Use an \c ITabStopsIterator object to iterate through the collection. */
class ITabStop
{
private:
TabStopRef fTabStop;
public:
/** Constructor.
@return The new object. */
ITabStop();
/** Copy constructor
@param src The object to copy.
@return The new object. */
ITabStop(const ITabStop& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
ITabStop& operator=(const ITabStop& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const ITabStop& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const ITabStop& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param tabstop The C object.
@return The new C++ object. */
explicit ITabStop(TabStopRef tabstop);
/** Destructor */
virtual ~ITabStop();
/** Retrieves a reference to this object.
@return The object reference. */
TabStopRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
// =======================================================================
// PROPERTIES
// =======================================================================
/** Retrieves the type of this tab stop (right or left).
@return The tab type constant. */
TabType GetTabType( ) const;
/** Sets the type of this tab stop (right or left).
@param tabType The tab type constant.
@return Nothing. */
void SetTabType( TabType tabType);
/** Retrieves the position of this tab stop.
@return The tab position in document points. */
ATETextDOM::Real GetPosition( ) const;
/** Sets the position of this tab stop.
@param position The tab position in document points.
@return Nothing. */
void SetPosition( ATETextDOM::Real position);
/** Reports whether this tab stop uses a leader.
@return True if the tab uses a leader. */
bool HasLeader( ) const;
/** Retrieves the leader string for this tab stop.
@param leader [out] A buffer in which to return the string.
@param maxLength The number of characters in the buffer.
@return Nothing. */
void GetLeader( ATETextDOM::Unicode* leader, ATETextDOM::Int32 maxLength) const;
/** Sets the leader string for this tab stop.
@param leader The string.
@return Nothing. */
void SetLeader( ATETextDOM::Unicode* leader);
/** Retrieves the decimal character for this tab stop.
@return A string containing the character. */
ATETextDOM::Unicode GetDecimalCharacter( ) const;
/** Sets the decimal character for this tab stop.
@param decimalChar A string containing the character. */
void SetDecimalCharacter( ATETextDOM::Unicode decimalChar);
};
//////////////////////////////////////////////
// --ITabStops--
//////////////////////////////////////////////
/** Encapsulates a set if tab stops in a paragraph.
You can create a new set of tab stops to apply to a paragraph,
with \c IParaFeatures::SetTabStops(), or retrieve the existing
tab stops with \c IParaFeatures::GetTabStops().
Tab stop sets are collected in an \c IArrayTabStops object,
which you can retrieve from a set of paragraphs using
\c IParaInspector::GetTabStops. Use an \c ITabStopsIterator
object to iterate through each set in the array.
*/
class ITabStops
{
private:
TabStopsRef fTabStops;
public:
/** Constructor. Creates an empty container.
@return The new object. */
ITabStops();
/** Copy constructor
@param src The object to copy.
@return The new object. */
ITabStops(const ITabStops& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
ITabStops& operator=(const ITabStops& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const ITabStops& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const ITabStops& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param tabstops The C object.
@return The new C++ object. */
explicit ITabStops(TabStopsRef tabstops);
/** Destructor */
virtual ~ITabStops();
/** Retrieves a reference to this object.
@return The object reference. */
TabStopsRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
// =======================================================================
// PROPERTIES
// =======================================================================
/** Retrieves the number of members of this set.
@return The number of members. */
ATETextDOM::Int32 GetSize( ) const;
/** Retrieves the first member of this set.
@return The member object. */
ITabStop GetFirst( ) const;
/** Retrieves the last member of this set.
@return The member object. */
ITabStop GetLast( ) const;
// =======================================================================
// METHODS
// =======================================================================
/** Replaces or adds a tab stop to this set.
@param pTabStop The replacement or new tab stop object.
@return Nothing.
*/
void ReplaceOrAdd( const ITabStop& pTabStop);
/** Retrieves a member of this set by position index. Use with \c GetSize()
to iterate through members.
@param nIndex The 0-based position index.
@return The member object.
*/
ITabStop Item( ATETextDOM::Int32 nIndex) const;
/** Removes a member from the set.
@param nIndex The 0-based position index of the member to remove.
@return Nothing. */
void Remove( ATETextDOM::Int32 nIndex);
/** Removes all members from the set.
@return Nothing. */
void RemoveAll( );
};
//////////////////////////////////////////////
// --ITabStopsIterator--
//////////////////////////////////////////////
/** This class allows you to iterate through a set of tab stops.
Create the iterator object from a \c ITabStops object.
Use it to access the \c ITabStop objects in the collection.
*/
class ITabStopsIterator
{
private:
TabStopsIteratorRef fTabStopsIterator;
public:
/** Constructor.
@return The new object. */
ITabStopsIterator();
/** Copy constructor
@param src The object to copy.
@return The new object. */
ITabStopsIterator(const ITabStopsIterator& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
ITabStopsIterator& operator=(const ITabStopsIterator& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const ITabStopsIterator& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const ITabStopsIterator& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param tabstopsiterator The C object.
@return The new C++ object. */
explicit ITabStopsIterator(TabStopsIteratorRef tabstopsiterator);
/** Destructor */
virtual ~ITabStopsIterator();
/** Retrieves a reference to this object.
@return The object reference. */
TabStopsIteratorRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
/** Constructor. Creates an iterator object for a specific tab stop set
that is ordered first-to-last or last-to-first.
@param tabStops The tab stops set object.
@param direction Optional. The order of iteration. Default is first-to-last.
@return The new iterator object.
*/
ITabStopsIterator( ITabStops tabStops, Direction direction = kForward);
/** Reports whether the end of the set has been reached.
@return True if no more members remain in the set. */
bool IsDone( ) const;
/** Reports whether the end of the set has been reached.
@return True if more members remain in the set. */
bool IsNotDone( ) const;
/** Reports whether the set is empty.
@return True if the set is empty. */
bool IsEmpty( );
/** Sets the current position to the first member of this set.
@return Nothing. */
void MoveToFirst( );
/** Sets the current position to the last member of this set.
@return Nothing. */
void MoveToLast( );
/** Increments the current position in the set in the iterator's current direction.
@return Nothing. */
void Next( );
/** Retrieves the current tab stop.
@return The tab stop object. */
ITabStop Item( ) const;
};
/** A text range, the basic text unit of the Adobe Text Engine, is a set
of characters that ranges from a start offset to an end offset within a story.
Use a text range object:
\li To access selected text, paragraphs, words, text frames,
and text runs (character sequences that share attributes)
within the contained text.
\li To access and modify paragraph and character styles and features in the contained text.
\li To convert text to a Unicode or C string.
\li To select or deselect text programmatically.
\li To convert case in text.
\li To find a single glyph that represents a multiple characters.
Each time you manipulate the contents of a text range, a reflow operation occurs.
Reflow can change the length and endpoints of any text range in the containing story,
and can cause previously obtained text runs to become invalid; see \c ITextRunIterator.
For efficiency, you can temporarily disable reflowing, then renable it after
making your changes. Use \c IStory::SuspendReflow() and \c IStory::ResumeReflow(),
or the \c IInhibitReflow class. Functions that can cause reflow are:
<br><br>\c InsertAfter()
<br>\c InsertBefore()
<br>\c #Remove()
<br>\c #SetLocalCharFeatures()
<br>\c #ReplaceOrAddLocalCharFeatures()
<br>\c #SetLocalParaFeatures()
<br>\c #ReplaceOrAddLocalParaFeatures()
For example, suppose you have the initial text "0123456789", and have created two
ranges, Range1 from 0 to 5 whose content is "01234", and Range2 from 3 to 9
whose content is "345678". If you call <code>Range1.insertAfter("abc")</code>
the text becomes "01234abc56789", Range1 becomes "01234abc", and
Range2 becomes "34abc5678". The offsets change automatically so that the
contained text in the ranges reflects the insertion.
*/
//////////////////////////////////////////////
// --ITextRange--
//////////////////////////////////////////////
class ITextRange
{
private:
TextRangeRef fTextRange;
public:
/** Constructor.
@return The new object. */
ITextRange();
/** Copy constructor
@param src The object to copy.
@return The new object. */
ITextRange(const ITextRange& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
ITextRange& operator=(const ITextRange& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const ITextRange& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const ITextRange& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param textrange The C object.
@return The new C++ object. */
explicit ITextRange(TextRangeRef textrange);
/** Destructor */
virtual ~ITextRange();
/** Retrieves a reference to this object.
@return The object reference. */
TextRangeRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
// =======================================================================
// PROPERTIES
// ========================================================================
/** Retrieves the start offset of this text range.
@return The 0-based index of the start offset from the
beginning of the containing story. */
ATETextDOM::Int32 GetStart( ) const;
/** Sets the start offset of this text range.
@param start The 0-based index of the start offset from the
beginning of the containing story.
@return Nothing. */
void SetStart( ATETextDOM::Int32 start);
/** Retrieves the end offset of this text range.
@return The 0-based index of the end offset from the
beginning of the containing story. */
ATETextDOM::Int32 GetEnd( ) const;
/** Sets the end offset of this text range.
@param end The 0-based index of the end offset from the
beginning of the containing story.
@return Nothing. */
void SetEnd( ATETextDOM::Int32 end);
/** Retrieves the size of this text range.
@return The number of characters. */
ATETextDOM::Int32 GetSize( ) const;
// =======================================================================
// NAVIGATION OBJECTS
// ========================================================================
/** Retrieves the story that contains this text range.
@return The story object. */
IStory GetStory( ) const;
/** Retrieves the selected text within this text range.
@return The text ranges object containing the selected text. */
ITextRanges GetTextSelection( ) const;
/** Creates an iterator for the text frames contained in this text range.
@return The iterator object. */
ITextFramesIterator GetTextFramesIterator( ) const;
/** Creates an iterator for the paragraphs contained in this text range.
@return The iterator object. */
IParagraphsIterator GetParagraphsIterator( ) const;
/** Creates an iterator for the words contained in this text range.
@return The iterator object. */
IWordsIterator GetWordsIterator( ) const;
/** Creates an iterator for the text runs contained in this text range.
Text runs are character sequences that share attributes.
@return The iterator object. */
ITextRunsIterator GetTextRunsIterator( ) const;
// =======================================================================
// ATTRIBUTE INSPECTION AND MODIFICATION
// ========================================================================
/** Creates an inspector with which to access the character features of
all characters in this text range.
@return The inspector object. */
ICharInspector GetCharInspector( ) const;
/** Creates an inspector with which to access the paragraph features of
all paragraphs in this text range.
@return The inspector object. */
IParaInspector GetParaInspector( ) const;
/** Retrieves a set of all named character styles used in this text range.
@return The character style set object. */
ICharStyles GetNamedCharStyles( ) const;
/** Retrieves a set of all named paragraph styles used in this text range.
@return The paragraph style set object. */
IParaStyles GetNamedParaStyles( ) const;
/** Associates a named character style to this text range. The inherited values can
be overridden by styles or features specified locally in contained
text ranges or individual characters.
@param pName The style name.
@return True if the style is successfully applied, false if there
is no style with the specified name. */
bool SetNamedCharStyle( const ATETextDOM::Unicode* pName);
/** Associates a named paragraph style to this text range. The inherited values can
be overridden by styles or features specified locally in contained
text ranges or individual paragraphs.
@param pName The style name.
@return True if the style is successfully applied, false if there
is no style with the specified name. */
bool SetNamedParaStyle( const ATETextDOM::Unicode* pName);
/** Removes the association of this text range and its character style.
Copies the feature values of the character style into local override
values in the contained characters. See \c ICharFeatures.
@return Nothing. */
void ClearNamedCharStyle( );
/** Removes the association of this text range and its paragraph style.
Copies the feature values of the paragraph style into local override
values in the contained paragraphs. See \c IParaFeatures.
@return Nothing. */
void ClearNamedParaStyle( );
/** Retrieves the unique character features used in this text range.
Unique features are those which have the same value in all text
runs in the range.
@return The character features object containing the unique
feature values. Other features are unassigned.*/
ICharFeatures GetUniqueCharFeatures( ) const;
/** Retrieves the unique paragraph features used in this text range.
Unique features are those which have the same value in all text
runs in the range.
@return The paragraph features object containing the unique
feature values. Other features are unassigned.*/
IParaFeatures GetUniqueParaFeatures( ) const;
/** Reports whether there any local character feature overrides for
characters contained in this text range.
@return True if there are local overrides. */
bool HasLocalCharFeatures( );
/** Reports whether there any local paragraph feature overrides for
paragraphs contained in this text range.
@return True if there are local overrides. */
bool HasLocalParaFeatures( );
/** Retrieves the character features that have local overrides in this text range,
and whose local values are the same in all text runs in the range.
@return The character features object containing the unique
local feature values. Other features are unassigned. If all
features are unassigned, either there are no local overrides,
or the local overrides have no common values. */
ICharFeatures GetUniqueLocalCharFeatures( );
/** Retrieves the paragraph features that have local overrides in this text range,
and whose local values are the same in all text runs in the range.
@return The paragraph features object containing the unique
local feature values. Other features are unassigned. If all
features are unassigned, either there are no local overrides,
or the local overrides have no common values. */
IParaFeatures GetUniqueLocalParaFeatures( );
/** Replaces all of the local overrides for all characters in this text range
with a new set of feature values. All values that are assigned
become local values, replacing any previous local value. These local
values override any specified in a style associated with the
character or the text range. All values that are unassigned remove
any previous local values, so that those values are inherited.
Triggers a reflow operation that can cause previously obtained
text runs to become invalid; see \c ITextRunIterator.
@param pFeatures The new feature set object.
@return Nothing.
@see \c IStory::SuspendReflow(), \c IStory::ResumeReflow() */
void SetLocalCharFeatures( const ICharFeatures& pFeatures);
/** Modifies the local overrides for all characters in this text range.
All values that are assigned become local values, replacing any
previous local value. Values that are unassigned leave any previous
local values unchanged.
Triggers a reflow operation that can cause previously obtained
text runs to become invalid; see \c ITextRunIterator.
@param pFeatures The new feature set object.
@return Nothing.
@see \c IStory::SuspendReflow(), \c IStory::ResumeReflow() */
void ReplaceOrAddLocalCharFeatures( const ICharFeatures& pFeatures);
/** Removes all local overrides for all characters in this text range.
All character features are then inherited from styles associated
with the character or text range, or from the Normal style.
@return Nothing. */
void ClearLocalCharFeatures( );
/** Replaces all of the local overrides for all paragraphs in this text range
with a new set of feature values. All values that are assigned
become local values, replacing any previous local value. These local
values override any specified in a style associated with the
paragraph or the text range. All values that are unassigned remove
any previous local values, so that those values are inherited.
Triggers a reflow operation that can cause previously obtained
text runs to become invalid; see \c ITextRunIterator.
@param pFeatures The new feature set object.
@return Nothing.
@see \c IStory::SuspendReflow(), \c IStory::ResumeReflow() */
void SetLocalParaFeatures( const IParaFeatures& pFeatures);
/** Modifies the local overrides for all paragraphs in this text range.
All values that are assigned become local values, replacing any
previous local value. Values that are unassigned leave any previous
local values unchanged.
Triggers a reflow operation that can cause previously obtained
text runs to become invalid; see \c ITextRunIterator.
@param pFeatures The new feature set object.
@return Nothing.
@see \c IStory::SuspendReflow(), \c IStory::ResumeReflow() */
void ReplaceOrAddLocalParaFeatures( const IParaFeatures& pFeatures);
/** Removes all local overrides for all paragraphs in this text range.
All paragraph features are then inherited from styles associated
with the paragraph or text range, or from the Normal style.
@return Nothing. */
void ClearLocalParaFeatures( );
// =======================================================================
// METHODS
// ========================================================================
/** Associates this text range with a new story.
@param story The story object.
@return Nothing. */
void SetStory( const IStory& story);
/** Sets the start and end points of this text range.
@param start The 0-based index of the start offset from the
beginning of the containing story.
@param end The 0-based index of the end offset from the
beginning of the containing story.
@return Nothing. */
void SetRange( ATETextDOM::Int32 start, ATETextDOM::Int32 end);
/** Resets start or end point of this range so that it contains only
one character, either the first or the last.
@param direction Optional. The direction constant. Default is
\c CollapseEnd, which sets the start offset to the end offset.
Use \c CollapseStart to set the end offset to the start offset. */
void Collapse( CollapseDirection direction = CollapseEnd);
/** Moves this text range by adding or subtracting a number of characters
to or from the start and end offsets. Does not move the range if the
result would be out of the story bounds.
@param unit The number of characters, positive to move the range
toward the end, negative to move it toward the beginning of
the story.
@return The number of characters by which the range was translated,
or 0 if the translation could not be made within the story bounds. */
ATETextDOM::Int32 Move( ATETextDOM::Int32 unit);
/** Creates a duplicate of this object.
@return The new object. */
ITextRange Clone( ) const;
/** Inserts text into this text range before the current start point. Triggers a
reflow operation that resets the start and end points of this and any other
affected ranges to include both the old and new text.
@param text A Unicode string containing the text.
@param length (Optional) The number of characters, or -1 (the default) if
the string is NULL-terminated.
@see \c IStory::SuspendReflow(), \c IStory::ResumeReflow() */
void InsertBefore( const ATETextDOM::Unicode* text, ATETextDOM::Int32 length = -1);
/** Inserts text into this text range after the current end point. Triggers a
reflow operation that resets the start and end points of this and any other
affected ranges to include both the old and new text.
@param text A Unicode string containing the text.
@param length (Optional) The number of characters, or -1 (the default) if
the string is NULL-terminated.
@see \c IStory::SuspendReflow(), \c IStory::ResumeReflow() */
void InsertAfter( const ATETextDOM::Unicode* text, ATETextDOM::Int32 length = -1);
/** Inserts text into this text range before the current start point. Triggers a
reflow operation that resets the start and end points of this and any other
affected ranges to include both the old and new text.
@param anotherRange A text range object containing the text.
@see \c IStory::SuspendReflow(), \c IStory::ResumeReflow() */
void InsertBefore( const ITextRange& anotherRange);
/** Inserts text into this text range after the current end point. Triggers a
reflow operation that resets the start and end points of this and any other
affected ranges to include both the old and new text.
@param anotherRange A text range object containing the text.
@see \c IStory::SuspendReflow(), \c IStory::ResumeReflow() */
void InsertAfter( const ITextRange& anotherRange);
/** Retrieves the contents of this text range as a Unicode string.
@param text [out] A buffer in which to return the string.
@param maxLength The number of characters in the buffer.
@return The number of characters in the returned string. */
ATETextDOM::Int32 GetContents( ATETextDOM::Unicode* text, ATETextDOM::Int32 maxLength) const;
/** Retrieves the contents of this text range as a C string.
@param text [out] A buffer in which to return the string.
@param maxLength The number of characters in the buffer.
@return The number of characters in the returned string. */
ATETextDOM::Int32 GetContents( char* text, ATETextDOM::Int32 maxLength) const;
/** Reports whether the characters in this text range map to a single glyph,
and if so, retrieves that glyph.
@param pSingleGlyph [out] A buffer in which to return the glyph identifier,
if there is one. Otherwise, the buffer is not changed.
@return True if the characters in this range map to a single glyph. */
bool GetSingleGlyphInRange( ATEGlyphID* pSingleGlyph) const;
/** Selects the text in this text range.
@param addToSelection (Optional) True to add this text to the current
selection, false (the default) to clear the current selection before
selecting this text.
@return Nothing. */
void Select( bool addToSelection = false);
/** Deselects the text in this text range. This can result in a discontiguous selection,
if this text range is a subset of the selected text.
@return Nothing. */
void DeSelect( );
/** Changes the case of the text in this text range.
@param caseChangeType The case type constant.
@return Nothing. */
void ChangeCase( CaseChangeType caseChangeType);
/** Adjusts the tracking of the text in this range to
fit on one line spanning the width of the area text object.
This is the equivalent of choosing Type > Fit Headline with
the text range selected.
@return Nothing. */
void FitHeadlines( );
/** Deletes all of the characters in this text range. Triggers a
reflow operation that resets the start and end points of any other
affected ranges.
@return Nothing.
@see \c IStory::SuspendReflow(), \c IStory::ResumeReflow() */
void Remove( );
/** Retrieves the character type of the single character in this
text range. Throws \c #kBadParameterErr if this text range
does not contain exactly one character.
@return The character type constant, */
ASCharType GetCharacterType( ) const;
};
//////////////////////////////////////////////
// --ITextRanges--
//////////////////////////////////////////////
/** Encapsulates a set of text ranges. Contains a collection of \c ITextRange objects.
Allows you to perform many of the text operations on all of the member ranges
at once. Use an \c ITextRangesIterator object to iterate through the member ranges. */
class ITextRanges
{
private:
TextRangesRef fTextRanges;
public:
/** Constructor.
@return The new object. */
ITextRanges();
/** Copy constructor
@param src The object to copy.
@return The new object. */
ITextRanges(const ITextRanges& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
ITextRanges& operator=(const ITextRanges& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const ITextRanges& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const ITextRanges& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param textranges The C object.
@return The new C++ object. */
explicit ITextRanges(TextRangesRef textranges);
/** Destructor */
virtual ~ITextRanges();
/** Retrieves a reference to this object.
@return The object reference. */
TextRangesRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
// =======================================================================
// PROPERTIES
// ======================================================================
/** Retrieves the number of members of this set.
@return The number of members.
*/
ATETextDOM::Int32 GetSize( ) const;
/** Retrieves the first member of this set.
@return The member object. */
ITextRange GetFirst( ) const;
/** Retrieves the last member of this set.
@return The member object. */
ITextRange GetLast( ) const;
// navigation objects.
/** Retrieves the selected text within this text range set.
@return The text ranges object containing the selected text. */
ITextRanges GetTextSelection( ) const;
/** Creates an iterator for the paragraphs contained in this text range set.
@return The iterator object. */
IParagraphsIterator GetParagraphsIterator( ) const;
/** Creates an iterator for the words contained in this text range set.
@return The iterator object. */
IWordsIterator GetWordsIterator( ) const;
/** Creates an iterator for the text runs contained in this text range set.
@return The iterator object. */
ITextRunsIterator GetTextRunsIterator( ) const;
// =======================================================================
// ATTRIBUTE INSPECTION AND MODIFICATION
// ========================================================================
/** Creates an inspector with which to access the character features of
all characters in this text range set.
@return The inspector object. */
ICharInspector GetCharInspector( ) const;
/** Creates an inspector with which to access the paragraph features of
all paragraphs in this text range set.
@return The inspector object. */
IParaInspector GetParaInspector( ) const;
/** Removes the association of this text range set and its character style.
Copies the feature values of the character style into local override
values in the contained characters. See \c ICharFeatures.
@return Nothing. */
void ClearNamedCharStyle( );
/** Removes the association of this text range set and its paragraph style.
Copies the feature values of the paragraph style into local override
values in the contained paragraphs. See \c IParaFeatures.
@return Nothing. */
void ClearNamedParaStyle( );
/** Retrieves the unique character features used in this text range set.
Unique features are those which have the same value in all text
runs in the ranges.
@return The character features object containing the unique
feature values. Other features are unassigned.*/
ICharFeatures GetUniqueCharFeatures( ) const;
/** Retrieves the unique paragraph features used in this text range set.
Unique features are those which have the same value in all text
runs in the ranges.
@return The paragraph features object containing the unique
feature values. Other features are unassigned.*/
IParaFeatures GetUniqueParaFeatures( ) const;
/** Reports whether there any local character feature overrides for
characters contained in this text range set.
@return True if there are local overrides. */
bool HasLocalCharFeatures( );
/** Reports whether there any local paragraph feature overrides for
paragraphs contained in this text range set.
@return True if there are local overrides. */
bool HasLocalParaFeatures( );
/** Retrieves the character features that have local overrides in this text range set,
and whose local values are the same in all text runs in the ranges.
@return The character features object containing the unique
local feature values. Other features are unassigned. If all
features are unassigned, either there are no local overrides,
or the local overrides have no common values. */
ICharFeatures GetUniqueLocalCharFeatures( );
/** Retrieves the paragraph features that have local overrides in this text range set,
and whose local values are the same in all text runs in the ranges.
@return The paragraph features object containing the unique
local feature values. Other features are unassigned. If all
features are unassigned, either there are no local overrides,
or the local overrides have no common values. */
IParaFeatures GetUniqueLocalParaFeatures( );
/** Replaces all of the local overrides for all characters in this text range set
with a new set of feature values. All values that are assigned
become local values, replacing any previous local value. These local
values override any specified in a style associated with a
character or a text range. All values that are unassigned remove
any previous local values, so that those values are inherited.
@param pFeatures The new feature set object.
@return Nothing. */
void SetLocalCharFeatures( const ICharFeatures& pFeatures);
/** Modifies the local overrides for all characters in this text range set.
All values that are assigned become local values, replacing any
previous local value. Values that are unassigned leave any previous
local values unchanged.
@param pFeatures The new feature set object.
@return Nothing. */
void ReplaceOrAddLocalCharFeatures( const ICharFeatures& pFeatures);
/** Removes all local overrides for all characters in this text range set.
All character features are then inherited from styles associated
with the character or text range, or from the Normal style.
@return Nothing. */
void ClearLocalCharFeatures( );
/** Replaces all of the local overrides for all paragraphs in this text range set
with a new set of feature values. All values that are assigned
become local values, replacing any previous local value. These local
values override any specified in a style associated with a
paragraph or a text range. All values that are unassigned remove
any previous local values, so that those values are inherited.
@param pFeatures The new feature set object.
@return Nothing. */
void SetLocalParaFeatures( const IParaFeatures& pFeatures);
/** Modifies the local overrides for all paragraphs in this text range set.
All values that are assigned become local values, replacing any
previous local value. Values that are unassigned leave any previous
local values unchanged.
@param pFeatures The new feature set object.
@return Nothing. */
void ReplaceOrAddLocalParaFeatures( const IParaFeatures& pFeatures);
/** Removes all local overrides for all paragraphs in this text range set.
All paragraph features are then inherited from styles associated
with the paragraph or text range, or from the Normal style.
@return Nothing. */
void ClearLocalParaFeatures( );
// =======================================================================
// METHODS
// ======================================================================
/** Selects the text in this text range set.
@param addToSelection (Optional) True to add this text to the current
selection, false (the default) to clear the current selection before
selecting this text.
@return Nothing. */
void Select( bool addToSelection = false);
/** Deselects the text in this text range set.
This can result in a discontiguous selection,
if this text is a subset of the selected text.
@return Nothing. */
void DeSelect( );
/** Retrieves the contents of this text range set as a Unicode string.
@param text [out] A buffer in which to return the string.
@param maxLength The number of characters in the buffer.
@return The number of characters in the returned string. */
ATETextDOM::Int32 GetContents( ATETextDOM::Unicode* text, ATETextDOM::Int32 maxLength) const;
/** Retrieves the contents of this text range set as a C string.
@param text [out] A buffer in which to return the string.
@param maxLength The number of characters in the buffer.
@return The number of characters in the returned string. */
ATETextDOM::Int32 GetContents( char* text, ATETextDOM::Int32 maxLength) const;
/** Changes the case of the text in this text range set.
@param caseChangeType The case type constant.
@return Nothing. */
void ChangeCase( CaseChangeType caseChangeType);
/** Adds a text range as a member of this set.
@param textRange The text range object.
@return Nothing. */
void Add( const ITextRange& textRange);
/** Retrieves a member of this set by position index. Use with \c GetSize()
to iterate through members.
@param nIndex The 0-based position index.
@return The member object.
*/
ITextRange Item( ATETextDOM::Int32 nIndex) const;
/** Removes all members from the set.
@return Nothing. */
void RemoveAll( );
/** Removes a member from the set.
@param nIndex The 0-based position index of the member to remove.
@return Nothing. */
void Remove( ATETextDOM::Int32 nIndex);
};
//////////////////////////////////////////////
// --ITextRangesIterator--
//////////////////////////////////////////////
/** This object allows you to iterate through a set of text ranges.
Create the iterator from a set of text ranges (\c ITextRanges). */
class ITextRangesIterator
{
private:
TextRangesIteratorRef fTextRangesIterator;
public:
/** Constructor.
@return The new object. */
ITextRangesIterator();
/** Copy constructor
@param src The object to copy.
@return The new object. */
ITextRangesIterator(const ITextRangesIterator& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
ITextRangesIterator& operator=(const ITextRangesIterator& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const ITextRangesIterator& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const ITextRangesIterator& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param textrangesiterator The C object.
@return The new C++ object. */
explicit ITextRangesIterator(TextRangesIteratorRef textrangesiterator);
/** Destructor */
virtual ~ITextRangesIterator();
/** Retrieves a reference to this object.
@return The object reference. */
TextRangesIteratorRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
/** Constructor. Creates an iterator object for a specific text range set
that is ordered first-to-last or last-to-first.
@param textRanges The text range set object.
@param direction Optional. The order of iteration. Default is first-to-last.
@return The new iterator object.
*/
ITextRangesIterator( ITextRanges textRanges, Direction direction = kForward);
/** Creates a duplicate of this object.
@return The new object. */
ITextRangesIterator Clone( ) const;
/** Reports whether the end of the set has been reached.
@return True if more members remain in the set. */
bool IsNotDone( ) const;
/** Reports whether the end of the set has been reached.
@return True if no more members remain in the set. */
bool IsDone( ) const;
/** Reports whether the set is empty.
@return True if the set is empty. */
bool IsEmpty( ) const;
/** Sets the current position to the first member of this set.
@return Nothing. */
void MoveToFirst( );
/** Sets the current position to the last member of this set.
@return Nothing. */
void MoveToLast( );
/** Increments the current position in the set in the iterator's current direction.
@return Nothing. */
void Next( );
/** Retrieves the current text range.
@return The text range object. */
ITextRange Item( ) const;
};
//////////////////////////////////////////////
// --ITextRunsIterator--
//////////////////////////////////////////////
/** This object allows you to iterate through a set of text runs in a story.
A text run is a range of text whose characters all share the
same set of attributes. If the text of the story changes through insertions
or deletions, an existing text run iterator is rendered invalid.
Create a text run iterator object using \c ITextRange::GetTextRunsIterator(),
or the corresponding method in \c ITextRanges, \c IStory, \c IStories, or \c IGlyphs.
*/
class ITextRunsIterator
{
private:
TextRunsIteratorRef fTextRunsIterator;
public:
/** Constructor.
@return The new object. */
ITextRunsIterator();
/** Copy constructor
@param src The object to copy.
@return The new object. */
ITextRunsIterator(const ITextRunsIterator& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
ITextRunsIterator& operator=(const ITextRunsIterator& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const ITextRunsIterator& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const ITextRunsIterator& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param textrunsiterator The C object.
@return The new C++ object. */
explicit ITextRunsIterator(TextRunsIteratorRef textrunsiterator);
/** Destructor */
virtual ~ITextRunsIterator();
/** Retrieves a reference to this object.
@return The object reference. */
TextRunsIteratorRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
/** Constructor. Creates an iterator object for a the text runs in a specific text range set
that is ordered first-to-last or last-to-first.
@param ranges The text range set object.
@param direction Optional. The order of iteration. Default is first-to-last.
@return The new iterator object.
*/
ITextRunsIterator( const ITextRanges& ranges, Direction direction = kForward);
/** Reports whether the end of the set has been reached.
@return True if more members remain in the set. */
bool IsNotDone( ) const;
/** Reports whether the end of the set has been reached.
@return True if no more members remain in the set. */
bool IsDone( ) const;
/** Reports whether the set is empty.
@return True if the set is empty. */
bool IsEmpty( ) const;
/** Sets the current position to the first member of this set.
@return Nothing. */
void MoveToFirst( );
/** Sets the current position to the last member of this set.
@return Nothing. */
void MoveToLast( );
/** Increments the current position in the set in the iterator's current direction.
@return Nothing. */
void Next( );
/** Retrieves the text range containing the current text run.
@return The text range object.
@note This can change from one call to the next if the story text changes.
For foward iteration, the new text run begins at or before the old one.
For backward iteration, the new text run begins at or after the old one. */
ITextRange Item( ) const;
};
//////////////////////////////////////////////
// --IWordsIterator--
//////////////////////////////////////////////
/** This object allows you to iterate through a set of words in a text range.
Create an iterator object using \c ITextRange::GetWordsIterator(),
or the corresponding method in \c ITextRanges, \c IStory, \c IStories,
\c IParagraph, or \c IGlyphs.
*/
class IWordsIterator
{
private:
WordsIteratorRef fWordsIterator;
public:
/** Constructor.
@return The new object. */
IWordsIterator();
/** Copy constructor
@param src The object to copy.
@return The new object. */
IWordsIterator(const IWordsIterator& src);
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
IWordsIterator& operator=(const IWordsIterator& rhs);
/** Comparison operator tests for equality.
@param rhs The object to compare to this one.
@return True if the two objects are the same. */
bool operator==(const IWordsIterator& rhs) const;
/** Comparison operator tests for inequality.
@param rhs The object to compare to this one.
@return True if the two objects are not the same. */
bool operator!=(const IWordsIterator& rhs) const;
/** Constructs this C++ object from the corresponding C object
returned by an ATE suite function.
The C++ object manages reference counting.
@param wordsiterator The C object.
@return The new C++ object. */
explicit IWordsIterator(WordsIteratorRef wordsiterator);
/** Destructor */
virtual ~IWordsIterator();
/** Retrieves a reference to this object.
@return The object reference. */
WordsIteratorRef GetRef() const;
/** Reports whether this is a null object.
@return True if this is a null object. */
bool IsNull() const;
/** Constructor. Creates an iterator object for the words in a specific text range set.
that is ordered first-to-last or last-to-first.
@param ranges The text range set object.
@param direction Optional. The order of iteration. Default is first-to-last.
@return The new iterator object.
*/
IWordsIterator( const ITextRanges& ranges, Direction direction = kForward);
/** Reports whether the end of the set has been reached.
@return True if more members remain in the set. */
bool IsNotDone( ) const;
/** Reports whether the end of the set has been reached.
@return True if no more members remain in the set. */
bool IsDone( ) const;
/** Reports whether the set is empty.
@return True if the set is empty. */
bool IsEmpty( ) const;
/** Sets the current position to the first member of this set.
@return Nothing. */
void MoveToFirst( );
/** Sets the current position to the last member of this set.
@return Nothing. */
void MoveToLast( );
/** Increments the current position in the set in the iterator's current direction.
@return Nothing. */
void Next( );
/** Retrieves the text range for the current word, including trailing characters.
This is equivalent to Ctrl/Cmd + arrow. For example, "..." is considered a word.
@return The text range object. */
ITextRange Item( ) const;
/// Trailing characters
/** Retrieves the number of trailing spaces for the current word.
Trailing spaces are those after the word, regardless of the direction of
iteration.
@return The number of trailing spaces. */
ATETextDOM::Int32 GetTrailingSpaceCount( ) const;
/** Retrieves the total number of trailing characters for the current word, including
spaces, other white-space characters, and punctuation characters.
Trailing characters are those after the word, regardless of the direction of
iteration.
@return The number of trailing characters. */
ATETextDOM::Int32 GetTrailingCount( ) const;
/** Retrieves the number of trailing punctuation characters for the current word.
Trailing characters are those after the word, regardless of the direction of
iteration.
@return The number of trailing punctuation characters. */
ATETextDOM::Int32 GetTrailingTerminatingPunctuationCount( ) const;
};
/** A convenience class for temporarily inhibiting reflow in a text story.
By default, as edits are made to the contents of a text story and its attributes,
the story contents are reflowed through the story containers. This operation
can be expensive. Use this class to inhibit reflow when batching together
a series of edits to one or more text objects. Destroy the object when
all the edits are complete, so that reflow is automatically resumed.
*/
class IInhibitReflow
{
public:
/** Constructor.
@return The new object. */
IInhibitReflow()
{
}
/** Constructor. Creates a reflow inhibitor object for a story.
@param story The story object.
@return The new reflow inhibitor object.
*/
IInhibitReflow(const IStory& story)
:fStory(story)
{
fStory.SuspendReflow();
}
/** Copy constructor
@param reflow The object to copy.
@return The new object. */
IInhibitReflow(const IInhibitReflow& reflow)
:fStory(reflow.fStory)
{
fStory.SuspendReflow();
}
/** Destructor. */
virtual ~IInhibitReflow()
{
try
{
if (!fStory.IsNull())
fStory.ResumeReflow();
}
catch (...) {}
}
/** Assignment operator.
@param rhs The object to assign to this one.
@return A reference to this object. */
IInhibitReflow& operator=(const IInhibitReflow& rhs)
{
this->~IInhibitReflow( );
fStory = rhs.fStory;
if(!fStory.IsNull())
fStory.SuspendReflow();
return *this;
}
protected:
IStory fStory;
};
}// namespace ATE
| 124,499 |
301 | <reponame>jonghenhan/iotivity
//******************************************************************
//
// Copyright 2016 Samsung Electronics 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 <iostream>
#include <vector>
#include <algorithm>
#include <condition_variable>
#include "OCPlatform.h"
#include "RCSDiscoveryManager.h"
#include "RCSRemoteResourceObject.h"
#include "RCSAddress.h"
#include "RemoteSceneList.h"
using namespace OC;
using namespace OIC::Service;
constexpr int CREATE_REMOTE_SCENE_LIST = 1;
constexpr int CREATE_REMOTE_SCENE_COLLECTION = 1;
constexpr int SHOW_REMOTE_SCENE_COLLECTION = 2;
constexpr int CREATE_REMOTE_SCENE = 1;
constexpr int CREATE_REMOTE_SCENE_ACTION = 1;
constexpr int EXECUTE_REMOTE_SCENE = 1;
constexpr int SCENE_RESULT_OK = 200;
constexpr int numCreatedSceneAction = 2;
static int numRecvSceneActionCreationResp = 0;
typedef std::function< void() > Run;
Run g_currentRun;
const std::string scene_name = "Night mode";
const std::string relativetUri = OC_RSRVD_WELL_KNOWN_URI;
const std::vector<std::string> resourceTypes{ "oic.wk.sceneList", "core.light", "core.fan" };
std::mutex g_mtx;
std::mutex g_discoverymtx;
std::condition_variable g_cond;
std::unique_ptr<RCSDiscoveryManager::DiscoveryTask> g_discoveryTask;
RCSRemoteResourceObject::Ptr g_foundListResource;
RCSRemoteResourceObject::Ptr g_foundLightResource;
RCSRemoteResourceObject::Ptr g_foundFanResource;
RemoteSceneList::Ptr g_sceneList;
RemoteSceneCollection::Ptr g_sceneCollection;
RemoteScene::Ptr g_scene;
void displaySceneList();
void runCreateRemoteSceneList();
void runRemoteSceneCollection();
void runCreateRemoteScene();
void runCreateRemoteSceneAction();
void runExecuteCreatedRemoteScene();
void runExecuteExistingRemoteScene();
// Scene Manager Remote API sample ---
void onRemoteSceneListCreated(RemoteSceneList::Ptr remoteSceneList, int eCode)
{
std::cout << __func__ << " - error code : " << eCode << std::endl;
if (eCode == SCENE_RESULT_OK)
{
g_sceneList = std::move(remoteSceneList);
g_currentRun = runRemoteSceneCollection;
}
else
{
std::cout << "Create Remote scene list failed." << std::endl;
g_currentRun = runCreateRemoteSceneList;
}
g_currentRun();
}
void onRemoteSceneCollectionCreated(RemoteSceneCollection::Ptr remoteSceneCol, int eCode)
{
std::cout << __func__ << " - error code : " << eCode << std::endl;
if (eCode == SCENE_RESULT_OK)
{
g_sceneCollection = remoteSceneCol;
g_currentRun = runCreateRemoteScene;
}
else
{
std::cout << "Create Remote scene collection failed." << std::endl;
g_currentRun = runRemoteSceneCollection;
}
g_currentRun();
}
void onRemoteSceneCreated(RemoteScene::Ptr remoteScene, int eCode)
{
std::cout << __func__ << " - error code : " << eCode << std::endl;
if (eCode == SCENE_RESULT_OK)
{
g_scene = remoteScene;
g_currentRun = runCreateRemoteSceneAction;
}
else
{
std::cout << "Create Remote scene failed." << std::endl;
g_currentRun = runCreateRemoteScene;
}
g_currentRun();
}
void onRemoteSceneActionCreated(RemoteSceneAction::Ptr, int eCode)
{
std::cout << __func__ << " - error code : " << eCode << std::endl;
if (eCode == SCENE_RESULT_OK)
{
g_currentRun = runExecuteCreatedRemoteScene;
}
else
{
std::cout << "Create Remote scene action failed." << std::endl;
g_currentRun = runCreateRemoteSceneAction;
}
numRecvSceneActionCreationResp++;
if(numCreatedSceneAction == numRecvSceneActionCreationResp)
{
g_currentRun();
}
}
void onRemoteSceneExecuted(const std::string &sceneName, int eCode)
{
std::cout << __func__ << " - scene name : " << sceneName
<< ", error code : " << eCode << std::endl;
if (eCode != SCENE_RESULT_OK)
{
std::cout << "Execute scene failed." << std::endl;
}
g_currentRun();
}
// --- Scene Manager Remote API sample
void createRemoteSceneList()
{
if (g_foundListResource)
{
RemoteSceneList::createInstance(g_foundListResource, onRemoteSceneListCreated);
}
else
{
std::cout << "Scene List Resource is not discovered." << std::endl;
g_currentRun();
}
}
void createRemoteSceneCollection()
{
if (!g_sceneList)
{
return;
}
g_sceneList->addNewSceneCollection(onRemoteSceneCollectionCreated);
}
void showRemoteSceneCollection()
{
if (!g_sceneList)
{
return;
}
if (g_sceneList->getRemoteSceneCollections().size() == 0)
{
return;
}
g_sceneCollection = g_sceneList->getRemoteSceneCollections().at(0);
if( g_sceneCollection->getRemoteScenes().size() == 0)
{
return;
}
g_scene = g_sceneCollection->getRemoteScenes().begin()->second;
}
void createRemoteScene()
{
if (!g_sceneCollection)
{
return;
}
g_sceneCollection->addNewScene(scene_name, onRemoteSceneCreated);
}
void createRemoteSceneAction(
RemoteScene::Ptr scene, RCSRemoteResourceObject::Ptr member,
const std::string &key, const std::string &value)
{
if (scene && member)
{
g_scene->addNewSceneAction(member, key, RCSResourceAttributes::Value(value),
onRemoteSceneActionCreated);
}
}
void createRemoteSceneActions()
{
createRemoteSceneAction(g_scene, g_foundLightResource, "power", "on");
createRemoteSceneAction(g_scene, g_foundFanResource, "speed", "50");
}
void executeScene()
{
displaySceneList();
if (g_scene)
{
g_scene->execute(onRemoteSceneExecuted);
std::cout << "\n\t'" << g_scene->getName() << "' is executed!\n" << std::endl;
}
}
// --- Scene Manager Remote API sample
void configurePlatform()
{
PlatformConfig config
{
OC::ServiceType::InProc, ModeType::Both, OC_DEFAULT_ADAPTER, OC::QualityOfService::LowQos
};
OCPlatform::Configure(config);
}
int processUserInput(int min, int max)
{
assert(min <= max);
int input = 0;
std::cin >> input;
if (!std::cin.fail())
{
if (input == max + 1)
{
exit(0);
}
if (min <= input && input <= max)
{
return input;
}
}
std::cin.clear();
std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
throw std::runtime_error("Invalid Input, please try again");
}
void displaySceneList()
{
if (!g_sceneList)
{
return;
}
std::cout << "\t" << g_sceneList->getName() << "(SceneList)" << std::endl;
if (!g_sceneCollection)
{
return;
}
std::cout << "\t\t |_ _ _ " << g_sceneCollection->getId() << " (SceneCollection)" << std::endl;
for( const auto &it_scene : g_sceneCollection->getRemoteScenes() )
{
std::cout << "\t\t\t |_ _ _ " << it_scene.first << " (Scene)" << std::endl;
auto sceneActionList = it_scene.second->getRemoteSceneActions();
for (const auto &it : sceneActionList)
{
auto attr = it->getExecutionParameter();
for (const auto &att : attr)
{
std::cout << "\t\t\t \t\t|_ _ _ ";
std::cout << it->getRemoteResourceObject()->getUri() << " : ";
std::cout << att.key() << " - " << att.value().toString() << std::endl;
}
}
}
}
void displayClear(Run runFunc)
{
auto ret = std::system("/usr/bin/clear");
if(ret == -1)
{
std::cout << "clear error!" << std::endl;
}
g_currentRun = runFunc;
}
void displayCreateRemoteSceneListMenu()
{
std::cout << "========================================================\n";
std::cout << CREATE_REMOTE_SCENE_LIST << ". Create a RemoteSceneList \n";
std::cout << CREATE_REMOTE_SCENE_LIST + 1 << ". Quit \n";
std::cout << "========================================================\n";
}
void displayRemoteSceneCollectionMenu()
{
std::cout << "======================================================== \n";
std::cout << CREATE_REMOTE_SCENE_COLLECTION << ". Create a RemoteSceneCollection \n";
std::cout << SHOW_REMOTE_SCENE_COLLECTION << ". Show existing RemoteSceneCollection \n";
std::cout << SHOW_REMOTE_SCENE_COLLECTION + 1 << ". Quit \n";
std::cout << "======================================================== \n";
}
void displayRemoteSceneCreationMenu()
{
std::cout << "========================================================\n";
std::cout << CREATE_REMOTE_SCENE << ". Create a RemoteScene \n";
std::cout << CREATE_REMOTE_SCENE + 1 << ". Quit \n";
std::cout << "========================================================\n";
}
void displayRemoteSceneActionCreationMenu()
{
std::cout << "======================================================== \n";
std::cout << CREATE_REMOTE_SCENE_ACTION << ". Create RemoteSceneActions \n";
std::cout << CREATE_REMOTE_SCENE_ACTION + 1 << ". Quit \n";
std::cout << "======================================================== \n";
}
void displayExecuteCreatedRemoteSceneCreationMenu()
{
std::cout << "========================================================\n";
std::cout << EXECUTE_REMOTE_SCENE << ". Execute RemoteScene \n";
std::cout << EXECUTE_REMOTE_SCENE + 1 << ". Quit \n";
std::cout << "========================================================\n";
}
void displayExecuteExistingRemoteSceneCreationMenu()
{
std::cout << "========================================================\n";
std::cout << EXECUTE_REMOTE_SCENE << ". Execute a first RemoteScene \n";
std::cout << EXECUTE_REMOTE_SCENE + 1 << ". Quit \n";
std::cout << "========================================================\n";
}
void runExecuteExistingRemoteScene()
{
displaySceneList();
displayExecuteExistingRemoteSceneCreationMenu();
try
{
int command = processUserInput(EXECUTE_REMOTE_SCENE, EXECUTE_REMOTE_SCENE);
switch(command)
{
case EXECUTE_REMOTE_SCENE:
executeScene();
displayClear(runExecuteExistingRemoteScene);
break;
}
} catch (std::exception &e)
{
std::cout << e.what() << std::endl;
g_currentRun();
}
}
void runExecuteCreatedRemoteScene()
{
displaySceneList();
displayExecuteCreatedRemoteSceneCreationMenu();
try
{
int command = processUserInput(EXECUTE_REMOTE_SCENE, EXECUTE_REMOTE_SCENE);
switch(command)
{
case EXECUTE_REMOTE_SCENE:
executeScene();
displayClear(runExecuteCreatedRemoteScene);
break;
}
} catch (std::exception &e)
{
std::cout << e.what() << std::endl;
g_currentRun();
}
}
void runCreateRemoteSceneAction()
{
displaySceneList();
displayRemoteSceneActionCreationMenu();
try
{
int command = processUserInput(CREATE_REMOTE_SCENE_ACTION, CREATE_REMOTE_SCENE_ACTION);
switch(command)
{
case CREATE_REMOTE_SCENE_ACTION:
createRemoteSceneActions();
displayClear(runExecuteCreatedRemoteScene);
break;
}
} catch (std::exception &e)
{
std::cout << e.what() << std::endl;
g_currentRun();
}
}
void runCreateRemoteScene()
{
displaySceneList();
displayRemoteSceneCreationMenu();
try
{
int command = processUserInput(CREATE_REMOTE_SCENE, CREATE_REMOTE_SCENE);
switch(command)
{
case CREATE_REMOTE_SCENE:
createRemoteScene();
displayClear(runCreateRemoteSceneAction);
break;
}
} catch (std::exception &e)
{
std::cout << e.what() << std::endl;
g_currentRun();
}
}
void runRemoteSceneCollection()
{
displaySceneList();
displayRemoteSceneCollectionMenu();
try
{
int command = processUserInput(CREATE_REMOTE_SCENE_COLLECTION, SHOW_REMOTE_SCENE_COLLECTION);
switch(command)
{
case CREATE_REMOTE_SCENE_COLLECTION:
createRemoteSceneCollection();
displayClear(runCreateRemoteScene);
break;
case SHOW_REMOTE_SCENE_COLLECTION:
showRemoteSceneCollection();
displayClear(runExecuteExistingRemoteScene);
g_currentRun();
break;
}
} catch (std::exception &e)
{
std::cout << e.what() << std::endl;
g_currentRun();
}
}
void runCreateRemoteSceneList()
{
displayCreateRemoteSceneListMenu();
try
{
int command = processUserInput(CREATE_REMOTE_SCENE_LIST, CREATE_REMOTE_SCENE_LIST);
switch(command)
{
case CREATE_REMOTE_SCENE_LIST:
createRemoteSceneList();
displayClear(runRemoteSceneCollection);
break;
}
}
catch (std::exception &e)
{
std::cout << e.what() << std::endl;
g_currentRun();
}
}
void onResourceDiscovered(std::shared_ptr<RCSRemoteResourceObject> foundResource)
{
std::lock_guard< std::mutex > lock(g_discoverymtx);
std::cout << "onResourceDiscovered callback" << std::endl;
std::string resourceURI = foundResource->getUri();
std::string hostAddress = foundResource->getAddress();
std::vector< std::string > vecRTs = foundResource->getTypes();
std::cout << "\t\tResource URI : " << resourceURI << std::endl;
std::cout << "\t\tResource Host : " << hostAddress << std::endl;
// if the found resource is a scene list resource
if (std::find(vecRTs.begin(), vecRTs.end(), "oic.wk.sceneList") != vecRTs.end())
{
g_foundListResource = foundResource;
}
// if the found resource is a light resource
else if (std::find(vecRTs.begin(), vecRTs.end(), "core.light") != vecRTs.end())
{
g_foundLightResource = foundResource;
}
// if the found resource is a fan resource
else if (std::find(vecRTs.begin(), vecRTs.end(), "core.fan") != vecRTs.end())
{
g_foundFanResource = foundResource;
}
if (g_foundListResource && g_foundLightResource && g_foundFanResource)
{
g_discoveryTask->cancel();
return;
}
g_cond.notify_all();
}
void discoverResource()
{
std::cout << "Wait 4 seconds until discovered." << std::endl;
try
{
g_discoveryTask
= RCSDiscoveryManager::getInstance()->discoverResourceByTypes(RCSAddress::multicast(),
relativetUri, resourceTypes, &onResourceDiscovered);
}
catch (const RCSPlatformException &e)
{
std::cout << e.what() << std::endl;
}
std::unique_lock<std::mutex> lck(g_mtx);
g_cond.wait_for(lck, std::chrono::seconds(4));
return;
}
int main()
{
configurePlatform();
try
{
discoverResource();
g_currentRun = runCreateRemoteSceneList;
g_currentRun();
}
catch(std::exception &e)
{
std::cout << e.what() << std::endl;
return 0;
}
while (true)
{
}
std::cout << "Stopping the scene client" << std::endl;
return 0;
}
| 6,588 |
1,894 | # Copyright 2017 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.
"""The datastore model TableConfig, which specify which reports to generate.
Each /speed_releasing report will be generated via creating a corresponding
configuration which lists which bots and tests the user is interested in,
as well as a user friendly name and the actual table layout.
Example input for bots:
["ChromiumPerf/Nexus5", "ClankInternal/mako"]
Example input for tests:
["memory.top_10_mobile/memory:chrome:all_processes:reported_by_os:system_memory:
ashmem:proportional_resident_size_avg",
memory.top_10_mobile/memory:chrome:all_processes:reported_by_os:system_memory:
java_heap:proportional_resident_size_avg"]
Example input for test_layout:
{
"system_health.memory_mobile/foreground/ashmem": ["Foreground", "Ashmem"]
...
}
Here, we have the test_path: [Category, Name]. This is useful for formatting
the table. We can split each test into different categories and rename the tests
to something more useful for the user.
"""
from __future__ import print_function
from __future__ import division
from __future__ import absolute_import
import json
import six
from google.appengine.ext import ndb
from dashboard.common import utils
from dashboard.models import internal_only_model
class BadRequestError(Exception):
"""An error indicating that a 400 response status should be returned."""
class TableConfig(internal_only_model.InternalOnlyModel):
# A list of bots the speed releasing report will contain.
bots = ndb.KeyProperty(repeated=True)
# A list of testsuites/subtests that each speed releasing report will contain.
tests = ndb.StringProperty(repeated=True)
# Aids in displaying the table by showing groupings and giving pretty names.
table_layout = ndb.JsonProperty()
internal_only = ndb.BooleanProperty(default=False, indexed=True)
# The username of the creator
username = ndb.StringProperty()
def CreateTableConfig(name, bots, tests, layout, username, override):
"""Performs checks to verify bots and layout are valid, sets internal_only.
Args:
name: User friendly name for the report.
bots: List of master/bot pairs.
tests: List of test paths.
layout: JSON serializable layout for the table.
username: Email address of user creating the report.
Returns:
The created table_config and a success. If nothing is created (because
of bad inputs), returns None, error message.
"""
internal_only = False
valid_bots = []
try:
for bot in bots:
if '/' in bot:
bot_name = bot.split('/')[1]
master_name = bot.split('/')[0]
entity_key = ndb.Key('Master', master_name, 'Bot', bot_name)
entity = entity_key.get()
if entity:
valid_bots.append(entity_key)
if entity.internal_only:
internal_only = True
else:
raise BadRequestError('Invalid Master/Bot: %s' % bot)
else:
raise BadRequestError('Invalid Master/Bot: %s' % bot)
table_check = ndb.Key('TableConfig', name).get()
if table_check and not override:
raise BadRequestError('%s already exists.' % name)
for bot in bots:
for test in tests:
test_key = utils.TestMetadataKey(bot + '/' + test)
if not test_key.get():
raise BadRequestError('%s is not a valid test.' % test)
except BadRequestError as e:
six.raise_from(BadRequestError(str(e)), e)
try:
json.loads(layout)
# TODO(jessimb): Verify that the layout matches what is expected
except ValueError as e:
six.raise_from(BadRequestError('Invalid JSON for table layout'), e)
# Input validates, create table now.
table_config = TableConfig(
id=name,
bots=valid_bots,
tests=tests,
table_layout=layout,
internal_only=internal_only,
username=username)
table_config.put()
return table_config
| 1,297 |
348 | <reponame>chamberone/Leaflet.PixiOverlay
{"nom":"Hasnon","circ":"20ème circonscription","dpt":"Nord","inscrits":3045,"abs":1801,"votants":1244,"blancs":67,"nuls":36,"exp":1141,"res":[{"nuance":"COM","nom":"<NAME>","voix":815},{"nuance":"FN","nom":"<NAME>","voix":326}]} | 110 |
348 | <gh_stars>100-1000
{"nom":"Samoëns","circ":"6ème circonscription","dpt":"Haute-Savoie","inscrits":2120,"abs":1001,"votants":1119,"blancs":22,"nuls":8,"exp":1089,"res":[{"nuance":"REM","nom":"<NAME>","voix":403},{"nuance":"LR","nom":"Mme <NAME>","voix":371},{"nuance":"FI","nom":"Mme <NAME>","voix":74},{"nuance":"ECO","nom":"M. <NAME>","voix":59},{"nuance":"DIV","nom":"<NAME>","voix":56},{"nuance":"FN","nom":"<NAME>","voix":55},{"nuance":"REG","nom":"<NAME>","voix":24},{"nuance":"DVD","nom":"M. <NAME>","voix":20},{"nuance":"DLF","nom":"Mme <NAME>","voix":16},{"nuance":"DIV","nom":"M. <NAME>","voix":7},{"nuance":"EXG","nom":"Mme <NAME>","voix":4}]} | 266 |
372 | /* Clean */
#include <config.h>
#include <unistd.h>
#include "dcethread-private.h"
#include "dcethread-util.h"
#include "dcethread-debug.h"
#include "dcethread-exception.h"
#ifdef API
ssize_t
dcethread_write(int fd, void *buf, size_t count)
{
DCETHREAD_SYSCALL(ssize_t, write(fd, buf, count));
}
#endif /* API */
| 141 |
1,993 | /*
* Copyright 2013-2020 The OpenZipkin 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 brave;
import brave.test.TestSpanHandler;
import org.junit.After;
import org.junit.Test;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.entry;
public class RealSpanCustomizerTest {
TestSpanHandler spans = new TestSpanHandler();
Tracing tracing = Tracing.newBuilder().addSpanHandler(spans).build();
Span span = tracing.tracer().newTrace();
SpanCustomizer spanCustomizer = span.customizer();
@After public void close() {
tracing.close();
}
@Test public void name() {
spanCustomizer.name("foo");
span.flush();
assertThat(spans.get(0).name())
.isEqualTo("foo");
}
@Test public void annotate() {
spanCustomizer.annotate("foo");
span.flush();
assertThat(spans.get(0).containsAnnotation("foo"))
.isTrue();
}
@Test public void tag() {
spanCustomizer.tag("foo", "bar");
span.flush();
assertThat(spans).flatExtracting(s -> s.tags().entrySet())
.containsExactly(entry("foo", "bar"));
}
}
| 523 |
1,093 | <reponame>StandCN/spring-integration<gh_stars>1000+
/*
* Copyright 2016-2021 the original author or 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
*
* https://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.springframework.integration.dsl.context;
import java.beans.Introspector;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.RootBeanDefinition;
import org.springframework.integration.config.IntegrationConfigurationInitializer;
import org.springframework.integration.dsl.IntegrationFlowDefinition;
import org.springframework.util.Assert;
/**
* The Java DSL Integration infrastructure {@code beanFactory} initializer.
* Registers {@link IntegrationFlowBeanPostProcessor} and checks if all
* {@link org.springframework.integration.dsl.IntegrationComponentSpec} are extracted to
* the target object using
* {@link org.springframework.integration.dsl.IntegrationComponentSpec#get()}.
*
* @author <NAME>
* @author <NAME>
* @since 5.0
*
* @see org.springframework.integration.config.IntegrationConfigurationBeanFactoryPostProcessor
*/
public class DslIntegrationConfigurationInitializer implements IntegrationConfigurationInitializer {
private static final String INTEGRATION_FLOW_BPP_BEAN_NAME =
Introspector.decapitalize(IntegrationFlowBeanPostProcessor.class.getName());
private static final String INTEGRATION_FLOW_CONTEXT_BEAN_NAME =
Introspector.decapitalize(IntegrationFlowContext.class.getName());
private static final String INTEGRATION_FLOW_REPLY_PRODUCER_CLEANER_BEAN_NAME =
Introspector.decapitalize(IntegrationFlowDefinition.ReplyProducerCleaner.class.getName());
@Override
public void initialize(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
Assert.isInstanceOf(BeanDefinitionRegistry.class, configurableListableBeanFactory,
"To use Spring Integration Java DSL the 'beanFactory' has to be an instance of " +
"'BeanDefinitionRegistry'. Consider using 'GenericApplicationContext' implementation."
);
BeanDefinitionRegistry registry = (BeanDefinitionRegistry) configurableListableBeanFactory;
if (!registry.containsBeanDefinition(INTEGRATION_FLOW_BPP_BEAN_NAME)) {
registry.registerBeanDefinition(INTEGRATION_FLOW_BPP_BEAN_NAME,
new RootBeanDefinition(IntegrationFlowBeanPostProcessor.class,
IntegrationFlowBeanPostProcessor::new));
registry.registerBeanDefinition(INTEGRATION_FLOW_CONTEXT_BEAN_NAME,
new RootBeanDefinition(StandardIntegrationFlowContext.class, StandardIntegrationFlowContext::new));
registry.registerBeanDefinition(INTEGRATION_FLOW_REPLY_PRODUCER_CLEANER_BEAN_NAME,
new RootBeanDefinition(IntegrationFlowDefinition.ReplyProducerCleaner.class,
IntegrationFlowDefinition.ReplyProducerCleaner::new));
}
}
}
| 1,030 |
2,777 | <gh_stars>1000+
#pragma once
#include <QKeyEvent>
class KonamiCode : public QObject
{
Q_OBJECT
public:
KonamiCode(QObject *parent = 0);
void input(QEvent *event);
signals:
void triggered();
private:
int m_progress = 0;
};
| 100 |
1,687 | import java.util.HashMap;
import java.util.Map;
public class Solution2 {
// 方法二：哈希表
public int[] twoSum(int[] nums, int target) {
int len = nums.length;
Map<Integer, Integer> hashMap = new HashMap<>(len - 1);
hashMap.put(nums[0], 0);
for (int i = 1; i < len; i++) {
int another = target - nums[i];
if (hashMap.containsKey(another)) {
return new int[]{i, hashMap.get(another)};
}
hashMap.put(nums[i], i);
}
throw new IllegalArgumentException("No two sum solution");
}
} | 298 |
1,382 | <filename>examples/flexframesync_reconfig_example.c
//
// flexframesync_reconfig_example.c
//
// Demonstrates the reconfigurability of the flexframegen and
// flexframesync objects.
//
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <time.h>
#include <getopt.h>
#include "liquid.h"
#define OUTPUT_FILENAME "flexframesync_reconfig_example.m"
void usage()
{
printf("flexframesync_example [options]\n");
printf(" u/h : print usage\n");
printf(" s : signal-to-noise ratio [dB], default: 30\n");
printf(" n : number of frames, default: 3\n");
}
int main(int argc, char *argv[]) {
srand( time(NULL) );
// define parameters
float SNRdB = 30.0f;
float noise_floor = -30.0f;
unsigned int num_frames = 3;
// get options
int dopt;
while((dopt = getopt(argc,argv,"uhvqs:f:m:p:n:")) != EOF){
switch (dopt) {
case 'u':
case 'h': usage(); return 0;
case 's': SNRdB = atof(optarg); break;
case 'n': num_frames = atoi(optarg); break;
default:
exit(1);
}
}
// create flexframegen object
flexframegenprops_s fgprops;
flexframegenprops_init_default(&fgprops);
flexframegen fg = flexframegen_create(NULL);
// frame data
unsigned char header[14];
unsigned char * payload = NULL;
// create flexframesync object with default properties
flexframesync fs = flexframesync_create(NULL,NULL);
// channel
float nstd = powf(10.0f, noise_floor/20.0f); // noise std. dev.
float gamma = powf(10.0f, (SNRdB+noise_floor)/20.0f); // channel gain
unsigned int i;
// initialize header, payload
for (i=0; i<14; i++)
header[i] = i;
// frame buffers, properties
unsigned int buf_len = 256;
float complex buf[buf_len];
unsigned int j;
for (j=0; j<num_frames; j++) {
// configure frame generator properties
unsigned int payload_len = (rand() % 256) + 1; // random payload length
fgprops.check = LIQUID_CRC_NONE; // data validity check
fgprops.fec0 = LIQUID_FEC_NONE; // inner FEC scheme
fgprops.fec1 = LIQUID_FEC_NONE; // outer FEC scheme
fgprops.mod_scheme = (rand() % 2) ? LIQUID_MODEM_QPSK : LIQUID_MODEM_QAM16;
// reallocate memory for payload
payload = realloc(payload, payload_len*sizeof(unsigned char));
// initialize payload
for (i=0; i<payload_len; i++)
payload[i] = rand() & 0xff;
// set properties and assemble the frame
flexframegen_setprops(fg, &fgprops);
flexframegen_assemble(fg, header, payload, payload_len);
printf("frame %u, ", j);
flexframegen_print(fg);
// write the frame in blocks
int frame_complete = 0;
while (!frame_complete) {
// write samples to buffer
frame_complete = flexframegen_write_samples(fg, buf, buf_len);
// add channel impairments (gain and noise)
for (i=0; i<buf_len; i++)
buf[i] = buf[i]*gamma + nstd * (randnf() + _Complex_I*randnf()) * M_SQRT1_2;
// push through sync
flexframesync_execute(fs, buf, buf_len);
}
} // num frames
// print frame data statistics
flexframesync_print(fs);
// clean up allocated memory
flexframegen_destroy(fg);
flexframesync_destroy(fs);
free(payload);
printf("done.\n");
return 0;
}
| 1,611 |
601 | <reponame>Harshagracy/sp-dev-fx-webparts
{
"$schema": "https://dev.office.com/json-schemas/spfx/client-side-web-part-manifest.schema.json",
"id": "be293fec-29f2-4db2-869a-604e560980fa",
"alias": "ReactAggregatedCalendarWebPart",
"componentType": "WebPart",
"version": "*",
"manifestVersion": 2,
"requiresCustomScript": false,
"preconfiguredEntries": [{
"groupId": "5c03119e-3074-46fd-976b-c60198311f70",
"group": {
"default": "Ayka"
},
"title": {
"default": "React Aggreagated Calendar App"
},
"description": {
"default": "React Aggreagated Calendar App developed by <NAME>"
},
"officeFabricIconFontName": "SearchCalendar",
"properties": {
"header": "My Calendar",
"showWeekends": "Off",
"showLegend": true,
"dateFormat": "MMMM Do YYYY, h:mm a",
"defaultView": "month",
"availableViews": [
"month",
"agendaWeek",
"agendaDay",
"listMonth"
]
}
}]
}
| 460 |
2,151 | /*
* Copyright (C) 2013 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 android.media.audiofx;
import android.media.AudioTrack;
import android.media.MediaPlayer;
import android.media.audiofx.AudioEffect;
import android.util.Log;
import java.util.StringTokenizer;
/**
* LoudnessEnhancer is an audio effect for increasing audio loudness.
* The processing is parametrized by a target gain value, which determines the maximum amount
* by which an audio signal will be amplified; signals amplified outside of the sample
* range supported by the platform are compressed.
* An application creates a LoudnessEnhancer object to instantiate and control a
* this audio effect in the audio framework.
* To attach the LoudnessEnhancer to a particular AudioTrack or MediaPlayer,
* specify the audio session ID of this AudioTrack or MediaPlayer when constructing the effect
* (see {@link AudioTrack#getAudioSessionId()} and {@link MediaPlayer#getAudioSessionId()}).
*/
public class LoudnessEnhancer extends AudioEffect {
private final static String TAG = "LoudnessEnhancer";
// These parameter constants must be synchronized with those in
// /system/media/audio_effects/include/audio_effects/effect_loudnessenhancer.h
/**
* The maximum gain applied applied to the signal to process.
* It is expressed in millibels (100mB = 1dB) where 0mB corresponds to no amplification.
*/
public static final int PARAM_TARGET_GAIN_MB = 0;
/**
* Registered listener for parameter changes.
*/
private OnParameterChangeListener mParamListener = null;
/**
* Listener used internally to to receive raw parameter change events
* from AudioEffect super class
*/
private BaseParameterListener mBaseParamListener = null;
/**
* Lock for access to mParamListener
*/
private final Object mParamListenerLock = new Object();
/**
* Class constructor.
* @param audioSession system-wide unique audio session identifier. The LoudnessEnhancer
* will be attached to the MediaPlayer or AudioTrack in the same audio session.
*
* @throws java.lang.IllegalStateException
* @throws java.lang.IllegalArgumentException
* @throws java.lang.UnsupportedOperationException
* @throws java.lang.RuntimeException
*/
public LoudnessEnhancer(int audioSession)
throws IllegalStateException, IllegalArgumentException,
UnsupportedOperationException, RuntimeException {
super(EFFECT_TYPE_LOUDNESS_ENHANCER, EFFECT_TYPE_NULL, 0, audioSession);
if (audioSession == 0) {
Log.w(TAG, "WARNING: attaching a LoudnessEnhancer to global output mix is deprecated!");
}
}
/**
* @hide
* Class constructor for the LoudnessEnhancer audio effect.
* @param priority the priority level requested by the application for controlling the
* LoudnessEnhancer engine. As the same engine can be shared by several applications,
* this parameter indicates how much the requesting application needs control of effect
* parameters. The normal priority is 0, above normal is a positive number, below normal a
* negative number.
* @param audioSession system-wide unique audio session identifier. The LoudnessEnhancer
* will be attached to the MediaPlayer or AudioTrack in the same audio session.
*
* @throws java.lang.IllegalStateException
* @throws java.lang.IllegalArgumentException
* @throws java.lang.UnsupportedOperationException
* @throws java.lang.RuntimeException
*/
public LoudnessEnhancer(int priority, int audioSession)
throws IllegalStateException, IllegalArgumentException,
UnsupportedOperationException, RuntimeException {
super(EFFECT_TYPE_LOUDNESS_ENHANCER, EFFECT_TYPE_NULL, priority, audioSession);
if (audioSession == 0) {
Log.w(TAG, "WARNING: attaching a LoudnessEnhancer to global output mix is deprecated!");
}
}
/**
* Set the target gain for the audio effect.
* The target gain is the maximum value by which a sample value will be amplified when the
* effect is enabled.
* @param gainmB the effect target gain expressed in mB. 0mB corresponds to no amplification.
* @throws IllegalStateException
* @throws IllegalArgumentException
* @throws UnsupportedOperationException
*/
public void setTargetGain(int gainmB)
throws IllegalStateException, IllegalArgumentException, UnsupportedOperationException {
checkStatus(setParameter(PARAM_TARGET_GAIN_MB, gainmB));
}
/**
* Return the target gain.
* @return the effect target gain expressed in mB.
* @throws IllegalStateException
* @throws IllegalArgumentException
* @throws UnsupportedOperationException
*/
public float getTargetGain()
throws IllegalStateException, IllegalArgumentException, UnsupportedOperationException {
int[] value = new int[1];
checkStatus(getParameter(PARAM_TARGET_GAIN_MB, value));
return value[0];
}
/**
* @hide
* The OnParameterChangeListener interface defines a method called by the LoudnessEnhancer
* when a parameter value has changed.
*/
public interface OnParameterChangeListener {
/**
* Method called when a parameter value has changed. The method is called only if the
* parameter was changed by another application having the control of the same
* LoudnessEnhancer engine.
* @param effect the LoudnessEnhancer on which the interface is registered.
* @param param ID of the modified parameter. See {@link #PARAM_GENERIC_PARAM1} ...
* @param value the new parameter value.
*/
void onParameterChange(LoudnessEnhancer effect, int param, int value);
}
/**
* Listener used internally to receive unformatted parameter change events from AudioEffect
* super class.
*/
private class BaseParameterListener implements AudioEffect.OnParameterChangeListener {
private BaseParameterListener() {
}
public void onParameterChange(AudioEffect effect, int status, byte[] param, byte[] value) {
// only notify when the parameter was successfully change
if (status != AudioEffect.SUCCESS) {
return;
}
OnParameterChangeListener l = null;
synchronized (mParamListenerLock) {
if (mParamListener != null) {
l = mParamListener;
}
}
if (l != null) {
int p = -1;
int v = Integer.MIN_VALUE;
if (param.length == 4) {
p = byteArrayToInt(param, 0);
}
if (value.length == 4) {
v = byteArrayToInt(value, 0);
}
if (p != -1 && v != Integer.MIN_VALUE) {
l.onParameterChange(LoudnessEnhancer.this, p, v);
}
}
}
}
/**
* @hide
* Registers an OnParameterChangeListener interface.
* @param listener OnParameterChangeListener interface registered
*/
public void setParameterListener(OnParameterChangeListener listener) {
synchronized (mParamListenerLock) {
if (mParamListener == null) {
mBaseParamListener = new BaseParameterListener();
super.setParameterListener(mBaseParamListener);
}
mParamListener = listener;
}
}
/**
* @hide
* The Settings class regroups the LoudnessEnhancer parameters. It is used in
* conjunction with the getProperties() and setProperties() methods to backup and restore
* all parameters in a single call.
*/
public static class Settings {
public int targetGainmB;
public Settings() {
}
/**
* Settings class constructor from a key=value; pairs formatted string. The string is
* typically returned by Settings.toString() method.
* @throws IllegalArgumentException if the string is not correctly formatted.
*/
public Settings(String settings) {
StringTokenizer st = new StringTokenizer(settings, "=;");
//int tokens = st.countTokens();
if (st.countTokens() != 3) {
throw new IllegalArgumentException("settings: " + settings);
}
String key = st.nextToken();
if (!key.equals("LoudnessEnhancer")) {
throw new IllegalArgumentException(
"invalid settings for LoudnessEnhancer: " + key);
}
try {
key = st.nextToken();
if (!key.equals("targetGainmB")) {
throw new IllegalArgumentException("invalid key name: " + key);
}
targetGainmB = Integer.parseInt(st.nextToken());
} catch (NumberFormatException nfe) {
throw new IllegalArgumentException("invalid value for key: " + key);
}
}
@Override
public String toString() {
String str = new String (
"LoudnessEnhancer"+
";targetGainmB="+Integer.toString(targetGainmB)
);
return str;
}
};
/**
* @hide
* Gets the LoudnessEnhancer properties. This method is useful when a snapshot of current
* effect settings must be saved by the application.
* @return a LoudnessEnhancer.Settings object containing all current parameters values
* @throws IllegalStateException
* @throws IllegalArgumentException
* @throws UnsupportedOperationException
*/
public LoudnessEnhancer.Settings getProperties()
throws IllegalStateException, IllegalArgumentException, UnsupportedOperationException {
Settings settings = new Settings();
int[] value = new int[1];
checkStatus(getParameter(PARAM_TARGET_GAIN_MB, value));
settings.targetGainmB = value[0];
return settings;
}
/**
* @hide
* Sets the LoudnessEnhancer properties. This method is useful when bass boost settings
* have to be applied from a previous backup.
* @param settings a LoudnessEnhancer.Settings object containing the properties to apply
* @throws IllegalStateException
* @throws IllegalArgumentException
* @throws UnsupportedOperationException
*/
public void setProperties(LoudnessEnhancer.Settings settings)
throws IllegalStateException, IllegalArgumentException, UnsupportedOperationException {
checkStatus(setParameter(PARAM_TARGET_GAIN_MB, settings.targetGainmB));
}
}
| 4,131 |
5,169 | {
"name": "spSDK",
"version": "0.1.0",
"summary": "spSDK gives you End to End encrpytion capability with almost zero code .",
"description": "Provide security & safety to your users with no hassle.\nBy integrating End to End Encryption in your app.\nhttps://sdk.safepixel.app",
"homepage": "https://sdk.safepixel.app",
"license": {
"type": "Proprietary",
"file": "LICENSE"
},
"authors": {
"Safe Pixel": "<EMAIL>"
},
"source": {
"git": "https://github.com/safepixel/spSDK-iOS.git",
"tag": "0.1.0"
},
"social_media_url": "https://facebook.com/safepixel",
"platforms": {
"ios": "10.0"
},
"public_header_files": "spSDK.framework/Headers/*.h",
"source_files": "spSDK.framework/Headers/*.h",
"vendored_frameworks": "spSDK.framework",
"swift_versions": "4.2",
"swift_version": "4.2"
}
| 343 |
315 | <filename>helper/delf_helper.py
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
delf_helper.py
helper functions to extract DeLF functions.
"""
import os, sys, time
import numpy as np
import h5py
import torch
import torch.nn.functional as F
import torchvision.transforms as transforms
from torch.autograd import Variable
from concurrent.futures import ThreadPoolExecutor, as_completed # for use of multi-threads
__DEBUG__ = False
def GenerateCoordinates(h,w):
'''generate coorinates
Returns: [h*w, 2] FloatTensor
'''
x = torch.floor(torch.arange(0, w*h) / w)
y = torch.arange(0, w).repeat(h)
coord = torch.stack([x,y], dim=1)
return coord
def CalculateReceptiveBoxes(height,
width,
rf,
stride,
padding):
'''
caculate receptive boxes from original image for each feature point.
Args:
height: The height of feature map.
width: The width of feature map.
rf: The receptive field size.
stride: The effective stride between two adjacent feature points.
padding: The effective padding size.
Returns:
rf_boxes: [N, 4] recpetive boxes tensor. (N = height x weight).
each box is represented by [ymin, xmin, ymax, xmax].
'''
coordinates = GenerateCoordinates(h=height,
w=width)
# create [ymin, xmin, ymax, xmax]
point_boxes = torch.cat([coordinates, coordinates], dim=1)
bias = torch.FloatTensor([-padding, -padding, -padding + rf - 1, -padding + rf - 1])
rf_boxes = stride * point_boxes + bias
return rf_boxes
def CalculateKeypointCenters(rf_boxes):
'''compute feature centers, from receptive field boxes (rf_boxes).
Args:
rf_boxes: [N, 4] FloatTensor.
Returns:
centers: [N, 2] FloatTensor.
'''
xymin = torch.index_select(rf_boxes, dim=1, index=torch.LongTensor([0,1]))
xymax = torch.index_select(rf_boxes, dim=1, index=torch.LongTensor([2,3]))
return (xymax + xymin) / 2.0
def ApplyPcaAndWhitening(data,
pca_matrix,
pca_mean,
pca_vars,
pca_dims,
use_whitening=False):
'''apply PCA/Whitening to data.
Args:
data: [N, dim] FloatTensor containing data which undergoes PCA/Whitening.
pca_matrix: [dim, dim] numpy array PCA matrix, row-major.
pca_mean: [dim] numpy array mean to subtract before projection.
pca_dims: # of dimenstions to use in output data, of type int.
pca_vars: [dim] numpy array containing PCA variances.
Only used if use_whitening is True.
use_whitening: Whether whitening is to be used. usually recommended.
Returns:
output: [N, output_dim] FloatTensor with output of PCA/Whitening operation.
(Warning: element 0 in pca_variances might produce nan/inf value.)
'''
pca_mean = torch.from_numpy(pca_mean).float()
pca_vars = torch.from_numpy(pca_vars).float()
pca_matrix = torch.from_numpy(pca_matrix).float()
data = data - pca_mean
output = data.matmul(pca_matrix.narrow(0, 0, pca_dims).transpose(0,1))
if use_whitening:
output = output.div((pca_vars.narrow(0, 0, pca_dims) ** 0.5))
return output
def GetDelfFeatureFromMultiScale(
x,
model,
filename,
pca_mean,
pca_vars,
pca_matrix,
pca_dims,
rf,
stride,
padding,
top_k,
scale_list,
iou_thres,
attn_thres,
use_pca=False,
workers=8):
'''GetDelfFeatureFromMultiScale
warning: use workers = 1 for serving otherwise out of memory error could occurs.
(because uwsgi uses multi-threads by itself.)
'''
# helper func.
def __concat_tensors_in_list__(tensor_list, dim):
res = None
tensor_list = [x for x in tensor_list if x is not None]
for tensor in tensor_list:
if res is None:
res = tensor
else:
res = torch.cat((res, tensor), dim=dim)
return res
# extract features for each scale, and concat.
output_boxes = []
output_features = []
output_scores = []
output_scales = []
output_original_scale_attn = None
# multi-threaded feature extraction from different scales.
with ThreadPoolExecutor(max_workers=workers) as pool:
# assign jobs.
futures = {
pool.submit(
GetDelfFeatureFromSingleScale,
x,
model,
scale,
pca_mean,
pca_vars,
pca_matrix,
pca_dims,
rf,
stride,
padding,
attn_thres,
use_pca):
scale for scale in scale_list
}
for future in as_completed(futures):
(selected_boxes, selected_features,
selected_scales, selected_scores,
selected_original_scale_attn) = future.result()
# append to list.
output_boxes.append(selected_boxes) if selected_boxes is not None else output_boxes
output_features.append(selected_features) if selected_features is not None else output_features
output_scales.append(selected_scales) if selected_scales is not None else output_scales
output_scores.append(selected_scores) if selected_scores is not None else output_scores
if selected_original_scale_attn is not None:
output_original_scale_attn = selected_original_scale_attn
# if scale == 1.0 is not included in scale list, just show noisy attention image.
if output_original_scale_attn is None:
output_original_scale_attn = x.clone().uniform()
# concat tensors precessed from different scales.
output_boxes = __concat_tensors_in_list__(output_boxes, dim=0)
output_features = __concat_tensors_in_list__(output_features, dim=0)
output_scales = __concat_tensors_in_list__(output_scales, dim=0)
output_scores = __concat_tensors_in_list__(output_scores, dim=0)
# perform Non Max Suppression(NMS) to select top-k bboxes arrcoding to the attn_score.
keep_indices, count = nms(boxes = output_boxes,
scores = output_scores,
overlap = iou_thres,
top_k = top_k)
keep_indices = keep_indices[:top_k]
output_boxes = torch.index_select(output_boxes, dim=0, index=keep_indices)
output_features = torch.index_select(output_features, dim=0, index=keep_indices)
output_scales = torch.index_select(output_scales, dim=0, index=keep_indices)
output_scores = torch.index_select(output_scores, dim=0, index=keep_indices)
output_locations = CalculateKeypointCenters(output_boxes)
data = {
'filename':filename,
'location_np_list':output_locations.cpu().numpy(),
'descriptor_np_list':output_features.cpu().numpy(),
'feature_scale_np_list':output_scales.cpu().numpy(),
'attention_score_np_list':output_scores.cpu().numpy(),
'attention_np_list':output_original_scale_attn.cpu().numpy()
}
# free GPU memory.
del output_locations
del output_boxes, selected_boxes
del output_features, selected_features
del output_scales, selected_scales
del output_scores, selected_scores
del output_original_scale_attn, selected_original_scale_attn
#torch.cuda.empty_cache() # it releases all unoccupied cached memory!! (but it makes process slow)
if __DEBUG__:
#PrintGpuMemoryStats()
PrintResult(data)
return data
def PrintGpuMemoryStats():
'''PyTorch >= 0.5.0
'''
print
print('\n----------------------------------------------------------')
print('[Monitor] max GPU Memory Used by Tensor: {}'.format(torch.cuda.max_memory_allocated()))
print('[Monitor] max GPU Memory Used by Cache: {}'.format(torch.cuda.max_memory_cached()))
print('----------------------------------------------------------')
def PrintResult(data):
print('\n----------------------------------------------------------')
print('filename: ', data['filename'])
print("location_np_list shape: ", data['location_np_list'].shape)
print("descriptor_np_list shape: ", data['descriptor_np_list'].shape)
print("feature_scale_np_list shape: ", data['feature_scale_np_list'].shape)
print("attention_score_np_list shape: ", data['attention_score_np_list'].shape)
print("attention_np_list shape: ", data['attention_np_list'].shape)
print('----------------------------------------------------------\n')
def GetDelfFeatureFromSingleScale(
x,
model,
scale,
pca_mean,
pca_vars,
pca_matrix,
pca_dims,
rf,
stride,
padding,
attn_thres,
use_pca):
# scale image then get features and attention.
new_h = int(round(x.size(2)*scale))
new_w = int(round(x.size(3)*scale))
scaled_x = F.upsample(x, size=(new_h, new_w), mode='bilinear')
scaled_features, scaled_scores = model.forward_for_serving(scaled_x)
# save original size attention (used for attention visualization.)
selected_original_scale_attn = None
if scale == 1.0:
selected_original_scale_attn = torch.clamp(scaled_scores*255, 0, 255) # 1 1 h w
# calculate receptive field boxes.
rf_boxes = CalculateReceptiveBoxes(
height=scaled_features.size(2),
width=scaled_features.size(3),
rf=rf,
stride=stride,
padding=padding)
# re-projection back to original image space.
rf_boxes = rf_boxes / scale
scaled_scores = scaled_scores.view(-1)
scaled_features = scaled_features.view(scaled_features.size(1), -1).t()
# do post-processing for dimension reduction by PCA.
scaled_features = DelfFeaturePostProcessing(
rf_boxes,
scaled_features,
pca_mean,
pca_vars,
pca_matrix,
pca_dims,
use_pca)
# use attention score to select feature.
indices = None
while(indices is None or len(indices) == 0):
indices = torch.gt(scaled_scores, attn_thres).nonzero().squeeze()
attn_thres = attn_thres * 0.5 # use lower threshold if no indexes are found.
if attn_thres < 0.001:
break;
try:
selected_boxes = torch.index_select(rf_boxes, dim=0, index=indices)
selected_features = torch.index_select(scaled_features, dim=0, index=indices)
selected_scores = torch.index_select(scaled_scores, dim=0, index=indices)
selected_scales = torch.ones_like(selected_scores) * scale
except Exception as e:
selected_boxes = None
selected_features = None
selected_scores = None
selected_scales = None
print(e)
pass;
return selected_boxes, selected_features, selected_scales, selected_scores, selected_original_scale_attn
def DelfFeaturePostProcessing(
boxes,
descriptors,
pca_mean,
pca_vars,
pca_matrix,
pca_dims,
use_pca):
''' Delf feature post-processing.
(1) apply L2 Normalization.
(2) apply PCA and Whitening.
(3) apply L2 Normalization once again.
Args:
descriptors: (w x h, fmap_depth) descriptor Tensor.
Retturn:
descriptors: (w x h, pca_dims) desciptor Tensor.
'''
locations = CalculateKeypointCenters(boxes)
# L2 Normalization.
descriptors = descriptors.squeeze()
l2_norm = descriptors.norm(p=2, dim=1, keepdim=True) # (1, w x h)
descriptors = descriptors.div(l2_norm.expand_as(descriptors)) # (N, w x h)
if use_pca:
# apply PCA and Whitening.
descriptors = ApplyPcaAndWhitening(
descriptors,
pca_matrix,
pca_mean,
pca_vars,
pca_dims,
True)
# L2 Normalization (we found L2 Norm is not helpful. DO NOT UNCOMMENT THIS.)
#descriptors = descriptors.view(descriptors.size(0), -1) # (N, w x h)
#l2_norm = descriptors.norm(p=2, dim=0, keepdim=True) # (1, w x h)
#descriptors = descriptors.div(l2_norm.expand_as(descriptors)) # (N, w x h)
return descriptors
# Original author: <NAME>:
# https://github.com/fmassa/object-detection.torch
# Ported to PyTorch by Max deGroot (02/01/2017)
def nms(boxes, scores, overlap=0.5, top_k=200):
"""Apply non-maximum suppression at test time to avoid detecting too many
overlapping bounding boxes for a given object.
Args:
boxes: (tensor) The location preds for the img, Shape: [num_priors,4].
scores: (tensor) The class predscores for the img, Shape:[num_priors].
overlap: (float) The overlap thresh for suppressing unnecessary boxes.
top_k: (int) The Maximum number of box preds to consider.
Returns:
The indices of the kept boxes with respect to num_priors.
"""
keep = scores.new(scores.size(0)).zero_().long()
if boxes.numel() == 0:
return keep
y1 = boxes[:, 0]
x1 = boxes[:, 1]
y2 = boxes[:, 2]
x2 = boxes[:, 3]
area = torch.mul(x2 - x1, y2 - y1)
v, idx = scores.sort(0) # sort in ascending order
# I = I[v >= 0.01]
idx = idx[-top_k:] # indices of the top-k largest vals
xx1 = boxes.new()
yy1 = boxes.new()
xx2 = boxes.new()
yy2 = boxes.new()
w = boxes.new()
h = boxes.new()
# keep = torch.Tensor()
count = 0
while idx.numel() > 0:
i = idx[-1] # index of current largest val
# keep.append(i)
keep[count] = i
count += 1
if idx.size(0) == 1:
break
idx = idx[:-1] # remove kept element from view
# load bboxes of next highest vals
torch.index_select(x1, 0, idx, out=xx1)
torch.index_select(y1, 0, idx, out=yy1)
torch.index_select(x2, 0, idx, out=xx2)
torch.index_select(y2, 0, idx, out=yy2)
# store element-wise max with next highest score
xx1 = torch.clamp(xx1, min=x1[i])
yy1 = torch.clamp(yy1, min=y1[i])
xx2 = torch.clamp(xx2, max=x2[i])
yy2 = torch.clamp(yy2, max=y2[i])
w.resize_as_(xx2)
h.resize_as_(yy2)
w = xx2 - xx1
h = yy2 - yy1
# check sizes of xx1 and xx2.. after each iteration
w = torch.clamp(w, min=0.0)
h = torch.clamp(h, min=0.0)
inter = w*h
# IoU = i / (area(a) + area(b) - i)
rem_areas = torch.index_select(area, 0, idx) # load remaining areas)
union = (rem_areas - inter) + area[i]
IoU = inter/union # store result in iou
# keep only elements with an IoU <= overlap
idx = idx[IoU.le(overlap)]
return keep, count
| 6,737 |
3,459 | /* FCE Ultra - NES/Famicom Emulator
*
* Copyright notice for this file:
* Copyright (C) 2012 CaH4e3
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* 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 Street, Fifth Floor, Boston, MA 02110-1301 USA
*
* VRC-1
*
*/
#include "mapinc.h"
static uint8 preg[3], creg[2], mode;
static SFORMAT StateRegs[] =
{
{ &mode, 1, "MODE" },
{ creg, 2, "CREG" },
{ preg, 3, "PREG" },
{ 0 }
};
static void Sync(void) {
setprg8(0x8000, preg[0]);
setprg8(0xA000, preg[1]);
setprg8(0xC000, preg[2]);
setprg8(0xE000, ~0);
setchr4(0x0000, creg[0] | ((mode & 2) << 3));
setchr4(0x1000, creg[1] | ((mode & 4) << 2));
setmirror((mode & 1) ^ 1);
}
static DECLFW(M75Write) {
switch (A & 0xF000) {
case 0x8000: preg[0] = V; Sync(); break;
case 0x9000: mode = V; Sync(); break;
case 0xA000: preg[1] = V; Sync(); break;
case 0xC000: preg[2] = V; Sync(); break;
case 0xE000: creg[0] = V & 0xF; Sync(); break;
case 0xF000: creg[1] = V & 0xF; Sync(); break;
}
}
static void M75Power(void) {
Sync();
SetWriteHandler(0x8000, 0xFFFF, M75Write);
SetReadHandler(0x8000, 0xFFFF, CartBR);
}
static void StateRestore(int version) {
Sync();
}
void Mapper75_Init(CartInfo *info) {
info->Power = M75Power;
AddExState(&StateRegs, ~0, 0, 0);
GameStateRestore = StateRestore;
}
| 796 |
575 | <gh_stars>100-1000
// Copyright 2017 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 "device/udev_linux/udev_watcher.h"
#include <utility>
#include "base/bind.h"
#include "base/logging.h"
#include "base/memory/ptr_util.h"
#include "base/threading/scoped_blocking_call.h"
namespace device {
UdevWatcher::Filter::Filter(base::StringPiece subsystem_in,
base::StringPiece devtype_in) {
if (!subsystem_in.empty())
subsystem_ = subsystem_in.as_string();
if (!devtype_in.empty())
devtype_ = devtype_in.as_string();
}
UdevWatcher::Filter::Filter(const Filter&) = default;
UdevWatcher::Filter::~Filter() = default;
const char* UdevWatcher::Filter::devtype() const {
return devtype_ ? devtype_.value().c_str() : nullptr;
}
const char* UdevWatcher::Filter::subsystem() const {
return subsystem_ ? subsystem_.value().c_str() : nullptr;
}
UdevWatcher::Observer::~Observer() = default;
std::unique_ptr<UdevWatcher> UdevWatcher::StartWatching(
Observer* observer,
const std::vector<Filter>& filters) {
base::ScopedBlockingCall scoped_blocking_call(FROM_HERE,
base::BlockingType::MAY_BLOCK);
ScopedUdevPtr udev(udev_new());
if (!udev) {
LOG(ERROR) << "Failed to initialize udev.";
return nullptr;
}
ScopedUdevMonitorPtr udev_monitor(
udev_monitor_new_from_netlink(udev.get(), "udev"));
if (!udev_monitor) {
LOG(ERROR) << "Failed to initialize a udev monitor.";
return nullptr;
}
for (const Filter& filter : filters) {
const int ret = udev_monitor_filter_add_match_subsystem_devtype(
udev_monitor.get(), filter.subsystem(), filter.devtype());
CHECK_EQ(0, ret);
}
if (udev_monitor_enable_receiving(udev_monitor.get()) != 0) {
LOG(ERROR) << "Failed to enable receiving udev events.";
return nullptr;
}
int monitor_fd = udev_monitor_get_fd(udev_monitor.get());
if (monitor_fd < 0) {
LOG(ERROR) << "Udev monitor file descriptor unavailable.";
return nullptr;
}
return base::WrapUnique(new UdevWatcher(
std::move(udev), std::move(udev_monitor), monitor_fd, observer, filters));
}
UdevWatcher::~UdevWatcher() {
DCHECK(sequence_checker_.CalledOnValidSequence());
}
void UdevWatcher::EnumerateExistingDevices() {
DCHECK(sequence_checker_.CalledOnValidSequence());
base::ScopedBlockingCall scoped_blocking_call(FROM_HERE,
base::BlockingType::MAY_BLOCK);
ScopedUdevEnumeratePtr enumerate(udev_enumerate_new(udev_.get()));
if (!enumerate) {
LOG(ERROR) << "Failed to initialize a udev enumerator.";
return;
}
for (const Filter& filter : udev_filters_) {
const int ret =
udev_enumerate_add_match_subsystem(enumerate.get(), filter.subsystem());
CHECK_EQ(0, ret);
}
if (udev_enumerate_scan_devices(enumerate.get()) != 0) {
LOG(ERROR) << "Failed to begin udev enumeration.";
return;
}
udev_list_entry* devices = udev_enumerate_get_list_entry(enumerate.get());
for (udev_list_entry* i = devices; i != nullptr;
i = udev_list_entry_get_next(i)) {
ScopedUdevDevicePtr device(
udev_device_new_from_syspath(udev_.get(), udev_list_entry_get_name(i)));
if (device)
observer_->OnDeviceAdded(std::move(device));
}
}
UdevWatcher::UdevWatcher(ScopedUdevPtr udev,
ScopedUdevMonitorPtr udev_monitor,
int monitor_fd,
Observer* observer,
const std::vector<Filter>& filters)
: udev_(std::move(udev)),
udev_monitor_(std::move(udev_monitor)),
observer_(observer),
udev_filters_(filters) {
file_watcher_ = base::FileDescriptorWatcher::WatchReadable(
monitor_fd, base::BindRepeating(&UdevWatcher::OnMonitorReadable,
base::Unretained(this)));
}
void UdevWatcher::OnMonitorReadable() {
base::ScopedBlockingCall scoped_blocking_call(FROM_HERE,
base::BlockingType::MAY_BLOCK);
ScopedUdevDevicePtr device(udev_monitor_receive_device(udev_monitor_.get()));
if (!device)
return;
std::string action(udev_device_get_action(device.get()));
if (action == "add")
observer_->OnDeviceAdded(std::move(device));
else if (action == "remove")
observer_->OnDeviceRemoved(std::move(device));
else if (action == "change")
observer_->OnDeviceChanged(std::move(device));
else
DVLOG(1) << "Unknown udev action: " << action;
}
} // namespace device
| 1,963 |
2,333 | <reponame>ZhengShouDong/SDVoiceSdkDemo
//
// IFlySpeechEvent.h
// MSCDemo
//
// Created by admin on 14-8-12.
// Copyright (c) 2014年 iflytek. All rights reserved.
//
#import <Foundation/Foundation.h>
/*!
* 事件类型
*/
typedef NS_ENUM(NSUInteger,IFlySpeechEventType){
/*!
* 网络状态消息
* 在消息到达时,可通过onEvent的第2个参数arg1,获取当前网络连接状态值
*/
IFlySpeechEventTypeNetPref = 10001,
/**
* 转写音频文件消息
* 在录音模式下，成功创建音频文件时返回。可通过onEvent
* 第4个参数data 指定Key为[IFlySpeechConstant IST_AUDIO_PATH],获取音频文件绝对路径.
* 或通过[IFlySpeechTranscripter getParameter:[IFlySpeechConstant IST_AUDIO_PATH]],
* 获取音频文件绝对路径.
*/
IFlySpeechEventTypeISTAudioFile = 10004,
/**
* 转写已上传字节消息
* 在消息到达时,通过onEvent
* 的第二个参数arg1,获取已确认上传到服务器的字节数.
* 若当前音频源为非写音频模式,还可通过onEvent
* 的第三个参数arg2,获取当前所有音频的字节大小.录音模式时，由于所有音频字节大小会变。
* 当停止音频输入后（等待录音时间超时
* [IFlySpeechConstant SPEECH_TIMEOUT]
* ，或调用[IFlySpeechTranscripter stopTranscripting]），
* 且服务器收到所有音频时，第四个参数data，将包含完成标记的布尔值(true)，可通过data调用
* 指定KEY为KCIFlySpeechEventKeyISTUploadComplete获取。
* 此消息可能多次返回.
*/
IFlySpeechEventTypeISTUploadBytes = 10006,
/**
* 转写缓存剩余
* 此消息仅在音频源为-1时需要关注
* 在调用[IFlySpeechTranscripter writeAudio]写音频时，应该关注此事件。
* 此事件在调用写音频接口、及音频最后被写入底库库时分别回调一次。当事件回调时，通过onEvent
* 的第二个参数arg1,获取当前剩余的缓存大小，当缓存小于要写入的音频时，应该先暂停写音频数据，直到下次缓存大小大于要写入的音频时.
* 最大缓存为128KByte。
*/
IFlySpeechEventTypeISTCacheLeft = 10007,
/**
* 转写结果等待时间消息
* 在消息到达时,通过 onEvent
* 的第二个参数arg1,获取当前结果需要的时间.
* 此消息可能多次返回，返回时间不定，且不一定会返回.
*/
IFlySpeechEventTypeISTResultTime= 10008,
/**
* 转写转写音频同步ID消息
* 在消息到达时,通过 onEvent
* 的第二个参数arg1,获取当前写音频同步ID.
* 此消息可能多次返回.
*/
IFlySpeechEventTypeISTSyncID= 10009,
/**
* 会话开始消息
* 在会话开始成功后返回
*/
IFlySpeechEventTypeSessionBegin = 10010,
/**
* 会话结束消息
* 在会话结束前返回
*/
IFlySpeechEventTypeSessionEnd = 10011,
/**
* 音量消息，在得到音量时抛出，暂时只有身份验证的声纹业务用到
*/
IFlySpeechEventTypeVolume = 10012,
/**
* VAD后端点消息，在检测到VAD后端点时抛出，暂时只有身份验证的声纹业务用到
*/
IFlySpeechEventTypeVadEOS = 10013,
/*!
* 服务端会话id
* 在消息到达时,可通过onEvent的第4个参数data(字典类型)，
* 指定key KCIFlySpeechEventKeySessionID,获取服务端会话id.
*/
IFlySpeechEventTypeSessionID = 20001,
/*!
* TTS合成数据消息
* -(void)onEvent:(int)eventType arg0:(int)arg0 arg1:(int)arg1 data:(NSData *)eventData
* 其中eventData中包含数据
*
*/
IFlySpeechEventTypeTTSBuffer = 21001,
/*!
* 通知cancel方法被调用的回调
*
*/
IFlySpeechEventTypeTTSCancel = 21002,
/*!
* IVW onshot 听写 or 识别结果
* 在消息到达时,第2个参数arg1包含是否为最后一个结果:1为是,0为否;
* 第4个参数data中包含数据，通过指定KEY为KCIFlySpeechEventKeyIVWResult获取.
*/
IFlySpeechEventTypeIVWResult = 22001,
/*!
* 开始处理录音数据
*
*/
IFlySpeechEventTypeSpeechStart= 22002,
/*!
* 录音停止
*
*/
IFlySpeechEventTypeRecordStop= 22003,
/*!
* 服务端音频url
* 在消息到达时,
* 第4个参数data,包含数据,通过
* 指定KEY为KCIFlySpeechEventKeyAudioUrl获取.
*/
IFlySpeechEventTypeAudioUrl = 23001,
/*!
* 变声数据结果返回
*
* 设置voice_change参数获取结果.
*/
IFlySpeechEventTypeVoiceChangeResult = 24001
};
#pragma mark - keys for event data
/**
* 转写是否已上传完标记key
*/
extern NSString* const KCIFlySpeechEventKeyISTUploadComplete;
/**
* 服务端会话key
*/
extern NSString* const KCIFlySpeechEventKeySessionID;
/**
* TTS取音频数据key
*/
extern NSString* const KCIFlySpeechEventKeyTTSBuffer;
/**
* IVW oneshot 听写 or 识别结果 key
*/
extern NSString* const KCIFlySpeechEventKeyIVWResult;
/**
* 服务端音频url key
*/
extern NSString* const KCIFlySpeechEventKeyAudioUrl;
| 3,324 |
1,702 | package com.example.demo;
import org.springframework.boot.actuate.endpoint.annotation.Endpoint;
import org.springframework.boot.actuate.endpoint.annotation.ReadOperation;
@Endpoint(id="customnc")
public class CustomNoComponent {
@ReadOperation
public String health() {
return "OK";
}
}
| 120 |
445 | <gh_stars>100-1000
"""
Loads functions that are mixed in to the standard library. E.g. builtins are
written in C (binaries), but my autocompletion only understands Python code. By
mixing in Python code, the autocompletion should work much better for builtins.
"""
import os
from itertools import chain
from jedi._compatibility import unicode
fake_modules = {}
def _get_path_dict():
path = os.path.dirname(os.path.abspath(__file__))
base_path = os.path.join(path, 'fake')
dct = {}
for file_name in os.listdir(base_path):
if file_name.endswith('.pym'):
dct[file_name[:-4]] = os.path.join(base_path, file_name)
return dct
_path_dict = _get_path_dict()
class FakeDoesNotExist(Exception):
pass
def _load_faked_module(evaluator, module_name):
try:
return fake_modules[module_name]
except KeyError:
pass
check_module_name = module_name
if module_name == '__builtin__' and evaluator.environment.version_info.major == 2:
check_module_name = 'builtins'
try:
path = _path_dict[check_module_name]
except KeyError:
fake_modules[module_name] = None
return
with open(path) as f:
source = f.read()
fake_modules[module_name] = m = evaluator.latest_grammar.parse(unicode(source))
if check_module_name != module_name:
# There are two implementations of `open` for either python 2/3.
# -> Rename the python2 version (`look at fake/builtins.pym`).
open_func = _search_scope(m, 'open')
open_func.children[1].value = 'open_python3'
open_func = _search_scope(m, 'open_python2')
open_func.children[1].value = 'open'
return m
def _search_scope(scope, obj_name):
for s in chain(scope.iter_classdefs(), scope.iter_funcdefs()):
if s.name.value == obj_name:
return s
def get_faked_with_parent_context(parent_context, name):
if parent_context.tree_node is not None:
# Try to search in already clearly defined stuff.
found = _search_scope(parent_context.tree_node, name)
if found is not None:
return found
raise FakeDoesNotExist
def get_faked_module(evaluator, string_name):
module = _load_faked_module(evaluator, string_name)
if module is None:
raise FakeDoesNotExist
return module
| 940 |
453 | #include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <wchar.h>
#include <locale.h>
#include "mbctype.h"
#include "local.h"
int
_DEFUN (_wctomb_r, (r, s, wchar, state),
struct _reent *r _AND
char *s _AND
wchar_t _wchar _AND
mbstate_t *state)
{
return __WCTOMB (r, s, _wchar, state);
}
int
_DEFUN (__ascii_wctomb, (r, s, wchar, state),
struct _reent *r _AND
char *s _AND
wchar_t _wchar _AND
mbstate_t *state)
{
/* Avoids compiler warnings about comparisons that are always false
due to limited range when sizeof(wchar_t) is 2 but sizeof(wint_t)
is 4, as is the case on cygwin. */
wint_t wchar = _wchar;
if (s == NULL)
return 0;
#ifdef __CYGWIN__
if ((size_t)wchar >= 0x80)
#else
if ((size_t)wchar >= 0x100)
#endif
{
r->_errno = EILSEQ;
return -1;
}
*s = (char) wchar;
return 1;
}
#ifdef _MB_CAPABLE
/* for some conversions, we use the __count field as a place to store a state value */
#define __state __count
int
_DEFUN (__utf8_wctomb, (r, s, wchar, state),
struct _reent *r _AND
char *s _AND
wchar_t _wchar _AND
mbstate_t *state)
{
wint_t wchar = _wchar;
int ret = 0;
if (s == NULL)
return 0; /* UTF-8 encoding is not state-dependent */
if (sizeof (wchar_t) == 2 && state->__count == -4
&& (wchar < 0xdc00 || wchar > 0xdfff))
{
/* There's a leftover lone high surrogate. Write out the CESU-8 value
of the surrogate and proceed to convert the given character. Note
to return extra 3 bytes. */
wchar_t tmp;
tmp = (state->__value.__wchb[0] << 16 | state->__value.__wchb[1] << 8)
- (0x10000 >> 10 | 0xd80d);
*s++ = 0xe0 | ((tmp & 0xf000) >> 12);
*s++ = 0x80 | ((tmp & 0xfc0) >> 6);
*s++ = 0x80 | (tmp & 0x3f);
state->__count = 0;
ret = 3;
}
if (wchar <= 0x7f)
{
*s = wchar;
return ret + 1;
}
if (wchar >= 0x80 && wchar <= 0x7ff)
{
*s++ = 0xc0 | ((wchar & 0x7c0) >> 6);
*s = 0x80 | (wchar & 0x3f);
return ret + 2;
}
if (wchar >= 0x800 && wchar <= 0xffff)
{
/* No UTF-16 surrogate handling in UCS-4 */
if (sizeof (wchar_t) == 2 && wchar >= 0xd800 && wchar <= 0xdfff)
{
wint_t tmp;
if (wchar <= 0xdbff)
{
/* First half of a surrogate pair. Store the state and
return ret + 0. */
tmp = ((wchar & 0x3ff) << 10) + 0x10000;
state->__value.__wchb[0] = (tmp >> 16) & 0xff;
state->__value.__wchb[1] = (tmp >> 8) & 0xff;
state->__count = -4;
*s = (0xf0 | ((tmp & 0x1c0000) >> 18));
return ret;
}
if (state->__count == -4)
{
/* Second half of a surrogate pair. Reconstruct the full
Unicode value and return the trailing three bytes of the
UTF-8 character. */
tmp = (state->__value.__wchb[0] << 16)
| (state->__value.__wchb[1] << 8)
| (wchar & 0x3ff);
state->__count = 0;
*s++ = 0xf0 | ((tmp & 0x1c0000) >> 18);
*s++ = 0x80 | ((tmp & 0x3f000) >> 12);
*s++ = 0x80 | ((tmp & 0xfc0) >> 6);
*s = 0x80 | (tmp & 0x3f);
return 4;
}
/* Otherwise translate into CESU-8 value. */
}
*s++ = 0xe0 | ((wchar & 0xf000) >> 12);
*s++ = 0x80 | ((wchar & 0xfc0) >> 6);
*s = 0x80 | (wchar & 0x3f);
return ret + 3;
}
if (wchar >= 0x10000 && wchar <= 0x10ffff)
{
*s++ = 0xf0 | ((wchar & 0x1c0000) >> 18);
*s++ = 0x80 | ((wchar & 0x3f000) >> 12);
*s++ = 0x80 | ((wchar & 0xfc0) >> 6);
*s = 0x80 | (wchar & 0x3f);
return 4;
}
r->_errno = EILSEQ;
return -1;
}
/* Cygwin defines its own doublebyte charset conversion functions
because the underlying OS requires wchar_t == UTF-16. */
#ifndef __CYGWIN__
int
_DEFUN (__sjis_wctomb, (r, s, wchar, state),
struct _reent *r _AND
char *s _AND
wchar_t _wchar _AND
mbstate_t *state)
{
wint_t wchar = _wchar;
unsigned char char2 = (unsigned char)wchar;
unsigned char char1 = (unsigned char)(wchar >> 8);
if (s == NULL)
return 0; /* not state-dependent */
if (char1 != 0x00)
{
/* first byte is non-zero..validate multi-byte char */
if (_issjis1(char1) && _issjis2(char2))
{
*s++ = (char)char1;
*s = (char)char2;
return 2;
}
else
{
r->_errno = EILSEQ;
return -1;
}
}
*s = (char) wchar;
return 1;
}
int
_DEFUN (__eucjp_wctomb, (r, s, wchar, state),
struct _reent *r _AND
char *s _AND
wchar_t _wchar _AND
mbstate_t *state)
{
wint_t wchar = _wchar;
unsigned char char2 = (unsigned char)wchar;
unsigned char char1 = (unsigned char)(wchar >> 8);
if (s == NULL)
return 0; /* not state-dependent */
if (char1 != 0x00)
{
/* first byte is non-zero..validate multi-byte char */
if (_iseucjp1 (char1) && _iseucjp2 (char2))
{
*s++ = (char)char1;
*s = (char)char2;
return 2;
}
else if (_iseucjp2 (char1) && _iseucjp2 (char2 | 0x80))
{
*s++ = (char)0x8f;
*s++ = (char)char1;
*s = (char)(char2 | 0x80);
return 3;
}
else
{
r->_errno = EILSEQ;
return -1;
}
}
*s = (char) wchar;
return 1;
}
int
_DEFUN (__jis_wctomb, (r, s, wchar, state),
struct _reent *r _AND
char *s _AND
wchar_t _wchar _AND
mbstate_t *state)
{
wint_t wchar = _wchar;
int cnt = 0;
unsigned char char2 = (unsigned char)wchar;
unsigned char char1 = (unsigned char)(wchar >> 8);
if (s == NULL)
return 1; /* state-dependent */
if (char1 != 0x00)
{
/* first byte is non-zero..validate multi-byte char */
if (_isjis (char1) && _isjis (char2))
{
if (state->__state == 0)
{
/* must switch from ASCII to JIS state */
state->__state = 1;
*s++ = ESC_CHAR;
*s++ = '$';
*s++ = 'B';
cnt = 3;
}
*s++ = (char)char1;
*s = (char)char2;
return cnt + 2;
}
r->_errno = EILSEQ;
return -1;
}
if (state->__state != 0)
{
/* must switch from JIS to ASCII state */
state->__state = 0;
*s++ = ESC_CHAR;
*s++ = '(';
*s++ = 'B';
cnt = 3;
}
*s = (char)char2;
return cnt + 1;
}
#endif /* !__CYGWIN__ */
#ifdef _MB_EXTENDED_CHARSETS_ISO
static int
___iso_wctomb (struct _reent *r, char *s, wchar_t _wchar, int iso_idx,
mbstate_t *state)
{
wint_t wchar = _wchar;
if (s == NULL)
return 0;
/* wchars <= 0x9f translate to all ISO charsets directly. */
if (wchar >= 0xa0)
{
if (iso_idx >= 0)
{
unsigned char mb;
for (mb = 0; mb < 0x60; ++mb)
if (__iso_8859_conv[iso_idx][mb] == wchar)
{
*s = (char) (mb + 0xa0);
return 1;
}
r->_errno = EILSEQ;
return -1;
}
}
if ((size_t)wchar >= 0x100)
{
r->_errno = EILSEQ;
return -1;
}
*s = (char) wchar;
return 1;
}
int __iso_8859_1_wctomb (struct _reent *r, char *s, wchar_t _wchar,
mbstate_t *state)
{
return ___iso_wctomb (r, s, _wchar, -1, state);
}
int __iso_8859_2_wctomb (struct _reent *r, char *s, wchar_t _wchar,
mbstate_t *state)
{
return ___iso_wctomb (r, s, _wchar, 0, state);
}
int __iso_8859_3_wctomb (struct _reent *r, char *s, wchar_t _wchar,
mbstate_t *state)
{
return ___iso_wctomb (r, s, _wchar, 1, state);
}
int __iso_8859_4_wctomb (struct _reent *r, char *s, wchar_t _wchar,
mbstate_t *state)
{
return ___iso_wctomb (r, s, _wchar, 2, state);
}
int __iso_8859_5_wctomb (struct _reent *r, char *s, wchar_t _wchar,
mbstate_t *state)
{
return ___iso_wctomb (r, s, _wchar, 3, state);
}
int __iso_8859_6_wctomb (struct _reent *r, char *s, wchar_t _wchar,
mbstate_t *state)
{
return ___iso_wctomb (r, s, _wchar, 4, state);
}
int __iso_8859_7_wctomb (struct _reent *r, char *s, wchar_t _wchar,
mbstate_t *state)
{
return ___iso_wctomb (r, s, _wchar, 5, state);
}
int __iso_8859_8_wctomb (struct _reent *r, char *s, wchar_t _wchar,
mbstate_t *state)
{
return ___iso_wctomb (r, s, _wchar, 6, state);
}
int __iso_8859_9_wctomb (struct _reent *r, char *s, wchar_t _wchar,
mbstate_t *state)
{
return ___iso_wctomb (r, s, _wchar, 7, state);
}
int __iso_8859_10_wctomb (struct _reent *r, char *s, wchar_t _wchar,
mbstate_t *state)
{
return ___iso_wctomb (r, s, _wchar, 8, state);
}
int __iso_8859_11_wctomb (struct _reent *r, char *s, wchar_t _wchar,
mbstate_t *state)
{
return ___iso_wctomb (r, s, _wchar, 9, state);
}
int __iso_8859_13_wctomb (struct _reent *r, char *s, wchar_t _wchar,
mbstate_t *state)
{
return ___iso_wctomb (r, s, _wchar, 10, state);
}
int __iso_8859_14_wctomb (struct _reent *r, char *s, wchar_t _wchar,
mbstate_t *state)
{
return ___iso_wctomb (r, s, _wchar, 11, state);
}
int __iso_8859_15_wctomb (struct _reent *r, char *s, wchar_t _wchar,
mbstate_t *state)
{
return ___iso_wctomb (r, s, _wchar, 12, state);
}
int __iso_8859_16_wctomb (struct _reent *r, char *s, wchar_t _wchar,
mbstate_t *state)
{
return ___iso_wctomb (r, s, _wchar, 13, state);
}
static wctomb_p __iso_8859_wctomb[17] = {
NULL,
__iso_8859_1_wctomb,
__iso_8859_2_wctomb,
__iso_8859_3_wctomb,
__iso_8859_4_wctomb,
__iso_8859_5_wctomb,
__iso_8859_6_wctomb,
__iso_8859_7_wctomb,
__iso_8859_8_wctomb,
__iso_8859_9_wctomb,
__iso_8859_10_wctomb,
__iso_8859_11_wctomb,
NULL, /* No ISO 8859-12 */
__iso_8859_13_wctomb,
__iso_8859_14_wctomb,
__iso_8859_15_wctomb,
__iso_8859_16_wctomb
};
/* val *MUST* be valid! All checks for validity are supposed to be
performed before calling this function. */
wctomb_p
__iso_wctomb (int val)
{
return __iso_8859_wctomb[val];
}
#endif /* _MB_EXTENDED_CHARSETS_ISO */
#ifdef _MB_EXTENDED_CHARSETS_WINDOWS
static int
___cp_wctomb (struct _reent *r, char *s, wchar_t _wchar, int cp_idx,
mbstate_t *state)
{
wint_t wchar = _wchar;
if (s == NULL)
return 0;
if (wchar >= 0x80)
{
if (cp_idx >= 0)
{
unsigned char mb;
for (mb = 0; mb < 0x80; ++mb)
if (__cp_conv[cp_idx][mb] == wchar)
{
*s = (char) (mb + 0x80);
return 1;
}
r->_errno = EILSEQ;
return -1;
}
}
if ((size_t)wchar >= 0x100)
{
r->_errno = EILSEQ;
return -1;
}
*s = (char) wchar;
return 1;
}
static int
__cp_437_wctomb (struct _reent *r, char *s, wchar_t _wchar, mbstate_t *state)
{
return ___cp_wctomb (r, s, _wchar, 0, state);
}
static int
__cp_720_wctomb (struct _reent *r, char *s, wchar_t _wchar, mbstate_t *state)
{
return ___cp_wctomb (r, s, _wchar, 1, state);
}
static int
__cp_737_wctomb (struct _reent *r, char *s, wchar_t _wchar, mbstate_t *state)
{
return ___cp_wctomb (r, s, _wchar, 2, state);
}
static int
__cp_775_wctomb (struct _reent *r, char *s, wchar_t _wchar, mbstate_t *state)
{
return ___cp_wctomb (r, s, _wchar, 3, state);
}
static int
__cp_850_wctomb (struct _reent *r, char *s, wchar_t _wchar, mbstate_t *state)
{
return ___cp_wctomb (r, s, _wchar, 4, state);
}
static int
__cp_852_wctomb (struct _reent *r, char *s, wchar_t _wchar, mbstate_t *state)
{
return ___cp_wctomb (r, s, _wchar, 5, state);
}
static int
__cp_855_wctomb (struct _reent *r, char *s, wchar_t _wchar, mbstate_t *state)
{
return ___cp_wctomb (r, s, _wchar, 6, state);
}
static int
__cp_857_wctomb (struct _reent *r, char *s, wchar_t _wchar, mbstate_t *state)
{
return ___cp_wctomb (r, s, _wchar, 7, state);
}
static int
__cp_858_wctomb (struct _reent *r, char *s, wchar_t _wchar, mbstate_t *state)
{
return ___cp_wctomb (r, s, _wchar, 8, state);
}
static int
__cp_862_wctomb (struct _reent *r, char *s, wchar_t _wchar, mbstate_t *state)
{
return ___cp_wctomb (r, s, _wchar, 9, state);
}
static int
__cp_866_wctomb (struct _reent *r, char *s, wchar_t _wchar, mbstate_t *state)
{
return ___cp_wctomb (r, s, _wchar, 10, state);
}
static int
__cp_874_wctomb (struct _reent *r, char *s, wchar_t _wchar, mbstate_t *state)
{
return ___cp_wctomb (r, s, _wchar, 11, state);
}
static int
__cp_1125_wctomb (struct _reent *r, char *s, wchar_t _wchar, mbstate_t *state)
{
return ___cp_wctomb (r, s, _wchar, 12, state);
}
static int
__cp_1250_wctomb (struct _reent *r, char *s, wchar_t _wchar, mbstate_t *state)
{
return ___cp_wctomb (r, s, _wchar, 13, state);
}
static int
__cp_1251_wctomb (struct _reent *r, char *s, wchar_t _wchar, mbstate_t *state)
{
return ___cp_wctomb (r, s, _wchar, 14, state);
}
static int
__cp_1252_wctomb (struct _reent *r, char *s, wchar_t _wchar, mbstate_t *state)
{
return ___cp_wctomb (r, s, _wchar, 15, state);
}
static int
__cp_1253_wctomb (struct _reent *r, char *s, wchar_t _wchar, mbstate_t *state)
{
return ___cp_wctomb (r, s, _wchar, 16, state);
}
static int
__cp_1254_wctomb (struct _reent *r, char *s, wchar_t _wchar, mbstate_t *state)
{
return ___cp_wctomb (r, s, _wchar, 17, state);
}
static int
__cp_1255_wctomb (struct _reent *r, char *s, wchar_t _wchar, mbstate_t *state)
{
return ___cp_wctomb (r, s, _wchar, 18, state);
}
static int
__cp_1256_wctomb (struct _reent *r, char *s, wchar_t _wchar, mbstate_t *state)
{
return ___cp_wctomb (r, s, _wchar, 19, state);
}
static int
__cp_1257_wctomb (struct _reent *r, char *s, wchar_t _wchar, mbstate_t *state)
{
return ___cp_wctomb (r, s, _wchar, 20, state);
}
static int
__cp_1258_wctomb (struct _reent *r, char *s, wchar_t _wchar, mbstate_t *state)
{
return ___cp_wctomb (r, s, _wchar, 21, state);
}
static int
__cp_20866_wctomb (struct _reent *r, char *s, wchar_t _wchar, mbstate_t *state)
{
return ___cp_wctomb (r, s, _wchar, 22, state);
}
static int
__cp_21866_wctomb (struct _reent *r, char *s, wchar_t _wchar, mbstate_t *state)
{
return ___cp_wctomb (r, s, _wchar, 23, state);
}
static int
__cp_101_wctomb (struct _reent *r, char *s, wchar_t _wchar, mbstate_t *state)
{
return ___cp_wctomb (r, s, _wchar, 24, state);
}
static int
__cp_102_wctomb (struct _reent *r, char *s, wchar_t _wchar, mbstate_t *state)
{
return ___cp_wctomb (r, s, _wchar, 25, state);
}
static wctomb_p __cp_xxx_wctomb[26] = {
__cp_437_wctomb,
__cp_720_wctomb,
__cp_737_wctomb,
__cp_775_wctomb,
__cp_850_wctomb,
__cp_852_wctomb,
__cp_855_wctomb,
__cp_857_wctomb,
__cp_858_wctomb,
__cp_862_wctomb,
__cp_866_wctomb,
__cp_874_wctomb,
__cp_1125_wctomb,
__cp_1250_wctomb,
__cp_1251_wctomb,
__cp_1252_wctomb,
__cp_1253_wctomb,
__cp_1254_wctomb,
__cp_1255_wctomb,
__cp_1256_wctomb,
__cp_1257_wctomb,
__cp_1258_wctomb,
__cp_20866_wctomb,
__cp_21866_wctomb,
__cp_101_wctomb,
__cp_102_wctomb
};
/* val *MUST* be valid! All checks for validity are supposed to be
performed before calling this function. */
wctomb_p
__cp_wctomb (int val)
{
return __cp_xxx_wctomb[__cp_val_index (val)];
}
#endif /* _MB_EXTENDED_CHARSETS_WINDOWS */
#endif /* _MB_CAPABLE */
| 7,630 |
5,941 | <reponame>zouhirzz/FreeRDP<filename>channels/printer/printer.h
/**
* FreeRDP: A Remote Desktop Protocol Implementation
* Definition for the printer channel
*
* Copyright 2016 <NAME> <<EMAIL>>
*
* 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.
*/
#ifndef FREERDP_CHANNEL_PRINTER_PRINTER_H
#define FREERDP_CHANNEL_PRINTER_PRINTER_H
/* SERVER_PRINTER_CACHE_EVENT.cachedata */
#define RDPDR_ADD_PRINTER_EVENT 0x00000001
#define RDPDR_UPDATE_PRINTER_EVENT 0x00000002
#define RDPDR_DELETE_PRINTER_EVENT 0x00000003
#define RDPDR_RENAME_PRINTER_EVENT 0x00000004
/* DR_PRN_DEVICE_ANNOUNCE.Flags */
#define RDPDR_PRINTER_ANNOUNCE_FLAG_ASCII 0x00000001
#define RDPDR_PRINTER_ANNOUNCE_FLAG_DEFAULTPRINTER 0x00000002
#define RDPDR_PRINTER_ANNOUNCE_FLAG_NETWORKPRINTER 0x00000004
#define RDPDR_PRINTER_ANNOUNCE_FLAG_TSPRINTER 0x00000008
#define RDPDR_PRINTER_ANNOUNCE_FLAG_XPSFORMAT 0x00000010
#endif /* FREERDP_CHANNEL_PRINTER_PRINTER_H */
| 496 |
3,055 | <filename>tools/font/build/single_font_files/u8g2_font_logisoso20_tf.c
/*
Fontname: -FreeType-Logisoso-Medium-R-Normal--30-300-72-72-P-38-ISO10646-1
Copyright: Created by <NAME> with FontForge 2.0 (http://fontforge.sf.net) - Brussels - 2009
Glyphs: 224/527
BBX Build Mode: 0
*/
const uint8_t u8g2_font_logisoso20_tf[4145] U8G2_FONT_SECTION("u8g2_font_logisoso20_tf") =
"\340\0\4\4\5\5\4\6\6\31\37\376\373\25\373\25\0\2\347\5\314\20\24 \6\0 \350\2!\14\243"
".\210\302\17\14\205(\1\0\42\12\206p\354\2\213 \261\0#/\253&\330\316\220\61C\306\14\31\63"
"d\314\210A#\6\215\30\361\340\301\220\21\203F\14y\360`\304\220\61C\4\215\30\64b\314\220\61C"
"\306\0$ Kg\327\322\300\311\14%\31\63b\224\205#\311\25\244\303\221\246L\211 \63\4\221\271\201"
"\23\1%(\253&\330\306 \21EF\10\11\62\242\210\230!\3\5N(pB\201\323\15\34(d\314"
"\20\42#FHCb\314\20\0&#\253&\330\16\261\63H\6\215\30\64b\344\300\201\344\210\231\62\65"
"b\204\211\21F\262AC$\15\242\23\0'\12\203h\214F\211 !\0(\26\245\62\350N\230!#"
"\206\14\21\62\377F\314\220\61C\306\204\0)\30\246\62\350J\230Ac\6\215\231H\242\61\263\21\63\223"
"\61CF\205\1*\25(\355\353\216\230 BF\210PBD\205\210!B\302\210\1+\16\10-\351\312"
"\250i\36$\31\65\6\0,\12\243\254\207F\210\42Q\0-\10h\354\351\302\203\4.\11c,\210F"
"\210\22\0/\30\252*\350\336\260q\223\215\233l\334d\343\306\211\233N\334d\343\246\3\60\25\253&\350"
"N\251\63)\6\215\30e\377\217\206\244\71U\6\0\61\15\246\62\350\316$$Z\214\231\377\37\62\34\253"
"*\350N\251\63)\6\215\30eU\251q\344\246#\67\35\271\11\307=x\60\0\63\34\253*\350\302\7"
"\343&\34\67\216\334\300b\6G\16\234\13A#J\20Ad\6\0\64\34\253&\350\222\300\31\12\234\335"
"\300)\6\11\31\63d\314\220\61\17\36\214\32\70\33\0\65\33\253&\350\302\7\6g\210&\211\212A#"
"F\15\234\241)CC\322\234*\3\0\66\35\253&\350N\251\63)\6\215\30epB\64IT\14\32"
"\61\312\36\15Is\252\14\0\67\30\253&\350\302\7\206F\14\32\70n\340\354\6\316n\340\354\6N\5"
"\0\70\36\253*\350N\251\63)\6\215\30e\253\63C\322\234I\61h\304(;\32\222\346\24!\0\71"
"\34\253&\350N\251\63)\6\215\30e\217H(I\203pBS\206\206\244\71U\6\0:\16\203\355\210"
"\202\210\21\341A\205(\1\0;\17\303m\210\202\210\21\341A\205(\22\5\0<\21\207\61\351\226\240\61"
"C\250\21%\212\20\251\251\4=\13\11\351\330\302\3\366`\36\60>\21\207\61\351B\60Q\244f\64f"
"\22\62\203\202\1\77\33\253&\330N\251\63)\6\215\30\65p\272q\304\250\33\70\357A\205\34(\12\0"
"@>\63\347V\233Y\205\255\310\221!\71f\214\221\21c\316\210\30sF\304\220i\214Lcd\32#"
"\323\30\231\306\310\64F\246\61\62\215\221i\314\260\30\303d\14\11B\344A\220\7\321\216\245\32\0A\42"
"\252*\350\316\270q\304\250\252\225\210A\42\306\214\30\63D\314\20\61C\206`\221b\220\210A\245J\15"
"B'\253&\330\302\241$I\6\215\30\64b\224\210A#\6\215H\202&\311\30\22\203F\214\262\321\210"
"A#\222\240\71\4\0C\27\253&\330N\251\63)\6\215\30ep\376W\206\206\244\71U\6\0D\25"
"\253&\330\2\232$*\6\215\30e\377\217F\250H\202\6\0E\22\253&\330\302\7\6\347!\32l\6"
"\316\303\7\17\6F\20\253&\330\302\7\6\347!\32l\6\316\37\2G\27\253&\330N\251\63)\6\215"
"\30ep\236\344\312\216H(I\203\0H\17\253&\330\302(\373\253\7\17R\331_\15I\10\243.\210"
"\302\37\14J\20\253*\350\342\374\377\320\224\241!iN\225\1K!\252*\350\302 \63gF\14\231\213"
"\61g\14\225*E\254T)CgF\214\31\62\67#\6\31\32L\15\253&\330\302\300\371\377\207*\36"
"\34M\35\253&\330\302(C\207\320 Q\241\342\301\27&F\230\20bB\210\221 \246\354\325\0N\32"
"\253&\330\302(S\207.B\203&I&&F\230\30a$\67\30\335j\0O\25\253&\330N\251\63"
")\6\215\30e\377\217\206\244\71U\6\0P\33\253&\330\302!\64I\6\215\30\64b\224\215F\214!"
"\221\4M\261\201\363C\0Q\25\253&\330N\251\63)\6\215\30e\377\217\206\244At\2\0R)\253"
"&\330\302!\64I\6\215\30\64b\224\215F\214!\221\4\15\232!c\306\210\231d\314\220AB\6\215"
"\30\64b\224\10\0S\32\253&\330N\251\63)\6\215\30ep \275\234\241)CC\322\234*\3\0"
"T\15\253&\350\302\7\203\6\316\377\77\2U\20\253&\330\302(\373\377GC\322\234*\3\0V \252"
"*\350\202\250R\206\14\211\30$D\314\20\61C\346\211 \21\203D\14\262\250\30\275\23\4\0W\60\253"
"&\330\302\240C#\6\215\30\64b\320\210A#\6\215\30\22b\210\220\20CD\210\30\42\302\210\10#"
"y\202\206\304\30\22c\206\214\31\62\4\0X)\252*\350\202(Cf\206\210\31\62\23\61#\6\211\30"
"T\252\30\251\252D\214\31\61f\210\230!C\304\214\30$bP\251\1Y!\252*\350\202(C\42\306"
"\214\30\63D\214\230\21cF\214\61U\25\271q\342\246\23\67\331\270\351\0Z\34\253&\350\302\7\343\310"
"\215#\67\216\334\70r\343\310\215#\67\216\334\70r\17\36\14[\15\246\62\350\302\3\63\363\377\315\203\1"
"\134\31\252*\350\302\270\201\343&\34\67\341\270\11\307M\70n\240\300q\3\5\16]\15\246\62\330\302\203"
"\61\363\377\315\3\3^\13\210\254\355\312\240\62\42&\31_\10N\240\347\302\203\6`\12\205\60\355\302\230"
"\61\202\4a \14&\350N\261CiD\11\31\65b\324\310AHT\254\30\65b\324\210Q#X\254"
")\42\0b\27\253&\330\302\300\71D\223D\305\240\21\243\354\217F\250H\202\6\0c\26\13&\330N"
"\251\63)\6\215\30ep\276\62\64$\315\251\62\0d\22\253&\330\342\274A\222\242\321)\373#\22J"
"\322 e\30\13&\330N\251\63)\6\215\30e\352\301\203\204\63\32\222\346T\31\0f\25\252&\330\22"
"\251\63G\306\10\31\67\253\24\331\214\233\177\5\0g\37\253\346\326\16\222\24\215F\214\262\352\314\220\64\207"
"\210\15\34i(\205\212Q\246\232\244\71\2\0h\23\253&\330\302\300\71D\223D\305\240\21\243\354\177\65"
"\0i\20\244*\210\202\220!AG\314\377\5\211!\2j\24H\357\326\226\260a\341\301\215\232\377_\225"
"Qq\206\10\0k!\252&\330\302\270yd\315\210\61#\206L\61f\304\30C\206\316\234!\61d\314"
"\210\61#\6\31\32l\15\246&\210\302\230\371\377\67&\212\20m+\23&X\3\232\62)\216<\30\61"
"\210\320\210Q\243L\215\62\65\312\324(S\243L\215\62\65\312\324(S\243L\215\62\65\312\324\4n\20"
"\13&\330\2\232$*\6\215\30e\377\253\1o\24\13&\330N\251\63)\6\215\30e\177\64$\315\251"
"\62\0p\27\253\346\326\2\232$*\6\215\30e\177\64BE\22\64\3\347\20\0q\22\253\346\326\16\222"
"\24\215N\331\37\221P\222\6\341<r\15\10&\250\302\3&\246\346\177\5\0s\26\11&\270J\231\23"
"l,+e\310\234\31kF\34\71C\6\0t\21\247&\230\306\240\271y`b\320\374\253\42\205\6u"
"\16\13&\330\302(\373\77\42\241$\15\2v!\12*\350\202\250R\206\14\211\30$D\314\20\61Cf"
"\42f\210 \21\203D\14\62T\252\30\31\0w\66\23&X\303\250)DM\61h\324\210A\204\204\214"
")\63dL\231\61b\312LRf\22\21C\4\215\230\321\210Y\211\30\42b\224\21\21\243\312\24+S"
"\254L\31\0x\42\12*\350\202(CB\304\14\31\42H\304\240b\304\306\215#UJ\304\230!b\304"
"\214\30$B\324\0y%\253\346\346\212\240!\202\206\214\31\62F\314\220AB\6\11\31\64b\320\10Q"
"\306jF\216\340\214\14\35\33\6\0z\25\13&\330\302\7\343\306\221\233\216\30\271\351\310\215{\360`\0"
"{\27(/\347\232 jF\315Gc\10\15#\65l\324\274\242j\134\0|\10cw\327\302\77\60}"
"\30(/\347\302(\252\206\215\232\317\210\11\42\63j>\32S\206\220\60\0~\16\213\244\351\206\230!+"
"\324\10\12\1\0\177\6\0 \350\2\200\6\0 \350\2\201\6\0 \350\2\202\6\0 \350\2\203\6\0"
" \350\2\204\6\0 \350\2\205\6\0 \350\2\206\6\0 \350\2\207\6\0 \350\2\210\6\0 \350"
"\2\211\6\0 \350\2\212\6\0 \350\2\213\6\0 \350\2\214\6\0 \350\2\215\6\0 \350\2\216"
"\6\0 \350\2\217\6\0 \350\2\220\6\0 \350\2\221\6\0 \350\2\222\6\0 \350\2\223\6\0"
" \350\2\224\6\0 \350\2\225\6\0 \350\2\226\6\0 \350\2\227\6\0 \350\2\230\6\0 \350"
"\2\231\6\0 \350\2\232\6\0 \350\2\233\6\0 \350\2\234\6\0 \350\2\235\6\0 \350\2\236"
"\6\0 \350\2\237\6\0 \350\2\240\6\0 \350\2\241\6\0 \350\2\242\6\0 \350\2\243\31\253"
"&\330\22\61CH\6\215\30\64b\340\354\16]\65p\336=x\60\0\244\6\0 \350\2\245\6\0 "
"\350\2\246\6\0 \350\2\247\64\26&\210\333\60\202\343F\16#H\252`!c#\304\214\30Eb\310"
"Dc\314\20\31Tj\310(b\247\210\235\42\206\306\320\210\20\17H\4\71\202\254\24!\0\250\6\0 "
"\350\2\251:\263&X\233Y\205\255\310\221!#h\314\20\63#\206 \31\61d\314\20\21\23\15\61\70"
"\304\340\20\23\203\206\230\30\64\304\10\32\21c\216LCh\10\311A\344H\265Sk\16\0\252\6\0 "
"\350\2\253\25Ji\351R\64R\220\70\62D\214l\206\214!Ad\242\10\254\6\0 \350\2\255\6\0"
" \350\2\256\6\0 \350\2\257\6\0 \350\2\260\13\204(\215\206\210 BH\0\261\6\0 \350\2"
"\262\6\0 \350\2\263\6\0 \350\2\264\6\0 \350\2\265\17\213&\327\302(\373\77z\360@\341\14"
"\1\266\6\0 \350\2\267\6\0 \350\2\270\6\0 \350\2\271\6\0 \350\2\272\6\0 \350\2\273"
"\31Ji\351B\240@b\304\220 \63d\214\234L\61d\304\220!\201\2\1\274\6\0 \350\2\275\6"
"\0 \350\2\276\6\0 \350\2\277\6\0 \350\2\300'J+\350\312\300\201\42\245\32\67\216\30U\265"
"\22\61H\304\230\21c\206\210\31\42f\310\20,R\14\22\61\250T\251\1\301&J+\350\326\260q\262"
"\34\67\216\30U\265\22\61H\304\230\21c\206\210\31\42f\310\20,R\14\22\61\250T\251\1\302+J"
"+\350\316\70R\42\4\15\21#H\320\270q\304\250\252\225\210A\42\306\214\30\63D\314\20\61C\206`"
"\221b\220\210A\245J\15\303\6\0 \350\2\304 J+\350N\220P\206\204\210\7+\216\30]\31\262"
"\221\20\61C\304\14\231\11.\6YTL\0\305\6\0 \350\2\306'\262\32\350\336\316\14\33\26\61v"
"\304\330\21C\207\14\35\202j\10\242\61\210\306\214\34\63Pw\243\306\215J!\214Y\2\307\6\0 \350"
"\2\310\31K'\330\316H\241\42G\212y\360\300\340<D\203\315\300y\370\340\301\0\311\30K'\330\232"
"@\201\3%{\360\300\340<D\203\315\300y\370\340\301\0\312\33K'\330\322\70r\42D\211\221H\310"
"\203\7\6\347!\32l\6\316\303\7\17\6\313\32K'\330N\220`\306D\210\7\372\340\201\301y\210\6"
"\233\201\363\360\301\203\1\314\21E\63\330\302\30Ab\306\210\30\62\377\377\27\0\315\20E\63\330\216\20!"
"C$\32\62\377\377\27\0\316\23H+\330\316 B\42\204\210!$f\324\374\377\237\0\317\20F\63\350"
"F\220\20HD\217\231\377\377\23\0\320\6\0 \350\2\321\6\0 \350\2\322\32K'\330\316H\241\42"
"G\12+u&\305\240\21\243\354\377\321\220\64\247\312\0\323\31K'\330\232@\201\3\245,u&\305\240"
"\21\243\354\377\321\220\64\247\312\0\324\35K'\330\322\70r\42D\211\221HT\251\63)\6\215\30e\377"
"\217\206\244\71U\6\0\325\25\253&\330N\251\63)\6\215\30e\377\217\206\244\71U\6\0\326\33K'"
"\330N\220`\306D\210\7]\352L\212A#F\331\377\243!iN\225\1\327\6\0 \350\2\330\6\0"
" \350\2\331\25K'\330\316H\241\42G\212\31e\377\377hH\232Se\0\332\24K'\330\232@\201"
"\3%\33e\377\377hH\232Se\0\333\30K'\330\322\70r\42D\211\221H\310(\373\377GC\322"
"\234*\3\0\334\26K'\330N\220`\306D\210\7:\312\376\377\321\220\64\247\312\0\335\6\0 \350\2"
"\336\6\0 \350\2\337%\253&\330J\251\63I\306\14\31\63d\314\220\21EF\24\31ab\320\210Q"
"\366\243\21#L\214(\62\202\14\0\340$\254&\350\316P\261\322\3*v(\215(!\243F\214\32\71"
"\10\211\212\25\243F\214\32\61j\4\213\65E\4\341$\314&\350\326H\231\206\7X\354P\32QBF"
"\215\30\65r\20\22\25+F\215\30\65b\324\10\26k\212\10\342'\254&\350\16\271bCD\11\22\17"
"\246\330\241\64\242\204\214\32\61j\344 $*V\214\32\61j\304\250\21,\326\24\21\343\6\0 \350\2"
"\344&\254&\350N\220p\346D\210\207\242\330\241\64\242\204\214\32\61j\344 $*V\214\32\61j\304"
"\250\21,\226\30\21\345\6\0 \350\2\346%\20&(\13\31B.\36\220\31df\320\260AcZ<"
"x@f\334\230qc\6\231\31\364`\210\211\63\324\0\347\32\213&\327N\251\63)\6\215\30ep\276"
"\62\64$\315\251r\303*#\5\0\350\35\253&\330\316H\241\322\3)u&\305\240\21\243\254z\360 "
"\341DC\322\234*\3\0\351\35\253&\330\326\270\201\322\203*u&\305\240\21\243L=x\220pFC"
"\322\234*\3\0\352 \253&\330\322\270RB\4\215\21\17\242\324\231\24\203F\214\62\365\340A\302\31\15"
"Is\252\14\0\353\37\253&\330N\220`\306D\210\7]\352L\212A#F\231z\360 \341\214\206\244"
"\71U\6\0\354\21\245&\210\302\230\61\202\204\15\231\377\23\42c\4\355\22\305*\210\312\210!\322\204\34"
"\62\377'D\306\210\0\356\25\247\42\210\312\230\22BD\210\21\71h\376\217\10\215\22\1\0\357\22\246&"
"\210\202\20\24A\202\217\231\377\243\61\203D\0\360\6\0 \350\2\361\6\0 \350\2\362\31K'\330\312"
"\310)\305\303u\251\63)\6\215\30e\177\64$\315\251\62\0\363\32\313&\330\326@\11\7\212\7U\352"
"L\212A#F\331\37\15Is\252\14\0\364\34\253&\330\322\270RB\4\215\21\17\242\324\231\24\203F"
"\214\262\77\32\222\346T\31\0\365\24\13&\330N\251\63)\6\215\30e\177\64$\315\251\62\0\366\33\253"
"&\330N\220`\306D\210\7]\352L\212A#F\331\37\15Is\252\14\0\367\21\210\255\350\216\250a"
"\341A=H\33l\230\30\0\370!\253&\330\316\31$)\6\215\30\203I&\42L\214\60\61\302\204\220"
"L\320\240\71tfH\22l\0\371\21\253&\330\316H\241\222\217\262\377#\22J\322 \372\22\253&\330"
"\326\270\201\322\3\31e\377G$\224\244A\373\25\253&\330\322\270RB\4\215\21=\312\376\217H(I"
"\203\0\374\25\253&\330N\220`\306D\210\7:\312\376\217H(I\203\0\375\6\0 \350\2\376\6\0"
" \350\2\377\6\0 \350\2\0\0\0\4\377\377\0";
| 7,441 |
732 | // Autogenerated code. Do not modify.
package org.inferred.freebuilder.processor.source;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Preconditions;
import java.util.EnumSet;
import java.util.Objects;
import java.util.Optional;
import java.util.function.IntUnaryOperator;
import java.util.function.UnaryOperator;
import javax.annotation.Generated;
/**
* Auto-generated superclass of {@link TypeUsage.Builder}, derived from the API of {@link
* TypeUsage}.
*/
@Generated("org.inferred.freebuilder.processor.Processor")
abstract class TypeUsage_Builder {
/**
* Creates a new builder using {@code value} as a template.
*
* <p>If {@code value} is a partial, the builder will return more partials.
*/
public static TypeUsage.Builder from(TypeUsage value) {
if (value instanceof Rebuildable) {
return ((Rebuildable) value).toBuilder();
} else {
return new TypeUsage.Builder().mergeFrom(value);
}
}
private enum Property {
START("start"),
END("end"),
TYPE("type"),
;
private final String name;
private Property(String name) {
this.name = name;
}
@Override
public String toString() {
return name;
}
}
private int start;
private int end;
private QualifiedName type;
// Store a nullable object instead of an Optional. Escape analysis then
// allows the JVM to optimize away the Optional objects created by and
// passed to our API.
private QualifiedName scope = null;
private final EnumSet<Property> _unsetProperties = EnumSet.allOf(Property.class);
/**
* Sets the value to be returned by {@link TypeUsage#start()}.
*
* @return this {@code Builder} object
*/
public TypeUsage.Builder start(int start) {
this.start = start;
_unsetProperties.remove(Property.START);
return (TypeUsage.Builder) this;
}
/**
* Replaces the value to be returned by {@link TypeUsage#start()} by applying {@code mapper} to it
* and using the result.
*
* @return this {@code Builder} object
* @throws NullPointerException if {@code mapper} is null
* @throws IllegalStateException if the field has not been set
*/
public TypeUsage.Builder mapStart(IntUnaryOperator mapper) {
Objects.requireNonNull(mapper);
return start(mapper.applyAsInt(start()));
}
/**
* Returns the value that will be returned by {@link TypeUsage#start()}.
*
* @throws IllegalStateException if the field has not been set
*/
public int start() {
Preconditions.checkState(!_unsetProperties.contains(Property.START), "start not set");
return start;
}
/**
* Sets the value to be returned by {@link TypeUsage#end()}.
*
* @return this {@code Builder} object
*/
public TypeUsage.Builder end(int end) {
this.end = end;
_unsetProperties.remove(Property.END);
return (TypeUsage.Builder) this;
}
/**
* Replaces the value to be returned by {@link TypeUsage#end()} by applying {@code mapper} to it
* and using the result.
*
* @return this {@code Builder} object
* @throws NullPointerException if {@code mapper} is null
* @throws IllegalStateException if the field has not been set
*/
public TypeUsage.Builder mapEnd(IntUnaryOperator mapper) {
Objects.requireNonNull(mapper);
return end(mapper.applyAsInt(end()));
}
/**
* Returns the value that will be returned by {@link TypeUsage#end()}.
*
* @throws IllegalStateException if the field has not been set
*/
public int end() {
Preconditions.checkState(!_unsetProperties.contains(Property.END), "end not set");
return end;
}
/**
* Sets the value to be returned by {@link TypeUsage#type()}.
*
* @return this {@code Builder} object
* @throws NullPointerException if {@code type} is null
*/
public TypeUsage.Builder type(QualifiedName type) {
this.type = Objects.requireNonNull(type);
_unsetProperties.remove(Property.TYPE);
return (TypeUsage.Builder) this;
}
/**
* Replaces the value to be returned by {@link TypeUsage#type()} by applying {@code mapper} to it
* and using the result.
*
* @return this {@code Builder} object
* @throws NullPointerException if {@code mapper} is null or returns null
* @throws IllegalStateException if the field has not been set
*/
public TypeUsage.Builder mapType(UnaryOperator<QualifiedName> mapper) {
Objects.requireNonNull(mapper);
return type(mapper.apply(type()));
}
/**
* Returns the value that will be returned by {@link TypeUsage#type()}.
*
* @throws IllegalStateException if the field has not been set
*/
public QualifiedName type() {
Preconditions.checkState(!_unsetProperties.contains(Property.TYPE), "type not set");
return type;
}
/**
* Sets the value to be returned by {@link TypeUsage#scope()}.
*
* @return this {@code Builder} object
* @throws NullPointerException if {@code scope} is null
*/
public TypeUsage.Builder scope(QualifiedName scope) {
this.scope = Objects.requireNonNull(scope);
return (TypeUsage.Builder) this;
}
/**
* Sets the value to be returned by {@link TypeUsage#scope()}.
*
* @return this {@code Builder} object
*/
public TypeUsage.Builder scope(Optional<? extends QualifiedName> scope) {
if (scope.isPresent()) {
return scope(scope.get());
} else {
return clearScope();
}
}
/**
* Sets the value to be returned by {@link TypeUsage#scope()}.
*
* @return this {@code Builder} object
*/
public TypeUsage.Builder nullableScope(QualifiedName scope) {
if (scope != null) {
return scope(scope);
} else {
return clearScope();
}
}
/**
* If the value to be returned by {@link TypeUsage#scope()} is present, replaces it by applying
* {@code mapper} to it and using the result.
*
* <p>If the result is null, clears the value.
*
* @return this {@code Builder} object
* @throws NullPointerException if {@code mapper} is null
*/
public TypeUsage.Builder mapScope(UnaryOperator<QualifiedName> mapper) {
return scope(scope().map(mapper));
}
/**
* Sets the value to be returned by {@link TypeUsage#scope()} to {@link Optional#empty()
* Optional.empty()}.
*
* @return this {@code Builder} object
*/
public TypeUsage.Builder clearScope() {
scope = null;
return (TypeUsage.Builder) this;
}
/** Returns the value that will be returned by {@link TypeUsage#scope()}. */
public Optional<QualifiedName> scope() {
return Optional.ofNullable(scope);
}
/**
* Copies values from {@code value}, skipping empty optionals.
*
* @return this {@code Builder} object
*/
public TypeUsage.Builder mergeFrom(TypeUsage value) {
TypeUsage_Builder defaults = new TypeUsage.Builder();
if (defaults._unsetProperties.contains(Property.START) || value.start() != defaults.start()) {
start(value.start());
}
if (defaults._unsetProperties.contains(Property.END) || value.end() != defaults.end()) {
end(value.end());
}
if (defaults._unsetProperties.contains(Property.TYPE)
|| !Objects.equals(value.type(), defaults.type())) {
type(value.type());
}
value.scope().ifPresent(this::scope);
return (TypeUsage.Builder) this;
}
/**
* Copies values from {@code template}, skipping empty optionals and unset properties.
*
* @return this {@code Builder} object
*/
public TypeUsage.Builder mergeFrom(TypeUsage.Builder template) {
// Upcast to access private fields; otherwise, oddly, we get an access violation.
TypeUsage_Builder base = template;
TypeUsage_Builder defaults = new TypeUsage.Builder();
if (!base._unsetProperties.contains(Property.START)
&& (defaults._unsetProperties.contains(Property.START)
|| template.start() != defaults.start())) {
start(template.start());
}
if (!base._unsetProperties.contains(Property.END)
&& (defaults._unsetProperties.contains(Property.END) || template.end() != defaults.end())) {
end(template.end());
}
if (!base._unsetProperties.contains(Property.TYPE)
&& (defaults._unsetProperties.contains(Property.TYPE)
|| !Objects.equals(template.type(), defaults.type()))) {
type(template.type());
}
template.scope().ifPresent(this::scope);
return (TypeUsage.Builder) this;
}
/**
* Resets the state of this builder.
*
* @return this {@code Builder} object
*/
public TypeUsage.Builder clear() {
TypeUsage_Builder defaults = new TypeUsage.Builder();
start = defaults.start;
end = defaults.end;
type = defaults.type;
scope = defaults.scope;
_unsetProperties.clear();
_unsetProperties.addAll(defaults._unsetProperties);
return (TypeUsage.Builder) this;
}
/**
* Returns a newly-created {@link TypeUsage} based on the contents of this {@code Builder}.
*
* @throws IllegalStateException if any field has not been set
*/
public TypeUsage build() {
Preconditions.checkState(_unsetProperties.isEmpty(), "Not set: %s", _unsetProperties);
return new Value(this);
}
/**
* Returns a newly-created partial {@link TypeUsage} for use in unit tests. State checking will
* not be performed. Unset properties will throw an {@link UnsupportedOperationException} when
* accessed via the partial object.
*
* <p>The builder returned by {@link TypeUsage.Builder#from(TypeUsage)} will propagate the partial
* status of its input, overriding {@link TypeUsage.Builder#build() build()} to return another
* partial. This allows for robust tests of modify-rebuild code.
*
* <p>Partials should only ever be used in tests. They permit writing robust test cases that won't
* fail if this type gains more application-level constraints (e.g. new required fields) in
* future. If you require partially complete values in production code, consider using a Builder.
*/
@VisibleForTesting()
public TypeUsage buildPartial() {
return new Partial(this);
}
private abstract static class Rebuildable implements TypeUsage {
public abstract Builder toBuilder();
}
private static final class Value extends Rebuildable {
private final int start;
private final int end;
private final QualifiedName type;
// Store a nullable object instead of an Optional. Escape analysis then
// allows the JVM to optimize away the Optional objects created by our
// getter method.
private final QualifiedName scope;
private Value(TypeUsage_Builder builder) {
this.start = builder.start;
this.end = builder.end;
this.type = builder.type;
this.scope = builder.scope;
}
@Override
public int start() {
return start;
}
@Override
public int end() {
return end;
}
@Override
public QualifiedName type() {
return type;
}
@Override
public Optional<QualifiedName> scope() {
return Optional.ofNullable(scope);
}
@Override
public Builder toBuilder() {
TypeUsage_Builder builder = new Builder();
builder.start = start;
builder.end = end;
builder.type = type;
builder.scope = scope;
builder._unsetProperties.clear();
return (Builder) builder;
}
@Override
public boolean equals(Object obj) {
if (!(obj instanceof Value)) {
return false;
}
Value other = (Value) obj;
return start == other.start
&& end == other.end
&& Objects.equals(type, other.type)
&& Objects.equals(scope, other.scope);
}
@Override
public int hashCode() {
return Objects.hash(start, end, type, scope);
}
@Override
public String toString() {
StringBuilder result =
new StringBuilder("TypeUsage{start=")
.append(start)
.append(", end=")
.append(end)
.append(", type=")
.append(type);
if (scope != null) {
result.append(", scope=").append(scope);
}
return result.append("}").toString();
}
}
private static final class Partial extends Rebuildable {
private final int start;
private final int end;
private final QualifiedName type;
// Store a nullable object instead of an Optional. Escape analysis then
// allows the JVM to optimize away the Optional objects created by our
// getter method.
private final QualifiedName scope;
private final EnumSet<Property> _unsetProperties;
Partial(TypeUsage_Builder builder) {
this.start = builder.start;
this.end = builder.end;
this.type = builder.type;
this.scope = builder.scope;
this._unsetProperties = builder._unsetProperties.clone();
}
@Override
public int start() {
if (_unsetProperties.contains(Property.START)) {
throw new UnsupportedOperationException("start not set");
}
return start;
}
@Override
public int end() {
if (_unsetProperties.contains(Property.END)) {
throw new UnsupportedOperationException("end not set");
}
return end;
}
@Override
public QualifiedName type() {
if (_unsetProperties.contains(Property.TYPE)) {
throw new UnsupportedOperationException("type not set");
}
return type;
}
@Override
public Optional<QualifiedName> scope() {
return Optional.ofNullable(scope);
}
private static class PartialBuilder extends Builder {
@Override
public TypeUsage build() {
return buildPartial();
}
}
@Override
public Builder toBuilder() {
TypeUsage_Builder builder = new PartialBuilder();
builder.start = start;
builder.end = end;
builder.type = type;
builder.scope = scope;
builder._unsetProperties.clear();
builder._unsetProperties.addAll(_unsetProperties);
return (Builder) builder;
}
@Override
public boolean equals(Object obj) {
if (!(obj instanceof Partial)) {
return false;
}
Partial other = (Partial) obj;
return start == other.start
&& end == other.end
&& Objects.equals(type, other.type)
&& Objects.equals(scope, other.scope)
&& Objects.equals(_unsetProperties, other._unsetProperties);
}
@Override
public int hashCode() {
return Objects.hash(start, end, type, scope, _unsetProperties);
}
@Override
public String toString() {
StringBuilder result = new StringBuilder("partial TypeUsage{");
String separator = "";
if (!_unsetProperties.contains(Property.START)) {
result.append("start=").append(start);
separator = ", ";
}
if (!_unsetProperties.contains(Property.END)) {
result.append(separator).append("end=").append(end);
separator = ", ";
}
if (!_unsetProperties.contains(Property.TYPE)) {
result.append(separator).append("type=").append(type);
separator = ", ";
}
if (scope != null) {
result.append(separator).append("scope=").append(scope);
}
return result.append("}").toString();
}
}
}
| 5,428 |
350 | // Copyright cocotb contributors
// Licensed under the Revised BSD License, see LICENSE for details.
// SPDX-License-Identifier: BSD-3-Clause
#ifndef PY_GPI_LOGGING_H
#define PY_GPI_LOGGING_H
#include <exports.h>
#ifdef PYGPILOG_EXPORTS
#define PYGPILOG_EXPORT COCOTB_EXPORT
#else
#define PYGPILOG_EXPORT COCOTB_IMPORT
#endif
#ifdef __cplusplus
extern "C" {
#endif
PYGPILOG_EXPORT void py_gpi_logger_set_level(int level);
PYGPILOG_EXPORT void py_gpi_logger_initialize(PyObject* handler,
PyObject* filter);
PYGPILOG_EXPORT void py_gpi_logger_finalize();
#ifdef __cplusplus
}
#endif
#endif
| 298 |
1,083 | // This source file is part of the polarphp.org open source project
//
// Copyright (c) 2017 - 2019 polarphp software foundation
// Copyright (c) 2017 - 2019 zzu_softboy <<EMAIL>>
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://polarphp.org/LICENSE.txt for license information
// See https://polarphp.org/CONTRIBUTORS.txt for the list of polarphp project authors
//
// Created by polarboy on 2019/11/19.
#include "polarphp/syntax/internal/TokenEnumDefs.h"
#include "polarphp/syntax/serialization/SyntaxJsonSerialization.h"
#include "polarphp/syntax/SyntaxNodeBuilders.h"
#include "polarphp/syntax/SyntaxNodeFactory.h"
#include "polarphp/parser/Token.h"
#include "gtest/gtest.h"
#include "nlohmann/json.hpp"
#include <list>
using polar::syntax::internal::TokenKindType;
using polar::syntax::TokenSyntax;
using polar::syntax::Trivia;
using nlohmann::json;
using polar::syntax::SyntaxNodeFactory;
using polar::syntax::EmptyStmtSyntax;
namespace {
TEST(SyntaxJsonSerializationTest, testSyntaxNode)
{
Trivia leftTrivia;
Trivia rightTrivia;
TokenSyntax semicolon = SyntaxNodeFactory::makeSemicolonToken(leftTrivia, rightTrivia);
EmptyStmtSyntax emptyStmt = SyntaxNodeFactory::makeEmptyStmt(semicolon);
json emptyStmtJson = emptyStmt;
std::cout << emptyStmtJson.dump(3) << std::endl;
}
}
| 458 |
1,286 | <filename>oauth2-authorization-server/src/main/java/org/springframework/security/oauth2/jwt/JwtEncoder.java
/*
* Copyright 2020-2022 the original author or 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
*
* https://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.springframework.security.oauth2.jwt;
/**
* Implementations of this interface are responsible for encoding
* a JSON Web Token (JWT) to it's compact claims representation format.
*
* <p>
* JWTs may be represented using the JWS Compact Serialization format for a
* JSON Web Signature (JWS) structure or JWE Compact Serialization format for a
* JSON Web Encryption (JWE) structure. Therefore, implementors are responsible
* for signing a JWS and/or encrypting a JWE.
*
* @author <NAME>
* @author <NAME>
* @since 0.0.1
* @see Jwt
* @see JoseHeader
* @see JwtClaimsSet
* @see JwtDecoder
* @see <a target="_blank" href="https://datatracker.ietf.org/doc/html/rfc7519">JSON Web Token (JWT)</a>
* @see <a target="_blank" href="https://datatracker.ietf.org/doc/html/rfc7515">JSON Web Signature (JWS)</a>
* @see <a target="_blank" href="https://datatracker.ietf.org/doc/html/rfc7516">JSON Web Encryption (JWE)</a>
* @see <a target="_blank" href="https://datatracker.ietf.org/doc/html/rfc7515#section-3.1">JWS Compact Serialization</a>
* @see <a target="_blank" href="https://datatracker.ietf.org/doc/html/rfc7516#section-3.1">JWE Compact Serialization</a>
* @deprecated See <a target="_blank" href="https://github.com/spring-projects/spring-authorization-server/issues/596">gh-596</a>
*/
@Deprecated
@FunctionalInterface
public interface JwtEncoder {
/**
* Encode the JWT to it's compact claims representation format.
*
* @param headers the JOSE header
* @param claims the JWT Claims Set
* @return a {@link Jwt}
* @throws JwtEncodingException if an error occurs while attempting to encode the JWT
*/
Jwt encode(JoseHeader headers, JwtClaimsSet claims) throws JwtEncodingException;
}
| 773 |
988 | /*
* 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.openide.explorer.view;
import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.GraphicsEnvironment;
import java.awt.event.ActionEvent;
import java.beans.PropertyVetoException;
import java.lang.ref.Reference;
import java.lang.ref.WeakReference;
import java.lang.reflect.InvocationTargetException;
import java.util.Arrays;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.logging.Level;
import javax.swing.AbstractAction;
import javax.swing.Action;
import javax.swing.JFrame;
import javax.swing.JScrollBar;
import javax.swing.JScrollPane;
import javax.swing.SwingUtilities;
import junit.framework.Test;
import junit.framework.TestSuite;
import org.netbeans.junit.Log;
import org.netbeans.junit.NbTestCase;
import org.netbeans.junit.RandomlyFails;
import org.openide.explorer.ExplorerManager;
import org.openide.nodes.AbstractNode;
import org.openide.nodes.Children;
import org.openide.nodes.FilterNode;
import org.openide.nodes.Node;
import org.openide.util.Exceptions;
import org.openide.util.HelpCtx;
import org.openide.util.Lookup;
import org.openide.util.RequestProcessor;
import org.openide.util.actions.NodeAction;
import org.openide.util.actions.SystemAction;
/**
*
* @author <NAME>, <NAME>
*/
public final class TreeViewTest extends NbTestCase {
public static Test suite() {
return GraphicsEnvironment.isHeadless() ? new TestSuite() : new TestSuite(TreeViewTest.class);
}
protected @Override int timeOut() {
return 50000;
}
private ExplorerWindow testWindow;
private volatile boolean isScrolledDown;
private final Object semaphore = new Object();
private CharSequence log;
public TreeViewTest(String testName) {
super(testName);
}
@Override
protected void setUp() throws Exception {
testWindow = null;
}
@Override
protected void runTest() throws Throwable {
VisualizerNode.LOG.setLevel(Level.FINE);
log = Log.enable(VisualizerNode.LOG.getName(), Level.FINE);
super.runTest();
if (log.length() > 0 && log.toString().indexOf("Children.MUTEX") >= 0) {
fail("something has been logged:\n" + log);
}
}
/**
* Tests whether <code>JTree</code>'s property <code>scrollsOnExpand</code>
* is taken into account in
* <code>TreeView.TreePropertyListener.treeExpanded(...)</code>.
*/
@RandomlyFails // NB-Core-Build #8278: Check the view has scrolled
public void testAutoscrollOnOff() throws InterruptedException, InvocationTargetException {
assert !EventQueue.isDispatchThread();
class Detector implements Runnable {
public void run() {
if (!EventQueue.isDispatchThread()) {
EventQueue.invokeLater(this);
return;
}
isScrolledDown = !testWindow.treeView.isUp();
synchronized (semaphore) {
semaphore.notify();
}
}
}
class Tester implements Runnable {
private final boolean autoscroll;
private final int part;
Tester(boolean autoscroll, int part) {
this.autoscroll = autoscroll;
this.part = part;
}
public void run() {
assert (part == 1) || (part == 2);
if (part == 1) {
testWindow.treeView.collapse();
testWindow.treeView.scrollUp();
assert testWindow.treeView.isUp();
} else {
testWindow.treeView.setAutoscroll(autoscroll);
testWindow.treeView.expand(); //<-- posts a request to the RequestProcessor
RequestProcessor.getDefault().post(new Detector(), 1000 /*ms*/);
}
}
}
SwingUtilities.invokeAndWait(new Runnable() {
@Override
public void run() {
testWindow = new ExplorerWindow();
}
});
testWindow.showWindow();
EventQueue.invokeLater(new Tester(true, 1));
Thread.sleep(2000); //wait for update of the screen
EventQueue.invokeLater(new Tester(true, 2));
synchronized (semaphore) {
semaphore.wait();
}
assertTrue("Check the view has scrolled", isScrolledDown);
EventQueue.invokeLater(new Tester(false, 1));
Thread.sleep(2000); //wait for update of the screen
EventQueue.invokeLater(new Tester(false, 2));
synchronized (semaphore) {
semaphore.wait();
}
assertTrue("Check the view has not scrolled", !isScrolledDown);
EventQueue.invokeLater(new Tester(true, 1)); //just collapse the tree
Thread.sleep(2000);
}
public void testExpandNodePreparedOutsideOfAWT() throws Exception {
assertFalse(EventQueue.isDispatchThread());
class OutOfAWT extends Keys {
Exception noAWTAddNotify;
Exception noAWTCreateNodes;
public OutOfAWT(boolean lazy, String... args) {
super(lazy, args);
}
@Override
protected void addNotify() {
if (EventQueue.isDispatchThread()) {
noAWTAddNotify = new Exception();
}
super.addNotify();
}
@Override
protected Node[] createNodes(Object key) {
if (EventQueue.isDispatchThread()) {
noAWTCreateNodes = new Exception();
}
return super.createNodes(key);
}
}
AbstractNode root = new AbstractNode(new Children.Array());
final OutOfAWT ch = new OutOfAWT(false, "A", "B", "C");
AbstractNode an = new AbstractNode(ch);
root.getChildren().add(new Node[] { an });
SwingUtilities.invokeAndWait(new Runnable() {
@Override
public void run() {
testWindow = new ExplorerWindow();
}
});
testWindow.showWindow();
testWindow.getExplorerManager().setRootContext(root);
testWindow.treeView.expandNode(an);
Thread.sleep(2000);
if (ch.noAWTAddNotify != null) {
throw ch.noAWTAddNotify;
}
if (ch.noAWTCreateNodes != null) {
throw ch.noAWTCreateNodes;
}
}
private static final class TestTreeView extends BeanTreeView {
private final Node rootNode;
final JScrollBar vertScrollBar;
private transient ExplorerManager explManager;
TestTreeView() {
super();
tree.setAutoscrolls(true);
setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);
vertScrollBar = getVerticalScrollBar();
rootNode = new AbstractNode(new TreeChildren());
rootNode.setDisplayName("Root node");
tree.setRowHeight(20);
Dimension prefSize = new Dimension(200, 6 * tree.getRowHeight() + 8);
prefSize.width = (int) (prefSize.width * 1.25f)
+ vertScrollBar.getWidth();
setPreferredSize(prefSize);
}
@Override
public void addNotify() {
super.addNotify();
explManager = ExplorerManager.find(this);
explManager.setRootContext(rootNode);
collapse();
}
void setAutoscroll(boolean autoscroll) {
tree.setScrollsOnExpand(autoscroll);
}
void scrollUp() {
vertScrollBar.setValue(vertScrollBar.getMinimum());
}
boolean isUp() {
return vertScrollBar.getValue()
== vertScrollBar.getMinimum();
}
void expand() {
tree.expandRow(4);
}
void collapse() {
tree.collapseRow(4);
}
static final class TreeChildren extends Children.Array {
private static final char[] letters
= new char[] {'A', 'B', 'C', 'D', 'E'};
TreeChildren() {
this(-1);
}
TreeChildren(final int first) {
super();
Node[] childNodes = new Node[5];
int i;
if (first == -1) {
for (i = 0; i < childNodes.length; i++) {
AbstractNode childNode = new AbstractNode(new TreeChildren(i));
childNode.setDisplayName("Child node " + i);
childNodes[i] = childNode;
}
} else {
for (i = 0; i < childNodes.length; i++) {
AbstractNode childNode = new AbstractNode(Children.LEAF);
StringBuffer buf = new StringBuffer(3);
childNode.setDisplayName(buf.append(first)
.append('.')
.append(letters[i])
.toString());
childNodes[i] = childNode;
}
}
add(childNodes);
}
}
}
private final class ExplorerWindow extends JFrame
implements ExplorerManager.Provider, Runnable {
private final ExplorerManager explManager = new ExplorerManager();
TestTreeView treeView;
ExplorerWindow() {
super("TreeView test"); //NOI18N
getContentPane().add(treeView = new TestTreeView());
}
public ExplorerManager getExplorerManager() {
return explManager;
}
public void run() {
pack();
setVisible(true);
}
void waitShown() throws InterruptedException {
while (!isShowing()) {
Thread.sleep(100);
}
Thread.sleep(500);
}
void showWindow() {
try {
EventQueue.invokeAndWait(this);
waitShown();
} catch (InterruptedException ex) {
Exceptions.printStackTrace(ex);
} catch (InvocationTargetException ex) {
ex.printStackTrace();
}
waitAWT();
}
}
/**
* Used as the preferred actions by the nodes below
*/
private static class MyAction extends NodeAction {
public boolean enable(Node[] nodes) {
return true;
}
public void performAction(Node[] nodes) {
}
public HelpCtx getHelpCtx() {
return HelpCtx.DEFAULT_HELP;
}
public String getName() {
return "My Action";
}
@Override
public Action createContextAwareInstance(Lookup actionContext) {
return new MyDelegateAction(actionContext);
}
}
/**
* Returned by MyAction.createContextAwareInstance().
*/
private static class MyDelegateAction extends AbstractAction {
Lookup contextLookup;
public MyDelegateAction(Lookup contextLookup) {
this.contextLookup = contextLookup;
}
public void actionPerformed(ActionEvent e) {
}
}
private static class NodeWhichHasItselfInLookup extends AbstractNode {
public NodeWhichHasItselfInLookup() {
super(Children.LEAF);
}
@Override
public Action getPreferredAction() {
return SystemAction.get(MyAction.class);
}
}
private static class NodeWhichDoesntHaveItselfInLookup extends AbstractNode {
public NodeWhichDoesntHaveItselfInLookup() {
super(Children.LEAF, Lookup.EMPTY);
}
@Override
public Action getPreferredAction() {
return SystemAction.get(MyAction.class);
}
}
/**
* Tests that the context lookup created by TreeView.takeAction() only contains
* the node once when the node contains itself in its lookup.
*/
public void testTakeActionNodeInLookup() {
doTestTakeAction(new NodeWhichHasItselfInLookup());
}
/**
* Tests that the context lookup created by TreeView.takeAction() only contains
* the node once when the node doesn't contain itself in its lookup.
*/
public void testTakeActionNodeNotInLookup() {
doTestTakeAction(new NodeWhichDoesntHaveItselfInLookup());
}
/**
* Tests that the context lookup created by TreeView.takeAction() only contains
* the node once when the node contains itself in its lookup and is filtered by a FilterNode.
*/
public void testTakeActionNodeInLookupAndFiltered() {
doTestTakeAction(new FilterNode(new NodeWhichHasItselfInLookup()));
}
/**
* Tests that the context lookup created by TreeView.takeAction() only contains
* the node once when the node doesn't contain itself in its lookup
* and is filtered by a FilterNode.
*/
public void testTakeActionNodeNotInLookupAndFiltered() {
doTestTakeAction(new FilterNode(new NodeWhichDoesntHaveItselfInLookup()));
}
private void doTestTakeAction(Node node) {
// if the preferred action instanceof ContextAwareAction
// calls its createContextAwareInstance() method
Action a = TreeView.takeAction(node.getPreferredAction(), node);
int count = ((MyDelegateAction)a).contextLookup.lookup(new Lookup.Template(Node.class)).allInstances().size();
assertEquals("The context lookup created by TreeView.takeAction() should contain the node only once.", 1, count);
}
private static void waitAWT() {
try {
SwingUtilities.invokeAndWait(new Runnable() {
public void run() {
}
});
} catch (InterruptedException ex) {
Exceptions.printStackTrace(ex);
} catch (InvocationTargetException ex) {
Exceptions.printStackTrace(ex);
}
}
private void setSelectedNodes(final Node[] arr) throws Exception {
class R implements Runnable {
Exception e;
public void run() {
try {
testWindow.getExplorerManager().setSelectedNodes(arr);
} catch (PropertyVetoException ex) {
e = ex;
}
}
}
R run = new R();
SwingUtilities.invokeAndWait(run);
if (run.e != null) {
throw run.e;
}
}
public void testPreventGCOfVisibleNodesEager() throws Exception {
doPreventGCOfVisibleNodes(false);
}
public void testPreventGCOfVisibleNodesLazy() throws Exception {
doPreventGCOfVisibleNodes(true);
}
private void doPreventGCOfVisibleNodes(boolean lazy) throws Exception {
assert !EventQueue.isDispatchThread();
Keys keys = new Keys(lazy, "A", "B", "C");
AbstractNode node = new AbstractNode(keys);
node.setName(getName());
AbstractNode root = node;
SwingUtilities.invokeAndWait(new Runnable() {
@Override
public void run() {
testWindow = new ExplorerWindow();
}
});
testWindow.showWindow();
testWindow.getExplorerManager().setRootContext(root);
assertSame("Root is OK", root, testWindow.getExplorerManager().getRootContext());
Node[] arr = node.getChildren().getNodes();
testWindow.getExplorerManager().setExploredContext(node);
setSelectedNodes(arr);
waitAWT();
Reference<Object> ref = new WeakReference<Object>(arr[2]);
root = null;
node = null;
arr = null;
setSelectedNodes(new Node[0]);
waitAWT();
try {
EQFriendlyGC.assertGC("Cannot GC the children", ref);
} catch (Error ex) {
// OK
return;
}
fail("Node shall not be GCed: " + ref.get());
}
@RandomlyFails // http://deadlock.netbeans.org/job/NB-Core-Build/9880/testReport/
public void testNodesGCedAfterSetChildrenLazy() throws Exception {
doTestNodesGCedAfterSetChildren(true);
}
@RandomlyFails // NB-Core-Build #9918: Unstable, NB-Core-Build #9919 on the same sources passed
public void testNodesGCedAfterSetChildrenEager() throws Exception {
doTestNodesGCedAfterSetChildren(false);
}
void doTestNodesGCedAfterSetChildren(boolean lazy) throws Exception {
Keys keys = new Keys(lazy, "A", "B", "C");
class MyNode extends AbstractNode {
public MyNode(Children children) {
super(children);
}
void callSetChildren(Children newCh) {
setChildren(newCh);
}
}
MyNode root = new MyNode(keys);
root.setName(getName());
SwingUtilities.invokeAndWait(new Runnable() {
@Override
public void run() {
testWindow = new ExplorerWindow();
}
});
testWindow.showWindow();
testWindow.getExplorerManager().setRootContext(root);
testWindow.getExplorerManager().setExploredContext(root);
Node[] nodes = root.getChildren().getNodes();
try {
testWindow.getExplorerManager().setSelectedNodes(nodes);
} catch (PropertyVetoException ex) {
Exceptions.printStackTrace(ex);
}
waitAWT();
Reference<Object> ref = new WeakReference<Object>(nodes[2]);
nodes = null;
root.callSetChildren(Children.LEAF);
waitAWT();
EQFriendlyGC.assertGC("should gc children", ref);
}
@RandomlyFails // NB-Core-Build Unstable: #9954, locally passes
public void testSetSelectedNodeIsSynchronizedEager() throws Exception {
doSetSelectedNodeIsSynchronized(false);
}
public void testSetSelectedNodeIsSynchronizedLazy() throws Exception {
doSetSelectedNodeIsSynchronized(true);
}
private void doSetSelectedNodeIsSynchronized(boolean lazy) throws Exception {
assert !EventQueue.isDispatchThread();
final Keys keys = new Keys(lazy, "A", "B", "C");
AbstractNode node = new AbstractNode(keys);
node.setName(getName());
final AbstractNode root = node;
SwingUtilities.invokeAndWait(new Runnable() {
@Override
public void run() {
testWindow = new ExplorerWindow();
}
});
testWindow.getExplorerManager().setRootContext(root);
testWindow.showWindow();
waitAWT();
testWindow.getExplorerManager().setRootContext(root);
assertSame("Root is OK", root, testWindow.getExplorerManager().getRootContext());
Node[] arr = node.getChildren().getNodes();
testWindow.getExplorerManager().setExploredContext(node);
final AwtBlock block = new AwtBlock();
block.block();
class SetSelectedFromAwt implements Runnable {
Throwable e = null;
public void run() {
Node[] arr2 = root.getChildren().getNodes();
try {
testWindow.getExplorerManager().setSelectedNodes(arr2);
} catch (Throwable ex) {
e = ex;
}
}
}
SetSelectedFromAwt setSel = new SetSelectedFromAwt();
SwingUtilities.invokeLater(setSel);
keys.keys("A", "B", "C", "D");
block.unblock();
waitAWT();
assertEquals("Selection should be updated", Arrays.asList(keys.getNodes()),
Arrays.asList(testWindow.getExplorerManager().getSelectedNodes()));
if (setSel.e != null) {
fail();
}
}
public void testPartialNodeSelectionEager() throws Exception {
doTestPartialNodeSelection(false);
}
@RandomlyFails // NB-Core-Build Unstable: #9953, locally passes
public void testPartialNodeSelectionLazy() throws Exception {
doTestPartialNodeSelection(true);
}
private void doTestPartialNodeSelection(boolean lazy) throws Exception {
assert !EventQueue.isDispatchThread();
final Keys keys = new Keys(lazy, "A", "B", "-B", "C");
AbstractNode node = new AbstractNode(keys);
node.setName(getName());
final AbstractNode root = node;
SwingUtilities.invokeAndWait(new Runnable() {
@Override
public void run() {
testWindow = new ExplorerWindow();
}
});
testWindow.getExplorerManager().setRootContext(root);
testWindow.showWindow();
testWindow.getExplorerManager().setRootContext(root);
assertSame("Root is OK", root, testWindow.getExplorerManager().getRootContext());
Node[] arr = node.getChildren().getNodes();
testWindow.getExplorerManager().setExploredContext(node);
final CountDownLatch block1 = new CountDownLatch(1);
final CountDownLatch block2 = new CountDownLatch(1);
final AtomicBoolean exc = new AtomicBoolean(false);
SwingUtilities.invokeLater(new Runnable() {
public void run() {
Node[] arr2 = root.getChildren().getNodes();
block1.countDown();
try {
block2.await();
} catch (InterruptedException ex) {
Exceptions.printStackTrace(ex);
}
try {
testWindow.getExplorerManager().setSelectedNodes(arr2);
} catch (Throwable ex) {
ex.printStackTrace();
exc.set(true);
}
}
});
block1.await();
keys.keys("B", "D");
block2.countDown();
waitAWT();
assertEquals("B should be selected", Arrays.asList(keys.getNodes()[0]),
Arrays.asList(testWindow.getExplorerManager().getSelectedNodes()));
if (exc.get()) {
fail();
}
}
class AwtBlock implements Runnable {
public synchronized void run() {
notify();
try {
wait();
} catch (InterruptedException ex) {
Exceptions.printStackTrace(ex);
}
}
synchronized void block() {
SwingUtilities.invokeLater(this);
try {
wait();
} catch (InterruptedException ex) {
Exceptions.printStackTrace(ex);
}
}
synchronized void unblock() {
notifyAll();
}
}
class Block {
synchronized void block() {
try {
wait();
} catch (InterruptedException ex) {
Exceptions.printStackTrace(ex);
}
}
synchronized void unblock() {
notifyAll();
}
}
/** Sample keys.
*/
public static class Keys extends Children.Keys {
/** Constructor.
*/
public Keys (boolean lazy, String... args) {
super(lazy);
if (args != null && args.length > 0) {
setKeys (args);
}
}
/** Changes the keys.
*/
public void keys (String... args) {
super.setKeys (args);
}
/** Create nodes for a given key.
* @param key the key
* @return child nodes for this key or null if there should be no
* nodes for this key
*/
protected Node[] createNodes(Object key) {
if (key.toString().startsWith("-")) {
return null;
}
AbstractNode an = new AbstractNode (Children.LEAF);
an.setName (key.toString ());
return new Node[] { an };
}
}
}
| 11,806 |
582 | <reponame>martinChenZ/spring-boot-demo<filename>security-oauth2-credentials/src/main/java/com/easy/securityOauth2Credentials/entity/Role.java
package com.easy.securityOauth2Credentials.entity;
import com.easy.securityOauth2Credentials.base.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
/**
* <p>
*
* </p>
*
* @author ltq
* @since 2019-08-14
*/
@Data
@EqualsAndHashCode(callSuper = true)
@Accessors(chain = true)
public class Role extends BaseEntity {
private static final long serialVersionUID = 1L;
private String name;
} | 214 |
372 | <filename>clients/google-api-services-videointelligence/v1/1.31.0/com/google/api/services/videointelligence/v1/model/GoogleCloudVideointelligenceV1AnnotateVideoRequest.java
/*
* 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.
*/
/*
* This code was generated by https://github.com/googleapis/google-api-java-client-services/
* Modify at your own risk.
*/
package com.google.api.services.videointelligence.v1.model;
/**
* Video annotation request.
*
* <p> This is the Java data model class that specifies how to parse/serialize into the JSON that is
* transmitted over HTTP when working with the Cloud Video Intelligence API. For a detailed
* explanation see:
* <a href="https://developers.google.com/api-client-library/java/google-http-java-client/json">https://developers.google.com/api-client-library/java/google-http-java-client/json</a>
* </p>
*
* @author Google, Inc.
*/
@SuppressWarnings("javadoc")
public final class GoogleCloudVideointelligenceV1AnnotateVideoRequest extends com.google.api.client.json.GenericJson {
/**
* Required. Requested video annotation features.
* The value may be {@code null}.
*/
@com.google.api.client.util.Key
private java.util.List<java.lang.String> features;
/**
* The video data bytes. If unset, the input video(s) should be specified via the `input_uri`. If
* set, `input_uri` must be unset.
* The value may be {@code null}.
*/
@com.google.api.client.util.Key
private java.lang.String inputContent;
/**
* Input video location. Currently, only [Cloud Storage](https://cloud.google.com/storage/) URIs
* are supported. URIs must be specified in the following format: `gs://bucket-id/object-id`
* (other URI formats return google.rpc.Code.INVALID_ARGUMENT). For more information, see [Request
* URIs](https://cloud.google.com/storage/docs/request-endpoints). To identify multiple videos, a
* video URI may include wildcards in the `object-id`. Supported wildcards: '*' to match 0 or more
* characters; '?' to match 1 character. If unset, the input video should be embedded in the
* request as `input_content`. If set, `input_content` must be unset.
* The value may be {@code null}.
*/
@com.google.api.client.util.Key
private java.lang.String inputUri;
/**
* Optional. Cloud region where annotation should take place. Supported cloud regions are: `us-
* east1`, `us-west1`, `europe-west1`, `asia-east1`. If no region is specified, the region will be
* determined based on video file location.
* The value may be {@code null}.
*/
@com.google.api.client.util.Key
private java.lang.String locationId;
/**
* Optional. Location where the output (in JSON format) should be stored. Currently, only [Cloud
* Storage](https://cloud.google.com/storage/) URIs are supported. These must be specified in the
* following format: `gs://bucket-id/object-id` (other URI formats return
* google.rpc.Code.INVALID_ARGUMENT). For more information, see [Request
* URIs](https://cloud.google.com/storage/docs/request-endpoints).
* The value may be {@code null}.
*/
@com.google.api.client.util.Key
private java.lang.String outputUri;
/**
* Additional video context and/or feature-specific parameters.
* The value may be {@code null}.
*/
@com.google.api.client.util.Key
private GoogleCloudVideointelligenceV1VideoContext videoContext;
/**
* Required. Requested video annotation features.
* @return value or {@code null} for none
*/
public java.util.List<java.lang.String> getFeatures() {
return features;
}
/**
* Required. Requested video annotation features.
* @param features features or {@code null} for none
*/
public GoogleCloudVideointelligenceV1AnnotateVideoRequest setFeatures(java.util.List<java.lang.String> features) {
this.features = features;
return this;
}
/**
* The video data bytes. If unset, the input video(s) should be specified via the `input_uri`. If
* set, `input_uri` must be unset.
* @see #decodeInputContent()
* @return value or {@code null} for none
*/
public java.lang.String getInputContent() {
return inputContent;
}
/**
* The video data bytes. If unset, the input video(s) should be specified via the `input_uri`. If
* set, `input_uri` must be unset.
* @see #getInputContent()
* @return Base64 decoded value or {@code null} for none
*
* @since 1.14
*/
public byte[] decodeInputContent() {
return com.google.api.client.util.Base64.decodeBase64(inputContent);
}
/**
* The video data bytes. If unset, the input video(s) should be specified via the `input_uri`. If
* set, `input_uri` must be unset.
* @see #encodeInputContent()
* @param inputContent inputContent or {@code null} for none
*/
public GoogleCloudVideointelligenceV1AnnotateVideoRequest setInputContent(java.lang.String inputContent) {
this.inputContent = inputContent;
return this;
}
/**
* The video data bytes. If unset, the input video(s) should be specified via the `input_uri`. If
* set, `input_uri` must be unset.
* @see #setInputContent()
*
* <p>
* The value is encoded Base64 or {@code null} for none.
* </p>
*
* @since 1.14
*/
public GoogleCloudVideointelligenceV1AnnotateVideoRequest encodeInputContent(byte[] inputContent) {
this.inputContent = com.google.api.client.util.Base64.encodeBase64URLSafeString(inputContent);
return this;
}
/**
* Input video location. Currently, only [Cloud Storage](https://cloud.google.com/storage/) URIs
* are supported. URIs must be specified in the following format: `gs://bucket-id/object-id`
* (other URI formats return google.rpc.Code.INVALID_ARGUMENT). For more information, see [Request
* URIs](https://cloud.google.com/storage/docs/request-endpoints). To identify multiple videos, a
* video URI may include wildcards in the `object-id`. Supported wildcards: '*' to match 0 or more
* characters; '?' to match 1 character. If unset, the input video should be embedded in the
* request as `input_content`. If set, `input_content` must be unset.
* @return value or {@code null} for none
*/
public java.lang.String getInputUri() {
return inputUri;
}
/**
* Input video location. Currently, only [Cloud Storage](https://cloud.google.com/storage/) URIs
* are supported. URIs must be specified in the following format: `gs://bucket-id/object-id`
* (other URI formats return google.rpc.Code.INVALID_ARGUMENT). For more information, see [Request
* URIs](https://cloud.google.com/storage/docs/request-endpoints). To identify multiple videos, a
* video URI may include wildcards in the `object-id`. Supported wildcards: '*' to match 0 or more
* characters; '?' to match 1 character. If unset, the input video should be embedded in the
* request as `input_content`. If set, `input_content` must be unset.
* @param inputUri inputUri or {@code null} for none
*/
public GoogleCloudVideointelligenceV1AnnotateVideoRequest setInputUri(java.lang.String inputUri) {
this.inputUri = inputUri;
return this;
}
/**
* Optional. Cloud region where annotation should take place. Supported cloud regions are: `us-
* east1`, `us-west1`, `europe-west1`, `asia-east1`. If no region is specified, the region will be
* determined based on video file location.
* @return value or {@code null} for none
*/
public java.lang.String getLocationId() {
return locationId;
}
/**
* Optional. Cloud region where annotation should take place. Supported cloud regions are: `us-
* east1`, `us-west1`, `europe-west1`, `asia-east1`. If no region is specified, the region will be
* determined based on video file location.
* @param locationId locationId or {@code null} for none
*/
public GoogleCloudVideointelligenceV1AnnotateVideoRequest setLocationId(java.lang.String locationId) {
this.locationId = locationId;
return this;
}
/**
* Optional. Location where the output (in JSON format) should be stored. Currently, only [Cloud
* Storage](https://cloud.google.com/storage/) URIs are supported. These must be specified in the
* following format: `gs://bucket-id/object-id` (other URI formats return
* google.rpc.Code.INVALID_ARGUMENT). For more information, see [Request
* URIs](https://cloud.google.com/storage/docs/request-endpoints).
* @return value or {@code null} for none
*/
public java.lang.String getOutputUri() {
return outputUri;
}
/**
* Optional. Location where the output (in JSON format) should be stored. Currently, only [Cloud
* Storage](https://cloud.google.com/storage/) URIs are supported. These must be specified in the
* following format: `gs://bucket-id/object-id` (other URI formats return
* google.rpc.Code.INVALID_ARGUMENT). For more information, see [Request
* URIs](https://cloud.google.com/storage/docs/request-endpoints).
* @param outputUri outputUri or {@code null} for none
*/
public GoogleCloudVideointelligenceV1AnnotateVideoRequest setOutputUri(java.lang.String outputUri) {
this.outputUri = outputUri;
return this;
}
/**
* Additional video context and/or feature-specific parameters.
* @return value or {@code null} for none
*/
public GoogleCloudVideointelligenceV1VideoContext getVideoContext() {
return videoContext;
}
/**
* Additional video context and/or feature-specific parameters.
* @param videoContext videoContext or {@code null} for none
*/
public GoogleCloudVideointelligenceV1AnnotateVideoRequest setVideoContext(GoogleCloudVideointelligenceV1VideoContext videoContext) {
this.videoContext = videoContext;
return this;
}
@Override
public GoogleCloudVideointelligenceV1AnnotateVideoRequest set(String fieldName, Object value) {
return (GoogleCloudVideointelligenceV1AnnotateVideoRequest) super.set(fieldName, value);
}
@Override
public GoogleCloudVideointelligenceV1AnnotateVideoRequest clone() {
return (GoogleCloudVideointelligenceV1AnnotateVideoRequest) super.clone();
}
}
| 3,336 |
1,350 | <filename>sdk/cosmos/azure-cosmos/src/main/java/com/azure/cosmos/models/CosmosItemOperation.java
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
package com.azure.cosmos.models;
/**
* Encapsulates Cosmos Item Operation
*/
public interface CosmosItemOperation {
/**
* @return the id.
*/
String getId();
/**
* @return the partition key value.
*/
PartitionKey getPartitionKeyValue();
/**
* @return the operation type.
*/
CosmosItemOperationType getOperationType();
/**
* @param <T> type of the item.
* @return the item.
*/
<T> T getItem();
/**
* @param <T> type of the context.
* @return the context.
*/
<T> T getContext();
}
| 294 |
1,144 | /** Generated Model - DO NOT CHANGE */
package org.compiere.model;
import java.sql.ResultSet;
import java.util.Properties;
/** Generated Model for AD_Window_Access
* @author Adempiere (generated)
*/
@SuppressWarnings("javadoc")
public class X_AD_Window_Access extends org.compiere.model.PO implements I_AD_Window_Access, org.compiere.model.I_Persistent
{
/**
*
*/
private static final long serialVersionUID = -1015854001L;
/** Standard Constructor */
public X_AD_Window_Access (Properties ctx, int AD_Window_Access_ID, String trxName)
{
super (ctx, AD_Window_Access_ID, trxName);
/** if (AD_Window_Access_ID == 0)
{
setAD_Role_ID (0);
setAD_Window_Access_ID (0);
setAD_Window_ID (0);
setIsReadWrite (false);
} */
}
/** Load Constructor */
public X_AD_Window_Access (Properties ctx, ResultSet rs, String trxName)
{
super (ctx, rs, trxName);
}
/** Load Meta Data */
@Override
protected org.compiere.model.POInfo initPO (Properties ctx)
{
org.compiere.model.POInfo poi = org.compiere.model.POInfo.getPOInfo (ctx, Table_Name, get_TrxName());
return poi;
}
@Override
public org.compiere.model.I_AD_Role getAD_Role() throws RuntimeException
{
return get_ValueAsPO(COLUMNNAME_AD_Role_ID, org.compiere.model.I_AD_Role.class);
}
@Override
public void setAD_Role(org.compiere.model.I_AD_Role AD_Role)
{
set_ValueFromPO(COLUMNNAME_AD_Role_ID, org.compiere.model.I_AD_Role.class, AD_Role);
}
/** Set Rolle.
@param AD_Role_ID
Responsibility Role
*/
@Override
public void setAD_Role_ID (int AD_Role_ID)
{
if (AD_Role_ID < 0)
set_ValueNoCheck (COLUMNNAME_AD_Role_ID, null);
else
set_ValueNoCheck (COLUMNNAME_AD_Role_ID, Integer.valueOf(AD_Role_ID));
}
/** Get Rolle.
@return Responsibility Role
*/
@Override
public int getAD_Role_ID ()
{
Integer ii = (Integer)get_Value(COLUMNNAME_AD_Role_ID);
if (ii == null)
return 0;
return ii.intValue();
}
/** Set AD_Window_Access.
@param AD_Window_Access_ID AD_Window_Access */
@Override
public void setAD_Window_Access_ID (int AD_Window_Access_ID)
{
if (AD_Window_Access_ID < 1)
set_ValueNoCheck (COLUMNNAME_AD_Window_Access_ID, null);
else
set_ValueNoCheck (COLUMNNAME_AD_Window_Access_ID, Integer.valueOf(AD_Window_Access_ID));
}
/** Get AD_Window_Access.
@return AD_Window_Access */
@Override
public int getAD_Window_Access_ID ()
{
Integer ii = (Integer)get_Value(COLUMNNAME_AD_Window_Access_ID);
if (ii == null)
return 0;
return ii.intValue();
}
@Override
public org.compiere.model.I_AD_Window getAD_Window() throws RuntimeException
{
return get_ValueAsPO(COLUMNNAME_AD_Window_ID, org.compiere.model.I_AD_Window.class);
}
@Override
public void setAD_Window(org.compiere.model.I_AD_Window AD_Window)
{
set_ValueFromPO(COLUMNNAME_AD_Window_ID, org.compiere.model.I_AD_Window.class, AD_Window);
}
/** Set Fenster.
@param AD_Window_ID
Data entry or display window
*/
@Override
public void setAD_Window_ID (int AD_Window_ID)
{
if (AD_Window_ID < 1)
set_ValueNoCheck (COLUMNNAME_AD_Window_ID, null);
else
set_ValueNoCheck (COLUMNNAME_AD_Window_ID, Integer.valueOf(AD_Window_ID));
}
/** Get Fenster.
@return Data entry or display window
*/
@Override
public int getAD_Window_ID ()
{
Integer ii = (Integer)get_Value(COLUMNNAME_AD_Window_ID);
if (ii == null)
return 0;
return ii.intValue();
}
/** Set Lesen und Schreiben.
@param IsReadWrite
Field is read / write
*/
@Override
public void setIsReadWrite (boolean IsReadWrite)
{
set_Value (COLUMNNAME_IsReadWrite, Boolean.valueOf(IsReadWrite));
}
/** Get Lesen und Schreiben.
@return Field is read / write
*/
@Override
public boolean isReadWrite ()
{
Object oo = get_Value(COLUMNNAME_IsReadWrite);
if (oo != null)
{
if (oo instanceof Boolean)
return ((Boolean)oo).booleanValue();
return "Y".equals(oo);
}
return false;
}
} | 1,662 |
401 | <filename>tests/test_savepoints.py
import pytest
from tests import TestCase
class TestSavepoints(TestCase):
def test_flush_and_nested_rollback(self):
article = self.Article(name=u'Some article')
self.session.add(article)
self.session.flush()
self.session.begin_nested()
self.session.add(self.Article(name=u'Some article'))
article.name = u'Updated name'
self.session.rollback()
self.session.commit()
assert article.versions.count() == 1
assert article.versions[-1].name == u'Some article'
def test_partial_rollback(self):
article = self.Article(name=u'Some article')
self.session.add(article)
self.session.begin_nested()
self.session.add(self.Article(name=u'Some article'))
article.name = u'Updated name'
self.session.rollback()
self.session.commit()
assert article.versions.count() == 1
assert article.versions[-1].name == u'Some article'
def test_multiple_savepoints(self):
if self.driver == 'sqlite':
pytest.skip()
article = self.Article(name=u'Some article')
self.session.add(article)
self.session.flush()
self.session.begin_nested()
article.name = u'Updated name'
self.session.commit()
self.session.begin_nested()
article.name = u'Another article'
self.session.commit()
self.session.commit()
assert article.versions.count() == 1
assert article.versions[-1].name == u'Another article'
| 661 |
647 | <reponame>gilbertguoze/trick<filename>include/trick/TrickConstant.hh
/*
PURPOSE:
(All defined constant variables.)
*/
#ifndef TRICKCONSTANT_HH
#define TRICKCONSTANT_HH
#define TRICK_MAX_LONG_LONG 9223372036854775807LL
#endif
| 104 |
1,736 | <filename>examples/parallel_for/polygon_overlay/polyover.cpp
/*
Copyright (c) 2005-2021 Intel 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.
*/
// Polygon overlay
//
#include <cstdlib>
#include <cstring>
#include <cassert>
#include <iostream>
#include <algorithm>
#include "oneapi/tbb/tick_count.h"
#include "oneapi/tbb/blocked_range.h"
#include "oneapi/tbb/parallel_for.h"
#include "oneapi/tbb/spin_mutex.h"
#include "oneapi/tbb/global_control.h"
#include "common/utility/get_default_num_threads.hpp"
#include "polyover.hpp"
#include "polymain.hpp"
#include "pover_video.hpp"
/*!
* @brief intersects a polygon with a map, adding any results to output map
*
* @param[out] resultMap output map (must be allocated)
* @param[in] polygon to be intersected
* @param[in] map intersected against
* @param[in] lock to use when adding output polygons to result map
*
*/
void OverlayOnePolygonWithMap(Polygon_map_t *resultMap,
RPolygon *myPoly,
Polygon_map_t *map2,
oneapi::tbb::spin_mutex *rMutex) {
int r1, g1, b1, r2, g2, b2;
int myr = 0;
int myg = 0;
int myb = 0;
int p1Area = myPoly->area();
for (unsigned int j = 1; (j < map2->size()) && (p1Area > 0); j++) {
RPolygon *p2 = &((*map2)[j]);
RPolygon *pnew;
int newxMin, newxMax, newyMin, newyMax;
myPoly->getColor(&r1, &g1, &b1);
if (PolygonsOverlap(myPoly, p2, newxMin, newyMin, newxMax, newyMax)) {
p2->getColor(&r2, &g2, &b2);
myr = r1 + r2;
myg = g1 + g2;
myb = b1 + b2;
p1Area -= (newxMax - newxMin + 1) * (newyMax - newyMin + 1);
if (rMutex) {
oneapi::tbb::spin_mutex::scoped_lock lock(*rMutex);
resultMap->push_back(RPolygon(newxMin, newyMin, newxMax, newyMax, myr, myg, myb));
}
else {
resultMap->push_back(RPolygon(newxMin, newyMin, newxMax, newyMax, myr, myg, myb));
}
}
}
}
/*!
* @brief Serial version of polygon overlay
* @param[out] output map
* @param[in] first map (map that individual polygons are taken from)
* @param[in] second map (map passed to OverlayOnePolygonWithMap)
*/
void SerialOverlayMaps(Polygon_map_t **resultMap, Polygon_map_t *map1, Polygon_map_t *map2) {
std::cout << "SerialOverlayMaps called"
<< "\n";
*resultMap = new Polygon_map_t;
RPolygon *p0 = &((*map1)[0]);
int mapxSize, mapySize, ignore1, ignore2;
p0->get(&ignore1, &ignore2, &mapxSize, &mapySize);
(*resultMap)->reserve(mapxSize * mapySize); // can't be any bigger than this
// push the map size as the first polygon,
(*resultMap)->push_back(RPolygon(0, 0, mapxSize, mapySize));
for (unsigned int i = 1; i < map1->size(); i++) {
RPolygon *p1 = &((*map1)[i]);
OverlayOnePolygonWithMap(*resultMap, p1, map2, nullptr);
}
}
/*!
* @class ApplyOverlay
* @brief Simple version of parallel overlay (make parallel on polygons in map1)
*/
class ApplyOverlay {
Polygon_map_t *m_map1, *m_map2, *m_resultMap;
oneapi::tbb::spin_mutex *m_rMutex;
public:
/*!
* @brief functor to apply
* @param[in] r range of polygons to intersect from map1
*/
void operator()(const oneapi::tbb::blocked_range<int> &r) const {
PRINT_DEBUG("From " << r.begin() << " to " << r.end());
for (int i = r.begin(); i != r.end(); i++) {
RPolygon *myPoly = &((*m_map1)[i]);
OverlayOnePolygonWithMap(m_resultMap, myPoly, m_map2, m_rMutex);
}
}
ApplyOverlay(Polygon_map_t *resultMap,
Polygon_map_t *map1,
Polygon_map_t *map2,
oneapi::tbb::spin_mutex *rmutex)
: m_resultMap(resultMap),
m_map1(map1),
m_map2(map2),
m_rMutex(rmutex) {}
};
/*!
* @brief apply the parallel algorithm
* @param[out] result_map generated map
* @param[in] polymap1 first map to be applied (algorithm is parallel on this map)
* @param[in] polymap2 second map.
*/
void NaiveParallelOverlay(Polygon_map_t *&result_map,
Polygon_map_t &polymap1,
Polygon_map_t &polymap2) {
// -----------------------------------
bool automatic_threadcount = false;
if (gThreadsLow == THREADS_UNSET || gThreadsLow == utility::get_default_num_threads()) {
gThreadsLow = gThreadsHigh = utility::get_default_num_threads();
automatic_threadcount = true;
}
result_map = new Polygon_map_t;
RPolygon *p0 = &(polymap1[0]);
int mapxSize, mapySize, ignore1, ignore2;
p0->get(&ignore1, &ignore2, &mapxSize, &mapySize);
result_map->reserve(mapxSize * mapySize); // can't be any bigger than this
// push the map size as the first polygon,
oneapi::tbb::spin_mutex *resultMutex = new oneapi::tbb::spin_mutex();
int grain_size = gGrainSize;
for (int nthreads = gThreadsLow; nthreads <= gThreadsHigh; nthreads++) {
oneapi::tbb::global_control c(oneapi::tbb::global_control::max_allowed_parallelism,
nthreads);
if (gIsGraphicalVersion) {
RPolygon *xp =
new RPolygon(0, 0, gMapXSize - 1, gMapYSize - 1, 0, 0, 0); // Clear the output space
delete xp;
}
// put size polygon in result map
result_map->push_back(RPolygon(0, 0, mapxSize, mapySize));
oneapi::tbb::tick_count t0 = oneapi::tbb::tick_count::now();
oneapi::tbb::parallel_for(
oneapi::tbb::blocked_range<int>(1, (int)(polymap1.size()), grain_size),
ApplyOverlay(result_map, &polymap1, &polymap2, resultMutex));
oneapi::tbb::tick_count t1 = oneapi::tbb::tick_count::now();
double naiveParallelTime = (t1 - t0).seconds() * 1000;
std::cout << "Naive parallel with spin lock and ";
if (automatic_threadcount)
std::cout << "automatic";
else
std::cout << nthreads;
std::cout << ((nthreads == 1) ? " thread" : " threads");
std::cout << " took " << naiveParallelTime << " msec : speedup over serial "
<< (gSerialTime / naiveParallelTime) << "\n";
if (gCsvFile.is_open()) {
gCsvFile << "," << naiveParallelTime;
}
#if _DEBUG
CheckPolygonMap(result_map);
ComparePolygonMaps(result_map, gResultMap);
#endif
result_map->clear();
}
delete resultMutex;
if (gCsvFile.is_open()) {
gCsvFile << "\n";
}
// -----------------------------------
}
template <typename T>
void split_at(Flagged_map_t &in_map,
Flagged_map_t &left_out,
Flagged_map_t &right_out,
const T median) {
left_out.reserve(in_map.size());
right_out.reserve(in_map.size());
for (Flagged_map_t::iterator i = in_map.begin(); i != in_map.end(); ++i) {
RPolygon *p = i->p();
if (p->xmax() < median) {
// in left map
left_out.push_back(*i);
}
else if (p->xmin() >= median) {
right_out.push_back(*i);
// in right map
}
else {
// in both maps.
left_out.push_back(*i);
right_out.push_back(RPolygon_flagged(p, true));
}
}
}
// range that splits the maps as well as the range. the flagged_map_t are
// vectors of pointers, and each range owns its maps (has to free them on destruction.)
template <typename T>
class blocked_range_with_maps {
typedef oneapi::tbb::blocked_range<T> my_range_type;
private:
my_range_type my_range;
Flagged_map_t my_map1;
Flagged_map_t my_map2;
public:
blocked_range_with_maps(T begin,
T end,
typename my_range_type::size_type my_grainsize,
Polygon_map_t *p1,
Polygon_map_t *p2)
: my_range(begin, end, my_grainsize) {
my_map1.reserve(p1->size());
my_map2.reserve(p2->size());
for (int i = 1; i < p1->size(); ++i) {
my_map1.push_back(RPolygon_flagged(&((*p1)[i]), false));
}
for (int i = 1; i < p2->size(); ++i) {
my_map2.push_back(RPolygon_flagged(&(p2->at(i)), false));
}
}
// copy-constructor required for deep copy of flagged maps. One copy is done at the start of the
// parallel for.
blocked_range_with_maps(const blocked_range_with_maps &other)
: my_range(other.my_range),
my_map1(other.my_map1),
my_map2(other.my_map2) {}
bool empty() const {
return my_range.empty();
}
bool is_divisible() const {
return my_range.is_divisible();
}
#if _DEBUG
void check_my_map() {
assert(my_range.begin() <= my_range.end());
for (Flagged_map_t::iterator i = my_map1.begin(); i != my_map1.end(); ++i) {
RPolygon *rp = i->p();
assert(rp->xmax() >= my_range.begin());
assert(rp->xmin() < my_range.end());
}
for (Flagged_map_t::iterator i = my_map2.begin(); i != my_map2.end(); ++i) {
RPolygon *rp = i->p();
assert(rp->xmax() >= my_range.begin());
assert(rp->xmin() < my_range.end());
}
}
void dump_map(Flagged_map_t &mapx) {
std::cout << " ** MAP **\n";
for (Flagged_map_t::iterator i = mapx.begin(); i != mapx.end(); ++i) {
std::cout << *(i->p());
if (i->isDuplicate()) {
std::cout << " -- is_duplicate";
}
std::cout << "\n";
}
std::cout << "\n";
}
#endif
blocked_range_with_maps(blocked_range_with_maps &lhs_r, oneapi::tbb::split)
: my_range(my_range_type(lhs_r.my_range, oneapi::tbb::split())) {
// lhs_r.my_range makes my_range from [median, high) and rhs_r.my_range from [low, median)
Flagged_map_t original_map1 = lhs_r.my_map1;
Flagged_map_t original_map2 = lhs_r.my_map2;
lhs_r.my_map1.clear();
lhs_r.my_map2.clear();
split_at(original_map1, lhs_r.my_map1, my_map1, my_range.begin());
split_at(original_map2, lhs_r.my_map2, my_map2, my_range.begin());
#if _DEBUG
this->check_my_map();
lhs_r.check_my_map();
#endif
}
const my_range_type &range() const {
return my_range;
}
Flagged_map_t &map1() {
return my_map1;
}
Flagged_map_t &map2() {
return my_map2;
}
};
/*!
* @class ApplySplitOverlay
* @brief parallel by columnar strip
*/
class ApplySplitOverlay {
Polygon_map_t *m_map1, *m_map2, *m_resultMap;
oneapi::tbb::spin_mutex *m_rMutex;
public:
/*!
* @brief functor for columnar parallel version
* @param[in] r range of map to be operated on
*/
void operator()(/*const*/ blocked_range_with_maps<int> &r) const {
#ifdef _DEBUG
// if we are debugging, serialize the method. That way we can
// see what is happening in each strip without the interleaving
// confusing things.
oneapi::tbb::spin_mutex::scoped_lock lock(*m_rMutex);
std::cout << std::unitbuf << "From " << r.range().begin() << " to " << r.range().end() - 1
<< "\n";
#endif
// get yMapSize
int r1, g1, b1, r2, g2, b2;
int myr = -1;
int myg = -1;
int myb = -1;
int i1, i2, i3, yMapSize;
(*m_map1)[0].get(&i1, &i2, &i3, &yMapSize);
Flagged_map_t &fmap1 = r.map1();
Flagged_map_t &fmap2 = r.map2();
// When intersecting polygons from fmap1 and fmap2, if BOTH are flagged
// as duplicate, don't add the result to the output map. We can still
// intersect them, because we are keeping track of how much of the polygon
// is left over from intersecting, and quitting when the polygon is
// used up.
for (unsigned int i = 0; i < fmap1.size(); i++) {
RPolygon *p1 = fmap1[i].p();
bool is_dup = fmap1[i].isDuplicate();
int parea = p1->area();
p1->getColor(&r1, &g1, &b1);
for (unsigned int j = 0; (j < fmap2.size()) && (parea > 0); j++) {
int xl, yl, xh, yh;
RPolygon *p2 = fmap2[j].p();
if (PolygonsOverlap(p1, p2, xl, yl, xh, yh)) {
if (!(is_dup && fmap2[j].isDuplicate())) {
p2->getColor(&r2, &g2, &b2);
myr = r1 + r2;
myg = g1 + g2;
myb = b1 + b2;
#ifdef _DEBUG
#else
oneapi::tbb::spin_mutex::scoped_lock lock(*m_rMutex);
#endif
(*m_resultMap).push_back(RPolygon(xl, yl, xh, yh, myr, myg, myb));
}
parea -= (xh - xl + 1) * (yh - yl + 1);
}
}
}
}
ApplySplitOverlay(Polygon_map_t *resultMap,
Polygon_map_t *map1,
Polygon_map_t *map2,
oneapi::tbb::spin_mutex *rmutex)
: m_resultMap(resultMap),
m_map1(map1),
m_map2(map2),
m_rMutex(rmutex) {}
};
/*!
* @brief intersects two maps strip-wise
*
* @param[out] resultMap output map (must be allocated)
* @param[in] polymap1 map to be intersected
* @param[in] polymap2 map to be intersected
*/
void SplitParallelOverlay(Polygon_map_t **result_map,
Polygon_map_t *polymap1,
Polygon_map_t *polymap2) {
int nthreads;
bool automatic_threadcount = false;
double domainSplitParallelTime;
oneapi::tbb::tick_count t0, t1;
oneapi::tbb::spin_mutex *resultMutex;
if (gThreadsLow == THREADS_UNSET || gThreadsLow == utility::get_default_num_threads()) {
gThreadsLow = gThreadsHigh = utility::get_default_num_threads();
automatic_threadcount = true;
}
*result_map = new Polygon_map_t;
RPolygon *p0 = &((*polymap1)[0]);
int mapxSize, mapySize, ignore1, ignore2;
p0->get(&ignore1, &ignore2, &mapxSize, &mapySize);
(*result_map)->reserve(mapxSize * mapySize); // can't be any bigger than this
resultMutex = new oneapi::tbb::spin_mutex();
int grain_size;
#ifdef _DEBUG
grain_size = gMapXSize / 4;
#else
grain_size = gGrainSize;
#endif
for (nthreads = gThreadsLow; nthreads <= gThreadsHigh; nthreads++) {
oneapi::tbb::global_control c(oneapi::tbb::global_control::max_allowed_parallelism,
nthreads);
if (gIsGraphicalVersion) {
RPolygon *xp =
new RPolygon(0, 0, gMapXSize - 1, gMapYSize - 1, 0, 0, 0); // Clear the output space
delete xp;
}
// push the map size as the first polygon,
(*result_map)->push_back(RPolygon(0, 0, mapxSize, mapySize));
t0 = oneapi::tbb::tick_count::now();
oneapi::tbb::parallel_for(
blocked_range_with_maps<int>(0, (int)(mapxSize + 1), grain_size, polymap1, polymap2),
ApplySplitOverlay((*result_map), polymap1, polymap2, resultMutex));
t1 = oneapi::tbb::tick_count::now();
domainSplitParallelTime = (t1 - t0).seconds() * 1000;
std::cout << "Splitting parallel with spin lock and ";
if (automatic_threadcount)
std::cout << "automatic";
else
std::cout << nthreads;
std::cout << ((nthreads == 1) ? " thread" : " threads");
std::cout << " took " << domainSplitParallelTime << " msec : speedup over serial "
<< (gSerialTime / domainSplitParallelTime) << "\n";
if (gCsvFile.is_open()) {
gCsvFile << "," << domainSplitParallelTime;
}
#if _DEBUG
CheckPolygonMap(*result_map);
ComparePolygonMaps(*result_map, gResultMap);
#endif
(*result_map)->clear();
}
delete resultMutex;
if (gCsvFile.is_open()) {
gCsvFile << "\n";
}
}
class ApplySplitOverlayCV {
Polygon_map_t *m_map1, *m_map2;
concurrent_Polygon_map_t *m_resultMap;
public:
/*!
* @brief functor for columnar parallel version
* @param[in] r range of map to be operated on
*/
void operator()(blocked_range_with_maps<int> &r) const {
// get yMapSize
int r1, g1, b1, r2, g2, b2;
int myr = -1;
int myg = -1;
int myb = -1;
int i1, i2, i3, yMapSize;
(*m_map1)[0].get(&i1, &i2, &i3, &yMapSize);
Flagged_map_t &fmap1 = r.map1();
Flagged_map_t &fmap2 = r.map2();
// When intersecting polygons from fmap1 and fmap2, if BOTH are flagged
// as duplicate, don't add the result to the output map. We can still
// intersect them, because we are keeping track of how much of the polygon
// is left over from intersecting, and quitting when the polygon is
// used up.
for (unsigned int i = 0; i < fmap1.size(); i++) {
RPolygon *p1 = fmap1[i].p();
bool is_dup = fmap1[i].isDuplicate();
int parea = p1->area();
p1->getColor(&r1, &g1, &b1);
for (unsigned int j = 0; (j < fmap2.size()) && (parea > 0); j++) {
int xl, yl, xh, yh;
RPolygon *p2 = fmap2[j].p();
if (PolygonsOverlap(p1, p2, xl, yl, xh, yh)) {
if (!(is_dup && fmap2[j].isDuplicate())) {
p2->getColor(&r2, &g2, &b2);
myr = r1 + r2;
myg = g1 + g2;
myb = b1 + b2;
(*m_resultMap).push_back(RPolygon(xl, yl, xh, yh, myr, myg, myb));
}
parea -= (xh - xl + 1) * (yh - yl + 1);
}
}
}
}
ApplySplitOverlayCV(concurrent_Polygon_map_t *resultMap,
Polygon_map_t *map1,
Polygon_map_t *map2)
: m_resultMap(resultMap),
m_map1(map1),
m_map2(map2) {}
};
/*!
* @brief intersects two maps strip-wise, accumulating into a concurrent_vector
*
* @param[out] resultMap output map (must be allocated)
* @param[in] polymap1 map to be intersected
* @param[in] polymap2 map to be intersected
*/
void SplitParallelOverlayCV(concurrent_Polygon_map_t **result_map,
Polygon_map_t *polymap1,
Polygon_map_t *polymap2) {
int nthreads;
bool automatic_threadcount = false;
double domainSplitParallelTime;
oneapi::tbb::tick_count t0, t1;
if (gThreadsLow == THREADS_UNSET || gThreadsLow == utility::get_default_num_threads()) {
gThreadsLow = gThreadsHigh = utility::get_default_num_threads();
automatic_threadcount = true;
}
*result_map = new concurrent_Polygon_map_t;
RPolygon *p0 = &((*polymap1)[0]);
int mapxSize, mapySize, ignore1, ignore2;
p0->get(&ignore1, &ignore2, &mapxSize, &mapySize);
// (*result_map)->reserve(mapxSize*mapySize); // can't be any bigger than this
int grain_size;
#ifdef _DEBUG
grain_size = gMapXSize / 4;
#else
grain_size = gGrainSize;
#endif
for (nthreads = gThreadsLow; nthreads <= gThreadsHigh; nthreads++) {
oneapi::tbb::global_control c(oneapi::tbb::global_control::max_allowed_parallelism,
nthreads);
if (gIsGraphicalVersion) {
RPolygon *xp =
new RPolygon(0, 0, gMapXSize - 1, gMapYSize - 1, 0, 0, 0); // Clear the output space
delete xp;
}
// push the map size as the first polygon,
(*result_map)->push_back(RPolygon(0, 0, mapxSize, mapySize));
t0 = oneapi::tbb::tick_count::now();
oneapi::tbb::parallel_for(
blocked_range_with_maps<int>(0, (int)(mapxSize + 1), grain_size, polymap1, polymap2),
ApplySplitOverlayCV((*result_map), polymap1, polymap2));
t1 = oneapi::tbb::tick_count::now();
domainSplitParallelTime = (t1 - t0).seconds() * 1000;
std::cout << "Splitting parallel with concurrent_vector and ";
if (automatic_threadcount)
std::cout << "automatic";
else
std::cout << nthreads;
std::cout << ((nthreads == 1) ? " thread" : " threads");
std::cout << " took " << domainSplitParallelTime << " msec : speedup over serial "
<< (gSerialTime / domainSplitParallelTime) << "\n";
if (gCsvFile.is_open()) {
gCsvFile << "," << domainSplitParallelTime;
}
#if _DEBUG
{
Polygon_map_t s_result_map;
for (concurrent_Polygon_map_t::const_iterator i = (*result_map)->begin();
i != (*result_map)->end();
++i) {
s_result_map.push_back(*i);
}
CheckPolygonMap(&s_result_map);
ComparePolygonMaps(&s_result_map, gResultMap);
}
#endif
(*result_map)->clear();
}
if (gCsvFile.is_open()) {
gCsvFile << "\n";
}
}
// ------------------------------------------------------
class ApplySplitOverlayETS {
Polygon_map_t *m_map1, *m_map2;
ETS_Polygon_map_t *m_resultMap;
public:
/*!
* @brief functor for columnar parallel version
* @param[in] r range of map to be operated on
*/
void operator()(blocked_range_with_maps<int> &r) const {
// get yMapSize
int r1, g1, b1, r2, g2, b2;
int myr = -1;
int myg = -1;
int myb = -1;
int i1, i2, i3, yMapSize;
(*m_map1)[0].get(&i1, &i2, &i3, &yMapSize);
Flagged_map_t &fmap1 = r.map1();
Flagged_map_t &fmap2 = r.map2();
// When intersecting polygons from fmap1 and fmap2, if BOTH are flagged
// as duplicate, don't add the result to the output map. We can still
// intersect them, because we are keeping track of how much of the polygon
// is left over from intersecting, and quitting when the polygon is
// used up.
for (unsigned int i = 0; i < fmap1.size(); i++) {
RPolygon *p1 = fmap1[i].p();
bool is_dup = fmap1[i].isDuplicate();
int parea = p1->area();
p1->getColor(&r1, &g1, &b1);
for (unsigned int j = 0; (j < fmap2.size()) && (parea > 0); j++) {
int xl, yl, xh, yh;
RPolygon *p2 = fmap2[j].p();
if (PolygonsOverlap(p1, p2, xl, yl, xh, yh)) {
if (!(is_dup && fmap2[j].isDuplicate())) {
p2->getColor(&r2, &g2, &b2);
myr = r1 + r2;
myg = g1 + g2;
myb = b1 + b2;
(*m_resultMap).local().push_back(RPolygon(xl, yl, xh, yh, myr, myg, myb));
}
parea -= (xh - xl + 1) * (yh - yl + 1);
}
}
}
}
ApplySplitOverlayETS(ETS_Polygon_map_t *resultMap, Polygon_map_t *map1, Polygon_map_t *map2)
: m_resultMap(resultMap),
m_map1(map1),
m_map2(map2) {}
};
/*!
* @brief intersects two maps strip-wise, accumulating into an ets variable
*
* @param[out] resultMap output map (must be allocated)
* @param[in] polymap1 map to be intersected
* @param[in] polymap2 map to be intersected
*/
void SplitParallelOverlayETS(ETS_Polygon_map_t **result_map,
Polygon_map_t *polymap1,
Polygon_map_t *polymap2) {
int nthreads;
bool automatic_threadcount = false;
double domainSplitParallelTime;
oneapi::tbb::tick_count t0, t1;
if (gThreadsLow == THREADS_UNSET || gThreadsLow == utility::get_default_num_threads()) {
gThreadsLow = gThreadsHigh = utility::get_default_num_threads();
automatic_threadcount = true;
}
*result_map = new ETS_Polygon_map_t;
RPolygon *p0 = &((*polymap1)[0]);
int mapxSize, mapySize, ignore1, ignore2;
p0->get(&ignore1, &ignore2, &mapxSize, &mapySize);
// (*result_map)->reserve(mapxSize*mapySize); // can't be any bigger than this
int grain_size;
#ifdef _DEBUG
grain_size = gMapXSize / 4;
#else
grain_size = gGrainSize;
#endif
for (nthreads = gThreadsLow; nthreads <= gThreadsHigh; nthreads++) {
oneapi::tbb::global_control c(oneapi::tbb::global_control::max_allowed_parallelism,
nthreads);
if (gIsGraphicalVersion) {
RPolygon *xp =
new RPolygon(0, 0, gMapXSize - 1, gMapYSize - 1, 0, 0, 0); // Clear the output space
delete xp;
}
// push the map size as the first polygon,
// This polygon needs to be first, so we can push it at the start of a combine.
// (*result_map)->local.push_back(RPolygon(0,0,mapxSize, mapySize));
t0 = oneapi::tbb::tick_count::now();
oneapi::tbb::parallel_for(
blocked_range_with_maps<int>(0, (int)(mapxSize + 1), grain_size, polymap1, polymap2),
ApplySplitOverlayETS((*result_map), polymap1, polymap2));
t1 = oneapi::tbb::tick_count::now();
domainSplitParallelTime = (t1 - t0).seconds() * 1000;
std::cout << "Splitting parallel with ETS and ";
if (automatic_threadcount)
std::cout << "automatic";
else
std::cout << nthreads;
std::cout << ((nthreads == 1) ? " thread" : " threads");
std::cout << " took " << domainSplitParallelTime << " msec : speedup over serial "
<< (gSerialTime / domainSplitParallelTime) << "\n";
if (gCsvFile.is_open()) {
gCsvFile << "," << domainSplitParallelTime;
}
#if _DEBUG
{
Polygon_map_t s_result_map;
oneapi::tbb::flattened2d<ETS_Polygon_map_t> psv = flatten2d(**result_map);
s_result_map.push_back(RPolygon(0, 0, mapxSize, mapySize));
for (oneapi::tbb::flattened2d<ETS_Polygon_map_t>::const_iterator ci = psv.begin();
ci != psv.end();
++ci) {
s_result_map.push_back(*ci);
}
CheckPolygonMap(&s_result_map);
ComparePolygonMaps(&s_result_map, gResultMap);
}
#endif
(*result_map)->clear();
}
if (gCsvFile.is_open()) {
gCsvFile << "\n";
}
}
| 13,524 |
360 | /*
* contrib/btree_gist/btree_bytea.c
*/
#include "postgres.h"
#include "knl/knl_variable.h"
#include "btree_gist.h"
#include "btree_utils_var.h"
#include "utils/bytea.h"
/*
** Bytea ops
*/
PG_FUNCTION_INFO_V1(gbt_bytea_compress);
PG_FUNCTION_INFO_V1(gbt_bytea_union);
PG_FUNCTION_INFO_V1(gbt_bytea_picksplit);
PG_FUNCTION_INFO_V1(gbt_bytea_consistent);
PG_FUNCTION_INFO_V1(gbt_bytea_penalty);
PG_FUNCTION_INFO_V1(gbt_bytea_same);
extern "C" Datum gbt_bytea_compress(PG_FUNCTION_ARGS);
extern "C" Datum gbt_bytea_union(PG_FUNCTION_ARGS);
extern "C" Datum gbt_bytea_picksplit(PG_FUNCTION_ARGS);
extern "C" Datum gbt_bytea_consistent(PG_FUNCTION_ARGS);
extern "C" Datum gbt_bytea_penalty(PG_FUNCTION_ARGS);
extern "C" Datum gbt_bytea_same(PG_FUNCTION_ARGS);
/* define for comparison */
static bool gbt_byteagt(const void* a, const void* b, Oid collation)
{
return DatumGetBool(DirectFunctionCall2(byteagt, PointerGetDatum(a), PointerGetDatum(b)));
}
static bool gbt_byteage(const void* a, const void* b, Oid collation)
{
return DatumGetBool(DirectFunctionCall2(byteage, PointerGetDatum(a), PointerGetDatum(b)));
}
static bool gbt_byteaeq(const void* a, const void* b, Oid collation)
{
return DatumGetBool(DirectFunctionCall2(byteaeq, PointerGetDatum(a), PointerGetDatum(b)));
}
static bool gbt_byteale(const void* a, const void* b, Oid collation)
{
return DatumGetBool(DirectFunctionCall2(byteale, PointerGetDatum(a), PointerGetDatum(b)));
}
static bool gbt_bytealt(const void* a, const void* b, Oid collation)
{
return DatumGetBool(DirectFunctionCall2(bytealt, PointerGetDatum(a), PointerGetDatum(b)));
}
static int32 gbt_byteacmp(const void* a, const void* b, Oid collation)
{
return DatumGetInt32(DirectFunctionCall2(byteacmp, PointerGetDatum(a), PointerGetDatum(b)));
}
static const gbtree_vinfo tinfo = {
gbt_t_bytea, 0, TRUE, gbt_byteagt, gbt_byteage, gbt_byteaeq, gbt_byteale, gbt_bytealt, gbt_byteacmp, NULL};
/**************************************************
* Text ops
**************************************************/
Datum gbt_bytea_compress(PG_FUNCTION_ARGS)
{
GISTENTRY* entry = (GISTENTRY*)PG_GETARG_POINTER(0);
PG_RETURN_POINTER(gbt_var_compress(entry, &tinfo));
}
Datum gbt_bytea_consistent(PG_FUNCTION_ARGS)
{
GISTENTRY* entry = (GISTENTRY*)PG_GETARG_POINTER(0);
void* query = (void*)DatumGetByteaP(PG_GETARG_DATUM(1));
StrategyNumber strategy = (StrategyNumber)PG_GETARG_UINT16(2);
bool* recheck = (bool*)PG_GETARG_POINTER(4);
bool retval = false;
GBT_VARKEY* key = (GBT_VARKEY*)DatumGetPointer(entry->key);
GBT_VARKEY_R r = gbt_var_key_readable(key);
/* All cases served by this function are exact */
*recheck = false;
retval = gbt_var_consistent(&r, query, strategy, PG_GET_COLLATION(), GIST_LEAF(entry), &tinfo);
PG_RETURN_BOOL(retval);
}
Datum gbt_bytea_union(PG_FUNCTION_ARGS)
{
GistEntryVector* entryvec = (GistEntryVector*)PG_GETARG_POINTER(0);
int32* size = (int*)PG_GETARG_POINTER(1);
PG_RETURN_POINTER(gbt_var_union(entryvec, size, PG_GET_COLLATION(), &tinfo));
}
Datum gbt_bytea_picksplit(PG_FUNCTION_ARGS)
{
GistEntryVector* entryvec = (GistEntryVector*)PG_GETARG_POINTER(0);
GIST_SPLITVEC* v = (GIST_SPLITVEC*)PG_GETARG_POINTER(1);
gbt_var_picksplit(entryvec, v, PG_GET_COLLATION(), &tinfo);
PG_RETURN_POINTER(v);
}
Datum gbt_bytea_same(PG_FUNCTION_ARGS)
{
Datum d1 = PG_GETARG_DATUM(0);
Datum d2 = PG_GETARG_DATUM(1);
bool* result = (bool*)PG_GETARG_POINTER(2);
*result = gbt_var_same(d1, d2, PG_GET_COLLATION(), &tinfo);
PG_RETURN_POINTER(result);
}
Datum gbt_bytea_penalty(PG_FUNCTION_ARGS)
{
GISTENTRY* o = (GISTENTRY*)PG_GETARG_POINTER(0);
GISTENTRY* n = (GISTENTRY*)PG_GETARG_POINTER(1);
float* result = (float*)PG_GETARG_POINTER(2);
PG_RETURN_POINTER(gbt_var_penalty(result, o, n, PG_GET_COLLATION(), &tinfo));
}
| 1,751 |
643 | <reponame>wbarbosa0/hellokoding-courses<gh_stars>100-1000
package com.hellokoding.spring;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Component;
import org.springframework.web.reactive.function.server.ServerRequest;
import org.springframework.web.reactive.function.server.ServerResponse;
import reactor.core.publisher.Mono;
@Component
public class HelloHandler {
public Mono<ServerResponse> hello(ServerRequest request) {
String name = request
.queryParam("name")
.orElse("Spring WebFlux");
return ServerResponse.ok()
.contentType(MediaType.TEXT_PLAIN)
.bodyValue(String.format("Hello, %s!", name));
}
}
| 262 |
6,238 | import ujson
from typing import Optional
from .base import SessionEngine, Session
try:
from cryptography.fernet import Fernet
except ImportError:
raise ImportError('To use encrypted sessions you need to install the cryptography library or implement your own '
'engine by extending the SessionEngine class.')
class EncryptedCookiesEngine(SessionEngine):
def __init__(self, cookie_name='vibora', secret_key=None):
super().__init__(cookie_name=cookie_name)
self.cipher = Fernet(secret_key)
def load_cookie(self, request) -> Optional[str]:
"""
:param request:
:return:
"""
cookie = request.cookies.get(self.cookie_name)
if cookie:
try:
return self.cipher.decrypt(cookie.encode())
except (AttributeError, ValueError):
pass
async def load(self, request) -> Session:
"""
:param request:
:return:
"""
cookie = self.load_cookie(request)
if cookie:
try:
return Session(ujson.loads(cookie))
except ValueError:
# In this case, the user has an invalid session.
# Probably a malicious user or secret key update.
return Session(pending_flush=True)
return Session()
async def save(self, request, response) -> None:
"""
Inject headers in the response object so the user will receive
an encrypted cookie with session values.
:param request: current Request object
:param response: current Response object where headers will be inject.
:return:
"""
value = self.cipher.encrypt(request.session.dumps().encode())
cookie = f'{self.cookie_name}={value.decode()}; SameSite=Lax'
response.headers['Set-Cookie'] = cookie
| 776 |
421 | <filename>samples/snippets/cpp/VS_Snippets_Remoting/System.Net.IPAddress.IsLoopback/CPP/isloopback.cpp<gh_stars>100-1000
/*
This program checks whether the specified address is a loopback address.
It invokes the IPAddress Parse method to translate the address
input String* into the correct internal format.
The IP address String* must be in dotted-quad notation for IPv4 or in
colon-hexadecimal notation for IPv6.
*/
// <Snippet1>
#using <System.dll>
using namespace System;
using namespace System::Net;
using namespace System::Net::Sockets;
// This method calls the IPAddress::Parse method to check if the
// passed ipAddress parameter is in the correct format.
// Then it checks whether it represents a loopback address.
// Finally, it displays the results.
void parse( String^ ipAddress )
{
String^ loopBack = " is not a loopback address.";
try
{
// Perform syntax check by parsing the address string entered by the user.
IPAddress^ address = IPAddress::Parse( ipAddress );
// Perform semantic check by verifying that the address is a valid IPv4
// or IPv6 loopback address.
if ( IPAddress::IsLoopback( address ) && address->AddressFamily == AddressFamily::InterNetworkV6 )
loopBack = String::Concat( " is an IPv6 loopback address whose internal format is: ", address, "." );
else
if ( IPAddress::IsLoopback( address ) && address->AddressFamily == AddressFamily::InterNetwork )
loopBack = String::Concat( " is an IPv4 loopback address whose internal format is: ", address, "." );
// Display the results.
Console::WriteLine( "Your input address: \" {0} \" {1}", ipAddress, loopBack );
}
catch ( FormatException^ e )
{
Console::WriteLine( "FormatException caught!!!" );
Console::WriteLine( "Source : {0}", e->Source );
Console::WriteLine( "Message : {0}", e->Message );
}
catch ( Exception^ e )
{
Console::WriteLine( "Exception caught!!!" );
Console::WriteLine( "Source : {0}", e->Source );
Console::WriteLine( "Message : {0}", e->Message );
}
}
int main()
{
array<String^>^args = Environment::GetCommandLineArgs();
if ( args->Length == 1 )
{
// No parameters entered. Display program usage.
Console::WriteLine( "Please enter an IP address." );
Console::WriteLine( "Usage: >ipaddress_isloopback any IPv4 or IPv6 address." );
Console::WriteLine( "Example: >ipaddress_isloopback 127.0.0.1" );
Console::WriteLine( "Example: >ipaddress_isloopback 0:0:0:0:0:0:0:1" );
}
else
parse( args[ 1 ] );
// Parse the address string entered by the user.
}
// </Snippet1>
| 1,012 |
412 | /*******************************************************************\
Module: C Scanner
Author: <NAME>, <EMAIL>
\*******************************************************************/
/// \file
/// cscanner
#ifndef CPROVER_CRANGLER_CSCANNER_H
#define CPROVER_CRANGLER_CSCANNER_H
#include <iosfwd>
#include <vector>
#include "ctoken.h"
class cscannert
{
public:
explicit cscannert(std::istream &);
~cscannert();
ctokent operator()();
std::istream ∈
std::size_t line_number = 1;
bool return_WS_and_comments = false;
void set_token(std::string text, ctokent::kindt kind)
{
token.line_number = line_number;
token.text = std::move(text);
token.kind = kind;
}
std::vector<ctokent> get_tokens();
protected:
ctokent token;
};
extern cscannert *cscanner_ptr;
#endif // CPROVER_CRANGLER_CSCANNER_H
| 313 |
378 | <reponame>ShermanMarshall/tomee
/*
* 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.openejb;
import org.apache.openejb.assembler.classic.DeploymentExceptionManager;
import org.apache.openejb.cdi.CdiBuilder;
import org.apache.openejb.core.ServerFederation;
import org.apache.openejb.loader.SystemInstance;
import org.apache.openejb.spi.ApplicationServer;
import org.apache.openejb.spi.Assembler;
import org.apache.openejb.spi.ContainerSystem;
import org.apache.openejb.spi.SecurityService;
import org.apache.openejb.util.LogCategory;
import org.apache.openejb.util.Logger;
import org.apache.openejb.util.Messages;
import org.apache.openejb.util.OpenEjbVersion;
import org.apache.openejb.util.OptionsLog;
import org.apache.openejb.util.SafeToolkit;
import javax.transaction.TransactionManager;
import java.util.Date;
import java.util.Properties;
import java.util.concurrent.atomic.AtomicReference;
/**
* @version $Rev$ $Date$
*/
public final class OpenEJB {
private static Instance instance;
private OpenEJB() {
}
public static ApplicationServer getApplicationServer() {
return SystemInstance.get().getComponent(ApplicationServer.class);
}
public static TransactionManager getTransactionManager() {
return SystemInstance.get().getComponent(TransactionManager.class);
}
public static class Instance {
private final Throwable initialized;
/**
* 1 usage
* org.apache.openejb.core.ivm.naming.InitContextFactory
*/
public Instance(final Properties props) throws OpenEJBException {
this(props, new ServerFederation());
}
/**
* 2 usages
*/
public Instance(final Properties initProps, final ApplicationServer appServer) throws OpenEJBException {
if (appServer == null) {
throw new IllegalArgumentException("appServer must not be null");
}
initialized = new InitializationException("Initialized at " + new Date())/*.fillInStackTrace()*/;
try {
SystemInstance.init(initProps);
// do it after having gotten the properties
Logger.configure();
OptionsLog.install();
} catch (final Exception e) {
throw new OpenEJBException(e);
}
final SystemInstance system = SystemInstance.get();
final Logger logger = Logger.getInstance(LogCategory.OPENEJB_STARTUP, "org.apache.openejb.util.resources");
system.setComponent(DeploymentExceptionManager.class, new DeploymentExceptionManager());
system.setComponent(ApplicationServer.class, appServer);
final OpenEjbVersion versionInfo = OpenEjbVersion.get();
if (!system.getOptions().get("openejb.nobanner", true)) {
//noinspection UseOfSystemOutOrSystemErr
versionInfo.print(System.out);
}
final Logger logger2 = Logger.getInstance(LogCategory.OPENEJB, "org.apache.openejb.util.resources");
final String[] bannerValues = new String[]{
null, versionInfo.getUrl(), new Date().toString(), versionInfo.getCopyright(),
versionInfo.getVersion(), versionInfo.getDate(), versionInfo.getTime(), null
};
for (int i = 0; i < bannerValues.length; i++) {
if (bannerValues[i] == null) {
logger2.info("startup.banner." + i);
} else {
logger2.info("startup.banner." + i, bannerValues[i]);
}
}
logger.info("openejb.home = " + system.getHome().getDirectory().getAbsolutePath());
logger.info("openejb.base = " + system.getBase().getDirectory().getAbsolutePath());
//OWB support. The classloader has to be able to load all OWB components including the ones supplied by OpenEjb.
CdiBuilder.initializeOWB();
final String className = system.getOptions().get("openejb.assembler", (String) null);
logger.debug("startup.instantiatingAssemblerClass", className);
final Assembler assembler;
try {
assembler = className == null ?
new org.apache.openejb.assembler.classic.Assembler() : (Assembler) SafeToolkit.getToolkit("OpenEJB").newInstance(className);
} catch (final OpenEJBException oe) {
logger.fatal("startup.assemblerCannotBeInstantiated", oe);
throw oe;
} catch (final Throwable t) {
final String msg = messages().message("startup.openejbEncounteredUnexpectedError");
logger.fatal(msg, t);
throw new OpenEJBException(msg, t);
}
try {
assembler.init(system.getProperties());
} catch (final OpenEJBException oe) {
logger.fatal("startup.assemblerFailedToInitialize", oe);
throw oe;
} catch (final Throwable t) {
final String msg = messages().message("startup.assemblerEncounteredUnexpectedError");
logger.fatal(msg, t);
throw new OpenEJBException(msg, t);
}
try {
assembler.build();
} catch (final OpenEJBException oe) {
logger.fatal("startup.assemblerFailedToBuild", oe);
throw oe;
} catch (final Throwable t) {
final String msg = messages().message("startup.assemblerEncounterUnexpectedBuildError");
logger.fatal(msg, t);
throw new OpenEJBException(msg, t);
}
final ContainerSystem containerSystem = assembler.getContainerSystem();
if (containerSystem == null) {
final String msg = messages().message("startup.assemblerReturnedNullContainer");
logger.fatal(msg);
throw new OpenEJBException(msg);
}
system.setComponent(ContainerSystem.class, containerSystem);
if (logger.isDebugEnabled()) {
logger.debug("startup.debugContainers", containerSystem.containers().length);
if (containerSystem.containers().length > 0) {
final Container[] c = containerSystem.containers();
logger.debug("startup.debugContainersType");
for (Container container : c) {
String entry = " ";
switch (container.getContainerType()) {
case BMP_ENTITY:
entry += "BMP ENTITY ";
break;
case CMP_ENTITY:
entry += "CMP ENTITY ";
break;
case STATEFUL:
entry += "STATEFUL ";
break;
case STATELESS:
entry += "STATELESS ";
break;
case MESSAGE_DRIVEN:
entry += "MESSAGE ";
break;
}
entry += container.getContainerID();
logger.debug("startup.debugEntry", entry);
}
}
logger.debug("startup.debugDeployments", containerSystem.deployments().length);
if (containerSystem.deployments().length > 0) {
logger.debug("startup.debugDeploymentsType");
final BeanContext[] d = containerSystem.deployments();
for (BeanContext beanContext : d) {
String entry = " ";
switch (beanContext.getComponentType()) {
case BMP_ENTITY:
entry += "BMP_ENTITY ";
break;
case CMP_ENTITY:
entry += "CMP_ENTITY ";
break;
case STATEFUL:
entry += "STATEFUL ";
break;
case MANAGED:
entry += "MANAGED ";
break;
case STATELESS:
entry += "STATELESS ";
break;
case SINGLETON:
entry += "SINGLETON ";
break;
case MESSAGE_DRIVEN:
entry += "MESSAGE ";
break;
}
entry += beanContext.getDeploymentID();
logger.debug("startup.debugEntry", entry);
}
}
}
final SecurityService securityService = assembler.getSecurityService();
if (securityService == null) {
final String msg = messages().message("startup.assemblerReturnedNullSecurityService");
logger.fatal(msg);
throw new OpenEJBException(msg);
} else {
logger.debug("startup.securityService", securityService.getClass().getName());
}
system.setComponent(SecurityService.class, securityService);
final TransactionManager transactionManager = assembler.getTransactionManager();
if (transactionManager == null) {
final String msg = messages().message("startup.assemblerReturnedNullTransactionManager");
logger.fatal(msg);
throw new OpenEJBException(msg);
} else {
logger.debug("startup.transactionManager", transactionManager.getClass().getName());
}
system.setComponent(TransactionManager.class, transactionManager);
logger.debug("startup.ready");
}
public Throwable getInitialized() {
return initialized.fillInStackTrace();
}
}
public static void destroy() {
final Assembler assembler = SystemInstance.get().getComponent(Assembler.class);
if (assembler != null) {
assembler.destroy();
} else {
SystemInstance.reset();
}
instance = null;
}
/**
* 1 usage
* org.apache.openejb.core.ivm.naming.InitContextFactory
*/
public static void init(final Properties props) throws OpenEJBException {
init(props, null);
}
private static final AtomicReference<Messages> messagesRef = new AtomicReference<>();
private static Messages messages() { // only used for errors so lazy init is great
Messages m = messagesRef.get();
if (m == null) {
m = new Messages("org.apache.openejb.util.resources");
messagesRef.compareAndSet(null, m);
}
return m;
}
/**
* 2 usages
*/
public static void init(final Properties initProps, final ApplicationServer appServer) throws OpenEJBException {
if (isInitialized()) {
if (instance != null) {
final String msg = messages().message("startup.alreadyInitialized");
logger().error(msg, instance.initialized);
throw new OpenEJBException(msg, instance.initialized);
} else {
final String msg = messages().message("startup.alreadyInitialized");
logger().error(msg);
throw new OpenEJBException(msg);
}
} else {
instance = appServer == null ? new Instance(initProps) : new Instance(initProps, appServer);
}
}
private static Logger logger() { // do it lazily to avoid to trigger logger creation before properties are read + generally useless
return Logger.getInstance(LogCategory.OPENEJB_STARTUP, "org.apache.openejb.util.resources");
}
/**
* 1 usages
*/
public static boolean isInitialized() {
return instance != null || SystemInstance.get().getComponent(ContainerSystem.class) != null;
}
public static class InitializationException extends Exception {
public InitializationException(final String message) {
super(message);
}
}
}
| 6,350 |
17,702 | <filename>Source/Readers/LUSequenceReader/DataWriterLocal.cpp
//
// Copyright (c) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE.md file in the project root for full license information.
//
// DataWriter.cpp : Defines the exported functions for the DLL application.
//
// TODO: Unify with shared DataWriter.cpp.
//
#include "stdafx.h"
#include "Basics.h"
#define DATAWRITER_EXPORTS
#include "DataWriter.h"
#include "LUSequenceWriter.h"
namespace Microsoft { namespace MSR { namespace CNTK {
template <class ConfigRecordType>
void DataWriter::InitFromConfig(const ConfigRecordType& writerConfig)
{
wstring precision = writerConfig(L"precision", L"float");
if (precision == L"float")
m_dataWriter = new LUSequenceWriter<float>();
else if (precision == L"double")
m_dataWriter = new LUSequenceWriter<double>();
else
InvalidArgument("DataWriter (LUSequenceWriter): The 'precision' parameter must be 'float' or 'double'.");
m_dataWriter->Init(writerConfig);
}
// Destroy - cleanup and remove this class
// NOTE: this destroys the object, and it can't be used past this point
void DataWriter::Destroy()
{
delete m_dataWriter;
// TODO: don't we need to destroy ourselves?
}
// DataWriter Constructor
// config - [in] configuration data for the data writer
template <class ConfigRecordType>
DataWriter::DataWriter(const ConfigRecordType& config)
{
Init(config);
}
// destructor - cleanup temp files, etc.
DataWriter::~DataWriter()
{
Destroy();
}
// GetSections - Get the sections of the file
// sections - a map of section name to section. Data sepcifications from config file will be used to determine where and how to save data
void DataWriter::GetSections(std::map<std::wstring, SectionType, nocase_compare>& sections)
{
m_dataWriter->GetSections(sections);
}
// SaveData - save data in the file/files
// recordStart - Starting record number
// matricies - a map of section name (section:subsection) to data pointer. Data sepcifications from config file will be used to determine where and how to save data
// numRecords - number of records we are saving, can be zero if not applicable
// datasetSize - Size of the dataset
// byteVariableSized - for variable sized data, size of current block to be written, zero when not used, or ignored if not variable sized data
bool DataWriter::SaveData(size_t recordStart, const std::map<std::wstring, void*, nocase_compare>& matrices, size_t numRecords, size_t datasetSize, size_t byteVariableSized)
{
return m_dataWriter->SaveData(recordStart, matrices, numRecords, datasetSize, byteVariableSized);
}
// SaveMapping - save a map into the file
// saveId - name of the section to save into (section:subsection format)
// labelMapping - map we are saving to the file
void DataWriter::SaveMapping(std::wstring saveId, const std::map<LabelIdType, LabelType>& labelMapping)
{
m_dataWriter->SaveMapping(saveId, labelMapping);
}
}}}
| 906 |
333 | package com.alipay.api.response;
import com.alipay.api.AlipayResponse;
/**
* ALIPAY API: alipay.open.servicemarket.commodity.extendinfos.confirm response.
*
* @author auto create
* @since 1.0, 2021-07-14 10:12:40
*/
public class AlipayOpenServicemarketCommodityExtendinfosConfirmResponse extends AlipayResponse {
private static final long serialVersionUID = 7124932225828665343L;
}
| 169 |
1,439 | <gh_stars>1000+
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2008-2015 <NAME> <<EMAIL>>
// Copyright (C) 2006-2008 <NAME> <<EMAIL>>
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_META_H
#define EIGEN_META_H
#if defined(__CUDA_ARCH__)
#include <cfloat>
#include <math_constants.h>
#endif
#if EIGEN_COMP_ICC>=1600 && __cplusplus >= 201103L
#include <cstdint>
#endif
namespace Eigen {
typedef EIGEN_DEFAULT_DENSE_INDEX_TYPE DenseIndex;
/**
* \brief The Index type as used for the API.
* \details To change this, \c \#define the preprocessor symbol \c EIGEN_DEFAULT_DENSE_INDEX_TYPE.
* \sa \blank \ref TopicPreprocessorDirectives, StorageIndex.
*/
typedef EIGEN_DEFAULT_DENSE_INDEX_TYPE Index;
namespace internal {
/** \internal
* \file Meta.h
* This file contains generic metaprogramming classes which are not specifically related to Eigen.
* \note In case you wonder, yes we're aware that Boost already provides all these features,
* we however don't want to add a dependency to Boost.
*/
// Only recent versions of ICC complain about using ptrdiff_t to hold pointers,
// and older versions do not provide *intptr_t types.
#if EIGEN_COMP_ICC>=1600 && __cplusplus >= 201103L
typedef std::intptr_t IntPtr;
typedef std::uintptr_t UIntPtr;
#else
typedef std::ptrdiff_t IntPtr;
typedef std::size_t UIntPtr;
#endif
struct true_type { enum { value = 1 }; };
struct false_type { enum { value = 0 }; };
template<bool Condition, typename Then, typename Else>
struct conditional { typedef Then type; };
template<typename Then, typename Else>
struct conditional <false, Then, Else> { typedef Else type; };
template<typename T, typename U> struct is_same { enum { value = 0 }; };
template<typename T> struct is_same<T,T> { enum { value = 1 }; };
template<typename T> struct remove_reference { typedef T type; };
template<typename T> struct remove_reference<T&> { typedef T type; };
template<typename T> struct remove_pointer { typedef T type; };
template<typename T> struct remove_pointer<T*> { typedef T type; };
template<typename T> struct remove_pointer<T*const> { typedef T type; };
template <class T> struct remove_const { typedef T type; };
template <class T> struct remove_const<const T> { typedef T type; };
template <class T> struct remove_const<const T[]> { typedef T type[]; };
template <class T, unsigned int Size> struct remove_const<const T[Size]> { typedef T type[Size]; };
template<typename T> struct remove_all { typedef T type; };
template<typename T> struct remove_all<const T> { typedef typename remove_all<T>::type type; };
template<typename T> struct remove_all<T const&> { typedef typename remove_all<T>::type type; };
template<typename T> struct remove_all<T&> { typedef typename remove_all<T>::type type; };
template<typename T> struct remove_all<T const*> { typedef typename remove_all<T>::type type; };
template<typename T> struct remove_all<T*> { typedef typename remove_all<T>::type type; };
template<typename T> struct is_arithmetic { enum { value = false }; };
template<> struct is_arithmetic<float> { enum { value = true }; };
template<> struct is_arithmetic<double> { enum { value = true }; };
template<> struct is_arithmetic<long double> { enum { value = true }; };
template<> struct is_arithmetic<bool> { enum { value = true }; };
template<> struct is_arithmetic<char> { enum { value = true }; };
template<> struct is_arithmetic<signed char> { enum { value = true }; };
template<> struct is_arithmetic<unsigned char> { enum { value = true }; };
template<> struct is_arithmetic<signed short> { enum { value = true }; };
template<> struct is_arithmetic<unsigned short>{ enum { value = true }; };
template<> struct is_arithmetic<signed int> { enum { value = true }; };
template<> struct is_arithmetic<unsigned int> { enum { value = true }; };
template<> struct is_arithmetic<signed long> { enum { value = true }; };
template<> struct is_arithmetic<unsigned long> { enum { value = true }; };
template<typename T> struct is_integral { enum { value = false }; };
template<> struct is_integral<bool> { enum { value = true }; };
template<> struct is_integral<char> { enum { value = true }; };
template<> struct is_integral<signed char> { enum { value = true }; };
template<> struct is_integral<unsigned char> { enum { value = true }; };
template<> struct is_integral<signed short> { enum { value = true }; };
template<> struct is_integral<unsigned short> { enum { value = true }; };
template<> struct is_integral<signed int> { enum { value = true }; };
template<> struct is_integral<unsigned int> { enum { value = true }; };
template<> struct is_integral<signed long> { enum { value = true }; };
template<> struct is_integral<unsigned long> { enum { value = true }; };
template <typename T> struct add_const { typedef const T type; };
template <typename T> struct add_const<T&> { typedef T& type; };
template <typename T> struct is_const { enum { value = 0 }; };
template <typename T> struct is_const<T const> { enum { value = 1 }; };
template<typename T> struct add_const_on_value_type { typedef const T type; };
template<typename T> struct add_const_on_value_type<T&> { typedef T const& type; };
template<typename T> struct add_const_on_value_type<T*> { typedef T const* type; };
template<typename T> struct add_const_on_value_type<T* const> { typedef T const* const type; };
template<typename T> struct add_const_on_value_type<T const* const> { typedef T const* const type; };
template<typename From, typename To>
struct is_convertible_impl
{
private:
struct any_conversion
{
template <typename T> any_conversion(const volatile T&);
template <typename T> any_conversion(T&);
};
struct yes {int a[1];};
struct no {int a[2];};
static yes test(const To&, int);
static no test(any_conversion, ...);
public:
static From ms_from;
#ifdef __INTEL_COMPILER
#pragma warning push
#pragma warning ( disable : 2259 )
#endif
enum { value = sizeof(test(ms_from, 0))==sizeof(yes) };
#ifdef __INTEL_COMPILER
#pragma warning pop
#endif
};
template<typename From, typename To>
struct is_convertible
{
enum { value = is_convertible_impl<typename remove_all<From>::type,
typename remove_all<To >::type>::value };
};
/** \internal Allows to enable/disable an overload
* according to a compile time condition.
*/
template<bool Condition, typename T=void> struct enable_if;
template<typename T> struct enable_if<true,T>
{ typedef T type; };
#if defined(__CUDA_ARCH__)
#if !defined(__FLT_EPSILON__)
#define __FLT_EPSILON__ FLT_EPSILON
#define __DBL_EPSILON__ DBL_EPSILON
#endif
namespace device {
template<typename T> struct numeric_limits
{
EIGEN_DEVICE_FUNC
static T epsilon() { return 0; }
static T (max)() { assert(false && "Highest not supported for this type"); }
static T (min)() { assert(false && "Lowest not supported for this type"); }
static T infinity() { assert(false && "Infinity not supported for this type"); }
static T quiet_NaN() { assert(false && "quiet_NaN not supported for this type"); }
};
template<> struct numeric_limits<float>
{
EIGEN_DEVICE_FUNC
static float epsilon() { return __FLT_EPSILON__; }
EIGEN_DEVICE_FUNC
static float (max)() { return CUDART_MAX_NORMAL_F; }
EIGEN_DEVICE_FUNC
static float (min)() { return FLT_MIN; }
EIGEN_DEVICE_FUNC
static float infinity() { return CUDART_INF_F; }
EIGEN_DEVICE_FUNC
static float quiet_NaN() { return CUDART_NAN_F; }
};
template<> struct numeric_limits<double>
{
EIGEN_DEVICE_FUNC
static double epsilon() { return __DBL_EPSILON__; }
EIGEN_DEVICE_FUNC
static double (max)() { return DBL_MAX; }
EIGEN_DEVICE_FUNC
static double (min)() { return DBL_MIN; }
EIGEN_DEVICE_FUNC
static double infinity() { return CUDART_INF; }
EIGEN_DEVICE_FUNC
static double quiet_NaN() { return CUDART_NAN; }
};
template<> struct numeric_limits<int>
{
EIGEN_DEVICE_FUNC
static int epsilon() { return 0; }
EIGEN_DEVICE_FUNC
static int (max)() { return INT_MAX; }
EIGEN_DEVICE_FUNC
static int (min)() { return INT_MIN; }
};
template<> struct numeric_limits<unsigned int>
{
EIGEN_DEVICE_FUNC
static unsigned int epsilon() { return 0; }
EIGEN_DEVICE_FUNC
static unsigned int (max)() { return UINT_MAX; }
EIGEN_DEVICE_FUNC
static unsigned int (min)() { return 0; }
};
template<> struct numeric_limits<long>
{
EIGEN_DEVICE_FUNC
static long epsilon() { return 0; }
EIGEN_DEVICE_FUNC
static long (max)() { return LONG_MAX; }
EIGEN_DEVICE_FUNC
static long (min)() { return LONG_MIN; }
};
template<> struct numeric_limits<unsigned long>
{
EIGEN_DEVICE_FUNC
static unsigned long epsilon() { return 0; }
EIGEN_DEVICE_FUNC
static unsigned long (max)() { return ULONG_MAX; }
EIGEN_DEVICE_FUNC
static unsigned long (min)() { return 0; }
};
template<> struct numeric_limits<long long>
{
EIGEN_DEVICE_FUNC
static long long epsilon() { return 0; }
EIGEN_DEVICE_FUNC
static long long (max)() { return LLONG_MAX; }
EIGEN_DEVICE_FUNC
static long long (min)() { return LLONG_MIN; }
};
template<> struct numeric_limits<unsigned long long>
{
EIGEN_DEVICE_FUNC
static unsigned long long epsilon() { return 0; }
EIGEN_DEVICE_FUNC
static unsigned long long (max)() { return ULLONG_MAX; }
EIGEN_DEVICE_FUNC
static unsigned long long (min)() { return 0; }
};
}
#endif
/** \internal
* A base class do disable default copy ctor and copy assignement operator.
*/
class noncopyable
{
EIGEN_DEVICE_FUNC noncopyable(const noncopyable&);
EIGEN_DEVICE_FUNC const noncopyable& operator=(const noncopyable&);
protected:
EIGEN_DEVICE_FUNC noncopyable() {}
EIGEN_DEVICE_FUNC ~noncopyable() {}
};
/** \internal
* Convenient struct to get the result type of a unary or binary functor.
*
* It supports both the current STL mechanism (using the result_type member) as well as
* upcoming next STL generation (using a templated result member).
* If none of these members is provided, then the type of the first argument is returned. FIXME, that behavior is a pretty bad hack.
*/
#if EIGEN_HAS_STD_RESULT_OF
template<typename T> struct result_of {
typedef typename std::result_of<T>::type type1;
typedef typename remove_all<type1>::type type;
};
#else
template<typename T> struct result_of { };
struct has_none {int a[1];};
struct has_std_result_type {int a[2];};
struct has_tr1_result {int a[3];};
template<typename Func, typename ArgType, int SizeOf=sizeof(has_none)>
struct unary_result_of_select {typedef typename internal::remove_all<ArgType>::type type;};
template<typename Func, typename ArgType>
struct unary_result_of_select<Func, ArgType, sizeof(has_std_result_type)> {typedef typename Func::result_type type;};
template<typename Func, typename ArgType>
struct unary_result_of_select<Func, ArgType, sizeof(has_tr1_result)> {typedef typename Func::template result<Func(ArgType)>::type type;};
template<typename Func, typename ArgType>
struct result_of<Func(ArgType)> {
template<typename T>
static has_std_result_type testFunctor(T const *, typename T::result_type const * = 0);
template<typename T>
static has_tr1_result testFunctor(T const *, typename T::template result<T(ArgType)>::type const * = 0);
static has_none testFunctor(...);
// note that the following indirection is needed for gcc-3.3
enum {FunctorType = sizeof(testFunctor(static_cast<Func*>(0)))};
typedef typename unary_result_of_select<Func, ArgType, FunctorType>::type type;
};
template<typename Func, typename ArgType0, typename ArgType1, int SizeOf=sizeof(has_none)>
struct binary_result_of_select {typedef typename internal::remove_all<ArgType0>::type type;};
template<typename Func, typename ArgType0, typename ArgType1>
struct binary_result_of_select<Func, ArgType0, ArgType1, sizeof(has_std_result_type)>
{typedef typename Func::result_type type;};
template<typename Func, typename ArgType0, typename ArgType1>
struct binary_result_of_select<Func, ArgType0, ArgType1, sizeof(has_tr1_result)>
{typedef typename Func::template result<Func(ArgType0,ArgType1)>::type type;};
template<typename Func, typename ArgType0, typename ArgType1>
struct result_of<Func(ArgType0,ArgType1)> {
template<typename T>
static has_std_result_type testFunctor(T const *, typename T::result_type const * = 0);
template<typename T>
static has_tr1_result testFunctor(T const *, typename T::template result<T(ArgType0,ArgType1)>::type const * = 0);
static has_none testFunctor(...);
// note that the following indirection is needed for gcc-3.3
enum {FunctorType = sizeof(testFunctor(static_cast<Func*>(0)))};
typedef typename binary_result_of_select<Func, ArgType0, ArgType1, FunctorType>::type type;
};
template<typename Func, typename ArgType0, typename ArgType1, typename ArgType2, int SizeOf=sizeof(has_none)>
struct ternary_result_of_select {typedef typename internal::remove_all<ArgType0>::type type;};
template<typename Func, typename ArgType0, typename ArgType1, typename ArgType2>
struct ternary_result_of_select<Func, ArgType0, ArgType1, ArgType2, sizeof(has_std_result_type)>
{typedef typename Func::result_type type;};
template<typename Func, typename ArgType0, typename ArgType1, typename ArgType2>
struct ternary_result_of_select<Func, ArgType0, ArgType1, ArgType2, sizeof(has_tr1_result)>
{typedef typename Func::template result<Func(ArgType0,ArgType1,ArgType2)>::type type;};
template<typename Func, typename ArgType0, typename ArgType1, typename ArgType2>
struct result_of<Func(ArgType0,ArgType1,ArgType2)> {
template<typename T>
static has_std_result_type testFunctor(T const *, typename T::result_type const * = 0);
template<typename T>
static has_tr1_result testFunctor(T const *, typename T::template result<T(ArgType0,ArgType1,ArgType2)>::type const * = 0);
static has_none testFunctor(...);
// note that the following indirection is needed for gcc-3.3
enum {FunctorType = sizeof(testFunctor(static_cast<Func*>(0)))};
typedef typename ternary_result_of_select<Func, ArgType0, ArgType1, ArgType2, FunctorType>::type type;
};
#endif
struct meta_yes { char a[1]; };
struct meta_no { char a[2]; };
// Check whether T::ReturnType does exist
template <typename T>
struct has_ReturnType
{
template <typename C> static meta_yes testFunctor(typename C::ReturnType const *);
template <typename C> static meta_no testFunctor(...);
enum { value = sizeof(testFunctor<T>(0)) == sizeof(meta_yes) };
};
template<typename T> const T* return_ptr();
template <typename T, typename IndexType=Index>
struct has_nullary_operator
{
template <typename C> static meta_yes testFunctor(C const *,typename enable_if<(sizeof(return_ptr<C>()->operator()())>0)>::type * = 0);
static meta_no testFunctor(...);
enum { value = sizeof(testFunctor(static_cast<T*>(0))) == sizeof(meta_yes) };
};
template <typename T, typename IndexType=Index>
struct has_unary_operator
{
template <typename C> static meta_yes testFunctor(C const *,typename enable_if<(sizeof(return_ptr<C>()->operator()(IndexType(0)))>0)>::type * = 0);
static meta_no testFunctor(...);
enum { value = sizeof(testFunctor(static_cast<T*>(0))) == sizeof(meta_yes) };
};
template <typename T, typename IndexType=Index>
struct has_binary_operator
{
template <typename C> static meta_yes testFunctor(C const *,typename enable_if<(sizeof(return_ptr<C>()->operator()(IndexType(0),IndexType(0)))>0)>::type * = 0);
static meta_no testFunctor(...);
enum { value = sizeof(testFunctor(static_cast<T*>(0))) == sizeof(meta_yes) };
};
/** \internal In short, it computes int(sqrt(\a Y)) with \a Y an integer.
* Usage example: \code meta_sqrt<1023>::ret \endcode
*/
template<int Y,
int InfX = 0,
int SupX = ((Y==1) ? 1 : Y/2),
bool Done = ((SupX-InfX)<=1 ? true : ((SupX*SupX <= Y) && ((SupX+1)*(SupX+1) > Y))) >
// use ?: instead of || just to shut up a stupid gcc 4.3 warning
class meta_sqrt
{
enum {
MidX = (InfX+SupX)/2,
TakeInf = MidX*MidX > Y ? 1 : 0,
NewInf = int(TakeInf) ? InfX : int(MidX),
NewSup = int(TakeInf) ? int(MidX) : SupX
};
public:
enum { ret = meta_sqrt<Y,NewInf,NewSup>::ret };
};
template<int Y, int InfX, int SupX>
class meta_sqrt<Y, InfX, SupX, true> { public: enum { ret = (SupX*SupX <= Y) ? SupX : InfX }; };
/** \internal Computes the least common multiple of two positive integer A and B
* at compile-time. It implements a naive algorithm testing all multiples of A.
* It thus works better if A>=B.
*/
template<int A, int B, int K=1, bool Done = ((A*K)%B)==0>
struct meta_least_common_multiple
{
enum { ret = meta_least_common_multiple<A,B,K+1>::ret };
};
template<int A, int B, int K>
struct meta_least_common_multiple<A,B,K,true>
{
enum { ret = A*K };
};
/** \internal determines whether the product of two numeric types is allowed and what the return type is */
template<typename T, typename U> struct scalar_product_traits
{
enum { Defined = 0 };
};
// FIXME quick workaround around current limitation of result_of
// template<typename Scalar, typename ArgType0, typename ArgType1>
// struct result_of<scalar_product_op<Scalar>(ArgType0,ArgType1)> {
// typedef typename scalar_product_traits<typename remove_all<ArgType0>::type, typename remove_all<ArgType1>::type>::ReturnType type;
// };
} // end namespace internal
namespace numext {
#if defined(__CUDA_ARCH__)
template<typename T> EIGEN_DEVICE_FUNC void swap(T &a, T &b) { T tmp = b; b = a; a = tmp; }
#else
template<typename T> EIGEN_STRONG_INLINE void swap(T &a, T &b) { std::swap(a,b); }
#endif
#if defined(__CUDA_ARCH__)
using internal::device::numeric_limits;
#else
using std::numeric_limits;
#endif
// Integer division with rounding up.
// T is assumed to be an integer type with a>=0, and b>0
template<typename T>
T div_ceil(const T &a, const T &b)
{
return (a+b-1) / b;
}
} // end namespace numext
} // end namespace Eigen
#endif // EIGEN_META_H
| 6,761 |
17,481 | /*
* Copyright (C) 2021 The Dagger 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 dagger.internal.codegen;
import static com.google.testing.compile.CompilationSubject.assertThat;
import static dagger.internal.codegen.Compilers.daggerCompiler;
import com.google.testing.compile.Compilation;
import com.google.testing.compile.JavaFileObjects;
import javax.tools.JavaFileObject;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
@RunWith(JUnit4.class)
public final class UnresolvableDependencyTest {
private static final String DEFERRED_ERROR_MESSAGE =
"dagger.internal.codegen.ComponentProcessor was unable to process 'test.FooComponent' "
+ "because not all of its dependencies could be resolved. Check for compilation errors "
+ "or a circular dependency with generated code.";
@Test
public void referencesUnresolvableDependency() {
JavaFileObject fooComponent =
JavaFileObjects.forSourceLines(
"test.FooComponent",
"package test;",
"",
"import dagger.Component;",
"",
"@Component",
"interface FooComponent {",
" Foo foo();",
"}");
JavaFileObject foo =
JavaFileObjects.forSourceLines(
"test.Foo",
"package test;",
"",
"import javax.inject.Inject;",
"",
"class Foo {",
" @Inject",
" Foo(Bar bar) {}",
"}");
JavaFileObject bar =
JavaFileObjects.forSourceLines(
"test.Bar",
"package test;",
"",
"import javax.inject.Inject;",
"",
"class Bar {",
" @Inject",
" Bar(UnresolvableDependency dep) {}",
"}");
Compilation compilation = daggerCompiler().compile(fooComponent, foo, bar);
assertThat(compilation).failed();
assertThat(compilation).hadErrorContaining(DEFERRED_ERROR_MESSAGE);
}
@Test
public void referencesUnresolvableAnnotationOnType() {
JavaFileObject fooComponent =
JavaFileObjects.forSourceLines(
"test.FooComponent",
"package test;",
"",
"import dagger.Component;",
"",
"@Component",
"interface FooComponent {",
" Foo foo();",
"}");
JavaFileObject foo =
JavaFileObjects.forSourceLines(
"test.Foo",
"package test;",
"",
"import javax.inject.Inject;",
"",
"class Foo {",
" @Inject",
" Foo(Bar bar) {}",
"}");
JavaFileObject bar =
JavaFileObjects.forSourceLines(
"test.Bar",
"package test;",
"",
"import javax.inject.Inject;",
"",
"@UnresolvableAnnotation",
"class Bar {",
" @Inject",
" Bar(String dep) {}",
"}");
Compilation compilation = daggerCompiler().compile(fooComponent, foo, bar);
assertThat(compilation).failed();
assertThat(compilation).hadErrorContaining(DEFERRED_ERROR_MESSAGE);
}
@Test
public void referencesUnresolvableAnnotationOnTypeOnParameter() {
JavaFileObject fooComponent =
JavaFileObjects.forSourceLines(
"test.FooComponent",
"package test;",
"",
"import dagger.Component;",
"",
"@Component",
"interface FooComponent {",
" Foo foo();",
"}");
JavaFileObject foo =
JavaFileObjects.forSourceLines(
"test.Foo",
"package test;",
"",
"import javax.inject.Inject;",
"",
"class Foo {",
" @Inject",
" Foo(Bar bar) {}",
"}");
JavaFileObject bar =
JavaFileObjects.forSourceLines(
"test.Bar",
"package test;",
"",
"import javax.inject.Inject;",
"",
"class Bar {",
" @Inject",
" Bar(@UnresolvableAnnotation String dep) {}",
"}");
Compilation compilation = daggerCompiler().compile(fooComponent, foo, bar);
assertThat(compilation).failed();
assertThat(compilation).hadErrorContaining(DEFERRED_ERROR_MESSAGE);
}
}
| 2,324 |
337 | public final class Inheritor implements p.I, p.I2 {
public final void f() { /* compiled code */ }
public void g() { /* compiled code */ }
public Inheritor() { /* compiled code */ }
@org.jetbrains.annotations.NotNull
public java.lang.String foo() { /* compiled code */ }
@org.jetbrains.annotations.NotNull
public java.lang.String bar() { /* compiled code */ }
} | 128 |
1,093 | <reponame>StandCN/spring-integration
/*
* Copyright 2015-2019 the original author or 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
*
* https://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.springframework.integration.store;
import org.springframework.util.Assert;
/**
* @author <NAME>
* @author <NAME>
* @since 4.2
*
*/
public abstract class AbstractBatchingMessageGroupStore implements BasicMessageGroupStore {
private static final int DEFAULT_REMOVE_BATCH_SIZE = 100;
private volatile int removeBatchSize = DEFAULT_REMOVE_BATCH_SIZE;
private volatile MessageGroupFactory messageGroupFactory = new SimpleMessageGroupFactory();
/**
* Set the batch size when bulk removing messages from groups for message stores
* that support batch removal.
* Default 100.
* @param removeBatchSize the batch size.
* @since 4.2
*/
public void setRemoveBatchSize(int removeBatchSize) {
this.removeBatchSize = removeBatchSize;
}
public int getRemoveBatchSize() {
return this.removeBatchSize;
}
/**
* Specify the {@link MessageGroupFactory} to create {@link MessageGroup} object where
* it is necessary.
* Defaults to {@link SimpleMessageGroupFactory}.
* @param messageGroupFactory the {@link MessageGroupFactory} to use.
* @since 4.3
*/
public void setMessageGroupFactory(MessageGroupFactory messageGroupFactory) {
Assert.notNull(messageGroupFactory, "'messageGroupFactory' must not be null");
this.messageGroupFactory = messageGroupFactory;
}
protected MessageGroupFactory getMessageGroupFactory() {
return this.messageGroupFactory;
}
}
| 579 |
7,676 | // Copyright 2019 Microsoft. 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.
// =============================================================================
#ifndef HOROVOD_ADASUM_MPI_OPERATIONS_H
#define HOROVOD_ADASUM_MPI_OPERATIONS_H
#include "mpi.h"
#include <iostream>
#include "adasum/adasum_mpi.h"
#include "collective_operations.h"
namespace horovod {
namespace common {
class AdasumMPIAllreduceOp : public AdasumMPI, public AllreduceOp {
public:
AdasumMPIAllreduceOp(MPIContext* mpi_context,
HorovodGlobalState* global_state);
Status Execute(std::vector<TensorTableEntry>& entries,
const Response& response) override;
bool Enabled(const ParameterManager& param_manager,
const std::vector<TensorTableEntry>& entries,
const Response& response) const override;
};
} // namespace common
} // namespace horovod
#endif // HOROVOD_ADASUM_MPI_OPERATIONS_H
| 480 |
310 | # coding=utf-8
# Author: <NAME> <<EMAIL>>
#
# License: BSD 3 clause
import numpy as np
from scipy.stats import mode
from sklearn.neighbors import NearestNeighbors
"""
This file contains the implementation of different functions to measure
instance hardness. Instance hardness can be defined as the likelihood that a
given sample will be misclassified by different learning algorithms.
References
----------
<NAME>., <NAME>. and <NAME>., 2014. An instance level
analysis of data complexity.
Machine learning, 95(2), pp.225-256
"""
def hardness_region_competence(neighbors_idx, labels, safe_k):
"""Calculate the Instance hardness of the sample based on its neighborhood.
The sample is deemed hard to classify when there is overlap between
different classes in the region of competence. This method does not
takes into account the target label of the test sample
This hardness measure is used to select whether use DS or use the KNN for
the classification of a given query sample
Parameters
----------
neighbors_idx : array of shape = [n_samples_test, k]
Indices of the nearest neighbors for each considered sample
labels : array of shape = [n_samples_train]
labels associated with each training sample
safe_k : int
Number of neighbors used to estimate the hardness of the corresponding
region
Returns
-------
hardness : array of shape = [n_samples_test]
The Hardness level associated with each example.
References
----------
<NAME>., <NAME>. and <NAME>., 2014. An instance level
analysis of data complexity.
Machine learning, 95(2), pp.225-256
"""
if neighbors_idx.ndim < 2:
neighbors_idx = np.atleast_2d(neighbors_idx)
neighbors_y = labels[neighbors_idx[:, :safe_k]]
_, num_majority_class = mode(neighbors_y, axis=1)
hardness = ((safe_k - num_majority_class) / safe_k).reshape(-1, )
return hardness
def kdn_score(X, y, k):
"""
Calculates the K-Disagreeing Neighbors score (KDN) of each sample in the
input dataset.
Parameters
----------
X : array of shape (n_samples, n_features)
The input data.
y : array of shape (n_samples)
class labels of each example in X.
k : int
Neighborhood size for calculating the KDN score.
Returns
-------
score : array of shape = [n_samples,1]
KDN score of each sample in X.
neighbors : array of shape = [n_samples,k]
Indexes of the k neighbors of each sample in X.
References
----------
<NAME>, <NAME>, <NAME>, An instance level analysis of
data complexity,
Machine Learning 95 (2) (2014) 225-256.
"""
nbrs = NearestNeighbors(n_neighbors=k + 1, algorithm='kd_tree').fit(X)
_, indices = nbrs.kneighbors(X)
neighbors = indices[:, 1:]
diff_class = np.tile(y, (k, 1)).transpose() != y[neighbors]
score = np.sum(diff_class, axis=1) / k
return score, neighbors
| 1,027 |
8,649 | package org.hswebframework.web.crud.web;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import org.hswebframework.ezorm.rdb.mapping.ReactiveRepository;
import org.hswebframework.ezorm.rdb.mapping.SyncRepository;
import org.hswebframework.web.api.crud.entity.PagerResult;
import org.hswebframework.web.api.crud.entity.QueryNoPagingOperation;
import org.hswebframework.web.api.crud.entity.QueryOperation;
import org.hswebframework.web.api.crud.entity.QueryParamEntity;
import org.hswebframework.web.authorization.annotation.Authorize;
import org.hswebframework.web.authorization.annotation.QueryAction;
import org.hswebframework.web.exception.NotFoundException;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import java.util.Collections;
import java.util.List;
/**
* 基于{@link SyncRepository}的查询控制器.
*
* @param <E> 实体类
* @param <K> 主键类型
* @see SyncRepository
*/
public interface QueryController<E, K> {
@Authorize(ignore = true)
SyncRepository<E, K> getRepository();
/**
* 查询,但是不返回分页结果.
*
* <pre>
* GET /_query/no-paging?pageIndex=0&pageSize=20&where=name is 张三&orderBy=id desc
* </pre>
*
* @param query 动态查询条件
* @return 结果流
* @see QueryParamEntity
*/
@GetMapping("/_query/no-paging")
@QueryAction
@QueryOperation(summary = "使用GET方式分页动态查询(不返回总数)",
description = "此操作不返回分页总数,如果需要获取全部数据,请设置参数paging=false")
default List<E> query(@Parameter(hidden = true) QueryParamEntity query) {
return getRepository()
.createQuery()
.setParam(query)
.fetch();
}
/**
* POST方式查询.不返回分页结果
*
* <pre>
* POST /_query/no-paging
*
* {
* "pageIndex":0,
* "pageSize":20,
* "where":"name like 张%", //放心使用,没有SQL注入
* "orderBy":"id desc",
* "terms":[ //高级条件
* {
* "column":"name",
* "termType":"like",
* "value":"张%"
* }
* ]
* }
* </pre>
*
* @param query 查询条件
* @return 结果流
* @see QueryParamEntity
*/
@PostMapping("/_query/no-paging")
@QueryAction
@QueryNoPagingOperation(summary = "使用POST方式分页动态查询(不返回总数)",
description = "此操作不返回分页总数,如果需要获取全部数据,请设置参数paging=false")
default List<E> postQuery(@Parameter(hidden = true) @RequestBody QueryParamEntity query) {
return this.query(query);
}
/**
* GET方式分页查询
*
* <pre>
* GET /_query/no-paging?pageIndex=0&pageSize=20&where=name is 张三&orderBy=id desc
* </pre>
*
* @param query 查询条件
* @return 分页查询结果
* @see PagerResult
*/
@GetMapping("/_query")
@QueryAction
@QueryOperation(summary = "使用GET方式分页动态查询")
default PagerResult<E> queryPager(@Parameter(hidden = true) QueryParamEntity query) {
if (query.getTotal() != null) {
return PagerResult
.of(query.getTotal(),
getRepository()
.createQuery()
.setParam(query.rePaging(query.getTotal()))
.fetch(), query)
;
}
int total = getRepository().createQuery().setParam(query.clone()).count();
if (total == 0) {
return PagerResult.of(0, Collections.emptyList(), query);
}
query.rePaging(total);
return PagerResult
.of(total,
getRepository()
.createQuery()
.setParam(query.rePaging(query.getTotal()))
.fetch(), query);
}
@PostMapping("/_query")
@QueryAction
@SuppressWarnings("all")
@QueryOperation(summary = "使用POST方式分页动态查询")
default PagerResult<E> postQueryPager(@Parameter(hidden = true) @RequestBody QueryParamEntity query) {
return queryPager(query);
}
@PostMapping("/_count")
@QueryAction
@QueryNoPagingOperation(summary = "使用POST方式查询总数")
default int postCount(@Parameter(hidden = true) @RequestBody QueryParamEntity query) {
return this.count(query);
}
/**
* 统计查询
*
* <pre>
* GET /_count
* </pre>
*
* @param query 查询条件
* @return 统计结果
*/
@GetMapping("/_count")
@QueryAction
@QueryNoPagingOperation(summary = "使用GET方式查询总数")
default int count(@Parameter(hidden = true) QueryParamEntity query) {
return getRepository()
.createQuery()
.setParam(query)
.count();
}
@GetMapping("/{id:.+}")
@QueryAction
@Operation(summary = "根据ID查询")
default E getById(@PathVariable K id) {
return getRepository()
.findById(id)
.orElseThrow(NotFoundException::new);
}
}
| 2,862 |
879 | package org.zstack.sdk;
public class ResetTemplateConfigResult {
}
| 23 |
348 | <reponame>chamberone/Leaflet.PixiOverlay<filename>docs/data/leg-t2/062/06205773.json<gh_stars>100-1000
{"nom":"Samer","circ":"5ème circonscription","dpt":"Pas-de-Calais","inscrits":2928,"abs":1732,"votants":1196,"blancs":59,"nuls":33,"exp":1104,"res":[{"nuance":"REM","nom":"<NAME>","voix":640},{"nuance":"FN","nom":"<NAME>","voix":464}]} | 144 |
514 | <filename>src/gfx/sun.cpp<gh_stars>100-1000
#include "gfx/sun.hpp"
using namespace gfx;
void Sun::update(
level::Area &area,
const util::PerspectiveCamera &camera) {
const auto old_view_proj = this->camera.proj * this->camera.view;
// TODO: configured by area size
const f32 distance = 128.0f;
const f32 frustum_size = 256.0f;
const glm::vec2 depth_range = glm::vec2(1.0f, 256.0f);
const auto
n_direction = -glm::normalize(this->direction),
position = camera.position + (n_direction * distance);
const auto
min = glm::vec2(-frustum_size),
max = glm::vec2(frustum_size);
this->camera.proj =
glm::ortho(
min.x, max.x, min.y, max.y,
depth_range.x, depth_range.y);
this->camera.view =
glm::lookAt(
position,
camera.position,
glm::vec3(0.0f, 1.0f, 0.0f));
// TODO: !!! BAD HACK
static bool first = true;
const auto view_proj = !first ? old_view_proj : (this->camera.proj * this->camera.view);
first = false;
// take real view center, project into shadow map space
// additionally move from [-1, 1] NDC into [0, 1] space
const auto center_s =
(((view_proj * glm::vec4(camera.position, 1.0)).xyz()) * 0.5f) + 0.5f;
// comput offset from nearest texel
const auto texel = 1.0f / this->texture_size;
const auto offset = glm::mod(center_s.xy(), texel);
// translate center according to offset to get texel-quantized center
// move back into [-1, 1] space
const auto center_fixed =
(glm::vec3(center_s.xy() - offset, center_s.z) * 2.0f) - 1.0f;
// transform into world space
const auto center_fixed_w =
(glm::inverse(view_proj) * glm::vec4(center_fixed, 1.0)).xyz();
// use corrected center in view matrix
this->camera.view =
glm::lookAt(
position,
center_fixed_w,
glm::vec3(0.0f, 1.0f, 0.0f));
}
void Sun::set_uniforms(Program &program) {
this->camera.set_uniforms("u_sun", program);
program.try_set("u_sun_direction", glm::vec4(this->direction, 0.0));
program.try_set("u_sun_diffuse", glm::vec4(this->diffuse, 1.0));
program.try_set("u_sun_ambient", glm::vec4(this->ambient, 1.0));
}
| 1,022 |
3,212 | /*
* Copyright 2014 the original author or 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 org.apache.nifi.processors.gettcp;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
/**
*
*/
public class Server extends AbstractSocketHandler {
public static void main(String[] args) throws Exception {
InetSocketAddress address = new InetSocketAddress(9999);
Server server = new Server(address, 4096, (byte) '\n');
server.start();
System.in.read();
}
/**
* @param address the socket address
* @param readingBufferSize the buffer size
* @param endOfMessageByte the byte indicating the EOM
*/
public Server(InetSocketAddress address, int readingBufferSize, byte endOfMessageByte) {
super(address, readingBufferSize, endOfMessageByte);
}
/**
*
*/
@Override
InetSocketAddress connect() throws IOException {
this.rootChannel = ServerSocketChannel.open();
ServerSocketChannel channel = (ServerSocketChannel) rootChannel;
channel.configureBlocking(false);
channel.socket().bind(this.address);
channel.register(this.selector, SelectionKey.OP_ACCEPT);
return this.address;
}
/**
*
*/
@Override
void doAccept(SelectionKey selectionKey) throws IOException {
ServerSocketChannel serverChannel = (ServerSocketChannel) selectionKey.channel();
SocketChannel channel = serverChannel.accept();
if (logger.isInfoEnabled()) {
logger.info("Accepted connection from: " + channel.socket());
}
channel.configureBlocking(false);
channel.register(this.selector, SelectionKey.OP_READ);
}
/**
* Unlike the client side the read on the server will happen using receiving
* thread.
*/
@Override
void processData(SelectionKey selectionKey, ByteBuffer readBuffer) throws IOException {
logger.info("Server received message of " + readBuffer.limit() + " bytes in size and will delegate to all registered clients.");
for (SelectionKey key : selector.keys()) {
if (key.isValid() && key.channel() instanceof SocketChannel && !selectionKey.equals(key)) {
if (logger.isDebugEnabled()) {
logger.debug("Distributing incoming message to " + key.channel());
}
SocketChannel sch = (SocketChannel) key.channel();
sch.write(readBuffer);
readBuffer.rewind();
}
}
}
} | 1,152 |
8,629 | <reponame>vvd170501/ClickHouse<gh_stars>1000+
#include <Backups/BackupCoordinationHelpers.h>
#include <Storages/MergeTree/MergeTreePartInfo.h>
#include <Common/Exception.h>
#include <Common/escapeForFileName.h>
#include <IO/ReadHelpers.h>
#include <base/chrono_io.h>
#include <boost/range/adaptor/map.hpp>
namespace DB
{
namespace ErrorCodes
{
extern const int CANNOT_BACKUP_TABLE;
extern const int FAILED_TO_SYNC_BACKUP_OR_RESTORE;
extern const int LOGICAL_ERROR;
}
namespace
{
struct LessReplicaName
{
bool operator()(const std::shared_ptr<const String> & left, const std::shared_ptr<const String> & right) { return *left < *right; }
};
}
class BackupCoordinationReplicatedPartNames::CoveredPartsFinder
{
public:
explicit CoveredPartsFinder(const String & table_name_for_logs_) : table_name_for_logs(table_name_for_logs_) {}
void addPartName(const String & new_part_name, const std::shared_ptr<const String> & replica_name)
{
addPartName(MergeTreePartInfo::fromPartName(new_part_name, MERGE_TREE_DATA_MIN_FORMAT_VERSION_WITH_CUSTOM_PARTITIONING), replica_name);
}
void addPartName(MergeTreePartInfo && new_part_info, const std::shared_ptr<const String> & replica_name)
{
auto new_min_block = new_part_info.min_block;
auto new_max_block = new_part_info.max_block;
auto & parts = partitions[new_part_info.partition_id];
/// Find the first part with max_block >= `part_info.min_block`.
auto first_it = parts.lower_bound(new_min_block);
if (first_it == parts.end())
{
/// All max_blocks < part_info.min_block, so we can safely add the `part_info` to the list of parts.
parts.emplace(new_max_block, PartInfo{std::move(new_part_info), replica_name});
return;
}
{
/// part_info.min_block <= current_info.max_block
const auto & part = first_it->second;
if (new_max_block < part.info.min_block)
{
/// (prev_info.max_block < part_info.min_block) AND (part_info.max_block < current_info.min_block),
/// so we can safely add the `part_info` to the list of parts.
parts.emplace(new_max_block, PartInfo{std::move(new_part_info), replica_name});
return;
}
/// (part_info.min_block <= current_info.max_block) AND (part_info.max_block >= current_info.min_block), parts intersect.
if (part.info.contains(new_part_info))
{
/// `part_info` is already contained in another part.
return;
}
}
/// Probably `part_info` is going to replace multiple parts, find the range of parts to replace.
auto last_it = first_it;
while (last_it != parts.end())
{
const auto & part = last_it->second;
if (part.info.min_block > new_max_block)
break;
if (!new_part_info.contains(part.info))
{
throw Exception(
ErrorCodes::CANNOT_BACKUP_TABLE,
"Intersected parts detected in the table {}: {} on replica {} and {} on replica {}. It should be investigated",
table_name_for_logs,
part.info.getPartName(),
*part.replica_name,
new_part_info.getPartName(),
*replica_name);
}
++last_it;
}
/// `part_info` will replace multiple parts [first_it..last_it)
parts.erase(first_it, last_it);
parts.emplace(new_max_block, PartInfo{std::move(new_part_info), replica_name});
}
bool isCoveredByAnotherPart(const String & part_name) const
{
return isCoveredByAnotherPart(MergeTreePartInfo::fromPartName(part_name, MERGE_TREE_DATA_MIN_FORMAT_VERSION_WITH_CUSTOM_PARTITIONING));
}
bool isCoveredByAnotherPart(const MergeTreePartInfo & part_info) const
{
auto partition_it = partitions.find(part_info.partition_id);
if (partition_it == partitions.end())
return false;
const auto & parts = partition_it->second;
/// Find the first part with max_block >= `part_info.min_block`.
auto it_part = parts.lower_bound(part_info.min_block);
if (it_part == parts.end())
{
/// All max_blocks < part_info.min_block, so there is no parts covering `part_info`.
return false;
}
/// part_info.min_block <= current_info.max_block
const auto & existing_part = it_part->second;
if (part_info.max_block < existing_part.info.min_block)
{
/// (prev_info.max_block < part_info.min_block) AND (part_info.max_block < current_info.min_block),
/// so there is no parts covering `part_info`.
return false;
}
/// (part_info.min_block <= current_info.max_block) AND (part_info.max_block >= current_info.min_block), parts intersect.
if (existing_part.info == part_info)
{
/// It's the same part, it's kind of covers itself, but we check in this function whether a part is covered by another part.
return false;
}
/// Check if `part_info` is covered by `current_info`.
return existing_part.info.contains(part_info);
}
private:
struct PartInfo
{
MergeTreePartInfo info;
std::shared_ptr<const String> replica_name;
};
using Parts = std::map<Int64 /* max_block */, PartInfo>;
std::unordered_map<String, Parts> partitions;
const String table_name_for_logs;
};
BackupCoordinationReplicatedPartNames::BackupCoordinationReplicatedPartNames() = default;
BackupCoordinationReplicatedPartNames::~BackupCoordinationReplicatedPartNames() = default;
void BackupCoordinationReplicatedPartNames::addPartNames(
const String & table_zk_path,
const String & table_name_for_logs,
const String & replica_name,
const std::vector<PartNameAndChecksum> & part_names_and_checksums)
{
if (part_names_prepared)
throw Exception(ErrorCodes::LOGICAL_ERROR, "addPartNames() must not be called after getPartNames()");
auto & table_info = table_infos[table_zk_path];
if (!table_info.covered_parts_finder)
table_info.covered_parts_finder = std::make_unique<CoveredPartsFinder>(table_name_for_logs);
auto replica_name_ptr = std::make_shared<String>(replica_name);
for (const auto & part_name_and_checksum : part_names_and_checksums)
{
const auto & part_name = part_name_and_checksum.part_name;
const auto & checksum = part_name_and_checksum.checksum;
auto it = table_info.parts_replicas.find(part_name);
if (it == table_info.parts_replicas.end())
{
it = table_info.parts_replicas.emplace(part_name, PartReplicas{}).first;
it->second.checksum = checksum;
}
else
{
const auto & other = it->second;
if (other.checksum != checksum)
{
const String & other_replica_name = **other.replica_names.begin();
throw Exception(
ErrorCodes::CANNOT_BACKUP_TABLE,
"Table {} on replica {} has part {} which is different from the part on replica {}. Must be the same",
table_name_for_logs,
replica_name,
part_name,
other_replica_name);
}
}
auto & replica_names = it->second.replica_names;
/// `replica_names` should be ordered because we need this vector to be in the same order on every replica.
replica_names.insert(
std::upper_bound(replica_names.begin(), replica_names.end(), replica_name_ptr, LessReplicaName{}), replica_name_ptr);
table_info.covered_parts_finder->addPartName(part_name, replica_name_ptr);
}
}
Strings BackupCoordinationReplicatedPartNames::getPartNames(const String & table_zk_path, const String & replica_name) const
{
preparePartNames();
auto it = table_infos.find(table_zk_path);
if (it == table_infos.end())
return {};
const auto & replicas_parts = it->second.replicas_parts;
auto it2 = replicas_parts.find(replica_name);
if (it2 == replicas_parts.end())
return {};
return it2->second;
}
void BackupCoordinationReplicatedPartNames::preparePartNames() const
{
if (part_names_prepared)
return;
size_t counter = 0;
for (const auto & table_info : table_infos | boost::adaptors::map_values)
{
for (const auto & [part_name, part_replicas] : table_info.parts_replicas)
{
if (table_info.covered_parts_finder->isCoveredByAnotherPart(part_name))
continue;
size_t chosen_index = (counter++) % part_replicas.replica_names.size();
const auto & chosen_replica_name = *part_replicas.replica_names[chosen_index];
table_info.replicas_parts[chosen_replica_name].push_back(part_name);
}
}
part_names_prepared = true;
}
/// Helps to wait until all hosts come to a specified stage.
BackupCoordinationStageSync::BackupCoordinationStageSync(const String & zookeeper_path_, zkutil::GetZooKeeper get_zookeeper_, Poco::Logger * log_)
: zookeeper_path(zookeeper_path_)
, get_zookeeper(get_zookeeper_)
, log(log_)
{
createRootNodes();
}
void BackupCoordinationStageSync::createRootNodes()
{
auto zookeeper = get_zookeeper();
zookeeper->createAncestors(zookeeper_path);
zookeeper->createIfNotExists(zookeeper_path, "");
}
void BackupCoordinationStageSync::syncStage(const String & current_host, int new_stage, const Strings & wait_hosts, std::chrono::seconds timeout)
{
/// Put new stage to ZooKeeper.
auto zookeeper = get_zookeeper();
zookeeper->createIfNotExists(zookeeper_path + "/" + current_host + "|" + std::to_string(new_stage), "");
if (wait_hosts.empty() || ((wait_hosts.size() == 1) && (wait_hosts.front() == current_host)))
return;
/// Wait for other hosts.
/// Current stages of all hosts.
std::optional<String> host_with_error;
std::optional<String> error_message;
std::map<String, std::optional<int>> unready_hosts;
for (const String & host : wait_hosts)
unready_hosts.emplace(host, std::optional<int>{});
/// Process ZooKeeper's nodes and set `all_hosts_ready` or `unready_host` or `error_message`.
auto process_zk_nodes = [&](const Strings & zk_nodes)
{
for (const String & zk_node : zk_nodes)
{
if (zk_node == "error")
{
String str = zookeeper->get(zookeeper_path + "/" + zk_node);
size_t separator_pos = str.find('|');
if (separator_pos == String::npos)
throw Exception(ErrorCodes::FAILED_TO_SYNC_BACKUP_OR_RESTORE, "Unexpected value of zk node {}: {}", zookeeper_path + "/" + zk_node, str);
host_with_error = str.substr(0, separator_pos);
error_message = str.substr(separator_pos + 1);
return;
}
else if (!zk_node.starts_with("remove_watch-"))
{
size_t separator_pos = zk_node.find('|');
if (separator_pos == String::npos)
throw Exception(ErrorCodes::FAILED_TO_SYNC_BACKUP_OR_RESTORE, "Unexpected zk node {}", zookeeper_path + "/" + zk_node);
String host = zk_node.substr(0, separator_pos);
int found_stage = parseFromString<int>(zk_node.substr(separator_pos + 1));
auto it = unready_hosts.find(host);
if (it != unready_hosts.end())
{
auto & stage = it->second;
if (!stage || (stage < found_stage))
stage = found_stage;
if (stage >= new_stage)
unready_hosts.erase(it);
}
}
}
};
/// Wait until all hosts are ready or an error happens or time is out.
std::atomic<bool> watch_set = false;
std::condition_variable watch_triggered_event;
auto watch_callback = [&](const Coordination::WatchResponse &)
{
watch_set = false; /// After it's triggered it's not set until we call getChildrenWatch() again.
watch_triggered_event.notify_all();
};
auto watch_triggered = [&] { return !watch_set; };
bool use_timeout = (timeout.count() >= 0);
std::chrono::steady_clock::time_point start_time = std::chrono::steady_clock::now();
std::chrono::steady_clock::duration elapsed;
std::mutex dummy_mutex;
while (!unready_hosts.empty() && !error_message)
{
watch_set = true;
Strings nodes = zookeeper->getChildrenWatch(zookeeper_path, nullptr, watch_callback);
process_zk_nodes(nodes);
if (!unready_hosts.empty() && !error_message)
{
LOG_TRACE(log, "Waiting for host {}", unready_hosts.begin()->first);
std::unique_lock dummy_lock{dummy_mutex};
if (use_timeout)
{
elapsed = std::chrono::steady_clock::now() - start_time;
if ((elapsed > timeout) || !watch_triggered_event.wait_for(dummy_lock, timeout - elapsed, watch_triggered))
break;
}
else
watch_triggered_event.wait(dummy_lock, watch_triggered);
}
}
if (watch_set)
{
/// Remove watch by triggering it.
zookeeper->create(zookeeper_path + "/remove_watch-", "", zkutil::CreateMode::EphemeralSequential);
std::unique_lock dummy_lock{dummy_mutex};
watch_triggered_event.wait(dummy_lock, watch_triggered);
}
if (error_message)
throw Exception(ErrorCodes::FAILED_TO_SYNC_BACKUP_OR_RESTORE, "Error occurred on host {}: {}", *host_with_error, *error_message);
if (!unready_hosts.empty())
{
throw Exception(
ErrorCodes::FAILED_TO_SYNC_BACKUP_OR_RESTORE,
"Waited for host {} too long ({})",
unready_hosts.begin()->first,
to_string(elapsed));
}
}
void BackupCoordinationStageSync::syncStageError(const String & current_host, const String & error_message)
{
auto zookeeper = get_zookeeper();
zookeeper->createIfNotExists(zookeeper_path + "/error", current_host + "|" + error_message);
}
}
| 6,457 |
618 | package hprose.example.io;
import hprose.io.convert.Converter;
import java.lang.reflect.Type;
import java.util.Map;
import org.apache.commons.lang3.tuple.ImmutablePair;
public class ImmutablePairConverter implements Converter<ImmutablePair> {
public static final ImmutablePairConverter instance = new ImmutablePairConverter();
public ImmutablePair convertTo(Object[] array) {
return new ImmutablePair(array[0], array[1]);
}
public ImmutablePair convertTo(Map<?, ?> map) {
if (map.size() == 1) {
Map.Entry entry = map.entrySet().iterator().next();
return new ImmutablePair(entry.getKey(), entry.getValue());
}
if (map.containsKey("key") && map.containsKey("value")) {
return new ImmutablePair(map.get("key"), map.get("value"));
}
if (map.containsKey("left") && map.containsKey("right")) {
return new ImmutablePair(map.get("left"), map.get("right"));
}
return null;
}
@Override
public ImmutablePair convertTo(Object obj, Type type) {
if (obj.getClass().isArray()) {
return convertTo((Object[]) obj);
}
else if (obj instanceof Map) {
return convertTo((Map<?, ?>) obj);
}
return (ImmutablePair) obj;
}
}
| 558 |
1,299 | /*
* 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.tika.parser.microsoft.ooxml;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.zip.ZipException;
import org.apache.commons.io.input.CloseShieldInputStream;
import org.apache.poi.openxml4j.exceptions.InvalidFormatException;
import org.apache.poi.openxml4j.opc.OPCPackage;
import org.apache.poi.openxml4j.opc.PackagePart;
import org.apache.poi.openxml4j.opc.PackagePartName;
import org.apache.poi.openxml4j.opc.PackageRelationship;
import org.apache.poi.openxml4j.opc.PackageRelationshipCollection;
import org.apache.poi.openxml4j.opc.PackagingURIHelper;
import org.apache.poi.openxml4j.opc.TargetMode;
import org.apache.poi.xslf.usermodel.XSLFRelation;
import org.xml.sax.Attributes;
import org.xml.sax.ContentHandler;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;
import org.apache.tika.exception.TikaException;
import org.apache.tika.metadata.Metadata;
import org.apache.tika.metadata.TikaCoreProperties;
import org.apache.tika.parser.ParseContext;
import org.apache.tika.parser.microsoft.ooxml.xslf.XSLFEventBasedPowerPointExtractor;
import org.apache.tika.sax.EmbeddedContentHandler;
import org.apache.tika.sax.OfflineContentHandler;
import org.apache.tika.sax.XHTMLContentHandler;
import org.apache.tika.utils.ExceptionUtils;
import org.apache.tika.utils.XMLReaderUtils;
/**
* SAX/Streaming pptx extractior
*/
public class SXSLFPowerPointExtractorDecorator extends AbstractOOXMLExtractor {
private final static String HANDOUT_MASTER =
"http://schemas.openxmlformats.org/officeDocument/2006/relationships/handoutMaster";
//a pptx file should have one of these "main story" parts
private final static String[] MAIN_STORY_PART_RELATIONS =
new String[]{XSLFRelation.MAIN.getContentType(),
XSLFRelation.PRESENTATION_MACRO.getContentType(),
XSLFRelation.PRESENTATIONML.getContentType(),
XSLFRelation.PRESENTATIONML_TEMPLATE.getContentType(),
XSLFRelation.MACRO.getContentType(),
XSLFRelation.MACRO_TEMPLATE.getContentType(),
XSLFRelation.THEME_MANAGER.getContentType()
//TODO: what else
};
private final OPCPackage opcPackage;
private final ParseContext context;
private final Metadata metadata;
private final CommentAuthors commentAuthors = new CommentAuthors();
private PackagePart mainDocument = null;
public SXSLFPowerPointExtractorDecorator(Metadata metadata, ParseContext context,
XSLFEventBasedPowerPointExtractor extractor) {
super(context, extractor);
this.metadata = metadata;
this.context = context;
this.opcPackage = extractor.getPackage();
for (String contentType : MAIN_STORY_PART_RELATIONS) {
List<PackagePart> pps = opcPackage.getPartsByContentType(contentType);
if (pps.size() > 0) {
mainDocument = pps.get(0);
break;
}
}
//if mainDocument == null, throw exception
}
/**
* @see org.apache.poi.xslf.extractor.XSLFPowerPointExtractor#getText()
*/
protected void buildXHTML(XHTMLContentHandler xhtml) throws SAXException, IOException {
loadCommentAuthors();
PackageRelationshipCollection slidesPRC = null;
try {
slidesPRC = mainDocument.getRelationshipsByType(XSLFRelation.SLIDE.getRelation());
} catch (InvalidFormatException e) {
metadata.add(TikaCoreProperties.TIKA_META_EXCEPTION_WARNING,
ExceptionUtils.getStackTrace(e));
}
if (slidesPRC != null && slidesPRC.size() > 0) {
for (int i = 0; i < slidesPRC.size(); i++) {
try {
handleSlidePart(mainDocument.getRelatedPart(slidesPRC.getRelationship(i)),
xhtml);
} catch (InvalidFormatException | ZipException e) {
metadata.add(TikaCoreProperties.TIKA_META_EXCEPTION_WARNING,
ExceptionUtils.getStackTrace(e));
}
}
}
if (config.isIncludeSlideMasterContent()) {
handleGeneralTextContainingPart(XSLFRelation.SLIDE_MASTER.getRelation(), "slide-master",
mainDocument, metadata, new PlaceHolderSkipper(
new OOXMLWordAndPowerPointTextHandler(
new OOXMLTikaBodyPartHandler(xhtml),
new HashMap<>())));
handleGeneralTextContainingPart(HANDOUT_MASTER, "slide-handout-master", mainDocument,
metadata,
new OOXMLWordAndPowerPointTextHandler(new OOXMLTikaBodyPartHandler(xhtml),
new HashMap<>()));
}
}
private void loadCommentAuthors() {
PackageRelationshipCollection prc = null;
try {
prc = mainDocument.getRelationshipsByType(XSLFRelation.COMMENT_AUTHORS.getRelation());
} catch (InvalidFormatException e) {
metadata.add(TikaCoreProperties.TIKA_META_EXCEPTION_WARNING,
ExceptionUtils.getStackTrace(e));
}
if (prc == null || prc.size() == 0) {
return;
}
for (int i = 0; i < prc.size(); i++) {
PackagePart commentAuthorsPart = null;
try {
commentAuthorsPart = mainDocument.getRelatedPart(prc.getRelationship(i));
} catch (InvalidFormatException e) {
metadata.add(TikaCoreProperties.TIKA_META_EXCEPTION_WARNING,
ExceptionUtils.getStackTrace(e));
}
if (commentAuthorsPart == null) {
continue;
}
try (InputStream stream = commentAuthorsPart.getInputStream()) {
XMLReaderUtils.parseSAX(new CloseShieldInputStream(stream),
new OfflineContentHandler(new XSLFCommentAuthorHandler()), context);
} catch (TikaException | SAXException | IOException e) {
metadata.add(TikaCoreProperties.TIKA_META_EXCEPTION_WARNING,
ExceptionUtils.getStackTrace(e));
}
}
}
private void handleSlidePart(PackagePart slidePart, XHTMLContentHandler xhtml)
throws IOException, SAXException {
Map<String, String> linkedRelationships =
loadLinkedRelationships(slidePart, false, metadata);
// Map<String, String> hyperlinks = loadHyperlinkRelationships(packagePart);
xhtml.startElement("div", "class", "slide-content");
try (InputStream stream = slidePart.getInputStream()) {
XMLReaderUtils.parseSAX(new CloseShieldInputStream(stream), new OfflineContentHandler(
new EmbeddedContentHandler(new OOXMLWordAndPowerPointTextHandler(
new OOXMLTikaBodyPartHandler(xhtml), linkedRelationships))), context);
} catch (TikaException | IOException e) {
metadata.add(TikaCoreProperties.TIKA_META_EXCEPTION_WARNING,
ExceptionUtils.getStackTrace(e));
}
xhtml.endElement("div");
if (config.isIncludeSlideMasterContent()) {
handleGeneralTextContainingPart(XSLFRelation.SLIDE_LAYOUT.getRelation(),
"slide-master-content", slidePart, metadata, new PlaceHolderSkipper(
new OOXMLWordAndPowerPointTextHandler(
new OOXMLTikaBodyPartHandler(xhtml), linkedRelationships)));
}
if (config.isIncludeSlideNotes()) {
handleGeneralTextContainingPart(XSLFRelation.NOTES.getRelation(), "slide-notes",
slidePart, metadata,
new OOXMLWordAndPowerPointTextHandler(new OOXMLTikaBodyPartHandler(xhtml),
linkedRelationships));
if (config.isIncludeSlideMasterContent()) {
handleGeneralTextContainingPart(XSLFRelation.NOTES_MASTER.getRelation(),
"slide-notes-master", slidePart, metadata,
new OOXMLWordAndPowerPointTextHandler(new OOXMLTikaBodyPartHandler(xhtml),
linkedRelationships));
}
}
handleGeneralTextContainingPart(XSLFRelation.COMMENTS.getRelation(), null, slidePart,
metadata, new XSLFCommentsHandler(xhtml));
handleGeneralTextContainingPart(AbstractOOXMLExtractor.RELATION_DIAGRAM_DATA,
"diagram-data", slidePart, metadata,
new OOXMLWordAndPowerPointTextHandler(new OOXMLTikaBodyPartHandler(xhtml),
linkedRelationships));
handleGeneralTextContainingPart(XSLFRelation.CHART.getRelation(), "chart", slidePart,
metadata, new OOXMLWordAndPowerPointTextHandler(new OOXMLTikaBodyPartHandler(xhtml),
linkedRelationships));
}
/**
* In PowerPoint files, slides have things embedded in them,
* and slide drawings which have the images
*/
@Override
protected List<PackagePart> getMainDocumentParts() {
List<PackagePart> parts = new ArrayList<>();
//TODO: consider: getPackage().getPartsByName(Pattern.compile("/ppt/embeddings/.*?
//TODO: consider: getPackage().getPartsByName(Pattern.compile("/ppt/media/.*?
PackageRelationshipCollection slidePRC = null;
try {
slidePRC = mainDocument.getRelationshipsByType(XSLFRelation.SLIDE.getRelation());
} catch (InvalidFormatException e) {
metadata.add(TikaCoreProperties.TIKA_META_EXCEPTION_WARNING,
ExceptionUtils.getStackTrace(e));
}
if (slidePRC != null) {
for (int i = 0; i < slidePRC.size(); i++) {
PackagePart slidePart = null;
try {
slidePart = mainDocument.getRelatedPart(slidePRC.getRelationship(i));
} catch (InvalidFormatException e) {
metadata.add(TikaCoreProperties.TIKA_META_EXCEPTION_WARNING,
ExceptionUtils.getStackTrace(e));
}
addSlideParts(slidePart, parts);
}
}
parts.add(mainDocument);
for (String rel : new String[]{XSLFRelation.SLIDE_MASTER.getRelation(), HANDOUT_MASTER}) {
PackageRelationshipCollection prc = null;
try {
prc = mainDocument.getRelationshipsByType(rel);
} catch (InvalidFormatException e) {
metadata.add(TikaCoreProperties.TIKA_META_EXCEPTION_WARNING,
ExceptionUtils.getStackTrace(e));
}
if (prc != null) {
for (int i = 0; i < prc.size(); i++) {
PackagePart pp = null;
try {
pp = mainDocument.getRelatedPart(prc.getRelationship(i));
} catch (InvalidFormatException e) {
metadata.add(TikaCoreProperties.TIKA_META_EXCEPTION_WARNING,
ExceptionUtils.getStackTrace(e));
}
if (pp != null) {
parts.add(pp);
}
}
}
}
return parts;
}
private void addSlideParts(PackagePart slidePart, List<PackagePart> parts) {
for (String relation : new String[]{XSLFRelation.VML_DRAWING.getRelation(),
XSLFRelation.SLIDE_LAYOUT.getRelation(), XSLFRelation.NOTES_MASTER.getRelation(),
XSLFRelation.NOTES.getRelation()}) {
PackageRelationshipCollection prc = null;
try {
prc = slidePart.getRelationshipsByType(relation);
} catch (InvalidFormatException e) {
metadata.add(TikaCoreProperties.TIKA_META_EXCEPTION_WARNING,
ExceptionUtils.getStackTrace(e));
}
if (prc != null) {
for (PackageRelationship packageRelationship : prc) {
if (packageRelationship.getTargetMode() == TargetMode.INTERNAL) {
PackagePartName relName = null;
try {
relName = PackagingURIHelper
.createPartName(packageRelationship.getTargetURI());
} catch (InvalidFormatException e) {
metadata.add(TikaCoreProperties.TIKA_META_EXCEPTION_WARNING,
ExceptionUtils.getStackTrace(e));
}
if (relName != null) {
parts.add(packageRelationship.getPackage().getPart(relName));
}
}
}
}
}
//and slide of course
parts.add(slidePart);
}
private static class PlaceHolderSkipper extends DefaultHandler {
private final ContentHandler wrappedHandler;
boolean inPH = false;
PlaceHolderSkipper(ContentHandler wrappedHandler) {
this.wrappedHandler = wrappedHandler;
}
@Override
public void startElement(String uri, String localName, String qName, Attributes atts)
throws SAXException {
if ("ph".equals(localName)) {
inPH = true;
}
if (!inPH) {
wrappedHandler.startElement(uri, localName, qName, atts);
}
}
@Override
public void endElement(String uri, String localName, String qName) throws SAXException {
if (!inPH) {
wrappedHandler.endElement(uri, localName, qName);
}
if ("sp".equals(localName)) {
inPH = false;
}
}
@Override
public void characters(char[] ch, int start, int length) throws SAXException {
if (!inPH) {
wrappedHandler.characters(ch, start, length);
}
}
@Override
public void ignorableWhitespace(char[] ch, int start, int length) throws SAXException {
if (!inPH) {
wrappedHandler.characters(ch, start, length);
}
}
}
private class XSLFCommentsHandler extends DefaultHandler {
private String commentAuthorId = null;
private StringBuilder commentBuffer = new StringBuilder();
private XHTMLContentHandler xhtml;
XSLFCommentsHandler(XHTMLContentHandler xhtml) {
this.xhtml = xhtml;
}
@Override
public void startElement(String uri, String localName, String qName, Attributes atts)
throws SAXException {
if ("cm".equals(localName)) {
commentAuthorId = atts.getValue("", "authorId");
//get date (dt)?
}
}
@Override
public void characters(char[] ch, int start, int length) throws SAXException {
//TODO: require that we're in <p:text>?
commentBuffer.append(ch, start, length);
}
@Override
public void endElement(String uri, String localName, String qName) throws SAXException {
if ("cm".equals(localName)) {
xhtml.startElement("p", "class", "slide-comment");
String authorString = commentAuthors.getName(commentAuthorId);
String authorInitials = commentAuthors.getInitials(commentAuthorId);
if (authorString != null || authorInitials != null) {
xhtml.startElement("b");
boolean authorExists = false;
if (authorString != null) {
xhtml.characters(authorString);
authorExists = true;
}
if (authorExists && authorInitials != null) {
xhtml.characters(" (");
}
if (authorInitials != null) {
xhtml.characters(authorInitials);
}
if (authorExists && authorInitials != null) {
xhtml.characters(")");
}
xhtml.endElement("b");
}
xhtml.characters(commentBuffer.toString());
xhtml.endElement("p");
commentBuffer.setLength(0);
commentAuthorId = null;
}
}
}
private class XSLFCommentAuthorHandler extends DefaultHandler {
String id = null;
String name = null;
String initials = null;
@Override
public void startElement(String uri, String localName, String qName, Attributes atts)
throws SAXException {
if ("cmAuthor".equals(localName)) {
for (int i = 0; i < atts.getLength(); i++) {
if ("id".equals(atts.getLocalName(i))) {
id = atts.getValue(i);
} else if ("name".equals(atts.getLocalName(i))) {
name = atts.getValue(i);
} else if ("initials".equals(atts.getLocalName(i))) {
initials = atts.getValue(i);
}
}
commentAuthors.add(id, name, initials);
//clear out
id = null;
name = null;
initials = null;
}
}
}
private static class CommentAuthors {
Map<String, String> nameMap = new HashMap<>();
Map<String, String> initialMap = new HashMap<>();
void add(String id, String name, String initials) {
if (id == null) {
return;
}
if (name != null) {
nameMap.put(id, name);
}
if (initials != null) {
initialMap.put(id, initials);
}
}
String getName(String id) {
if (id == null) {
return null;
}
return nameMap.get(id);
}
String getInitials(String id) {
if (id == null) {
return null;
}
return initialMap.get(id);
}
}
}
| 9,395 |
1,603 | # coding: utf-8
from .ArticlesUrls import PublicAccountsWeb
from .ArticlesInfo import ArticlesInfo
class ArticlesAPI(object):
"""
整合PublicAccountsWeb和ArticlesInfo，该API慎用，不再维护
"""
def __init__(
self,
username=None,
password=<PASSWORD>,
official_cookie=None,
token=None,
appmsg_token=None,
wechat_cookie=None,
outfile=None,
):
"""
初始化参数
Parameters
----------
username: str
用户账号
password: str
用户密码
official_cookie : str
登录微信公众号平台之后获取的cookie
token : str
登录微信公众号平台之后获取的token
wechat_cookie: str
点开微信公众号文章抓包工具获取的cookie
appmsg_token: str
点开微信公众号文章抓包工具获取的appmsg_token
"""
# 两种登录方式, 扫码登录和手动输入登录
if (token != None) and (official_cookie != None):
self.official = PublicAccountsWeb(cookie=official_cookie, token=token)
elif (username != None) and (password != None):
self.official = PublicAccountsWeb(username=username, password=password)
else:
raise SystemError("please check your params")
# 支持两种方式， mitmproxy自动获取参数和手动获取参数
if (appmsg_token == None) and (wechat_cookie == None) and (outfile != None):
raise SystemError("Not support this method")
elif (appmsg_token != None) and (wechat_cookie != None):
self.appmsg_token, self.cookie = appmsg_token, wechat_cookie
else:
raise SystemError("please check your params")
self.wechat = ArticlesInfo(self.appmsg_token, self.cookie)
def complete_info(self, nickname, begin=0, count=5):
"""
获取公众号的抓取的文章文章信息
Parameters
----------
nickname: str
公众号名称
begin: str or int
起始爬取的页数
count: str or int
每次爬取的数量，1-5
Returns
-------
list:
由每个文章信息构成的数组::
[
{
'aid': '2650949647_1',
'appmsgid': 2650949647,
'comments': 文章评论信息
{
"base_resp": {
"errmsg": "ok",
"ret": 0
},
"elected_comment": [
{
"content": 用户评论文字,
"content_id": "6846263421277569047",
"create_time": 1520098511,
"id": 3,
"is_from_friend": 0,
"is_from_me": 0,
"is_top": 0, 是否被置顶
"like_id": 10001,
"like_num": 3,
"like_status": 0,
"logo_url": "http://wx.qlogo.cn/mmhead/OibRNdtlJdkFLMHYLMR92Lvq0PicDpJpbnaicP3Z6kVcCicLPVjCWbAA9w/132",
"my_id": 23,
"nick_name": 评论用户的名字,
"reply": {
"reply_list": [ ]
}
}
],
"elected_comment_total_cnt": 3, 评论总数
"enabled": 1,
"friend_comment": [ ],
"is_fans": 1,
"logo_url": "http://wx.qlogo.cn/mmhead/Q3auHgzwzM6GAic0FAHOu9Gtv5lEu5kUqO6y6EjEFjAhuhUNIS7Y2AQ/132",
"my_comment": [ ],
"nick_name": 当前用户名,
"only_fans_can_comment": false
},
'cover': 封面的url'digest': 文章摘要,
'itemidx': 1,
'like_num': 18, 文章点赞数
'link': 文章的url,
'read_num': 610, 文章阅读数
'title': 文章标题,
'update_time': 更新文章的时间戳
},
]
如果list为空则说明没有相关文章
"""
# 获取文章数据
article_data = self.official.get_urls(
nickname, begin=str(begin), count=str(count)
)
# 提取每个文章的url，获取文章的点赞、阅读、评论信息，并加入到原来的json中
for data in article_data:
article_url = data["link"]
comments = self.wechat.comments(article_url)
read_like_nums = self.wechat.read_like_nums(article_url)
data["comments"] = comments
data["read_num"], data["like_num"], data["old_like_num"] = read_like_nums
return article_data
def __extract_info(self, articles_data):
# 提取每个文章的url，获取文章的点赞、阅读、评论信息，并加入到原来的json中
for data in articles_data:
article_url = data["link"]
comments = self.wechat.comments(article_url)
read_like_nums = self.wechat.read_like_nums(article_url)
data["comments"] = comments
data["read_num"], data["like_num"], data["old_like_num"] = read_like_nums
return articles_data
def continue_info(self, nickname, begin=0):
"""
自动获取公众号的抓取的文章文章信息，直到爬取失败为止
Parameters
----------
nickname: str
公众号名称
begin: str or int
起始爬取的页数
Returns
-------
list:
由每个文章信息构成的数组::
[
{
'aid': '2650949647_1',
'appmsgid': 2650949647,
'comments': 文章评论信息
{
"base_resp": {
"errmsg": "ok",
"ret": 0
},
"elected_comment": [
{
"content": 用户评论文字,
"content_id": "6846263421277569047",
"create_time": 1520098511,
"id": 3,
"is_from_friend": 0,
"is_from_me": 0,
"is_top": 0, 是否被置顶
"like_id": 10001,
"like_num": 3,
"like_status": 0,
"logo_url": "http://wx.qlogo.cn/mmhead/OibRNdtlJdkFLMHYLMR92Lvq0PicDpJpbnaicP3Z6kVcCicLPVjCWbAA9w/132",
"my_id": 23,
"nick_name": 评论用户的名字,
"reply": {
"reply_list": [ ]
}
}
],
"elected_comment_total_cnt": 3, 评论总数
"enabled": 1,
"friend_comment": [ ],
"is_fans": 1,
"logo_url": "http://wx.qlogo.cn/mmhead/Q3auHgzwzM6GAic0FAHOu9Gtv5lEu5kUqO6y6EjEFjAhuhUNIS7Y2AQ/132",
"my_comment": [ ],
"nick_name": 当前用户名,
"only_fans_can_comment": false
},
'cover': 封面的url'digest': 文章摘要,
'itemidx': 1,
'like_num': 18, 文章点赞数
'link': 文章的url,
'read_num': 610, 文章阅读数
'title': 文章标题,
'update_time': 更新文章的时间戳
},
]
如果list为空则说明没有相关文章
"""
article_datas = []
count = 5
while True:
try:
# 获取文章数据
article_datas.append(
self.official.get_urls(nickname, begin=str(begin), count=str(count))
)
except Exception as e:
print(e)
break
begin += count
if begin > 40:
break
def flatten(x):
return [y for l in x for y in flatten(l)] if type(x) is list else [x]
# flatten = lambda x: [y for l in x for y in flatten(l)] if type(x) is list else [x]
print("第{}篇文章爬取失败，请过段时间再次尝试或换个帐号继续爬取".format(begin))
return self.__extract_info(flatten(article_datas))
| 6,896 |
1,664 | /*
* 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.ambari.server.controller.internal;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.EnumSet;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import org.apache.ambari.server.AmbariException;
import org.apache.ambari.server.controller.AmbariManagementController;
import org.apache.ambari.server.controller.ConfigurationResponse;
import org.apache.ambari.server.controller.ServiceConfigVersionRequest;
import org.apache.ambari.server.controller.ServiceConfigVersionResponse;
import org.apache.ambari.server.controller.spi.NoSuchParentResourceException;
import org.apache.ambari.server.controller.spi.NoSuchResourceException;
import org.apache.ambari.server.controller.spi.Predicate;
import org.apache.ambari.server.controller.spi.Request;
import org.apache.ambari.server.controller.spi.RequestStatus;
import org.apache.ambari.server.controller.spi.Resource;
import org.apache.ambari.server.controller.spi.ResourceAlreadyExistsException;
import org.apache.ambari.server.controller.spi.SystemException;
import org.apache.ambari.server.controller.spi.UnsupportedPropertyException;
import org.apache.ambari.server.security.authorization.RoleAuthorization;
public class ServiceConfigVersionResourceProvider extends
AbstractControllerResourceProvider {
public static final String CLUSTER_NAME_PROPERTY_ID = "cluster_name";
public static final String SERVICE_CONFIG_VERSION_PROPERTY_ID = "service_config_version";
public static final String SERVICE_NAME_PROPERTY_ID = "service_name";
public static final String CREATE_TIME_PROPERTY_ID = "createtime";
public static final String USER_PROPERTY_ID = "user";
public static final String SERVICE_CONFIG_VERSION_NOTE_PROPERTY_ID = "service_config_version_note";
public static final String GROUP_ID_PROPERTY_ID = "group_id";
public static final String GROUP_NAME_PROPERTY_ID = "group_name";
public static final String STACK_ID_PROPERTY_ID = "stack_id";
public static final String IS_CURRENT_PROPERTY_ID = "is_current";
public static final String IS_COMPATIBLE_PROPERTY_ID = "is_cluster_compatible";
public static final String HOSTS_PROPERTY_ID = "hosts";
public static final String CONFIGURATIONS_PROPERTY_ID = "configurations";
public static final String APPLIED_TIME_PROPERTY_ID = "appliedtime";
/**
* The property ids for a service configuration resource.
*/
private static final Set<String> PROPERTY_IDS = new HashSet<>();
/**
* The key property ids for a service configuration resource.
*/
private static final Map<Resource.Type, String> KEY_PROPERTY_IDS = new HashMap<>();
static {
// properties
PROPERTY_IDS.add(CLUSTER_NAME_PROPERTY_ID);
PROPERTY_IDS.add(SERVICE_CONFIG_VERSION_PROPERTY_ID);
PROPERTY_IDS.add(SERVICE_NAME_PROPERTY_ID);
PROPERTY_IDS.add(CREATE_TIME_PROPERTY_ID);
PROPERTY_IDS.add(USER_PROPERTY_ID);
PROPERTY_IDS.add(SERVICE_CONFIG_VERSION_NOTE_PROPERTY_ID);
PROPERTY_IDS.add(GROUP_ID_PROPERTY_ID);
PROPERTY_IDS.add(GROUP_NAME_PROPERTY_ID);
PROPERTY_IDS.add(STACK_ID_PROPERTY_ID);
PROPERTY_IDS.add(IS_CURRENT_PROPERTY_ID);
PROPERTY_IDS.add(HOSTS_PROPERTY_ID);
PROPERTY_IDS.add(CONFIGURATIONS_PROPERTY_ID);
PROPERTY_IDS.add(IS_COMPATIBLE_PROPERTY_ID);
// keys
KEY_PROPERTY_IDS.put(Resource.Type.Service, SERVICE_NAME_PROPERTY_ID);
KEY_PROPERTY_IDS.put(Resource.Type.Cluster, CLUSTER_NAME_PROPERTY_ID);
KEY_PROPERTY_IDS.put(Resource.Type.ServiceConfigVersion,SERVICE_CONFIG_VERSION_PROPERTY_ID);
}
/**
* The primary key property ids for the service config version resource type.
*/
private static final Set<String> pkPropertyIds =
new HashSet<>(Arrays.asList(new String[]{
CLUSTER_NAME_PROPERTY_ID,
SERVICE_NAME_PROPERTY_ID}));
// ----- Constructors ------------------------------------------------------
/**
* Constructor
*
* @param managementController the associated management controller
*/
ServiceConfigVersionResourceProvider(
AmbariManagementController managementController) {
super(Resource.Type.ServiceConfigVersion, PROPERTY_IDS, KEY_PROPERTY_IDS, managementController);
setRequiredGetAuthorizations(EnumSet.of(RoleAuthorization.CLUSTER_VIEW_CONFIGS,
RoleAuthorization.SERVICE_VIEW_CONFIGS,
RoleAuthorization.SERVICE_COMPARE_CONFIGS));
}
@Override
protected Set<String> getPKPropertyIds() {
return pkPropertyIds;
}
@Override
public RequestStatus createResources(Request request) throws SystemException, UnsupportedPropertyException, ResourceAlreadyExistsException, NoSuchParentResourceException {
throw new UnsupportedOperationException("Cannot explicitly create service config version");
}
@Override
public Set<Resource> getResourcesAuthorized(Request request, Predicate predicate) throws SystemException, UnsupportedPropertyException, NoSuchResourceException, NoSuchParentResourceException {
final Set<ServiceConfigVersionRequest> requests = new HashSet<>();
for (Map<String, Object> properties : getPropertyMaps(predicate)) {
requests.add(createRequest(properties));
}
Set<ServiceConfigVersionResponse> responses = getResources(new Command<Set<ServiceConfigVersionResponse>>() {
@Override
public Set<ServiceConfigVersionResponse> invoke() throws AmbariException {
return getManagementController().getServiceConfigVersions(requests);
}
});
Set<Resource> resources = new HashSet<>();
for (ServiceConfigVersionResponse response : responses) {
String clusterName = response.getClusterName();
List<ConfigurationResponse> configurationResponses = response.getConfigurations();
List<Map<String,Object>> configVersionConfigurations = convertToSubResources(clusterName, configurationResponses);
Resource resource = new ResourceImpl(Resource.Type.ServiceConfigVersion);
resource.setProperty(CLUSTER_NAME_PROPERTY_ID, clusterName);
resource.setProperty(SERVICE_NAME_PROPERTY_ID, response.getServiceName());
resource.setProperty(USER_PROPERTY_ID, response.getUserName());
resource.setProperty(SERVICE_CONFIG_VERSION_PROPERTY_ID, response.getVersion());
resource.setProperty(CREATE_TIME_PROPERTY_ID, response.getCreateTime());
resource.setProperty(CONFIGURATIONS_PROPERTY_ID, configVersionConfigurations);
resource.setProperty(SERVICE_CONFIG_VERSION_NOTE_PROPERTY_ID, response.getNote());
resource.setProperty(GROUP_ID_PROPERTY_ID, response.getGroupId());
resource.setProperty(GROUP_NAME_PROPERTY_ID, response.getGroupName());
resource.setProperty(HOSTS_PROPERTY_ID, response.getHosts());
resource.setProperty(STACK_ID_PROPERTY_ID, response.getStackId());
resource.setProperty(IS_CURRENT_PROPERTY_ID, response.getIsCurrent());
resource.setProperty(IS_COMPATIBLE_PROPERTY_ID, response.isCompatibleWithCurrentStack());
resources.add(resource);
}
return resources;
}
@Override
public RequestStatus updateResources(Request request, Predicate predicate) throws SystemException, UnsupportedPropertyException, NoSuchResourceException, NoSuchParentResourceException {
throw new UnsupportedOperationException("Cannot update service config version");
}
@Override
public RequestStatus deleteResources(Request request, Predicate predicate) throws SystemException, UnsupportedPropertyException, NoSuchResourceException, NoSuchParentResourceException {
throw new UnsupportedOperationException("Cannot delete service config version");
}
@Override
public Set<String> checkPropertyIds(Set<String> propertyIds) {
propertyIds = super.checkPropertyIds(propertyIds);
if (propertyIds.isEmpty()) {
return propertyIds;
}
Set<String> unsupportedProperties = new HashSet<>();
for (String propertyId : propertyIds) {
if (!propertyId.equals("cluster_name") && !propertyId.equals("service_config_version") &&
!propertyId.equals("service_name") && !propertyId.equals("createtime") &&
!propertyId.equals("appliedtime") && !propertyId.equals("user") &&
!propertyId.equals("service_config_version_note") &&
!propertyId.equals("group_id") &&
!propertyId.equals("group_name") &&
!propertyId.equals("stack_id") &&
!propertyId.equals("is_current") &&
!propertyId.equals("is_cluster_compatible") &&
!propertyId.equals("hosts")) {
unsupportedProperties.add(propertyId);
}
}
return unsupportedProperties;
}
private ServiceConfigVersionRequest createRequest(Map<String, Object> properties) {
String clusterName = (String) properties.get(CLUSTER_NAME_PROPERTY_ID);
String serviceName = (String) properties.get(SERVICE_NAME_PROPERTY_ID);
String user = (String) properties.get(USER_PROPERTY_ID);
Boolean isCurrent = Boolean.valueOf((String) properties.get(IS_CURRENT_PROPERTY_ID));
Object versionObject = properties.get(SERVICE_CONFIG_VERSION_PROPERTY_ID);
Long version = versionObject == null ? null : Long.valueOf(versionObject.toString());
return new ServiceConfigVersionRequest(clusterName, serviceName, version, null, null, user, isCurrent);
}
private List<Map<String, Object>> convertToSubResources(final String clusterName, List<ConfigurationResponse> configs) {
List<Map<String, Object>> result = new ArrayList<>();
for (final ConfigurationResponse config : configs) {
Map<String, Object> subResourceMap = new LinkedHashMap<>();
Map<String,String> configMap = new HashMap<>();
String stackId = config.getStackId().getStackId();
configMap.put("cluster_name", clusterName);
configMap.put("stack_id", stackId);
subResourceMap.put("Config", configMap);
subResourceMap.put("type", config.getType());
subResourceMap.put("tag", config.getVersionTag());
subResourceMap.put("version", config.getVersion());
subResourceMap.put("properties", new TreeMap<>(config.getConfigs()));
subResourceMap.put("properties_attributes", config.getConfigAttributes());
result.add(subResourceMap);
}
return result;
}
}
| 3,571 |
333 | <reponame>alipay/alipay-sdk-java-all
package com.alipay.api.domain;
import java.util.List;
import com.alipay.api.AlipayObject;
import com.alipay.api.internal.mapping.ApiField;
import com.alipay.api.internal.mapping.ApiListField;
/**
* 支付宝商户活动批量信息查询
*
* @author auto create
* @since 1.0, 2021-07-13 16:40:02
*/
public class AlipayMarketingCampaignSelfActivityBatchqueryModel extends AlipayObject {
private static final long serialVersionUID = 7429188569514111963L;
/**
* 是否需要券核销范围信息（包括pid列表、门店id列表和小程序appid列表，由于字段可能较大默认不返回，业务方也请慎用。pid列表:PID，门店id列表:SHOP_ID，小程序appid列表:APP_ID）
*/
@ApiListField("need_use_scope_info")
@ApiField("string")
private List<String> needUseScopeInfo;
/**
* 分页查询的当前页号，从1开始（默认1）
*/
@ApiField("page_number")
private String pageNumber;
/**
* 分页查询的单页活动数量，不大于20（默认10）
*/
@ApiField("page_size")
private String pageSize;
/**
* 场景码：默认(DEFAULT)
*/
@ApiListField("scene_code")
@ApiField("string")
private List<String> sceneCode;
public List<String> getNeedUseScopeInfo() {
return this.needUseScopeInfo;
}
public void setNeedUseScopeInfo(List<String> needUseScopeInfo) {
this.needUseScopeInfo = needUseScopeInfo;
}
public String getPageNumber() {
return this.pageNumber;
}
public void setPageNumber(String pageNumber) {
this.pageNumber = pageNumber;
}
public String getPageSize() {
return this.pageSize;
}
public void setPageSize(String pageSize) {
this.pageSize = pageSize;
}
public List<String> getSceneCode() {
return this.sceneCode;
}
public void setSceneCode(List<String> sceneCode) {
this.sceneCode = sceneCode;
}
}
| 918 |
678 | <reponame>bzxy/cydia
/**
* This header is generated by class-dump-z 0.2b.
*
* Source: /System/Library/PrivateFrameworks/OfficeImport.framework/OfficeImport
*/
#import <OfficeImport/CMMapper.h>
#import <OfficeImport/OfficeImport-Structs.h>
@class EDResources, CHDAxis, CMState, CHDSeries, CHDChart, CHDChartType;
__attribute__((visibility("hidden")))
@interface EMChartMapper : CMMapper {
@private
CHDChart *mChart; // 8 = 0x8
CMState *mState; // 12 = 0xc
EDResources *mResources; // 16 = 0x10
CHDChartType *mMainType; // 20 = 0x14
CHDSeries *mMainSeries; // 24 = 0x18
CHDAxis *mBaseAxis; // 28 = 0x1c
CHDAxis *mPrimaryAxis; // 32 = 0x20
CHDAxis *mSecondaryAxis; // 36 = 0x24
BOOL mIsHorizontal; // 40 = 0x28
BOOL mIsStacked; // 41 = 0x29
BOOL mIsPercentStacked; // 42 = 0x2a
unsigned mPieIndex; // 44 = 0x2c
struct {
BOOL primaryCategoryHasDates;
BOOL secondaryCategoryHasDates;
BOOL primaryAxisHasDates;
BOOL secondaryAxisHasDates;
} mPlotInfos; // 48 = 0x30
BOOL mHasDateCategory; // 52 = 0x34
BOOL mHasPrimaryDateAxis; // 53 = 0x35
BOOL mHasSecondaryDateAxis; // 54 = 0x36
}
+ (CGColorRef)newColorWithCalibratedRed:(float)calibratedRed green:(float)green blue:(float)blue alpha:(float)alpha; // 0x17794d
- (id)_baseDateForState:(id)state; // 0x1fb12d
- (id)initWithChart:(id)chart parent:(id)parent; // 0x176d49
- (id)createPdfWithState:(id)state withSize:(CGSize)size; // 0x176d75
- (void)addTitleToDescription:(id)description withState:(id)state; // 0x177701
- (void)addBackgroundToDescription:(id)description withState:(id)state; // 0x17797d
- (void)addLegendToDescription:(id)description chartSize:(CGSize)size withState:(id)state; // 0x177da9
- (void)_addCategoryAxis:(id)axis series:(id)series state:(id)state toDescription:(id)description; // 0x179ff1
- (void)_addUnitAxis:(id)axis series:(id)series state:(id)state toDescription:(id)description; // 0x177f25
- (void)_addGraphicProperties:(id)properties toDescription:(id)description withState:(id)state; // 0x179d51
- (void)_addStandardSeries:(id)series toDescription:(id)description withState:(id)state; // 0x178301
- (void)addSeries:(id)series toDescription:(id)description withState:(id)state; // 0x1782f1
@end
| 851 |
3,631 | <filename>drools/drools-core/src/main/java/org/drools/core/util/AtomicBitwiseLong.java
/*
* Copyright 2015 Red Hat, Inc. and/or its affiliates.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
*
* 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.drools.core.util;
import java.util.concurrent.atomic.AtomicLong;
public class AtomicBitwiseLong extends AtomicLong {
public AtomicBitwiseLong(long initialValue) {
super(initialValue);
}
public AtomicBitwiseLong() {
super();
}
public long getAndBitwiseOr(long mask) {
while (true) {
long current = get();
if (compareAndSet(current, current | mask ) ) {
return current;
}
}
}
public long getAndBitwiseAnd(long mask) {
while (true) {
long current = get();
if (compareAndSet(current, current & mask ) ) {
return current;
}
}
}
public long getAndBitwiseXor(long mask) {
while (true) {
long current = get();
if (compareAndSet(current, current ^ mask ) ) {
return current;
}
}
}
public long getAndBitwiseReset(long mask) {
while (true) {
long current = get();
if (compareAndSet(current, current & (~mask) ) ) {
return current;
}
}
}
}
| 767 |
9,724 | /* poppler-link.cc: qt interface to poppler
* Copyright (C) 2006, 2008 <NAME>
* Adapting code from
* Copyright (C) 2004 by <NAME> <<EMAIL>>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2, or (at your option)
* any later version.
*
* 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 Street - Fifth Floor, Boston, MA 02110-1301, USA.
*/
#include <poppler-qt.h>
#include <poppler-private.h>
#include <qstringlist.h>
#include <Link.h>
namespace Poppler {
LinkDestination::LinkDestination(const LinkDestinationData &data)
{
bool deleteDest = false;
LinkDest *ld = data.ld;
if ( data.namedDest && !ld )
{
deleteDest = true;
ld = data.doc->doc.findDest( data.namedDest );
}
if (!ld) return;
if (ld->getKind() == ::destXYZ) m_kind = destXYZ;
else if (ld->getKind() == ::destFit) m_kind = destFit;
else if (ld->getKind() == ::destFitH) m_kind = destFitH;
else if (ld->getKind() == ::destFitV) m_kind = destFitV;
else if (ld->getKind() == ::destFitR) m_kind = destFitR;
else if (ld->getKind() == ::destFitB) m_kind = destFitB;
else if (ld->getKind() == ::destFitBH) m_kind = destFitBH;
else if (ld->getKind() == ::destFitBV) m_kind = destFitBV;
if ( !ld->isPageRef() ) m_pageNum = ld->getPageNum();
else
{
Ref ref = ld->getPageRef();
m_pageNum = data.doc->doc.findPage( ref.num, ref.gen );
}
double left = ld->getLeft();
double bottom = ld->getBottom();
double right = ld->getRight();
double top = ld->getTop();
m_zoom = ld->getZoom();
m_changeLeft = ld->getChangeLeft();
m_changeTop = ld->getChangeTop();
m_changeZoom = ld->getChangeZoom();
int leftAux = 0, topAux = 0, rightAux = 0, bottomAux = 0;
#if defined(HAVE_SPLASH)
SplashOutputDev *sod = data.doc->getOutputDev();
sod->cvtUserToDev( left, top, &leftAux, &topAux );
sod->cvtUserToDev( right, bottom, &rightAux, &bottomAux );
#endif
m_left = leftAux;
m_top = topAux;
m_right = rightAux;
m_bottom = bottomAux;
if (deleteDest) delete ld;
}
LinkDestination::LinkDestination(const QString &description)
{
QStringList tokens = QStringList::split(';', description);
m_kind = static_cast<Kind>(tokens[0].toInt());
m_pageNum = tokens[1].toInt();
m_left = tokens[2].toDouble();
m_bottom = tokens[3].toDouble();
m_right = tokens[4].toDouble();
m_top = tokens[5].toDouble();
m_zoom = tokens[6].toDouble();
m_changeLeft = static_cast<bool>(tokens[7].toInt());
m_changeTop = static_cast<bool>(tokens[8].toInt());
m_changeZoom = static_cast<bool>(tokens[9].toInt());
}
LinkDestination::Kind LinkDestination::kind() const
{
return m_kind;
}
int LinkDestination::pageNumber() const
{
return m_pageNum;
}
double LinkDestination::left() const
{
return m_left;
}
double LinkDestination::bottom() const
{
return m_bottom;
}
double LinkDestination::right() const
{
return m_right;
}
double LinkDestination::top() const
{
return m_top;
}
double LinkDestination::zoom() const
{
return m_zoom;
}
bool LinkDestination::isChangeLeft() const
{
return m_changeLeft;
}
bool LinkDestination::isChangeTop() const
{
return m_changeTop;
}
bool LinkDestination::isChangeZoom() const
{
return m_changeZoom;
}
QString LinkDestination::toString() const
{
QString s = QString::number( (Q_INT8)m_kind );
s += ";" + QString::number( m_pageNum );
s += ";" + QString::number( m_left );
s += ";" + QString::number( m_bottom );
s += ";" + QString::number( m_right );
s += ";" + QString::number( m_top );
s += ";" + QString::number( m_zoom );
s += ";" + QString::number( (Q_INT8)m_changeLeft );
s += ";" + QString::number( (Q_INT8)m_changeTop );
s += ";" + QString::number( (Q_INT8)m_changeZoom );
return s;
}
// Link
Link::~Link()
{
}
Link::Link(const QRect &linkArea) : m_linkArea(linkArea)
{
}
Link::LinkType Link::linkType() const
{
return None;
}
QRect Link::linkArea() const
{
return m_linkArea;
}
// LinkGoto
LinkGoto::LinkGoto( const QRect &linkArea, QString extFileName, const LinkDestination & destination ) : Link(linkArea), m_extFileName(extFileName), m_destination(destination)
{
}
bool LinkGoto::isExternal() const
{
return !m_extFileName.isEmpty();
}
const QString &LinkGoto::fileName() const
{
return m_extFileName;
}
const LinkDestination &LinkGoto::destination() const
{
return m_destination;
}
Link::LinkType LinkGoto::linkType() const
{
return Goto;
}
// LinkExecute
LinkExecute::LinkExecute( const QRect &linkArea, const QString & file, const QString & params ) : Link(linkArea), m_fileName(file), m_parameters(params)
{
}
const QString & LinkExecute::fileName() const
{
return m_fileName;
}
const QString & LinkExecute::parameters() const
{
return m_parameters;
}
Link::LinkType LinkExecute::linkType() const
{
return Execute;
}
// LinkBrowse
LinkBrowse::LinkBrowse( const QRect &linkArea, const QString &url ) : Link(linkArea), m_url(url)
{
}
const QString & LinkBrowse::url() const
{
return m_url;
}
Link::LinkType LinkBrowse::linkType() const
{
return Browse;
}
// LinkAction
LinkAction::LinkAction( const QRect &linkArea, ActionType actionType ) : Link(linkArea), m_type(actionType)
{
}
LinkAction::ActionType LinkAction::actionType() const
{
return m_type;
}
Link::LinkType LinkAction::linkType() const
{
return Action;
}
// LinkMovie
LinkMovie::LinkMovie( const QRect &linkArea ) : Link(linkArea)
{
}
Link::LinkType LinkMovie::linkType() const
{
return Movie;
}
}
| 2,403 |
692 | <filename>SingularityService/src/main/java/com/hubspot/singularity/config/CustomExecutorConfiguration.java
package com.hubspot.singularity.config;
import javax.validation.constraints.Min;
import org.hibernate.validator.constraints.NotEmpty;
public class CustomExecutorConfiguration {
@Min(0)
private double numCpus = 0;
@Min(0)
private int memoryMb = 0;
@Min(0)
private int diskMb = 0;
@NotEmpty
private String serviceLog = "service.log";
@NotEmpty
private String serviceFinishedTailLog = "tail_of_finished_service.log";
public double getNumCpus() {
return numCpus;
}
public void setNumCpus(double numCpus) {
this.numCpus = numCpus;
}
public int getMemoryMb() {
return memoryMb;
}
public void setMemoryMb(int memoryMb) {
this.memoryMb = memoryMb;
}
public int getDiskMb() {
return diskMb;
}
public void setDiskMb(int diskMb) {
this.diskMb = diskMb;
}
public String getServiceLog() {
return serviceLog;
}
public void setServiceLog(String serviceLog) {
this.serviceLog = serviceLog;
}
public String getServiceFinishedTailLog() {
return serviceFinishedTailLog;
}
public void setServiceFinishedTailLog(String serviceFinishedTailLog) {
this.serviceFinishedTailLog = serviceFinishedTailLog;
}
}
| 472 |
1,987 | <reponame>raccoongang/python-social-auth
from social_core.backends.base import BaseAuth
| 29 |
18,636 | <filename>pipenv/vendor/importlib_resources/tests/util.py
import abc
import importlib
import io
import sys
import types
from pathlib import Path, PurePath
from . import data01
from . import zipdata01
from ..abc import ResourceReader
from ._compat import import_helper
from importlib.machinery import ModuleSpec
class Reader(ResourceReader):
def __init__(self, **kwargs):
vars(self).update(kwargs)
def get_resource_reader(self, package):
return self
def open_resource(self, path):
self._path = path
if isinstance(self.file, Exception):
raise self.file
return self.file
def resource_path(self, path_):
self._path = path_
if isinstance(self.path, Exception):
raise self.path
return self.path
def is_resource(self, path_):
self._path = path_
if isinstance(self.path, Exception):
raise self.path
def part(entry):
return entry.split('/')
return any(
len(parts) == 1 and parts[0] == path_ for parts in map(part, self._contents)
)
def contents(self):
if isinstance(self.path, Exception):
raise self.path
yield from self._contents
def create_package_from_loader(loader, is_package=True):
name = 'testingpackage'
module = types.ModuleType(name)
spec = ModuleSpec(name, loader, origin='does-not-exist', is_package=is_package)
module.__spec__ = spec
module.__loader__ = loader
return module
def create_package(file=None, path=None, is_package=True, contents=()):
return create_package_from_loader(
Reader(file=file, path=path, _contents=contents),
is_package,
)
class CommonTests(metaclass=abc.ABCMeta):
"""
Tests shared by test_open, test_path, and test_read.
"""
@abc.abstractmethod
def execute(self, package, path):
"""
Call the pertinent legacy API function (e.g. open_text, path)
on package and path.
"""
def test_package_name(self):
# Passing in the package name should succeed.
self.execute(data01.__name__, 'utf-8.file')
def test_package_object(self):
# Passing in the package itself should succeed.
self.execute(data01, 'utf-8.file')
def test_string_path(self):
# Passing in a string for the path should succeed.
path = 'utf-8.file'
self.execute(data01, path)
def test_pathlib_path(self):
# Passing in a pathlib.PurePath object for the path should succeed.
path = PurePath('utf-8.file')
self.execute(data01, path)
def test_absolute_path(self):
# An absolute path is a ValueError.
path = Path(__file__)
full_path = path.parent / 'utf-8.file'
with self.assertRaises(ValueError):
self.execute(data01, full_path)
def test_relative_path(self):
# A reative path is a ValueError.
with self.assertRaises(ValueError):
self.execute(data01, '../data01/utf-8.file')
def test_importing_module_as_side_effect(self):
# The anchor package can already be imported.
del sys.modules[data01.__name__]
self.execute(data01.__name__, 'utf-8.file')
def test_non_package_by_name(self):
# The anchor package cannot be a module.
with self.assertRaises(TypeError):
self.execute(__name__, 'utf-8.file')
def test_non_package_by_package(self):
# The anchor package cannot be a module.
with self.assertRaises(TypeError):
module = sys.modules['importlib_resources.tests.util']
self.execute(module, 'utf-8.file')
def test_missing_path(self):
# Attempting to open or read or request the path for a
# non-existent path should succeed if open_resource
# can return a viable data stream.
bytes_data = io.BytesIO(b'Hello, world!')
package = create_package(file=bytes_data, path=FileNotFoundError())
self.execute(package, 'utf-8.file')
self.assertEqual(package.__loader__._path, 'utf-8.file')
def test_extant_path(self):
# Attempting to open or read or request the path when the
# path does exist should still succeed. Does not assert
# anything about the result.
bytes_data = io.BytesIO(b'Hello, world!')
# any path that exists
path = __file__
package = create_package(file=bytes_data, path=path)
self.execute(package, 'utf-8.file')
self.assertEqual(package.__loader__._path, 'utf-8.file')
def test_useless_loader(self):
package = create_package(file=FileNotFoundError(), path=FileNotFoundError())
with self.assertRaises(FileNotFoundError):
self.execute(package, 'utf-8.file')
class ZipSetupBase:
ZIP_MODULE = None
@classmethod
def setUpClass(cls):
data_path = Path(cls.ZIP_MODULE.__file__)
data_dir = data_path.parent
cls._zip_path = str(data_dir / 'ziptestdata.zip')
sys.path.append(cls._zip_path)
cls.data = importlib.import_module('ziptestdata')
@classmethod
def tearDownClass(cls):
try:
sys.path.remove(cls._zip_path)
except ValueError:
pass
try:
del sys.path_importer_cache[cls._zip_path]
del sys.modules[cls.data.__name__]
except KeyError:
pass
try:
del cls.data
del cls._zip_path
except AttributeError:
pass
def setUp(self):
modules = import_helper.modules_setup()
self.addCleanup(import_helper.modules_cleanup, *modules)
class ZipSetup(ZipSetupBase):
ZIP_MODULE = zipdata01 # type: ignore
| 2,446 |
2,816 | /*
* Legal Notice
*
* This document and associated source code (the "Work") is a part of a
* benchmark specification maintained by the TPC.
*
* The TPC reserves all right, title, and interest to the Work as provided
* under U.S. and international laws, including without limitation all patent
* and trademark rights therein.
*
* No Warranty
*
* 1.1 TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THE INFORMATION
* CONTAINED HEREIN IS PROVIDED "AS IS" AND WITH ALL FAULTS, AND THE
* AUTHORS AND DEVELOPERS OF THE WORK HEREBY DISCLAIM ALL OTHER
* WARRANTIES AND CONDITIONS, EITHER EXPRESS, IMPLIED OR STATUTORY,
* INCLUDING, BUT NOT LIMITED TO, ANY (IF ANY) IMPLIED WARRANTIES,
* DUTIES OR CONDITIONS OF MERCHANTABILITY, OF FITNESS FOR A PARTICULAR
* PURPOSE, OF ACCURACY OR COMPLETENESS OF RESPONSES, OF RESULTS, OF
* WORKMANLIKE EFFORT, OF LACK OF VIRUSES, AND OF LACK OF NEGLIGENCE.
* ALSO, THERE IS NO WARRANTY OR CONDITION OF TITLE, QUIET ENJOYMENT,
* QUIET POSSESSION, CORRESPONDENCE TO DESCRIPTION OR NON-INFRINGEMENT
* WITH REGARD TO THE WORK.
* 1.2 IN NO EVENT WILL ANY AUTHOR OR DEVELOPER OF THE WORK BE LIABLE TO
* ANY OTHER PARTY FOR ANY DAMAGES, INCLUDING BUT NOT LIMITED TO THE
* COST OF PROCURING SUBSTITUTE GOODS OR SERVICES, LOST PROFITS, LOSS
* OF USE, LOSS OF DATA, OR ANY INCIDENTAL, CONSEQUENTIAL, DIRECT,
* INDIRECT, OR SPECIAL DAMAGES WHETHER UNDER CONTRACT, TORT, WARRANTY,
* OR OTHERWISE, ARISING IN ANY WAY OUT OF THIS OR ANY OTHER AGREEMENT
* RELATING TO THE WORK, WHETHER OR NOT SUCH AUTHOR OR DEVELOPER HAD
* ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES.
*
* Contributors:
* Gradient Systems
*/
#ifndef W_STORE_H
#define W_STORE_H
#include "address.h"
#include "decimal.h"
#define RS_W_STORE_NAME 50
#define RS_W_STORE_MGR 40
#define RS_W_MARKET_MGR 40
#define RS_W_MARKET_DESC 100
#define STORE_MIN_TAX_PERCENTAGE "0.00"
#define STORE_MAX_TAX_PERCENTAGE "0.11"
/*
* STORE table structure
*/
struct W_STORE_TBL {
ds_key_t store_sk;
char store_id[RS_BKEY + 1];
ds_key_t rec_start_date_id;
ds_key_t rec_end_date_id;
ds_key_t closed_date_id;
char store_name[RS_W_STORE_NAME + 1];
int employees;
int floor_space;
char *hours;
char store_manager[RS_W_STORE_MGR + 1];
int market_id;
decimal_t dTaxPercentage;
char *geography_class;
char market_desc[RS_W_MARKET_DESC + 1];
char market_manager[RS_W_MARKET_MGR + 1];
ds_key_t division_id;
char *division_name;
ds_key_t company_id;
char *company_name;
ds_addr_t address;
};
/***
*** STORE_xxx Store Defines
***/
#define STORE_MIN_DAYS_OPEN 5
#define STORE_MAX_DAYS_OPEN 500
#define STORE_CLOSED_PCT 30
#define STORE_MIN_REV_GROWTH "-0.05"
#define STORE_MAX_REV_GROWTH "0.50"
#define STORE_DESC_MIN 15
int mk_w_store(void *info_arr, ds_key_t kIndex);
#endif
| 1,153 |
672 | /*
* Copyright (c) 2015-2016 Apple Inc. All rights reserved.
*
* @APPLE_LICENSE_HEADER_START@
*
* This file contains Original Code and/or Modifications of Original Code
* as defined in and that are subject to the Apple Public Source License
* Version 2.0 (the 'License'). You may not use this file except in
* compliance with the License. Please obtain a copy of the License at
* http://www.opensource.apple.com/apsl/ and read it before using this
* file.
*
* The Original Code and all software distributed under the License are
* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
* Please see the License for the specific language governing rights and
* limitations under the License.
*
* @APPLE_LICENSE_HEADER_END@
*/
#ifndef log_encode_h
#define log_encode_h
#include "log_encode_types.h"
#include <sys/param.h>
#if __has_feature(ptrauth_calls)
#include <mach/vm_param.h>
#include <ptrauth.h>
#endif /* __has_feature(ptrauth_calls) */
#ifdef KERNEL
#define isdigit(ch) (((ch) >= '0') && ((ch) <= '9'))
extern boolean_t doprnt_hide_pointers;
#endif
static bool
_encode_data(os_log_buffer_value_t content, const void *arg, uint16_t arg_len, os_log_buffer_context_t context)
{
struct os_log_arginfo_s arginfo;
void *databuf;
if (content->flags & OS_LOG_CONTENT_FLAG_PRIVATE) {
databuf = context->privdata + context->privdata_off;
arginfo.length = MIN(arg_len, (context->privdata_sz - context->privdata_off));
arginfo.offset = context->privdata_off;
} else {
databuf = context->pubdata + context->pubdata_off;
arginfo.length = MIN(arg_len, (context->pubdata_sz - context->pubdata_off));
arginfo.offset = context->pubdata_off;
}
if (context->arg_content_sz > 0) {
arginfo.length = MIN(context->arg_content_sz, arginfo.length);
}
memcpy(content->value, &arginfo, sizeof(arginfo));
content->size = sizeof(arginfo);
if (arginfo.length) {
if (content->type == OS_LOG_BUFFER_VALUE_TYPE_STRING
#ifndef KERNEL
|| content->type == OS_LOG_BUFFER_VALUE_TYPE_OBJECT
#endif
) {
strlcpy(databuf, arg, arginfo.length);
} else {
memcpy(databuf, arg, arginfo.length);
}
}
if (content->flags & OS_LOG_CONTENT_FLAG_PRIVATE) {
context->privdata_off += arginfo.length;
} else {
context->pubdata_off += arginfo.length;
}
context->content_off += sizeof(*content) + content->size;
context->arg_content_sz = 0;
return true;
}
#ifndef KERNEL
static void
_os_log_parse_annotated(char *annotated, const char **visibility, const char **library, const char **type)
{
char *values[3] = { NULL };
int cnt = 0;
int idx = 0;
for (; cnt < 3;) {
char *token = strsep(&annotated, ", {}");
if (token == NULL) {
break;
}
if (*token == '\0') {
continue;
}
values[cnt++] = token;
}
if ((cnt > 0) && (!strcmp(values[0], "public") || !strcmp(values[0], "private"))) {
if (visibility != NULL) {
(*visibility) = values[0];
}
idx++;
}
if (idx < cnt && (library != NULL) && (type != NULL)) {
char *decoder = values[idx];
for (cnt = 0; cnt < 3; ) {
char *token = strsep(&decoder, ": {}");
if (token == NULL) {
break;
}
if (*token == '\0') {
continue;
}
values[cnt++] = token;
}
if (cnt == 2) {
(*library) = values[0];
(*type) = values[1];
}
if (cnt == 1) {
(*library) = "builtin";
(*type) = values[0];
}
}
}
#endif /* !KERNEL */
OS_ALWAYS_INLINE
static inline bool
_os_log_encode_arg(void *arg, uint16_t arg_len, os_log_value_type_t ctype, bool is_private, os_log_buffer_context_t context)
{
os_log_buffer_value_t content = (os_log_buffer_value_t) &context->buffer->content[context->content_off];
size_t content_sz = sizeof(*content) + arg_len;
char tempString[OS_LOG_BUFFER_MAX_SIZE] = {};
#ifndef KERNEL
bool obj_private = true;
#endif
#ifdef KERNEL
/* scrub kernel pointers */
if (doprnt_hide_pointers &&
ctype == OS_LOG_BUFFER_VALUE_TYPE_SCALAR &&
arg_len >= sizeof(void *)) {
unsigned long long value = 0;
memcpy(&value, arg, arg_len);
#if __has_feature(ptrauth_calls)
/**
* Strip out the pointer authentication code before
* checking whether the pointer is a kernel address.
*/
value = (unsigned long long)VM_KERNEL_STRIP_PTR(value);
#endif /* __has_feature(ptrauth_calls) */
if (value >= VM_MIN_KERNEL_AND_KEXT_ADDRESS && value <= VM_MAX_KERNEL_ADDRESS) {
is_private = true;
bzero(arg, arg_len);
}
}
#endif
content->type = ctype;
content->flags = (is_private ? OS_LOG_CONTENT_FLAG_PRIVATE : 0);
#ifndef KERNEL
if (context->annotated != NULL) {
const char *visibility = NULL;
_os_log_parse_annotated(context->annotated, &visibility, NULL, NULL);
if (visibility) {
if (!strcasecmp(visibility, "private")) {
content->flags |= OS_LOG_CONTENT_FLAG_PRIVATE;
} else if (!strcasecmp(visibility, "public")) {
content->flags &= ~OS_LOG_CONTENT_FLAG_PRIVATE;
}
}
context->annotated = NULL;
}
#endif /* !KERNEL */
switch (ctype) {
case OS_LOG_BUFFER_VALUE_TYPE_COUNT:
case OS_LOG_BUFFER_VALUE_TYPE_SCALAR:
if (is_private) {
_encode_data(content, tempString, strlen(tempString) + 1, context);
} else {
if ((context->content_off + content_sz) > context->content_sz) {
return false;
}
memcpy(content->value, arg, arg_len);
content->size = arg_len;
context->content_off += content_sz;
}
break;
case OS_LOG_BUFFER_VALUE_TYPE_STRING:
context->buffer->flags |= OS_LOG_BUFFER_HAS_NON_SCALAR;
if (_os_log_string_is_public(arg)) {
content->flags &= ~OS_LOG_CONTENT_FLAG_PRIVATE;
}
_encode_data(content, arg, arg_len, context);
break;
#ifndef KERNEL
case OS_LOG_BUFFER_VALUE_TYPE_POINTER:
context->buffer->flags |= OS_LOG_BUFFER_HAS_NON_SCALAR;
_encode_data(content, arg, arg_len, context);
break;
case OS_LOG_BUFFER_VALUE_TYPE_OBJECT:
context->buffer->flags |= OS_LOG_BUFFER_HAS_NON_SCALAR;
if (!_NSCF2data(arg, tempString, sizeof(tempString), &obj_private)) {
tempString[0] = '\0';
}
if (!obj_private) {
content->flags &= ~OS_LOG_CONTENT_FLAG_PRIVATE;
}
_encode_data(content, tempString, strlen(tempString) + 1, context);
break;
#endif /* !KERNEL */
}
if (content->flags & OS_LOG_CONTENT_FLAG_PRIVATE) {
context->buffer->flags |= OS_LOG_BUFFER_HAS_PRIVATE;
}
context->arg_idx++;
return true;
}
static bool
_os_log_encode(const char *format, va_list args, int saved_errno, os_log_buffer_context_t context)
{
const char *percent = strchr(format, '%');
#ifndef KERNEL
char annotated[256];
#endif
while (percent != NULL) {
++percent;
if (percent[0] != '%') {
struct os_log_format_value_s value;
int type = OST_INT;
#ifndef KERNEL
bool long_double = false;
#endif
int prec = 0;
char ch;
for (bool done = false; !done; percent++) {
switch (ch = percent[0]) {
/* type of types or other */
case 'l': // longer
type++;
break;
case 'h': // shorter
type--;
break;
case 'z':
type = OST_SIZE;
break;
case 'j':
type = OST_INTMAX;
break;
case 't':
type = OST_PTRDIFF;
break;
case '.': // precision
if ((percent[1]) == '*') {
prec = va_arg(args, int);
_os_log_encode_arg(&prec, sizeof(prec), OS_LOG_BUFFER_VALUE_TYPE_COUNT, false, context);
percent++;
continue;
} else {
// we have to read the precision and do the right thing
const char *fmt = percent + 1;
prec = 0;
while (isdigit(ch = *fmt++)) {
prec = 10 * prec + (ch - '0');
}
if (prec > 1024) {
prec = 1024;
}
_os_log_encode_arg(&prec, sizeof(prec), OS_LOG_BUFFER_VALUE_TYPE_COUNT, false, context);
}
break;
case '-': // left-align
case '+': // force sign
case ' ': // prefix non-negative with space
case '#': // alternate
case '\'': // group by thousands
break;
/* fixed types */
case 'd': // integer
case 'i': // integer
case 'o': // octal
case 'u': // unsigned
case 'x': // hex
case 'X': // upper-hex
switch (type) {
case OST_CHAR:
value.type.ch = va_arg(args, int);
_os_log_encode_arg(&value.type.ch, sizeof(value.type.ch), OS_LOG_BUFFER_VALUE_TYPE_SCALAR, false, context);
break;
case OST_SHORT:
value.type.s = va_arg(args, int);
_os_log_encode_arg(&value.type.s, sizeof(value.type.s), OS_LOG_BUFFER_VALUE_TYPE_SCALAR, false, context);
break;
case OST_INT:
value.type.i = va_arg(args, int);
_os_log_encode_arg(&value.type.i, sizeof(value.type.i), OS_LOG_BUFFER_VALUE_TYPE_SCALAR, false, context);
break;
case OST_LONG:
value.type.l = va_arg(args, long);
_os_log_encode_arg(&value.type.l, sizeof(value.type.l), OS_LOG_BUFFER_VALUE_TYPE_SCALAR, false, context);
break;
case OST_LONGLONG:
value.type.ll = va_arg(args, long long);
_os_log_encode_arg(&value.type.ll, sizeof(value.type.ll), OS_LOG_BUFFER_VALUE_TYPE_SCALAR, false, context);
break;
case OST_SIZE:
value.type.z = va_arg(args, size_t);
_os_log_encode_arg(&value.type.z, sizeof(value.type.z), OS_LOG_BUFFER_VALUE_TYPE_SCALAR, false, context);
break;
case OST_INTMAX:
value.type.im = va_arg(args, intmax_t);
_os_log_encode_arg(&value.type.im, sizeof(value.type.im), OS_LOG_BUFFER_VALUE_TYPE_SCALAR, false, context);
break;
case OST_PTRDIFF:
value.type.pd = va_arg(args, ptrdiff_t);
_os_log_encode_arg(&value.type.pd, sizeof(value.type.pd), OS_LOG_BUFFER_VALUE_TYPE_SCALAR, false, context);
break;
default:
return false;
}
done = true;
break;
#ifndef KERNEL
case '{':
// we do not support this for shimmed code
if (context->shimmed) {
return false;
}
for (const char *curr2 = percent + 1; (ch = (*curr2)) != NUL; curr2++) {
if (ch == '}') {
strlcpy(annotated, percent, MIN(curr2 - (percent + 1), sizeof(annotated)));
context->annotated = annotated;
percent = curr2;
break;
}
}
break;
#endif /* !KERNEL */
case 'p': // pointer
value.type.p = va_arg(args, void *);
_os_log_encode_arg(&value.type.p, sizeof(value.type.p), OS_LOG_BUFFER_VALUE_TYPE_SCALAR, false, context);
done = true;
break;
#ifndef KERNEL
case 'P': // pointer data
if (context->shimmed) { // we do not support this for shimmed code
return false;
}
context->buffer->flags |= OS_LOG_BUFFER_HAS_NON_SCALAR;
value.type.p = va_arg(args, void *);
// capture the string pointer to generate a symptom
if (context->log && context->log->generate_symptoms && context->arg_idx == 1 && value.type.pch && prec) {
context->symptom_ptr = value.type.p;
context->symptom_ptr_len = prec;
}
_os_log_encode_arg(value.type.p, prec, OS_LOG_BUFFER_VALUE_TYPE_POINTER, false, context);
prec = 0;
done = true;
break;
#endif /* !KERNEL */
#ifndef KERNEL
case 'L': // long double
long_double = true;
break;
case 'a': case 'A': case 'e': case 'E': // floating types
case 'f': case 'F': case 'g': case 'G':
if (long_double) {
value.type.ld = va_arg(args, long double);
_os_log_encode_arg(&value.type.ld, sizeof(value.type.ld), OS_LOG_BUFFER_VALUE_TYPE_SCALAR, false, context);
} else {
value.type.d = va_arg(args, double);
_os_log_encode_arg(&value.type.d, sizeof(value.type.d), OS_LOG_BUFFER_VALUE_TYPE_SCALAR, false, context);
}
done = true;
break;
#endif /* !KERNEL */
case 'c': // char
value.type.ch = va_arg(args, int);
_os_log_encode_arg(&value.type.ch, sizeof(value.type.ch), OS_LOG_BUFFER_VALUE_TYPE_SCALAR, false, context);
done = true;
break;
#ifndef KERNEL
case 'C': // wide-char
value.type.wch = va_arg(args, wint_t);
_os_log_encode_arg(&value.type.wch, sizeof(value.type.wch), OS_LOG_BUFFER_VALUE_TYPE_SCALAR, false, context);
done = true;
break;
#endif /* !KERNEL */
case 's': // string
value.type.pch = va_arg(args, char *);
if (!prec && value.type.pch != NULL) {
prec = (int) strlen(value.type.pch) + 1;
}
#ifndef KERNEL
// capture the string pointer to generate a symptom
if (context->log && context->log->generate_symptoms && context->arg_idx == 0 && value.type.pch) {
context->symptom_str = value.type.pch;
}
#endif
context->buffer->flags |= OS_LOG_BUFFER_HAS_NON_SCALAR;
_os_log_encode_arg(value.type.pch, prec, OS_LOG_BUFFER_VALUE_TYPE_STRING, false, context);
prec = 0;
done = true;
break;
#ifndef KERNEL
case 'S': // wide-string
value.type.pwch = va_arg(args, wchar_t *);
if (!prec && value.type.pwch != NULL) {
prec = (int) wcslen(value.type.pwch) + 1;
}
context->buffer->flags |= OS_LOG_BUFFER_HAS_NON_SCALAR;
_os_log_encode_arg(value.type.pwch, prec, OS_LOG_BUFFER_VALUE_TYPE_STRING, false, context);
prec = 0;
done = true;
break;
#endif /* !KERNEL */
#ifndef KERNEL
case '@': // CFTypeRef aka NSObject *
context->buffer->flags |= OS_LOG_BUFFER_HAS_NON_SCALAR;
_os_log_encode_arg(va_arg(args, void *), 0, OS_LOG_BUFFER_VALUE_TYPE_OBJECT, false, context);
done = true;
break;
#endif /* !KERNEL */
case 'm':
value.type.i = saved_errno;
_os_log_encode_arg(&value.type.i, sizeof(value.type.i), OS_LOG_BUFFER_VALUE_TYPE_SCALAR, false, context);
done = true;
break;
default:
if (isdigit(ch)) { // [0-9]
continue;
}
return false;
}
if (done) {
percent = strchr(percent, '%'); // Find next format
break;
}
}
} else {
percent = strchr(percent+1, '%'); // Find next format after %%
}
}
context->buffer->arg_cnt = context->arg_idx;
context->content_sz = context->content_off;
context->pubdata_sz = context->pubdata_off;
context->privdata_sz = context->privdata_off;
context->arg_idx = context->content_off = context->pubdata_off = context->privdata_off = 0;
return true;
}
#endif /* log_encode_h */
| 12,217 |
30,785 | <filename>jadx-core/src/test/java/jadx/tests/integration/others/TestInsnsBeforeSuper2.java
package jadx.tests.integration.others;
import org.junit.jupiter.api.Test;
import jadx.tests.api.SmaliTest;
import static jadx.tests.api.utils.assertj.JadxAssertions.assertThat;
public class TestInsnsBeforeSuper2 extends SmaliTest {
// @formatter:off
/*
public class TestInsnsBeforeSuper2 extends java.lang.Exception {
private int mErrorType;
public TestInsnsBeforeSuper2(java.lang.String r9, int r10) {
r8 = this;
r0 = r8
r1 = r9
r2 = r10
r3 = r0
r4 = r1
r5 = r2
r6 = r1
r0.<init>(r6)
r7 = 0
r0.mErrorType = r7
r0.mErrorType = r2
return
}
}
*/
// @formatter:on
@Test
public void test() {
assertThat(getClassNodeFromSmali())
.code()
.containsOne("super(message);")
.containsOne("this.mErrorType = errorType;");
}
}
| 412 |
903 | package org.develnext.jphp.core.tokenizer.token.expr.operator;
import php.runtime.common.Association;
import org.develnext.jphp.core.tokenizer.TokenMeta;
import org.develnext.jphp.core.tokenizer.TokenType;
import org.develnext.jphp.core.tokenizer.token.expr.OperatorExprToken;
public class AmpersandRefToken extends OperatorExprToken {
public AmpersandRefToken(TokenMeta meta) {
super(meta, TokenType.T_J_CUSTOM);
}
@Override
public int getPriority() {
return 10;
}
@Override
public boolean isBinary() {
return false;
}
@Override
public Association getOnlyAssociation() {
return Association.RIGHT;
}
}
| 262 |
619 | <reponame>literakl/jsoup
/**
Contains the jsoup HTML cleaner, and whitelist definitions.
*/
package org.jsoup.safety;
| 38 |
488 | #ifndef BinQT_LCS_H
#define BinQT_LCS_H
#include <boost/smart_ptr.hpp>
#include <vector>
#include <string>
#include <map>
/**
* \brief Longest common subsequence algorithm used for BinaryDiff
*/
namespace LCS
{
template<typename T>
class vector_start_at_one
{
public:
vector_start_at_one() : sa(data){}
vector_start_at_one(const std::vector<T> & init) : sa(init) {}
size_t size() const { return sa.size(); }
//T* get() const { return sa.get(); }
//void push_back(T v) { sa.push_back(v); }
//T& operator[](size_t i) { return sa[i - 1]; }
const T& operator[](size_t i) const { return sa[i-1]; }
private:
vector_start_at_one(const vector_start_at_one<T>&); // Not copyable
std::vector<T> data;
const std::vector<T> & sa;
};
bool isEqual(SgNode* A, SgNode* B);
void LCSLength(boost::scoped_array<boost::scoped_array<size_t> >& C,
vector_start_at_one<SgNode*>& A, vector_start_at_one<SgNode*>& B);
void printDiff(vector_start_at_one<SgNode*>& A, vector_start_at_one<SgNode*>& B,
std::vector<int>& addInstr, std::vector<int>& minusInst);
void getDiff( const std::vector<SgNode*>& A,const std::vector<SgNode*>& B,
std::vector<std::pair<SgNode*,SgNode*> > & result);
std::string unparseInstrFast(SgAsmInstruction* iA);
};
#endif
| 775 |
892 | {
"schema_version": "1.2.0",
"id": "GHSA-mvvv-8xrh-cv67",
"modified": "2022-05-13T01:31:19Z",
"published": "2022-05-13T01:31:19Z",
"aliases": [
"CVE-2019-1834"
],
"details": "A vulnerability in the internal packet processing of Cisco Aironet Series Access Points (APs) could allow an unauthenticated, adjacent attacker to cause a denial of service (DoS) condition on an affected AP if the switch interface where the AP is connected has port security configured. The vulnerability exists because the AP forwards some malformed wireless client packets outside of the Control and Provisioning of Wireless Access Points (CAPWAP) tunnel. An attacker could exploit this vulnerability by sending crafted wireless packets to an affected AP. A successful exploit could allow the attacker to trigger a security violation on the adjacent switch port, which could result in a DoS condition. Note: Though the Common Vulnerability Scoring System (CVSS) score corresponds to a High Security Impact Rating (SIR), this vulnerability is considered Medium because a workaround is available and exploitation requires a specific switch configuration. There are workarounds that address this vulnerability.",
"severity": [
{
"type": "CVSS_V3",
"score": "CVSS:3.0/AV:A/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H"
}
],
"affected": [
],
"references": [
{
"type": "ADVISORY",
"url": "https://nvd.nist.gov/vuln/detail/CVE-2019-1834"
},
{
"type": "WEB",
"url": "https://tools.cisco.com/security/center/content/CiscoSecurityAdvisory/cisco-sa-20190417-air-ap-dos"
},
{
"type": "WEB",
"url": "http://www.securityfocus.com/bid/108000"
}
],
"database_specific": {
"cwe_ids": [
"CWE-20"
],
"severity": "MODERATE",
"github_reviewed": false
}
} | 629 |
376 | from django.core.management.base import BaseCommand, CommandError
from django.db import transaction
from django.contrib.auth import get_user_model
class Command(BaseCommand):
help = "Promotes the named users to an admin superuser."
def add_arguments(self, parser):
super(Command, self).add_arguments(parser)
parser.add_argument(
"usernames",
metavar="usernames",
nargs="*",
help="Usernames to promote to admin superuser.",
)
@transaction.atomic()
def handle(self, **kwargs):
verbosity = kwargs["verbosity"]
User = get_user_model()
for username in kwargs["usernames"]:
try:
user = User.objects.get(username=username)
except User.DoesNotExist:
raise CommandError("User with username {username} does not exist".format(
username=username,
))
else:
user.is_staff = True
user.is_superuser = True
user.save()
if verbosity >= 1:
self.stdout.write("Promoted {user} to admin superuser".format(
user=user,
))
| 604 |
5,975 | # Copyright (c) Facebook, Inc. and its affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
# flake8: noqa
import pyre
from django.http import HttpRequest
# Integration test illustrating that we check top-level functions.
request: HttpRequest = ...
eval(request.GET["bad"])
| 101 |
Subsets and Splits