blob_id stringlengths 40 40 | directory_id stringlengths 40 40 | path stringlengths 4 201 | content_id stringlengths 40 40 | detected_licenses listlengths 0 85 | license_type stringclasses 2
values | repo_name stringlengths 7 100 | snapshot_id stringlengths 40 40 | revision_id stringlengths 40 40 | branch_name stringclasses 260
values | visit_date timestamp[us] | revision_date timestamp[us] | committer_date timestamp[us] | github_id int64 11.4k 681M ⌀ | star_events_count int64 0 209k | fork_events_count int64 0 110k | gha_license_id stringclasses 17
values | gha_event_created_at timestamp[us] | gha_created_at timestamp[us] | gha_language stringclasses 80
values | src_encoding stringclasses 28
values | language stringclasses 1
value | is_vendor bool 1
class | is_generated bool 2
classes | length_bytes int64 8 9.86M | extension stringclasses 52
values | content stringlengths 8 9.86M | authors listlengths 1 1 | author stringlengths 0 119 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
9d79e26ddc2c93ea74b654608bd67625547cb0d9 | d347eaeda77811c162db03b7a7634f248c96ba4b | /events/gamepad_button_up_event.hpp | f0c5fb2cdb544148f15eb80d7f3c3e1f82867d4d | [
"MIT"
] | permissive | MrTAB/aabGameEngine | 0e1964190714a03267f17b96ff78005a89519406 | dc51c6e443bf087ca10e14e6884e4dfa6caef4a8 | refs/heads/master | 2021-01-13T07:15:55.392345 | 2016-12-09T01:19:54 | 2016-12-09T01:19:54 | 71,494,515 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 734 | hpp |
/**
*
* gamepad_button_up_event.hpp
*
**/
#if !defined(AAB_EVENTS_GAMEPAD_BUTTON_UP_EVENT_CLASS)
#define AAB_EVENTS_GAMEPAD_BUTTON_UP_EVENT_CLASS
#include"event.hpp"
#include"internal_event.hpp"
#include"imports.hpp"
namespace aab {
namespace events{
class GamepadButtonUpEvent : public Event
{
private:
unsigned int id;
unsigned int button;
public:
typedef aab::types::Smart <GamepadButtonUpEvent>::Ptr Ptr;
explicit GamepadButtonUpEvent (InternalEvent e);
virtual ~GamepadButtonUpEvent () throw ();
int getGamePadId () const;
int getButton () const;
static EventType getClassEventType ();
};
} // events
} // aab
#endif // AAB_EVENTS_GAMEPAD_BUTTON_UP_EVENT_CLASS
| [
"noreply@github.com"
] | noreply@github.com |
2546796acf69767c3294c441496782dfe12f58de | 82f88ee08a69dd55174e16beb3dd0ab16bda0f1d | /thrift/lib/cpp2/transport/http2/server/ThriftRequestHandler.cpp | f900f4e65c4484464eaa088f2bb1d423c92bb9ae | [
"Apache-2.0"
] | permissive | enterstudio/fbthrift | f160565458320402b3e4dcf4d41eac163dd12cb0 | 4e0a728be9324134b1c0291dc97cbf0807ad71aa | refs/heads/master | 2021-07-20T14:42:28.822593 | 2017-10-25T00:39:20 | 2017-10-25T00:44:44 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,386 | cpp | /*
* Copyright 2017-present Facebook, 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.
*/
#include <thrift/lib/cpp2/transport/http2/server/ThriftRequestHandler.h>
#include <thrift/lib/cpp2/transport/http2/common/SingleRpcChannel.h>
namespace apache {
namespace thrift {
using folly::IOBuf;
using proxygen::HTTPMessage;
using proxygen::ProxygenError;
using proxygen::RequestHandler;
using proxygen::UpgradeProtocol;
// TODO:
//
// For now we hard wire to using SingleRpcChannel. Going forward we
// will have different channel implementations and need to be able to
// choose which one to use.
//
// Ideally we will use a single kind of channel for each connection.
// This may be negotiated via SETTINGS frames for the connection.
//
// Alternatively, we can be more flexible and allow a different choice
// of channel for each stream, in which case the stream header has to
// specify this choice.
ThriftRequestHandler::ThriftRequestHandler(ThriftProcessor* processor)
: processor_(processor) {}
ThriftRequestHandler::~ThriftRequestHandler() {}
void ThriftRequestHandler::onRequest(
std::unique_ptr<HTTPMessage> headers) noexcept {
channel_ = std::make_shared<SingleRpcChannel>(downstream_, processor_);
channel_->onH2StreamBegin(std::move(headers));
}
void ThriftRequestHandler::onBody(std::unique_ptr<IOBuf> body) noexcept {
channel_->onH2BodyFrame(std::move(body));
}
void ThriftRequestHandler::onEOM() noexcept {
channel_->onH2StreamEnd();
}
void ThriftRequestHandler::onUpgrade(UpgradeProtocol /*prot*/) noexcept {}
void ThriftRequestHandler::requestComplete() noexcept {
channel_->onH2StreamClosed(ProxygenError::kErrorNone);
delete this;
}
void ThriftRequestHandler::onError(ProxygenError error) noexcept {
if (channel_) {
channel_->onH2StreamClosed(error);
}
delete this;
}
} // namespace thrift
} // namespace apache
| [
"facebook-github-bot@users.noreply.github.com"
] | facebook-github-bot@users.noreply.github.com |
61e84e5302c652dee297fb608730756bc28c6651 | b6fc873ffb116fb62f6af5f033918c874c8b7341 | /939 ___ Genes.cpp | fae3dc0013e87e3e90ca0c7a8b8f4742443d9a77 | [] | no_license | ZahraParsaeian/Uva_Solved_Problems | 4db03b61922f837a786568fa961d86006154a25d | 9ca36da5f85e0ae0e0a3d42b91642655cd5f1ecd | refs/heads/master | 2021-01-20T20:15:08.195163 | 2017-10-18T05:00:59 | 2017-10-18T05:00:59 | 62,248,326 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,444 | cpp | #include<iostream>
#include<map>
#include<string>
#include<vector>
using namespace std;
int sstoi(string sec){
if (sec == "dominant")
return 3;
else if (sec == "recessive")
return 2;
else if (sec == "non-existent")
return 1;
}
string itoss(int num){
if (num == 1)
return ("non-existent");
else if (num == 2)
return("recessive");
else if (num == 3)
return("dominant");
}
int main(){
ios::sync_with_stdio(false);
int tc,sum;
map<string, int> gn;
map<string, vector<string>> notgn;
cin >> tc;
string frs,sec;
while (tc--){
cin >> frs >> sec;
if (sec == "non-existent" || sec == "recessive" || sec == "dominant")
gn[frs] = sstoi(sec);
else{
notgn[sec].push_back(frs);
}
}
map<string, vector<string>>::iterator i;
map<string, vector<string>>::iterator i2;
i = notgn.begin();
int size = notgn.size(), j = 0,cont=0;
while (notgn.size()){
if (j == size){
size = notgn.size();
i = notgn.begin();
j = 0;
}
sum = 0;
if (gn.count(i->second[0]) && gn.count(i->second[1])){
sum += gn[i->second[0]];
sum += gn[i->second[1]];
if (sum != 5)
sum /= 2;
else
sum = 3;
gn[i->first] = sum;
i2 = i++;
notgn.erase(i2);
}
else
i++;
j++;
}
map<string, int>::iterator it;
for (it = gn.begin(); it != gn.end(); it++){
cout << it->first << " " << itoss(it->second) << endl;
}
return 0;
} | [
"zahra.parsaeian1996@gmail.com"
] | zahra.parsaeian1996@gmail.com |
9edd033c10d4696207f03f0136dece8358b8ecd0 | 9de21a495541eb992ad208cd2a3168ba32c42c29 | /source/FAST/Streamers/KinectStreamer.hpp | a8e0e371615986d00968c688418432d82ca5c70a | [
"BSD-2-Clause"
] | permissive | qinhuaping/FAST-1 | c95a8162f0f9c17d7807939caf1c7daec9b04a7f | 7ae498724cb7784ae71ed23dd3904d7441cea90d | refs/heads/master | 2021-08-16T22:47:22.274898 | 2017-06-05T07:07:49 | 2017-06-05T07:07:49 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,049 | hpp | #ifndef FAST_KINECT_STREAMER_HPP_
#define FAST_KINECT_STREAMER_HPP_
#include "FAST/ProcessObject.hpp"
#include "Streamer.hpp"
#include <thread>
namespace libfreenect2 {
class Frame;
class Registration;
}
namespace fast {
class MeshVertex;
/**
* \brief Streams data RGB and depth data from a kinect device.
*
* The RGB camera and depth stream are registered so that a color value for each point in the
* point cloud is established.
*
* Output port 0: Registered RGB image
* Output port 1: Registered depth image
* Output port 2: Registered point cloud
*/
class FAST_EXPORT KinectStreamer : public Streamer, public ProcessObject {
FAST_OBJECT(KinectStreamer);
public:
void producerStream();
void setPointCloudFiltering(bool enabled);
/**
* Set maximum range in meters. All points above this range will be dropped.
* @param range
*/
void setMaxRange(float range);
/**
* Set minimum range in meters. All points below this range will be dropped.
* @param range
*/
void setMinRange(float range);
bool hasReachedEnd() const;
uint getNrOfFrames() const;
/**
* Gets corresponding 3D point from rgb image coordinate
* @param x
* @param y
* @return
*/
MeshVertex getPoint(int x, int y);
~KinectStreamer();
void stop();
private:
KinectStreamer();
void execute();
bool mStreamIsStarted;
bool mFirstFrameIsInserted;
bool mHasReachedEnd;
bool mStop;
bool mPointCloudFilterEnabled;
float mMaxRange = std::numeric_limits<float>::max(), mMinRange = 0;
uint mNrOfFrames;
std::thread* mThread;
std::mutex mFirstFrameMutex;
std::mutex mStopMutex;
std::condition_variable mFirstFrameCondition;
libfreenect2::Registration* registration;
libfreenect2::Frame* mUndistorted;
libfreenect2::Frame* mRegistered;
};
}
#endif
| [
"ersmistad@gmail.com"
] | ersmistad@gmail.com |
6753f59f3f12e5b41fdee3db42e85c2dfbd2f1be | 281b3bfe55cf4e8994f6d94777936d9a616ad8e0 | /day8/exam9/exam9.cpp | da37aa713bdc34c60a87305c67a5237e86340a74 | [] | no_license | carloshee/cstudy | e013bc5042449262fa8a27a040e981b5a3ecad91 | b245d9f2e266a28db34c02ecac8762c04d50b534 | refs/heads/master | 2020-04-05T13:40:42.153043 | 2017-08-01T06:54:17 | 2017-08-01T06:54:17 | 94,970,529 | 0 | 0 | null | null | null | null | UHC | C++ | false | false | 348 | cpp | // exam9.cpp : 콘솔 응용 프로그램에 대한 진입점을 정의합니다.
//
#include "stdafx.h"
int main()
{
int ary[5] = { 10, 20, 30, 40, 50 };
int *pAry;
pAry = ary; // 배열은 &가 안붙어도 맨앞주소를 받음
for (int i = 0; i < 5; i++) {
printf("%d %d %d \n", pAry[i], *(pAry+i), *(ary+i));
}
return 0;
}
| [
"carloshee@naver.com"
] | carloshee@naver.com |
fc680c5352333ab672db199e82819354d1f1dfd1 | ac3cedc5af66b7f505005649a537f99107a0f919 | /king/src/king/Core/Hierarchy.cpp | 09cc78e291a63b074285daed3d1422a86d03346c | [
"MIT"
] | permissive | tobiasbu/king | 3d4b2e20a6f80fb4c8ae59b144e04473c1b546df | 7a6892a93d5d4c5f14e2618104f2955281f0bada | refs/heads/master | 2020-06-22T01:00:37.900416 | 2016-12-07T22:50:06 | 2016-12-07T22:50:06 | 74,764,931 | 4 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,489 | cpp |
#include <king/Core/Hierarchy.hpp>
#include <king/Entity/GameObject.hpp>
namespace king {
namespace system {
Hierarchy::Hierarchy() {
}
void Hierarchy::onUpdate() {
for (int i = 0; i < _childs.size(); i++) {
if (_childs[i]->getGameObject()->getActive()) {
// Update self
_childs[i]->getGameObject()->update();
// Update childrens
_childs[i]->onUpdate();
}
}
}
void Hierarchy::onEndUpdate() {
}
void Hierarchy::onFixedUpdate() {
}
Hierarchy::~Hierarchy() {
clear();
}
/*void Hierarchy::add(GameObject * gameObject) {
if (gameObject == nullptr)
gameObject = new GameObject();
_gameObjects.push_back(gameObject);
}
void Hierarchy::remove(int index) {
delete _gameObjects[index];
_gameObjects.erase(_gameObjects.begin() + index);
}
/*void Hierarchy::remove(GameObject * gameObject) {
std::vector<GameObject *>::iterator it; //_gameObjects
_gameObjects.at(gameObject);
//_gameObjects.erase(gameObject);
}
void Hierarchy::onUpdate() {
for (int i = 0; i < _gameObjects.size(); i++) {
if (_gameObjects[i]->getActive())
_gameObjects[i]->_updateChilds();
}
}
void Hierarchy::onEndUpdate() {
}
void Hierarchy::onFixedUpdate() {
}*/
void Hierarchy::clear() {
/*std::vector<GameObject *>::iterator it = _gameObjects.end();
while (!_gameObjects.empty()) {
delete (*it);
it--;
}
_gameObjects.clear();*/
}
}
} | [
"flamenco.bluegrass@gmail.com"
] | flamenco.bluegrass@gmail.com |
74d91ceae70725686b4fb504a99af444ec7ecaac | 4070f3d904114ba123d82cd5661c421fc708610e | /merc2rom/room.h | 46663b72a57e31a99f5cb1d4b0df04282d2283e5 | [
"LicenseRef-scancode-warranty-disclaimer"
] | no_license | kstenerud/curiosities | bc6218dbbbd3d8771c49db200491de91efa309c3 | 58efeed0340d922077bfdd489787cab668965b4c | refs/heads/master | 2020-05-18T17:21:55.208064 | 2019-05-02T09:15:35 | 2019-05-02T09:15:35 | 184,552,783 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 905 | h | // room.h
#ifndef _MY_ROOM_H
#define _MY_ROOM_H
#include <iostream.h>
#include <iomanip.h>
#include <fstream.h>
#include "cstring.h"
#include "fileio.h"
#include "flags.h"
#include "extra.h"
#include "dir.h"
#include "list.h"
#include "defaults.h"
class Room
{
public:
Room ();
~Room ();
void BaseVnum (int, int=-1, int=-1);
int FindLowVnum (int=-1);
int FindHighVnum (int=-1);
Room* FindVnum (int);
void ListAdd (List&);
ifstream& Read (ifstream&);
ofstream& Write (ofstream&);
private:
int _vnum;
Cstring _name;
Cstring _desc;
int _area_num;
Cstring _room_flags;
int _sector;
Dir _dir[6];
Extra *_extras;
int _mana_recover;
int _hp_recover;
Cstring _clan_name;
Room *_next;
};
ifstream& operator>>(ifstream&, Room&);
ofstream& operator<<(ofstream&, Room&);
#endif
| [
"kstenerud@gmail.com"
] | kstenerud@gmail.com |
416bdf97e12693d8ff77b372a588ca51e62ccea0 | 8b2ef59c269746188952d4da54c1313b89de3231 | /include/Notebook.hpp | 31149406592b5cf6ddb724c26be5821f7cf95bb1 | [] | no_license | yongchix/pixie_scan | 5d9823dcca9b83b769ceaa800c24f4807d7b4f82 | 53be0a8fa8ae71bf35baa9af6a4cd8cbdc58dc24 | refs/heads/master | 2020-09-24T23:53:53.398074 | 2017-04-30T17:12:13 | 2017-04-30T17:12:13 | 66,734,090 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 742 | hpp | /** \file Notebook.hpp
*
* An object to take notes
*/
#ifndef NOTEBOOKHPP
#define NOTEBOOKHPP
#include <string>
#include <fstream>
class Notebook {
public:
/** Returns only instance of Notebook class.*/
static Notebook* get();
/** Save string to file */
void report(std::string note);
/** Get current date and time */
const std::string currentDateTime() const;
~Notebook();
private:
/** Make constructor, copy-constructor and operator =
* private to complete singleton implementation.*/
Notebook();
/* Do not implement*/
Notebook(Notebook const&);
void operator=(Notebook const&);
static Notebook* instance;
std::string mode_;
std::string file_name_;
};
#endif
| [
"yongchix@gmail.com"
] | yongchix@gmail.com |
1dcbe0c0cd2bc8353e3a73e8ff4c2c2c24bb810c | 306ea58eb0d5798883beb744fee980055a533f09 | /src/protocol.cpp | 690b9d97c65eec48004169352e2e9dd01118424f | [
"MIT"
] | permissive | invictusproject/invictus | e68eefae7decf09b4d47359efa8919a567490501 | af8e35a2a053f9a1bf52eae89cd5b82d9d7943cf | refs/heads/master | 2021-04-15T15:23:46.887277 | 2016-06-03T18:38:26 | 2016-06-03T18:38:26 | 60,369,651 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,453 | cpp | // Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-2016 The Bitcoin developers
// Copyright (c) 2016 The Invictus developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include "protocol.h"
#include "util.h"
#include "netbase.h"
#ifndef WIN32
# include <arpa/inet.h>
#endif
static const char* ppszTypeName[] =
{
"ERROR",
"tx",
"block",
};
CMessageHeader::CMessageHeader()
{
memcpy(pchMessageStart, ::pchMessageStart, sizeof(pchMessageStart));
memset(pchCommand, 0, sizeof(pchCommand));
pchCommand[1] = 1;
nMessageSize = -1;
nChecksum = 0;
}
CMessageHeader::CMessageHeader(const char* pszCommand, unsigned int nMessageSizeIn)
{
memcpy(pchMessageStart, ::pchMessageStart, sizeof(pchMessageStart));
strncpy(pchCommand, pszCommand, COMMAND_SIZE);
nMessageSize = nMessageSizeIn;
nChecksum = 0;
}
std::string CMessageHeader::GetCommand() const
{
if (pchCommand[COMMAND_SIZE-1] == 0)
return std::string(pchCommand, pchCommand + strlen(pchCommand));
else
return std::string(pchCommand, pchCommand + COMMAND_SIZE);
}
bool CMessageHeader::IsValid() const
{
// Check start string
if (memcmp(pchMessageStart, ::pchMessageStart, sizeof(pchMessageStart)) != 0)
return false;
// Check the command string for errors
for (const char* p1 = pchCommand; p1 < pchCommand + COMMAND_SIZE; p1++)
{
if (*p1 == 0)
{
// Must be all zeros after the first zero
for (; p1 < pchCommand + COMMAND_SIZE; p1++)
if (*p1 != 0)
return false;
}
else if (*p1 < ' ' || *p1 > 0x7E)
return false;
}
// Message size
if (nMessageSize > MAX_SIZE)
{
printf("CMessageHeader::IsValid() : (%s, %u bytes) nMessageSize > MAX_SIZE\n", GetCommand().c_str(), nMessageSize);
return false;
}
return true;
}
CAddress::CAddress() : CService()
{
Init();
}
CAddress::CAddress(CService ipIn, uint64_t nServicesIn) : CService(ipIn)
{
Init();
nServices = nServicesIn;
}
void CAddress::Init()
{
nServices = NODE_NETWORK;
nTime = 100000000;
nLastTry = 0;
}
CInv::CInv()
{
type = 0;
hash = 0;
}
CInv::CInv(int typeIn, const uint256& hashIn)
{
type = typeIn;
hash = hashIn;
}
CInv::CInv(const std::string& strType, const uint256& hashIn)
{
unsigned int i;
for (i = 1; i < ARRAYLEN(ppszTypeName); i++)
{
if (strType == ppszTypeName[i])
{
type = i;
break;
}
}
if (i == ARRAYLEN(ppszTypeName))
throw std::out_of_range(strprintf("CInv::CInv(string, uint256) : unknown type '%s'", strType.c_str()));
hash = hashIn;
}
bool operator<(const CInv& a, const CInv& b)
{
return (a.type < b.type || (a.type == b.type && a.hash < b.hash));
}
bool CInv::IsKnownType() const
{
return (type >= 1 && type < (int)ARRAYLEN(ppszTypeName));
}
const char* CInv::GetCommand() const
{
if (!IsKnownType())
throw std::out_of_range(strprintf("CInv::GetCommand() : type=%d unknown type", type));
return ppszTypeName[type];
}
std::string CInv::ToString() const
{
return strprintf("%s %s", GetCommand(), hash.ToString().substr(0,20).c_str());
}
void CInv::print() const
{
printf("CInv(%s)\n", ToString().c_str());
}
| [
"invictus@tech-center.com"
] | invictus@tech-center.com |
1854bd146c6ebad24562a7112cc0fade0a3efc41 | 9b8ed2eb05e40016395a069013402610361ee499 | /Test/EventProcessorBase.h | f96c6c175c82df6582f4a143bceb93d6c29f8c05 | [] | no_license | singmelody/Test | 6b74674cc0219189caaf365df120a4420b77cd6f | 9f2d3d72627586bd07a66b2599a7106d7d6b1f1c | refs/heads/master | 2020-04-07T02:50:03.334288 | 2017-12-31T22:26:46 | 2017-12-31T22:34:09 | 45,405,601 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 836 | h | #pragma once
#include "MyListNode.h"
#include "EventBase.h"
class EventHandlerBase;
template <class T>
class EventProcessorBase
{
public:
EventProcessorBase(void)
{
m_ProcPtr = NULL;
m_ProcPtr = static_cast<T*>(this);
}
EventProcessorBase(T* pPtr)
{
m_ProcPtr = pPtr;
}
~EventProcessorBase(void)
{
}
virtual void TickEvent()
{
EventBase* pEvent = m_EventList.Pop_Head();
while (pEvent)
{
ProcEvent(pEvent);
EventFactory::Instance().Delete(pEvent);
pEvent = m_EventList.Pop_head();
}
}
virtual void PushEvent(EventBase* pEvent)
{
if(!pEvent)
return;
EventBase* pNew = (EventBase*)EventFactory::Instance().New(pEvent->GetClass()->ClassID());
if(!pNew)
return;
pNew->Clone(pEvent);
m_EventList.Push_back(pNew);
}
protected:
T* m_ProcPtr;
MyList<EventBase> m_EventList;
};
| [
"446538645@qq.com"
] | 446538645@qq.com |
f7486fb93ec01499188dfdeac517a2d5e614bb3c | 5b4312ddc24f29538dce0444b7be81e17191c005 | /autoware.ai/1.12.0_cuda/build/autoware_msgs/devel/include/autoware_msgs/Waypoint.h | 1431a664a3b04974cf30ff3f04a701ca0c42c4bf | [
"MIT"
] | permissive | muyangren907/autoware | b842f1aeb2bfe7913fb2be002ea4fc426b4e9be2 | 5ae70f0cdaf5fc70b91cd727cf5b5f90bc399d38 | refs/heads/master | 2020-09-22T13:08:14.237380 | 2019-12-03T07:12:49 | 2019-12-03T07:12:49 | 225,167,473 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 12,947 | h | // Generated by gencpp from file autoware_msgs/Waypoint.msg
// DO NOT EDIT!
#ifndef AUTOWARE_MSGS_MESSAGE_WAYPOINT_H
#define AUTOWARE_MSGS_MESSAGE_WAYPOINT_H
#include <string>
#include <vector>
#include <map>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
#include <geometry_msgs/PoseStamped.h>
#include <geometry_msgs/TwistStamped.h>
#include <autoware_msgs/DTLane.h>
#include <autoware_msgs/WaypointState.h>
namespace autoware_msgs
{
template <class ContainerAllocator>
struct Waypoint_
{
typedef Waypoint_<ContainerAllocator> Type;
Waypoint_()
: gid(0)
, lid(0)
, pose()
, twist()
, dtlane()
, change_flag(0)
, wpstate()
, lane_id(0)
, left_lane_id(0)
, right_lane_id(0)
, stop_line_id(0)
, cost(0.0)
, time_cost(0.0)
, direction(0) {
}
Waypoint_(const ContainerAllocator& _alloc)
: gid(0)
, lid(0)
, pose(_alloc)
, twist(_alloc)
, dtlane(_alloc)
, change_flag(0)
, wpstate(_alloc)
, lane_id(0)
, left_lane_id(0)
, right_lane_id(0)
, stop_line_id(0)
, cost(0.0)
, time_cost(0.0)
, direction(0) {
(void)_alloc;
}
typedef int32_t _gid_type;
_gid_type gid;
typedef int32_t _lid_type;
_lid_type lid;
typedef ::geometry_msgs::PoseStamped_<ContainerAllocator> _pose_type;
_pose_type pose;
typedef ::geometry_msgs::TwistStamped_<ContainerAllocator> _twist_type;
_twist_type twist;
typedef ::autoware_msgs::DTLane_<ContainerAllocator> _dtlane_type;
_dtlane_type dtlane;
typedef int32_t _change_flag_type;
_change_flag_type change_flag;
typedef ::autoware_msgs::WaypointState_<ContainerAllocator> _wpstate_type;
_wpstate_type wpstate;
typedef uint32_t _lane_id_type;
_lane_id_type lane_id;
typedef uint32_t _left_lane_id_type;
_left_lane_id_type left_lane_id;
typedef uint32_t _right_lane_id_type;
_right_lane_id_type right_lane_id;
typedef uint32_t _stop_line_id_type;
_stop_line_id_type stop_line_id;
typedef float _cost_type;
_cost_type cost;
typedef float _time_cost_type;
_time_cost_type time_cost;
typedef uint32_t _direction_type;
_direction_type direction;
typedef boost::shared_ptr< ::autoware_msgs::Waypoint_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::autoware_msgs::Waypoint_<ContainerAllocator> const> ConstPtr;
}; // struct Waypoint_
typedef ::autoware_msgs::Waypoint_<std::allocator<void> > Waypoint;
typedef boost::shared_ptr< ::autoware_msgs::Waypoint > WaypointPtr;
typedef boost::shared_ptr< ::autoware_msgs::Waypoint const> WaypointConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::autoware_msgs::Waypoint_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::autoware_msgs::Waypoint_<ContainerAllocator> >::stream(s, "", v);
return s;
}
} // namespace autoware_msgs
namespace ros
{
namespace message_traits
{
// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': False}
// {'std_msgs': ['/opt/ros/melodic/share/std_msgs/cmake/../msg'], 'pcl_msgs': ['/opt/ros/melodic/share/pcl_msgs/cmake/../msg'], 'sensor_msgs': ['/opt/ros/melodic/share/sensor_msgs/cmake/../msg'], 'jsk_footstep_msgs': ['/opt/ros/melodic/share/jsk_footstep_msgs/cmake/../msg'], 'geometry_msgs': ['/opt/ros/melodic/share/geometry_msgs/cmake/../msg'], 'jsk_recognition_msgs': ['/opt/ros/melodic/share/jsk_recognition_msgs/cmake/../msg'], 'actionlib_msgs': ['/opt/ros/melodic/share/actionlib_msgs/cmake/../msg'], 'autoware_msgs': ['/home/muyangren907/autoware/autoware.ai/1.12.0_cuda/src/autoware/messages/autoware_msgs/msg']}
// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
template <class ContainerAllocator>
struct IsFixedSize< ::autoware_msgs::Waypoint_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::autoware_msgs::Waypoint_<ContainerAllocator> const>
: FalseType
{ };
template <class ContainerAllocator>
struct IsMessage< ::autoware_msgs::Waypoint_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::autoware_msgs::Waypoint_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::autoware_msgs::Waypoint_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::autoware_msgs::Waypoint_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::autoware_msgs::Waypoint_<ContainerAllocator> >
{
static const char* value()
{
return "f980f8144ba8190e8db52ab486d506e2";
}
static const char* value(const ::autoware_msgs::Waypoint_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0xf980f8144ba8190eULL;
static const uint64_t static_value2 = 0x8db52ab486d506e2ULL;
};
template<class ContainerAllocator>
struct DataType< ::autoware_msgs::Waypoint_<ContainerAllocator> >
{
static const char* value()
{
return "autoware_msgs/Waypoint";
}
static const char* value(const ::autoware_msgs::Waypoint_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::autoware_msgs::Waypoint_<ContainerAllocator> >
{
static const char* value()
{
return "# global id\n"
"int32 gid \n"
"# local id\n"
"int32 lid\n"
"geometry_msgs/PoseStamped pose\n"
"geometry_msgs/TwistStamped twist\n"
"DTLane dtlane\n"
"int32 change_flag\n"
"WaypointState wpstate\n"
"\n"
"uint32 lane_id\n"
"uint32 left_lane_id\n"
"uint32 right_lane_id\n"
"uint32 stop_line_id\n"
"float32 cost\n"
"float32 time_cost\n"
"\n"
"# Lane Direction\n"
"# FORWARD = 0\n"
"# FORWARD_LEFT = 1\n"
"# FORWARD_RIGHT = 2\n"
"# BACKWARD = 3 \n"
"# BACKWARD_LEFT = 4\n"
"# BACKWARD_RIGHT = 5\n"
"# STANDSTILL = 6\n"
"uint32 direction\n"
"================================================================================\n"
"MSG: geometry_msgs/PoseStamped\n"
"# A Pose with reference coordinate frame and timestamp\n"
"Header header\n"
"Pose pose\n"
"\n"
"================================================================================\n"
"MSG: std_msgs/Header\n"
"# Standard metadata for higher-level stamped data types.\n"
"# This is generally used to communicate timestamped data \n"
"# in a particular coordinate frame.\n"
"# \n"
"# sequence ID: consecutively increasing ID \n"
"uint32 seq\n"
"#Two-integer timestamp that is expressed as:\n"
"# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n"
"# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n"
"# time-handling sugar is provided by the client library\n"
"time stamp\n"
"#Frame this data is associated with\n"
"string frame_id\n"
"\n"
"================================================================================\n"
"MSG: geometry_msgs/Pose\n"
"# A representation of pose in free space, composed of position and orientation. \n"
"Point position\n"
"Quaternion orientation\n"
"\n"
"================================================================================\n"
"MSG: geometry_msgs/Point\n"
"# This contains the position of a point in free space\n"
"float64 x\n"
"float64 y\n"
"float64 z\n"
"\n"
"================================================================================\n"
"MSG: geometry_msgs/Quaternion\n"
"# This represents an orientation in free space in quaternion form.\n"
"\n"
"float64 x\n"
"float64 y\n"
"float64 z\n"
"float64 w\n"
"\n"
"================================================================================\n"
"MSG: geometry_msgs/TwistStamped\n"
"# A twist with reference coordinate frame and timestamp\n"
"Header header\n"
"Twist twist\n"
"\n"
"================================================================================\n"
"MSG: geometry_msgs/Twist\n"
"# This expresses velocity in free space broken into its linear and angular parts.\n"
"Vector3 linear\n"
"Vector3 angular\n"
"\n"
"================================================================================\n"
"MSG: geometry_msgs/Vector3\n"
"# This represents a vector in free space. \n"
"# It is only meant to represent a direction. Therefore, it does not\n"
"# make sense to apply a translation to it (e.g., when applying a \n"
"# generic rigid transformation to a Vector3, tf2 will only apply the\n"
"# rotation). If you want your data to be translatable too, use the\n"
"# geometry_msgs/Point message instead.\n"
"\n"
"float64 x\n"
"float64 y\n"
"float64 z\n"
"================================================================================\n"
"MSG: autoware_msgs/DTLane\n"
"float64 dist\n"
"float64 dir\n"
"float64 apara\n"
"float64 r\n"
"float64 slope\n"
"float64 cant\n"
"float64 lw\n"
"float64 rw\n"
"\n"
"================================================================================\n"
"MSG: autoware_msgs/WaypointState\n"
"int32 aid\n"
"uint8 NULLSTATE=0\n"
"\n"
"# lanechange\n"
"uint8 lanechange_state\n"
"\n"
"# bilinker\n"
"uint8 steering_state\n"
"uint8 STR_LEFT=1\n"
"uint8 STR_RIGHT=2\n"
"uint8 STR_STRAIGHT=3\n"
"uint8 STR_BACK=4\n"
"\n"
"uint8 accel_state\n"
"\n"
"uint8 stop_state\n"
"# 1 is stopline, 2 is stop which can only be released manually.\n"
"uint8 TYPE_STOPLINE=1\n"
"uint8 TYPE_STOP=2\n"
"\n"
"uint8 event_state\n"
"uint8 TYPE_EVENT_NULL = 0\n"
"uint8 TYPE_EVENT_GOAL = 1\n"
"uint8 TYPE_EVENT_MIDDLE_GOAL = 2\n"
"uint8 TYPE_EVENT_POSITION_STOP = 3\n"
"uint8 TYPE_EVENT_BUS_STOP = 4\n"
"uint8 TYPE_EVENT_PARKING = 5\n"
;
}
static const char* value(const ::autoware_msgs::Waypoint_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::autoware_msgs::Waypoint_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.gid);
stream.next(m.lid);
stream.next(m.pose);
stream.next(m.twist);
stream.next(m.dtlane);
stream.next(m.change_flag);
stream.next(m.wpstate);
stream.next(m.lane_id);
stream.next(m.left_lane_id);
stream.next(m.right_lane_id);
stream.next(m.stop_line_id);
stream.next(m.cost);
stream.next(m.time_cost);
stream.next(m.direction);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct Waypoint_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::autoware_msgs::Waypoint_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::autoware_msgs::Waypoint_<ContainerAllocator>& v)
{
s << indent << "gid: ";
Printer<int32_t>::stream(s, indent + " ", v.gid);
s << indent << "lid: ";
Printer<int32_t>::stream(s, indent + " ", v.lid);
s << indent << "pose: ";
s << std::endl;
Printer< ::geometry_msgs::PoseStamped_<ContainerAllocator> >::stream(s, indent + " ", v.pose);
s << indent << "twist: ";
s << std::endl;
Printer< ::geometry_msgs::TwistStamped_<ContainerAllocator> >::stream(s, indent + " ", v.twist);
s << indent << "dtlane: ";
s << std::endl;
Printer< ::autoware_msgs::DTLane_<ContainerAllocator> >::stream(s, indent + " ", v.dtlane);
s << indent << "change_flag: ";
Printer<int32_t>::stream(s, indent + " ", v.change_flag);
s << indent << "wpstate: ";
s << std::endl;
Printer< ::autoware_msgs::WaypointState_<ContainerAllocator> >::stream(s, indent + " ", v.wpstate);
s << indent << "lane_id: ";
Printer<uint32_t>::stream(s, indent + " ", v.lane_id);
s << indent << "left_lane_id: ";
Printer<uint32_t>::stream(s, indent + " ", v.left_lane_id);
s << indent << "right_lane_id: ";
Printer<uint32_t>::stream(s, indent + " ", v.right_lane_id);
s << indent << "stop_line_id: ";
Printer<uint32_t>::stream(s, indent + " ", v.stop_line_id);
s << indent << "cost: ";
Printer<float>::stream(s, indent + " ", v.cost);
s << indent << "time_cost: ";
Printer<float>::stream(s, indent + " ", v.time_cost);
s << indent << "direction: ";
Printer<uint32_t>::stream(s, indent + " ", v.direction);
}
};
} // namespace message_operations
} // namespace ros
#endif // AUTOWARE_MSGS_MESSAGE_WAYPOINT_H
| [
"907097904@qq.com"
] | 907097904@qq.com |
21ad050317f846d62960747d0faf2399abbeaaf0 | dae026d34aebe84edc78b6f6f748ffa85fbd2556 | /Sequence_Reconstruction_TopologicalSort_BFS.cpp | 2fc6baccb4d06d9c2b7f679f7b09f43f2fd42806 | [] | no_license | Sambhav-27/Leetcode | ab95dc930945a56d054ed9224ca98385b9c56243 | dac83e19c918f432b77cfda229c65e2883cc0f06 | refs/heads/master | 2023-08-22T09:44:20.136258 | 2021-08-04T18:07:59 | 2021-08-04T18:07:59 | 293,711,690 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,406 | cpp |
/*
Kahn's algo using bfs.
Another question:
https://www.geeksforgeeks.org/check-if-the-given-array-can-be-constructed-uniquely-from-the-given-set-of-subsequences/
Boils down to checking if only one topo sort exists;
Just check if at any point there are multiple sources i.e. queue size is > 1;
Then multiple topo sorts are possible.
Also put a check if ordering rules for all numbers are present;
i.e.
array is [1,2,3,4] & subsequences are: [1,2] [2,3]
here order for 4 is not present, so we return false;
*/
vector<int> topoSort(int n, vector<int> gr[]) {
queue<int> q;
int visited = 0;
int indegree[10005] = {0};
for(int i=0; i<n; ++i) {
for(int c: gr[i]) {
indegree[c]++;
}
}
// pushing all 0 degree nodes takes care of a forest
for(int i=0; i<n; ++i) {
if(indegree[i] == 0)
q.push(i);
}
vector<int> ans;
while(!q.empty()) {
// if(q.size() > 1) { return -1 }
int p = q.front(); q.pop();
ans.push_back(p);
visited++;
for(int c: gr[p]) {
indegree[c]--;
if(indegree[c] == 0) {
q.push(c);
}
}
}
if(visited != n) {
// topo sort not possible; graph has a cycle;
}
// here ans would be in reverse order i.e. bigger to smaller
return ans;
}
| [
"noreply@github.com"
] | noreply@github.com |
f3413ae1b4b496a6bec13a15cee2aea83a68fb59 | 97561b2730c6211f6641f53d4e8228eec96c4849 | /RayTracer/PhongLambert_Material.h | 8176f7356a4ac31f8a13dbd605c88eb17a38a796 | [] | no_license | LucasVB-TheyCallMeAPoro/Graphics-Programming | 4bbcaabae64b8cd5d5e901bb3876d8622a97da7c | d9b55691dde8b3b06c5ae00029179da76c83cbd4 | refs/heads/master | 2022-12-25T22:24:33.890919 | 2020-10-04T12:52:08 | 2020-10-04T12:52:08 | 301,126,867 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 473 | h | #pragma once
#include "Material.h"
#include "ERGBColor.h"
class PhongLambert_Material : public Material
{
public:
PhongLambert_Material(float difRefl, float specRefl, const Elite::RGBColor& color, float exponent);
virtual Elite::RGBColor Shade(const HitRecord& hit, const Elite::FVector3& incLight, const Elite::FVector3& outLight) const;
private:
float m_DiffuseReflectance;
float m_SpecularReflectance;
float m_PhongExponent;
Elite::RGBColor m_DiffuseColor;
};
| [
"lucasvanbaeveghem@outlook.com"
] | lucasvanbaeveghem@outlook.com |
fd36b667a3828cde54a27a627aee9090f677957e | 3a070be34da0fee7efe9ef88d89d01c0c84fc8db | /RobotUI.h | 8000b32b87e1fc3f8a23e0ec627588d58f92bb53 | [] | no_license | twak/marvin | 0962cf80aa6afc8187bd0e055d9105efb329e3a4 | 881de35574dc701fb414c4e2d6e79bbd6b392350 | refs/heads/main | 2023-03-05T21:27:11.232596 | 2021-02-16T10:42:25 | 2021-02-16T10:42:25 | 339,107,245 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 419 | h | // generated by Fast Light User Interface Designer (fluid) version 1.0102
#ifndef RobotUI_h
#define RobotUI_h
#include <FL/Fl.H>
#include <FL/Fl_Double_Window.H>
#include <FL/Fl_Group.H>
#include "Robot.h"
class RobotUI {
public:
RobotUI();
private:
Fl_Double_Window *mainWindow;
public:
Fl_Group *VChange;
Fl_Group *HChange;
Fl_Group *MainView;
Robot *cube;
void show(int argc, char **argv);
};
#endif
| [
"twakelly@gmail.com"
] | twakelly@gmail.com |
1ed87bb75de1c4eed29af3f504aeecfa229431a1 | cf8ddfc720bf6451c4ef4fa01684327431db1919 | /SDK/ARKSurvivalEvolved_BirthdayCakeBP_structs.hpp | 7a8889784cc31720b36d557e1fd61508cdf639bb | [
"MIT"
] | permissive | git-Charlie/ARK-SDK | 75337684b11e7b9f668da1f15e8054052a3b600f | c38ca9925309516b2093ad8c3a70ed9489e1d573 | refs/heads/master | 2023-06-20T06:30:33.550123 | 2021-07-11T13:41:45 | 2021-07-11T13:41:45 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 368 | hpp | #pragma once
// ARKSurvivalEvolved (329.9) SDK
#ifdef _MSC_VER
#pragma pack(push, 0x8)
#endif
#include "ARKSurvivalEvolved_Basic.hpp"
#include "ARKSurvivalEvolved_StructureSeatingBaseBP_classes.hpp"
#include "ARKSurvivalEvolved_CoreUObject_classes.hpp"
#include "ARKSurvivalEvolved_Engine_classes.hpp"
namespace sdk
{
}
#ifdef _MSC_VER
#pragma pack(pop)
#endif
| [
"sergey.2bite@gmail.com"
] | sergey.2bite@gmail.com |
21a980c0d18ebdf1ae4aed5c6b997af40a6f7f2d | 6e1c7bcfd28e93b6533550786d393770ee0df780 | /source/Irrlicht/COpenGLCoreRenderTarget.h | 10ef958fbbdb74b7585764641d519be11dbe2e5e | [
"Zlib",
"LicenseRef-scancode-other-permissive",
"LicenseRef-scancode-unknown-license-reference"
] | permissive | savegame/sailfish-irrlicht | c6d4f895f62c86ab2a74cf0f090b99f5bfc59f90 | 919acfecbc73e9bcbdd5ad3a8f12a5cdacb23172 | refs/heads/master | 2021-06-04T03:55:52.389843 | 2017-08-07T18:22:24 | 2017-08-07T18:22:24 | 104,747,048 | 11 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 9,437 | h | // Copyright (C) 2015 Patryk Nadrowski
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#ifndef __C_OGLCORE_RENDER_TARGET_H_INCLUDED__
#define __C_OGLCORE_RENDER_TARGET_H_INCLUDED__
#include "IrrCompileConfig.h"
#if defined(_IRR_COMPILE_WITH_OPENGL_) || defined(_IRR_COMPILE_WITH_OGLES1_) || defined(_IRR_COMPILE_WITH_OGLES2_)
#include "IRenderTarget.h"
namespace irr
{
namespace video
{
template <class TOpenGLDriver, class TOpenGLTexture>
class COpenGLCoreRenderTarget : public IRenderTarget
{
public:
COpenGLCoreRenderTarget(TOpenGLDriver* driver) : AssignedDepth(false), AssignedStencil(false), RequestTextureUpdate(false), RequestDepthStencilUpdate(false),
BufferID(0), ColorAttachment(0), MultipleRenderTarget(0), Driver(driver)
{
#ifdef _DEBUG
setDebugName("COpenGLCoreRenderTarget");
#endif
DriverType = Driver->getDriverType();
Size = Driver->getScreenSize();
ColorAttachment = Driver->getFeature().ColorAttachment;
MultipleRenderTarget = Driver->getFeature().MultipleRenderTarget;
if (ColorAttachment > 0)
Driver->irrGlGenFramebuffers(1, &BufferID);
AssignedTexture.set_used(static_cast<u32>(ColorAttachment));
for (u32 i = 0; i < AssignedTexture.size(); ++i)
AssignedTexture[i] = GL_NONE;
}
virtual ~COpenGLCoreRenderTarget()
{
if (ColorAttachment > 0 && BufferID != 0)
Driver->irrGlDeleteFramebuffers(1, &BufferID);
for (u32 i = 0; i < Texture.size(); ++i)
{
if (Texture[i])
Texture[i]->drop();
}
if (DepthStencil)
DepthStencil->drop();
}
virtual void setTexture(const core::array<ITexture*>& texture, ITexture* depthStencil) _IRR_OVERRIDE_
{
bool textureUpdate = (Texture != texture) ? true : false;
bool depthStencilUpdate = (DepthStencil != depthStencil) ? true : false;
if (textureUpdate || depthStencilUpdate)
{
// Set color attachments.
if (textureUpdate)
{
for (u32 i = 0; i < Texture.size(); ++i)
{
if (Texture[i])
Texture[i]->drop();
}
if (texture.size() > static_cast<u32>(ColorAttachment))
{
core::stringc message = "This GPU supports up to ";
message += static_cast<u32>(ColorAttachment);
message += " textures per render target.";
os::Printer::log(message.c_str(), ELL_WARNING);
}
Texture.set_used(core::min_(texture.size(), static_cast<u32>(ColorAttachment)));
for (u32 i = 0; i < Texture.size(); ++i)
{
TOpenGLTexture* currentTexture = (texture[i] && texture[i]->getDriverType() == DriverType) ? static_cast<TOpenGLTexture*>(texture[i]) : 0;
GLuint textureID = 0;
if (currentTexture)
{
if (currentTexture->getType() == ETT_2D)
textureID = currentTexture->getOpenGLTextureName();
else
os::Printer::log("This driver doesn't support render to cubemaps.", ELL_WARNING);
}
if (textureID != 0)
{
Texture[i] = texture[i];
Texture[i]->grab();
}
else
{
Texture[i] = 0;
}
}
RequestTextureUpdate = true;
}
// Set depth and stencil attachments.
if (depthStencilUpdate)
{
TOpenGLTexture* currentTexture = (depthStencil && depthStencil->getDriverType() == DriverType) ? static_cast<TOpenGLTexture*>(depthStencil) : 0;
GLuint textureID = 0;
if (currentTexture)
{
if (currentTexture->getType() == ETT_2D)
textureID = currentTexture->getOpenGLTextureName();
else
os::Printer::log("This driver doesn't support render to cubemaps.", ELL_WARNING);
}
const ECOLOR_FORMAT textureFormat = (textureID != 0) ? depthStencil->getColorFormat() : ECF_UNKNOWN;
if (IImage::isDepthFormat(textureFormat))
{
DepthStencil = depthStencil;
DepthStencil->grab();
}
else
{
if (DepthStencil)
DepthStencil->drop();
DepthStencil = 0;
}
RequestDepthStencilUpdate = true;
}
// Set size required for a viewport.
ITexture* firstTexture = getTexture();
if (firstTexture)
Size = firstTexture->getSize();
else
{
if (DepthStencil)
Size = DepthStencil->getSize();
else
Size = Driver->getScreenSize();
}
}
}
void update()
{
if (RequestTextureUpdate || RequestDepthStencilUpdate)
{
// Set color attachments.
if (RequestTextureUpdate)
{
// Set new color textures.
const u32 textureSize = core::min_(Texture.size(), AssignedTexture.size());
for (u32 i = 0; i < textureSize; ++i)
{
GLuint textureID = (Texture[i]) ? static_cast<TOpenGLTexture*>(Texture[i])->getOpenGLTextureName() : 0;
if (textureID != 0)
{
AssignedTexture[i] = GL_COLOR_ATTACHMENT0 + i;
Driver->irrGlFramebufferTexture2D(GL_FRAMEBUFFER, AssignedTexture[i], GL_TEXTURE_2D, textureID, 0);
}
else if (AssignedTexture[i] != GL_NONE)
{
AssignedTexture[i] = GL_NONE;
Driver->irrGlFramebufferTexture2D(GL_FRAMEBUFFER, AssignedTexture[i], GL_TEXTURE_2D, 0, 0);
os::Printer::log("Error: Could not set render target.", ELL_ERROR);
}
}
// Reset other render target channels.
for (u32 i = textureSize; i < AssignedTexture.size(); ++i)
{
if (AssignedTexture[i] != GL_NONE)
{
Driver->irrGlFramebufferTexture2D(GL_FRAMEBUFFER, AssignedTexture[i], GL_TEXTURE_2D, 0, 0);
AssignedTexture[i] = GL_NONE;
}
}
RequestTextureUpdate = false;
}
// Set depth and stencil attachments.
if (RequestDepthStencilUpdate)
{
const ECOLOR_FORMAT textureFormat = (DepthStencil) ? DepthStencil->getColorFormat() : ECF_UNKNOWN;
if (IImage::isDepthFormat(textureFormat))
{
GLuint textureID = static_cast<TOpenGLTexture*>(DepthStencil)->getOpenGLTextureName();
Driver->irrGlFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, textureID, 0);
if (textureFormat == ECF_D24S8)
{
Driver->irrGlFramebufferTexture2D(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_TEXTURE_2D, textureID, 0);
AssignedStencil = true;
}
else
{
if (AssignedStencil)
Driver->irrGlFramebufferTexture2D(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_TEXTURE_2D, 0, 0);
AssignedStencil = false;
}
AssignedDepth = true;
}
else
{
if (AssignedDepth)
Driver->irrGlFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, 0, 0);
if (AssignedStencil)
Driver->irrGlFramebufferTexture2D(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_TEXTURE_2D, 0, 0);
AssignedDepth = false;
AssignedStencil = false;
}
RequestDepthStencilUpdate = false;
}
// Configure drawing operation.
if (ColorAttachment > 0 && BufferID != 0)
{
const u32 textureSize = Texture.size();
if (textureSize == 0)
Driver->irrGlDrawBuffer(GL_NONE);
else if (textureSize == 1 || MultipleRenderTarget == 0)
Driver->irrGlDrawBuffer(GL_COLOR_ATTACHMENT0);
else
{
const u32 bufferCount = core::min_(MultipleRenderTarget, core::min_(textureSize, AssignedTexture.size()));
Driver->irrGlDrawBuffers(bufferCount, AssignedTexture.pointer());
}
}
#ifdef _DEBUG
checkFBO(Driver);
#endif
}
}
GLuint getBufferID() const
{
return BufferID;
}
const core::dimension2d<u32>& getSize() const
{
return Size;
}
ITexture* getTexture() const
{
for (u32 i = 0; i < Texture.size(); ++i)
{
if (Texture[i])
return Texture[i];
}
return 0;
}
protected:
bool checkFBO(TOpenGLDriver* driver)
{
if (ColorAttachment == 0)
return true;
GLenum status = driver->irrGlCheckFramebufferStatus(GL_FRAMEBUFFER);
switch (status)
{
case GL_FRAMEBUFFER_COMPLETE:
return true;
case GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER:
os::Printer::log("FBO has invalid read buffer", ELL_ERROR);
break;
case GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER:
os::Printer::log("FBO has invalid draw buffer", ELL_ERROR);
break;
case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT:
os::Printer::log("FBO has one or several incomplete image attachments", ELL_ERROR);
break;
case GL_FRAMEBUFFER_INCOMPLETE_FORMATS:
os::Printer::log("FBO has one or several image attachments with different internal formats", ELL_ERROR);
break;
case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS:
os::Printer::log("FBO has one or several image attachments with different dimensions", ELL_ERROR);
break;
case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:
os::Printer::log("FBO missing an image attachment", ELL_ERROR);
break;
case GL_FRAMEBUFFER_UNSUPPORTED:
os::Printer::log("FBO format unsupported", ELL_ERROR);
break;
default:
os::Printer::log("FBO error", ELL_ERROR);
break;
}
return false;
}
core::array<GLenum> AssignedTexture;
bool AssignedDepth;
bool AssignedStencil;
bool RequestTextureUpdate;
bool RequestDepthStencilUpdate;
GLuint BufferID;
core::dimension2d<u32> Size;
u32 ColorAttachment;
u32 MultipleRenderTarget;
TOpenGLDriver* Driver;
};
}
}
#endif
#endif
| [
"nadro@dfc29bdd-3216-0410-991c-e03cc46cb475"
] | nadro@dfc29bdd-3216-0410-991c-e03cc46cb475 |
d1483ea12bc967686b960bfa5e92927e6dc5d749 | f3f850dc0ab5ba40f96c1d9db86e355a0e9fbd4d | /FuncAnalyze/functional_lib.h | b631459ee0178332da99d468832abb13073dd218 | [] | no_license | AlexeySrus/Reconfigurable-Neural-Network | 40dae7f5c07db1baa7ddd4cac68b3091d7770022 | 5b1cb09cea499bcbb73ec1469f8842865479ff76 | refs/heads/master | 2021-09-08T12:57:20.688380 | 2018-03-09T22:24:06 | 2018-03-09T22:24:06 | 112,357,754 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,310 | h | #ifndef FINDMINMAXFUNC_FUNCTIONAL_LIB_H
#define FINDMINMAXFUNC_FUNCTIONAL_LIB_H
#include <functional>
#include <vector>
#include <cstdlib>
namespace funclib {
const long long MAX_STEPS = 10000;
inline double GLOB_EPS = 1E-5;
unsigned long random(const unsigned long &t1, const unsigned long &t2);
void set_eps(const double &);
template<typename T>
T abs(const T &arg) { return arg < 0 ? -arg : arg; }
template<typename T>
std::vector<T> set_of_points(const T &left, const T &right, const unsigned long &count) {
if (count == 1)
return std::vector<T>({(left + right) / 2});
std::vector<T> res_v(count);
for (auto i = 0; i < count; ++i)
res_v[i] = left + i * (right - left) / (count - 1);
return res_v;
}
template<typename T>
T max(const std::vector<T> &v, const T &EPS) {
T max_elem = *v.begin();
for (auto &i : v)
if (i - max_elem > -EPS)
max_elem = i;
return max_elem;
}
template<typename T>
T min(const std::vector<T> &v, const T &EPS) {
T min_elem = *v.begin();
for (auto &i : v)
if (i - min_elem < EPS)
min_elem = i;
return min_elem;
}
template<typename T>
bool in(const std::vector<T> &v, const T &elem, const T &EPS) {
for (auto &i : v)
if (abs(i - elem) < EPS)
return true;
return false;
}
template<typename T>
T grad_max_of_func(const std::vector<std::pair<T, T>> &args_area,
std::function<T(const std::vector<T> &)> explored_func,
const T &h, const T &lambda, const std::vector<T> &start_point, T EPS) {
using namespace std;
auto n = args_area.size();
auto vec_add = [](vector<T> x, long i, T value) {
x[i] += value;
return x;
};
auto gradient = [&](const vector<T> &x) {
vector<T> grad_values;
for (auto i = 0; i < n; ++i)
grad_values.emplace_back((-3 * explored_func(x) - 4 * explored_func(vec_add(x, i, h)) -
explored_func(vec_add(x, i, 2 * h))) / 2 / h);
return grad_values;
};
auto rate = [](const vector<T> &x) {
T res = 0, s = 1;
for (auto &i : x)
res += i * i;
for (auto i = 0; i < 500; ++i)
s = (s + res / s) / 2;
return s;
};
auto add_vec_mul_coeff = [](vector<T> &v_res, const vector<T> &v_add, const T &a) {
for (auto i = 0; i < v_res.size(); ++i)
v_res[i] += v_add[i] * a;
return;
};
auto add_vec_mul_coeff_res = [](vector<T> v_res, const vector<T> &v_add, const T &a) {
for (auto i = 0; i < v_res.size(); ++i)
v_res[i] += v_add[i] * a;
return v_res;
};
const unsigned long count_protection_points = 2, max_count_equals_loop_points = 5;
vector<T> loop_protection_vec(count_protection_points);
unsigned long loop_protection_id = 0;
bool loop_protection_start = false;
long long explicit_stop = 0;
vector<T> x_next = start_point, x_pred = x_next;
T fn = explored_func(x_pred) + 10 * EPS, tmp = 0;
while (abs(explored_func(x_next) - fn) >= EPS) {
x_pred = x_next;
fn = explored_func(x_pred);
auto g = gradient(x_next);
T rate_g = rate(g);
add_vec_mul_coeff(x_next, g, -lambda / rate_g);
for (auto i = 0; i < x_next.size(); ++i)
if (x_next[i] - args_area[i].first < EPS)
x_next[i] = args_area[i].first;
else if (x_next[i] - args_area[i].second > -EPS)
x_next[i] = args_area[i].second;
loop_protection_id = ++loop_protection_id % count_protection_points;
loop_protection_vec[loop_protection_id] = fn;
if (!loop_protection_start && !loop_protection_id)
loop_protection_start = true;
else if (loop_protection_start)
if (in(loop_protection_vec, tmp = explored_func(x_next), EPS))
loop_protection_vec.push_back(tmp);
if (loop_protection_vec.size() > max_count_equals_loop_points + count_protection_points)
return max(loop_protection_vec, EPS);
if (++explicit_stop > MAX_STEPS) {
EPS *= 10;
explicit_stop = 0;
}
}
return max(vector<T>({explored_func(x_next), fn}), EPS);
}
template<typename T>
std::pair<T, T> grad_min_max_of_func(const std::vector<std::pair<T, T>> &args_area,
std::function<T(const std::vector<T> &)> explored_func,
const T &h, const T &lambda, const unsigned long &point_count) {
using namespace std;
srand(static_cast<unsigned int>(time(nullptr)));
auto n = args_area.size();
vector<vector<T>> v_points;
vector<T> left_p, right_p;
for (auto &i : args_area) {
v_points.push_back(set_of_points(i.first, i.second, point_count));
left_p.push_back(i.first);
right_p.push_back(i.second);
}
vector<T> v_res;
v_res.push_back(explored_func(left_p));
v_res.push_back(explored_func(right_p));
for (auto i = 0; i < point_count; ++i) {
vector<T> x;
for (auto &p : v_points)
x.push_back(p[random(0, p.size() - 1)]);
T t_eps = GLOB_EPS;
v_res.push_back(
-grad_max_of_func<T>(args_area, [&explored_func](const vector<T> &v) { return -explored_func(v); },
h, lambda, x, t_eps));
v_res.push_back(grad_max_of_func<T>(args_area, explored_func, h, lambda, x, t_eps));
}
return make_pair(min(v_res, T(GLOB_EPS)), max(v_res, T(GLOB_EPS)));
}
template<typename T>
std::vector<std::pair<T, T>> grad_min_max_of_multidimensional_func(const std::vector<std::pair<T, T>> &args_area,
std::function<std::vector<T>(
const std::vector<T> &)> explored_func,
const T &h, const T &lambda,
const unsigned long &point_count) {
using namespace std;
vector<pair<T, T>> res;
vector<T> test_func_input;
for (auto &i :args_area)
test_func_input.push_back((i.first + i.second) / 2);
auto func_out_dim = explored_func(test_func_input).size();
for (auto i = 0; i < func_out_dim; ++i)
res.push_back(grad_min_max_of_func<T>(args_area, [&](const vector<T> &v) {
return explored_func(v)[i];
}, h, lambda, point_count));
return res;
}
}
#endif //FINDMINMAXFUNC_FUNCTIONAL_LIB_H
| [
"alexey.s.russ@mail.ru"
] | alexey.s.russ@mail.ru |
b87a465d238a68c2bbdd7fb1dd2f0b305ef49707 | afd455d3a5a2b8a0f3d57f80aec1861846e9b958 | /liv2/PROTOTYPE/Serveur/action_Tradxxx/trad.cpp | a69a98b6ac65cb5edba6ffdf22ecf7a333b8eaef | [] | no_license | martiall99/Pro3600-RPG- | d28dd9da62445108c7d45eb196889baad991159a | 0b344f407acc9216766c89eb0ff4fdcb774c4952 | refs/heads/master | 2021-01-17T17:00:32.702724 | 2016-05-14T13:20:50 | 2016-05-14T13:20:50 | null | 0 | 0 | null | null | null | null | ISO-8859-1 | C++ | false | false | 2,926 | cpp | #include "traducteur.h"
#include "../co_client/debug.h"
using namespace std;
TradActions::TradActions(Personnage *papa)
{
erreur.ajParent(this);
moi = papa;
}
bool TradActions::ajAction(int id_a, Action *ac)
{
int d = rech(id_a);
if (d != -1)
{
debug("ERREUR l'ID numero" + to_string(id_a) + "est deja presente dans le traducteur, case " + to_string(d));
return false;
}
ID.push_back(id_a);
act.push_back(ac);
ac->ajParent(this);//on s'ajoute en parent de l'action qu'elle puisse acceder a nos Personnage moi, adv
return(verifStable());
}
int TradActions::rech(int id)//renvoie le numéro de la case du tableau correspondant a l id
{
int l = ID.size();
for (int i = 0; i < l; i++)
{
if (ID[i] == id)
{
return i;
}
}
return -1;
}
void TradActions::viderTrad()
{
int l = size();
for (int i = 0; i < l; i++)
{
delete act[i];
act[i] = 0;
}
ID.erase(ID.begin(), ID.end());// erase marche sur des iterators et nous rech() renvoie un int,
// donc on recupere le debut de la chaine et on rajoute le numeor de la case
act.erase(act.begin(), act.end());
}
bool TradActions::enlAction(int id_a)
{
int a = rech(id_a);
if (a != -1)
{
debug("a= " + to_string(a));
Action *b = act[a];
delete b;
act.at(a) = 0;
ID.erase(ID.begin() + a);// erase marche sur des iterators et nous rech() renvoie un int,
// donc on recupere le debut de la chaine et on rajoute le numeor de la case
act.erase(act.begin() + a);
return(verifStable());
}
else
{
debug("Erreur on essaye d'enlever l'id " + to_string(id_a) + " qui n'existe pas dans le traducteur");
return(verifStable());
}
}
Action* TradActions::rechID(int id_r)// utilise rech() puis r'envoie le pointeur du deuxième tableau dans la même case
{
int a = rech(id_r);
if (a == -1)
{
debug("Pas trouvé l'id " + to_string(id_r));
return &erreur;
}
else
return act.at(a);
}
string TradActions::listeID()
{
int l = ID.size();
string r = "";
for (int i = 0; i < l; i++)
{
if(act[i]->peutEff())// on ne propose au client que ce qu'il peut effectivement faire !
r += to_string(ID[i]) + ";";
}
return r;
}
string TradActions::toString()
{
string r = "";
int l = ID.size();
for (int i = 0; i < l - 1; i++)// -1 car le dernier on lui rajoute pas "/"
{
r += act.at(i)->toString() + "/";
}
r += act.at(l - 1)->toString();
return r;
}
bool TradActions::verifStable()
{
int l = size();
if (l == -1)
{
debug("ERREUR les tableaux act et ID n'ont pas la même taille");
return false;
}
for (int i = 0; i < l; i++)
{
for (int j = i + 1; j < l; j++)
{
if (ID[i] == ID[j])
{
debug("ERREUR deux elements du traducteur ont même ID");
return false;
}
}
}
return true;
}
int TradActions::size()
{
int l = ID.size();
int l2 = act.size();
if (l != l2)
{
debug("ERREUR, les ID et act n'ont pas même taille");
return -1;
}
else
return l;
}
| [
"willvi31@yahoo.fr"
] | willvi31@yahoo.fr |
8fb7a14a89769105e0a877e4f9e5fa009326423b | 1e603ccf664f8077f67beb5515ddac62bed4e81a | /src/Robby/frame.h | 058a54892d181ecb1386eeed30f8dbeb1c39ce27 | [] | no_license | physycom/intrphysycom | 2217c05b52b5a0ff213903440129bfc77d9759ca | 18aec988fddb500a9b56e818fabb7ecd63ebe371 | refs/heads/master | 2021-01-12T14:32:46.645696 | 2019-09-02T08:34:16 | 2019-09-02T08:34:16 | 72,006,942 | 2 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 251 | h | #ifndef FRAME_1_HPP
#define FRAME_1_HPP
#include <FL/Fl_Gl_Window.H>
class Frame : public Fl_Gl_Window {
void draw();
public:
Frame(int x, int y, int w, int h, const char *l = 0)
: Fl_Gl_Window(x, y, w, h, l) {}
};
#endif // FRAME_1_HPP
| [
"stesinigardi@hotmail.com"
] | stesinigardi@hotmail.com |
f2fe735938a30d8ae59647dda147d831aa7d9a13 | b41639f194ce38c23a10f7937d9b818bd075e952 | /AudioStreamingLibCore/AudioStreamingLibCore/levelmeter.h | 37ee00c1f89c618746afe6783b250de980d4772f | [
"MIT"
] | permissive | seyedmmousavi/AudioStreaming | 3cbd91ca2cf5196690c9afa242f03fa3648b3845 | 33d2c4872eb463455bd8e39f1915f10b05701b32 | refs/heads/master | 2021-01-22T05:42:20.154031 | 2017-05-01T15:59:03 | 2017-05-01T15:59:03 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 451 | h | #ifndef LEVELMETER_H
#define LEVELMETER_H
#include <QtCore>
#include <QtMultimedia>
#include "levelmeterthread.h"
class LevelMeter : public QObject
{
Q_OBJECT
public:
explicit LevelMeter(QObject *parent = 0);
signals:
void currentlevel(qreal);
public slots:
void start(const QAudioFormat &format);
void write(const QByteArray &data);
private:
LevelMeterThread *m_meter;
};
#endif // LEVELMETER_H
| [
"you@example.com"
] | you@example.com |
3d24218d5113d00b6a74acd5fee6c1e2a4ddec20 | 79767edb6e984936f24a75c91a81eca0fa05a356 | /OpcUaNodeSetModul/src/OpcUaNodeSetModul/OpcUaAttributeWidget/WriteMaskWidget.cpp | e12c8ea7aa93327ae010c636a659c9e673036f49 | [
"Apache-2.0"
] | permissive | WongJian1990/OpcUaDesigner | c0eb77fb5752f6668be4653854e6b0099f4c0cc3 | ec7c1150b957884cfd17696708ba7e7cbd5761d0 | refs/heads/master | 2023-03-19T06:33:02.717808 | 2019-07-23T07:25:27 | 2019-07-23T07:25:27 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,728 | cpp | /*
Copyright 2017-2019 Kai Huebl (kai@huebl-sgh.de)
Lizenziert gemäß Apache Licence Version 2.0 (die „Lizenz“); Nutzung dieser
Datei nur in Übereinstimmung mit der Lizenz erlaubt.
Eine Kopie der Lizenz erhalten Sie auf http://www.apache.org/licenses/LICENSE-2.0.
Sofern nicht gemäß geltendem Recht vorgeschrieben oder schriftlich vereinbart,
erfolgt die Bereitstellung der im Rahmen der Lizenz verbreiteten Software OHNE
GEWÄHR ODER VORBEHALTE – ganz gleich, ob ausdrücklich oder stillschweigend.
Informationen über die jeweiligen Bedingungen für Genehmigungen und Einschränkungen
im Rahmen der Lizenz finden Sie in der Lizenz.
Autor: Kai Huebl (kai@huebl-sgh.de)
*/
#include <QHBoxLayout>
#include <QVBoxLayout>
#include <QLineEdit>
#include "OpcUaNodeSetModul/OpcUaAttributeWidget/WriteMaskWidget.h"
using namespace OpcUaStackServer;
namespace OpcUaNodeSet
{
WriteMaskWidget::WriteMaskWidget(QWidget* parent)
: QWidget()
, checkOn_(true)
, isValid_(true)
{
// widgets
textWidget_ = new QLineEdit();
textWidget_->setFixedWidth(400);
// layout
QHBoxLayout* hBoxLayout = new QHBoxLayout();
hBoxLayout->addWidget(textWidget_);
hBoxLayout->setMargin(0);
//
// actions
//
connect(
textWidget_, SIGNAL(textChanged(const QString&)),
this, SLOT(onTextChangedTextWidget(const QString&))
);
setLayout(hBoxLayout);
}
WriteMaskWidget::~WriteMaskWidget(void)
{
}
bool
WriteMaskWidget::isValid(void)
{
return isValid_;
}
void
WriteMaskWidget::nodeChange(NodeInfo* nodeInfo)
{
BaseNodeClass::SPtr baseNode = nodeInfo->baseNode_;
if (baseNode->isNullWriteMask()) {
textWidget_->setText(QString("0"));
}
checkOn_ = false;
OpcUaUInt32 writeMask;
baseNode->getWriteMask(writeMask);
textWidget_->setText(QString("%1").arg((uint32_t)writeMask));
isValid_ = checkValue();
styleValue();
checkOn_ = true;
}
void
WriteMaskWidget::enabled(bool enabled)
{
textWidget_->setEnabled(enabled);
}
void
WriteMaskWidget::getValue(OpcUaUInt32& writeMask)
{
bool rc;
writeMask = textWidget_->text().toInt(&rc);
}
bool
WriteMaskWidget::checkValue(void)
{
textWidget_->text().toInt(&isValid_);
return isValid_;
}
void
WriteMaskWidget::styleValue(void)
{
if (isValid_) {
textWidget_->setStyleSheet("background-color:none;");
}
else {
textWidget_->setStyleSheet("background-color:red;");
}
}
void
WriteMaskWidget::onTextChangedTextWidget(const QString& text)
{
if (!checkOn_) return;
OpcUaUInt32 writeMask;
isValid_ = checkValue();
styleValue();
bool rc;
writeMask = textWidget_->text().toInt(&rc);
emit valueChanged(writeMask, isValid_);
emit update();
}
}
| [
"kai@huebl-sgh.de"
] | kai@huebl-sgh.de |
c8a4a8d16c043b4a166bbfbdf349fde55ca19dd7 | f73d752f775dcc9efd072025912c428b80fb238f | /sidescroller/Source/Scroller2D/GameMode2D.h | ea17ae51aa0ab3be3ac5f5ca62a629c4d35dc244 | [
"MIT"
] | permissive | ElonGame/2D-Path-Finding-and-Steering-Behaviors | 5100f7016c8b85cd43f5dc705ed9c682e08b93c8 | cf1c5049c08dd2a533e8bfb19416cf444b7ba529 | refs/heads/master | 2020-12-30T07:24:19.311952 | 2015-05-21T17:53:01 | 2015-05-21T17:53:01 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 195 | h |
#pragma once
#include "GameFramework/GameMode.h"
#include "GameMode2D.generated.h"
/**
*
*/
UCLASS()
class SCROLLER2D_API AGameMode2D : public AGameMode
{
GENERATED_UCLASS_BODY()
};
| [
"csanti4442@yahoo.com"
] | csanti4442@yahoo.com |
985d7d72d4d6f3497ec735c8a0399beb1dbd08af | 736c4a1f1783253594d08b48d5895d09f7b9b933 | /DataStructure/队列_循环队列_逆向.cpp | 5eb60a5096c02da1197cde81ea6a52fae39d7e18 | [] | no_license | SouthBegonia/Computer-Course | ff8023808997cabb699de3edfbfc3065ba858a9d | f2b44eab61ec6280744421484dcf8b513508754e | refs/heads/master | 2023-01-12T14:52:10.383650 | 2023-01-07T14:10:05 | 2023-01-07T14:10:05 | 173,942,304 | 6 | 1 | null | null | null | null | GB18030 | C++ | false | false | 1,761 | cpp | /*
程序功能：建立循环队列，要求逆序入队，即队首指针沿着 Maxsize-1,Maxsize-2,...,0,Maxsize-1,...
基本思路：两种队首指针的移向
队首指针正向： front = (front+1) % Maxsize
队首指针逆向： front = (front-1+Maxsize) % Maxsize
*/
#include<iostream>
#define Maxsize 7
using namespace std;
typedef struct Cycqueue{
int data[Maxsize];
int front; //标记入队元素的前一个位置
int rear; //标记队尾元素的位置
}Cycqueue;
/*出队，出队值赋予 x */
int DeQueue(Cycqueue &q, int &x)
{
if(q.front==q.rear) //队空
return 0;
else
{
x = q.data[q.rear];
q.rear = (q.rear-1+Maxsize)%Maxsize; //修改队尾指针
return 1;
}
}
/*入队，将值 x 入队*/
int EnQueue(Cycqueue &q, int x)
{
if(q.rear==(q.front-1+Maxsize)%Maxsize) //队满
return 0;
else
{
q.data[q.front] = x;
q.front = (q.front-1+Maxsize)%Maxsize; //修改队头指针
return 1;
}
}
/*初始化循环队列，默认数值 0*/
void Init(Cycqueue &q)
{
q.front = 0;
q.rear = 0;
for(int i=0;i<Maxsize;i++)
q.data[i] = 0;
}
/*打印队列*/
void DispQ(Cycqueue &q)
{
cout<<"front="<<q.front<<" rear="<<q.rear<<endl;
for(int i=0;i<Maxsize;i++)
cout<<q.data[i]<<" ";
cout<<endl;
}
int main()
{
int A[5] = {1,2,3,4,5}; //入队元素的数组
int num=0; //出队值
Cycqueue Q; //循环队列 Q
Init(Q); //初始化
DispQ(Q);
cout<<endl;
for(int i=0;i<5;i++) //将A[]内元素顺序入队并打印队列情况
{
EnQueue(Q,A[i]);
DispQ(Q);
cout<<endl;
}
cout<<endl;
for(int i=0;i<5;i++) //将Q队列内5个元素出队，打印队列情况及出队值
{
DeQueue(Q,num);
DispQ(Q);
cout<<"Num = "<<num<<endl<<endl;
}
return 0;
}
| [
"1687634916@qq.com"
] | 1687634916@qq.com |
5bc50f2bc9333fe2408abd2a9ad484c703e68e98 | 4e0b1f87ead5c9858d2be44e494b70888797a887 | /CorneredFigure.cpp | 7d4df720213eb774718b925f467aca0e5b99147c | [] | no_license | Hallgrenaren/CPROG_Klasser | ab4fa712afcbee49c95959414e300364473a6ce4 | dc97e9474b3e6ed9f459fe14509305c1dbbc35c2 | refs/heads/master | 2020-12-12T09:51:34.764084 | 2020-01-15T16:29:15 | 2020-01-15T16:29:15 | 234,102,470 | 0 | 0 | null | 2020-01-15T19:08:16 | 2020-01-15T14:49:23 | C++ | UTF-8 | C++ | false | false | 70 | cpp | //
// Created by Martin on 1/15/2020.
//
#include "CorneredFigure.h"
| [
"martin@tada.se"
] | martin@tada.se |
74e184f98d67e3f4f69a25c9b63a0a488a0acf25 | 9c48b69af0057561f2066bb5e7a5504578e7a7a0 | /C++/polimorfizm.cpp | 15f629f8c383ceeb491690a31cb2a6375e8412eb | [] | no_license | kbuczek/computerScienceStudies | 183cd027d09fecf17122c2ce849eb7a781033247 | 984bc1bda0d7e74abc4928db8787d59036cc01ba | refs/heads/master | 2023-03-07T23:14:49.533175 | 2021-02-22T12:24:53 | 2021-02-22T12:24:53 | 283,665,540 | 0 | 0 | null | 2021-02-22T12:21:57 | 2020-07-30T04:02:58 | Java | UTF-8 | C++ | false | false | 817 | cpp | #include <iostream>
#include <memory>
#include<vector>
class Base {
public:
virtual void SayHello() const = 0; //pure virtual function, isn't used
/*{
std::cout << "Hello from Base!" << std::endl;
}*/
};
class Derived : public Base {
public:
void SayHello() const override {
std::cout << "Hello from Derived!" << std::endl;
}
};
class DerivedDerived : public Base {
public:
void SayHello() const override {
std::cout << "Hello from DerivedDerived!" << std::endl;
}
};
int main() {
Base *pBase = new Derived();
Base *pBase2 = new DerivedDerived();
//Base *pBase3 = new Base();
//pBase->SayHello();
//pBase2->SayHello();
std::vector<Base*> v_modules;
v_modules.push_back(pBase);
v_modules.push_back(pBase2);
//v_modules.push_back(pBase3);
for(auto m : v_modules) {
m->SayHello();
}
}
| [
"noreply@github.com"
] | noreply@github.com |
846433f1056460c116d18c1a557c33bac1787c90 | f69b0e875076d7a9ef44dd6554f339095a34b33f | /main.cpp | ee3e2381e118ff7d02f20d7c9486c4f4cdf75429 | [] | no_license | ronghanghu/SanguoshaEX | ede0d79e99e7183afab6f9124bff65eb67d2d494 | 65fbc64a0d40c16abfe0b648653cdee331183342 | refs/heads/master | 2020-06-04T05:31:05.106205 | 2014-03-21T00:07:45 | 2014-03-21T00:07:45 | 17,962,199 | 5 | 3 | null | null | null | null | UTF-8 | C++ | false | false | 378 | cpp | /*
* main.cpp
*
* Created on: Feb 26, 2012
* Author: latios
*/
#include "sgsui_InitiateBox.h"
#include <QApplication>
#include <ctime>
#include <cstdlib>
int main(int argc, char** argv) {
srand(static_cast<unsigned>(time(0)));
QApplication app(argc, argv);
sgsui::InitiateBox * initiateBox = new sgsui::InitiateBox();
initiateBox->show();
return app.exec();
}
| [
"huronghang@hotmail.com"
] | huronghang@hotmail.com |
3dc6509c39724a50e9ff010931032c18cb77383f | 35f9def6e6d327d3a4a4f2959024eab96f199f09 | /Δ3/digital/software/Linux/nppPluginManager/pluginManager/src/PluginList.cpp | 96730618014e93951cfb0b2a80980311f3f556d2 | [
"GPL-2.0-only",
"CAL-1.0-Combined-Work-Exception",
"CAL-1.0",
"MIT",
"CC-BY-SA-4.0",
"LicenseRef-scancode-free-unknown"
] | permissive | arXiv-research/DevLab-III-1 | ec10aef27e1ca75f206fea11014da8784752e454 | c50cd2b9154c83c3db5e4a11b9e8874f7fb8afa2 | refs/heads/main | 2023-04-16T19:24:58.758519 | 2021-04-28T20:21:23 | 2021-04-28T20:21:23 | 362,599,929 | 2 | 0 | MIT | 2021-04-28T20:36:11 | 2021-04-28T20:36:11 | null | UTF-8 | C++ | false | false | 45,754 | cpp | /*
This file is part of Plugin Manager Plugin for Notepad++
Copyright (C)2009-2010 Dave Brotherstone <davegb@pobox.com>
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.
*/
#include "precompiled_headers.h"
#include "PluginList.h"
#include "PluginManager.h"
#include "tinyxml/tinyxml.h"
#include "libinstall/InstallStep.h"
#include "libinstall/DownloadStep.h"
#include "libinstall/InstallStepFactory.h"
#include "libinstall/md5.h"
#include "libinstall/DownloadManager.h"
#include "libinstall/Decompress.h"
#include "libinstall/DirectoryUtil.h"
#include "Utility.h"
#include "WcharMbcsConverter.h"
using namespace std;
using namespace std::placeholders;
typedef BOOL (__cdecl * PFUNCISUNICODE)();
PluginList::PluginList(void)
: _nppData(nullptr),
_variableHandler(nullptr)
{
_hListsAvailableEvent = CreateEvent(
NULL, // LPSECURITY_ATTRIBUTES
TRUE, // bManualReset
FALSE, // Initial state
NULL); // Event name
}
PluginList::~PluginList(void)
{
if (_variableHandler)
delete _variableHandler;
clearPluginList();
}
void PluginList::init(NppData *nppData)
{
_nppData = nppData;
TCHAR configDir[MAX_PATH];
TCHAR nppDir[MAX_PATH];
TCHAR allUsersPluginDir[MAX_PATH];
::SendMessage(nppData->_nppHandle, NPPM_GETPLUGINSCONFIGDIR, MAX_PATH, reinterpret_cast<LPARAM>(configDir));
::SendMessage(nppData->_nppHandle, NPPM_GETNPPDIRECTORY, MAX_PATH, reinterpret_cast<LPARAM>(nppDir));
LPARAM nppVersion = ::SendMessage(nppData->_nppHandle, NPPM_GETNPPVERSION, 0, 0);
int majorVersion = HIWORD(nppVersion);
int minorVersion = LOWORD(nppVersion);
TCHAR tmp[10];
_itot_s(majorVersion, tmp, 10, 10);
tstring versionString(tmp);
_itot_s(minorVersion, tmp, 10, 10);
for(int i = 0; tmp[i]; i++)
{
versionString.push_back(_T('.'));
versionString.push_back(tmp[i]);
}
_nppVersion = versionString;
_tcscpy_s(allUsersPluginDir, MAX_PATH, nppDir);
::PathAppend(allUsersPluginDir, _T("plugins"));
_variableHandler = new VariableHandler();
_variableHandler->setVariable(_T("NPPDIR"), nppDir);
_variableHandler->setVariable(_T("ALLUSERSPLUGINDIR"), allUsersPluginDir);
_variableHandler->setVariable(VALIDATE_BASE_URL_VAR, getValidateUrl());
ITEMIDLIST *pidl;
HRESULT result = SHGetSpecialFolderLocation(NULL, CSIDL_APPDATA, &pidl);
if (result == S_OK)
{
TCHAR appDataPluginDir[MAX_PATH];
if (SHGetPathFromIDList(pidl, appDataPluginDir))
{
PathAppend(appDataPluginDir, _T("Notepad++\\plugins"));
_variableHandler->setVariable(_T("USERPLUGINDIR"), appDataPluginDir);
}
else
{
_variableHandler->setVariable(_T("USERPLUGINDIR"), allUsersPluginDir);
}
}
else
{
_variableHandler->setVariable(_T("USERPLUGINDIR"), allUsersPluginDir);
}
if (g_options.installLocation == INSTALLLOC_APPDATA)
{
_variableHandler->setVariable(_T("PLUGINDIR"), _variableHandler->getVariable(_T("USERPLUGINDIR")).c_str());
}
else
{
_variableHandler->setVariable(_T("PLUGINDIR"), _variableHandler->getVariable(_T("ALLUSERSPLUGINDIR")).c_str());
}
_variableHandler->setVariable(_T("CONFIGDIR"), configDir);
}
void PluginList::addPluginNames(TiXmlElement* pluginNamesElement)
{
TiXmlElement *pluginNameNode = pluginNamesElement->FirstChildElement();
while(pluginNameNode)
{
if (pluginNameNode->Attribute(_T("md5")) && pluginNameNode->Attribute(_T("name")))
{
_pluginRealNames[pluginNameNode->Attribute(_T("md5"))] = pluginNameNode->Attribute(_T("name"));
}
pluginNameNode = (TiXmlElement*)pluginNamesElement->IterateChildren(pluginNameNode);
}
}
BOOL PluginList::parsePluginFile(CONST TCHAR *filename)
{
clearPluginList();
TiXmlDocument doc(filename);
doc.LoadFile();
if (doc.Error())
{
#ifdef ALLOW_OVERRIDE_XML_URL
tstring error = doc.ErrorDesc();
error += _T(" at row ");
TCHAR tmp[10];
tmp[0] = '\0';
if (!_itot_s(doc.ErrorRow(), tmp, 10, 10))
error += tmp;
error += _T(", col ");
if (!_itot_s(doc.ErrorCol(), tmp, 10, 10))
error += tmp;
::MessageBox(_nppData->_nppHandle, error.c_str(), _T("Error parsing XML File"), 0);
#endif
return FALSE;
}
TiXmlNode *pluginsDoc = doc.FirstChildElement(_T("plugins"));
if (pluginsDoc)
{
TiXmlElement *pluginNode = pluginsDoc->FirstChildElement();
Plugin *plugin;
while(pluginNode)
{
if (!_tcscmp(pluginNode->Value(), _T("pluginNames")))
{
addPluginNames(pluginNode);
}
else if (!_tcscmp(pluginNode->Value(), _T("plugin")))
{
plugin = new Plugin();
plugin->setName(pluginNode->Attribute(_T("name")));
BOOL available = FALSE;
if (g_isUnicode)
{
if (g_isX64)
{
TiXmlElement *versionUrlElement = pluginNode->FirstChildElement(_T("x64Version"));
if (versionUrlElement && versionUrlElement->FirstChild())
{
plugin->setVersion(PluginVersion(versionUrlElement->FirstChild()->Value()));
available = TRUE;
}
}
else
{
TiXmlElement *versionUrlElement = pluginNode->FirstChildElement(_T("unicodeVersion"));
if (versionUrlElement && versionUrlElement->FirstChild())
{
plugin->setVersion(PluginVersion(versionUrlElement->FirstChild()->Value()));
available = TRUE;
}
}
}
else
{
TiXmlElement *versionUrlElement = pluginNode->FirstChildElement(_T("ansiVersion"));
if (versionUrlElement && versionUrlElement->FirstChild())
{
plugin->setVersion(PluginVersion(versionUrlElement->FirstChild()->Value()));
available = TRUE;
}
}
/* Notepad++ Version checks */
TiXmlElement *minVersionElement = pluginNode->FirstChildElement(_T("minNotepadVersion"));
if (minVersionElement && minVersionElement->FirstChild())
{
if (_nppVersion < PluginVersion(minVersionElement->FirstChild()->Value()))
available = FALSE;
}
TiXmlElement *maxVersionElement = pluginNode->FirstChildElement(_T("maxNotepadVersion"));
if (maxVersionElement && maxVersionElement->FirstChild())
{
if (_nppVersion > PluginVersion(maxVersionElement->FirstChild()->Value()))
available = FALSE;
}
/* Plugin attributes - description, author etc */
TiXmlElement *descriptionUrlElement = pluginNode->FirstChildElement(_T("description"));
if (descriptionUrlElement && descriptionUrlElement->FirstChild())
plugin->setDescription(descriptionUrlElement->FirstChild()->Value());
TiXmlElement *filenameUrlElement = pluginNode->FirstChildElement(_T("filename"));
if (filenameUrlElement && filenameUrlElement->FirstChild())
plugin->setFilename(filenameUrlElement->FirstChild()->Value());
TiXmlElement *versionsUrlElement = pluginNode->FirstChildElement(_T("versions"));
if (versionsUrlElement)
{
TiXmlElement *versionUrlElement = versionsUrlElement->FirstChildElement(_T("version"));
while(versionUrlElement)
{
plugin->addVersion(versionUrlElement->Attribute(_T("md5")), PluginVersion(versionUrlElement->Attribute(_T("number"))));
versionUrlElement = (TiXmlElement *)versionsUrlElement->IterateChildren(versionUrlElement);
}
}
TiXmlElement *badVersionsElement = pluginNode->FirstChildElement(_T("badVersions"));
if (badVersionsElement)
{
TiXmlElement *versionElement = badVersionsElement->FirstChildElement(_T("version"));
while(versionElement)
{
plugin->addBadVersion(PluginVersion(versionElement->Attribute(_T("number"))), versionElement->Attribute(_T("report")));
versionElement = (TiXmlElement *)badVersionsElement->IterateChildren(versionElement);
}
}
TiXmlElement *aliasesElement = pluginNode->FirstChildElement(_T("aliases"));
if (aliasesElement)
{
TiXmlElement *aliasElement = aliasesElement->FirstChildElement(_T("alias"));
while(aliasElement)
{
_aliases[tstring(aliasElement->Attribute(_T("name")))] = plugin->getName();
aliasElement = (TiXmlElement *)aliasesElement->IterateChildren(aliasElement);
}
}
/* Installation / Removal */
TiXmlElement *installElement = pluginNode->FirstChildElement(_T("install"));
addSteps(plugin, installElement, INSTALL);
TiXmlElement *removeElement = pluginNode->FirstChildElement(_T("remove"));
if (NULL != removeElement)
{
addSteps(plugin, removeElement, REMOVE);
}
TiXmlElement *dependencies = pluginNode->FirstChildElement(_T("dependencies"));
if (dependencies && !dependencies->NoChildren())
{
TiXmlElement *dependency = dependencies->FirstChildElement();
while (dependency)
{
// If dependency is another plugin (currently the only supported dependency)
if (!_tcscmp(dependency->Value(), _T("plugin")))
{
const TCHAR* dependencyName = dependency->Attribute(_T("name"));
if (dependencyName)
plugin->addDependency(dependencyName);
}
dependency = reinterpret_cast<TiXmlElement*>(dependencies->IterateChildren(dependency));
}
}
TiXmlElement *authorElement = pluginNode->FirstChildElement(_T("author"));
if (authorElement && authorElement->FirstChild())
plugin->setAuthor(authorElement->FirstChild()->Value());
TiXmlElement *sourceElement = pluginNode->FirstChildElement(_T("sourceUrl"));
if (sourceElement && sourceElement->FirstChild())
plugin->setSourceUrl(sourceElement->FirstChild()->Value());
TiXmlElement *homepageElement = pluginNode->FirstChildElement(_T("homepage"));
if (homepageElement && homepageElement->FirstChild())
plugin->setHomepage(homepageElement->FirstChild()->Value());
TiXmlElement *categoryElement = pluginNode->FirstChildElement(_T("category"));
if (categoryElement && categoryElement->FirstChild())
plugin->setCategory(categoryElement->FirstChild()->Value());
else
plugin->setCategory(_T("Others"));
TiXmlElement *latestUpdateElement = pluginNode->FirstChildElement(_T("latestUpdate"));
if (latestUpdateElement && latestUpdateElement->FirstChild())
plugin->setLatestUpdate(latestUpdateElement->FirstChild()->Value());
// Check stability, default to "Good"
TiXmlElement *stabilityElement = pluginNode->FirstChildElement(_T("stability"));
if (stabilityElement && stabilityElement->FirstChild())
plugin->setStability(stabilityElement->FirstChild()->Value());
else
plugin->setStability(_T("Good"));
TiXmlElement *isLibraryElement = pluginNode->FirstChildElement(_T("isLibrary"));
if (isLibraryElement && isLibraryElement->FirstChild())
{
tstring isLibrary(isLibraryElement->FirstChild()->Value());
if (isLibrary == _T("true"))
{
_libraries[plugin->getName()] = plugin;
plugin->setIsLibrary(true);
}
}
if (available)
_plugins[plugin->getName()] = plugin;
}
pluginNode = (TiXmlElement *)pluginsDoc->IterateChildren(pluginNode);
}
}
return TRUE;
}
void PluginList::addSteps(Plugin* plugin, TiXmlElement* installElement, InstallOrRemove ior)
{
if (!installElement)
return;
TiXmlElement *installStepElement = installElement->FirstChildElement();
InstallStepFactory installStepFactory(_variableHandler);
while (installStepElement)
{
// If it is a unicode tag and build for x64, then only process the contents if it's a x64 N++, which is just available for unicode
// or if it's an unicode tag and build for x86, then only process the contents if it's an unicode N++
// or if it's an ansi tag, then only process the contents if it's an ansi N++
if ((g_isUnicode && g_isX64
&& !_tcscmp(installStepElement->Value(), _T("x64"))
&& installStepElement->FirstChild())
||
(g_isUnicode
&& !_tcscmp(installStepElement->Value(), _T("unicode"))
&& installStepElement->FirstChild())
||
(!g_isUnicode
&& !_tcscmp(installStepElement->Value(), _T("ansi"))
&& installStepElement->FirstChild()))
{
addSteps(plugin, installStepElement, ior);
}
else
{
std::shared_ptr<InstallStep> installStep = installStepFactory.create(installStepElement);
if (installStep.get())
{
if (INSTALL == ior)
plugin->addInstallStep(installStep);
else if (REMOVE == ior)
plugin->addRemoveStep(installStep);
}
}
installStepElement = (TiXmlElement *)installElement->IterateChildren(installStepElement);
}
}
BOOL PluginList::checkInstalledPlugins()
{
const tstring& nppDirectory = _variableHandler->getVariable(_T("ALLUSERSPLUGINDIR"));
_installedPlugins.clear();
_availablePlugins.clear();
_updateablePlugins.clear();
// Check in the default location
checkInstalledPlugins(nppDirectory.c_str(), TRUE);
//added for N++ 7.5.8 subdir feature
checkInstalledPluginsInSubdirs(nppDirectory.c_str(), TRUE);
if (g_options.appDataPluginsSupported)
{
const tstring& appDataPluginDir = _variableHandler->getVariable(_T("USERPLUGINDIR"));
if (!::PathFileExists(appDataPluginDir.c_str()))
{
DirectoryUtil::createDirectories(appDataPluginDir.c_str());
}
else
{
// No point checking what's installed if we've just created the directory!
checkInstalledPlugins(appDataPluginDir.c_str(), FALSE);
//added for N++ 7.5.8 subdir feature
checkInstalledPluginsInSubdirs(appDataPluginDir.c_str(), FALSE);
}
}
addAvailablePlugins();
return TRUE;
}
BOOL PluginList::checkInstalledPluginsInSubdirs(const TCHAR *pluginPath, BOOL allUsers)
{
tstring pluginsFullPathFilter(pluginPath);
pluginsFullPathFilter += _T("\\*");
WIN32_FIND_DATA foundData;
HANDLE hFindFile = ::FindFirstFile(pluginsFullPathFilter.c_str(), &foundData);
if (hFindFile != INVALID_HANDLE_VALUE)
{
do
{
if ((_tcsncmp(_T("."), foundData.cFileName, 1) != 0) && (_tcsncmp(_T(".."), foundData.cFileName, 2) != 0)
&& (_tcsncmp(_T("APIs"), foundData.cFileName, 4) != 0) && (_tcsncmp(_T("Config"), foundData.cFileName, 6) != 0)
&& (_tcsncmp(_T("disabled"), foundData.cFileName, 8) != 0) && (_tcsncmp(_T("doc"), foundData.cFileName, 3) != 0))
{
if (foundData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
{
tstring subDirName(pluginPath);
subDirName += _T("\\");
subDirName += foundData.cFileName;
checkInstalledPlugins(subDirName.c_str(), allUsers);
}
}
} while (::FindNextFile(hFindFile, &foundData));
FindClose(hFindFile);
}
return TRUE;
}
BOOL PluginList::checkInstalledPlugins(const TCHAR *pluginPath, BOOL allUsers)
{
tstring pluginsFullPathFilter(pluginPath);
pluginsFullPathFilter += _T("\\*.dll");
WIN32_FIND_DATA foundData;
HANDLE hFindFile = ::FindFirstFile(pluginsFullPathFilter.c_str(), &foundData);
if (hFindFile != INVALID_HANDLE_VALUE)
{
do
{
tstring pluginFilename(pluginPath);
pluginFilename += _T("\\");
pluginFilename += foundData.cFileName;
BOOL pluginOK = false;
tstring pluginName;
try
{
pluginName = getPluginName(pluginFilename);
pluginOK = true;
}
catch (...)
{
pluginOK = false;
}
if (pluginOK)
{
PluginContainer::iterator knownPlugin = _plugins.find(pluginName);
if (knownPlugin == _plugins.end())
{
// plugin name is not known, so see if we recognise the hash
// i.e. is it export plugin which renames itself
// (or some other plugin that does the same thing)
TCHAR hash[(MD5::HASH_LENGTH * 2) + 1];
if (MD5::hash(pluginFilename.c_str(), hash, (MD5::HASH_LENGTH * 2) + 1))
{
tstring hashString(hash);
map<tstring, tstring>::iterator realNameIter = _pluginRealNames.find(hashString);
if (realNameIter != _pluginRealNames.end())
{
knownPlugin = _plugins.find(realNameIter->second);
}
}
}
// If still unknown, check the aliases
if (knownPlugin == _plugins.end())
{
map<tstring, tstring>::iterator aliasIter = _aliases.find(pluginName);
if (aliasIter != _aliases.end())
{
knownPlugin = _plugins.find(aliasIter->second);
}
}
// Check if plugin known now
if (knownPlugin != _plugins.end())
{
Plugin* plugin = knownPlugin->second;
// If the plugin is already installed, then make a copy for the list
if (plugin->isInstalled())
{
plugin = new Plugin(*plugin);
}
plugin->setFilename(foundData.cFileName);
setInstalledVersion(pluginFilename, plugin);
plugin->setInstalledForAllUsers(allUsers);
TCHAR hashBuffer[(MD5LEN * 2) + 1];
if (MD5::hash(pluginFilename.c_str(), hashBuffer, (MD5LEN * 2) + 1))
{
tstring hash = hashBuffer;
plugin->setInstalledVersionFromHash(hash);
}
// If this is a user's plugin (in AppData), and there's already a version
// for all users, and AppData plugins are supported, then remove the
// allusers version of the plugin, as the appdata one will take precedence
if (g_options.appDataPluginsSupported && FALSE == allUsers)
{
list<Plugin*>::iterator it = _installedPlugins.begin();
while (it != _installedPlugins.end())
{
if (plugin->getName() == (*it)->getName()
&& (*it)->getInstalledForAllUsers())
{
it = _installedPlugins.erase(it);
}
else
{
++it;
}
}
// Remove the plugin from updateable plugins too, as whether or not it can be
// updated depends on THIS version, not the all users version
it = _updateablePlugins.begin();
while (it != _updateablePlugins.end())
{
if (plugin->getName() == (*it)->getName()
&& (*it)->getInstalledForAllUsers())
{
it = _updateablePlugins.erase(it);
}
else
{
++it;
}
}
// Also update the registered plugin version to the installed version
Plugin* registeredPlugin = getPlugin(plugin->getName());
if (registeredPlugin) {
registeredPlugin->setInstalledVersion(plugin->getInstalledVersion());
}
}
if (plugin->getInstalledVersion().getIsBad()
|| plugin->getVersion() > plugin->getInstalledVersion())
_updateablePlugins.push_back(plugin);
else
_installedPlugins.push_back(plugin);
}
else
{
// Plugin is still not known, so create an empty stub for it
Plugin* plugin = new Plugin();
plugin->setName(pluginName);
plugin->setFilename(foundData.cFileName);
setInstalledVersion(pluginFilename, plugin);
plugin->setDescription(_T("Unknown plugin - please let us know about this plugin on the forums"));
_installedPlugins.push_back(plugin);
}
}
} while(::FindNextFile(hFindFile, &foundData));
FindClose(hFindFile);
}
return TRUE;
}
void PluginList::addAvailablePlugins()
{
PluginContainer::iterator iter = _plugins.begin();
while (iter != _plugins.end())
{
if (!iter->second->isInstalled())
{
if (g_options.showUnstable || iter->second->getStability() == _T("Good"))
_availablePlugins.push_back(iter->second);
}
++iter;
}
}
tstring PluginList::getPluginName(tstring pluginFilename)
{
HINSTANCE pluginInstance = ::LoadLibrary(pluginFilename.c_str());
if (pluginInstance)
{
PFUNCISUNICODE pFuncIsUnicode = (PFUNCISUNICODE)GetProcAddress(pluginInstance, "isUnicode");
BOOL isUnicode;
if (!pFuncIsUnicode || !pFuncIsUnicode())
isUnicode = FALSE;
else
isUnicode = TRUE;
PFUNCGETNAME pFuncGetName = (PFUNCGETNAME)GetProcAddress(pluginInstance, "getName");
if (pFuncGetName)
{
CONST TCHAR* pluginName = pFuncGetName();
if (pluginName)
{
tstring tpluginName = pluginName;
tstring::size_type ampPosition = tpluginName.find(_T("&"));
while(ampPosition != tstring::npos)
{
tpluginName.replace(ampPosition, 1, _T(""));
ampPosition = tpluginName.find(_T("&"));
}
::FreeLibrary(pluginInstance);
return tpluginName;
}
else
{
::FreeLibrary(pluginInstance);
return _T("");
}
}
else
{
::FreeLibrary(pluginInstance);
throw tstring(_T("Plugin name call not defined"));
}
}
else
{
throw tstring(_T("Load library failed"));
}
}
BOOL PluginList::setInstalledVersion(tstring pluginFilename, Plugin* plugin)
{
DWORD handle;
DWORD bufferSize = ::GetFileVersionInfoSize(pluginFilename.c_str(), &handle);
if (bufferSize <= 0)
return FALSE;
unsigned char* buffer = new unsigned char[bufferSize];
::GetFileVersionInfo(pluginFilename.c_str(), handle, bufferSize, buffer);
/*struct LANGANDCODEPAGE {
WORD wLanguage;
WORD wCodePage;
} *lpTranslate;*/
VS_FIXEDFILEINFO* lpFileInfo;
UINT cbFileInfo;
VerQueryValue(buffer,
_T("\\"),
(LPVOID*)&lpFileInfo,
&cbFileInfo);
if (cbFileInfo)
{
plugin->setInstalledVersion(PluginVersion((lpFileInfo->dwFileVersionMS & 0xFFFF0000) >> 16,
lpFileInfo->dwFileVersionMS & 0x0000FFFF,
(lpFileInfo->dwFileVersionLS & 0xFFFF0000) >> 16,
lpFileInfo->dwFileVersionLS & 0x0000FFFF));
/*
HRESULT hr;
TCHAR subBlock[50];
hr = StringCchPrintf(subBlock, 50,
_T("\\StringFileInfo\\%04x%04x\\FileVersion"),
lpTranslate[0].wLanguage,
lpTranslate[0].wCodePage);
if (FAILED(hr))
{
return FALSE;
}
else
{
TCHAR *fileVersion;
UINT fileVersionLength;
if(::VerQueryValue(buffer, subBlock, reinterpret_cast<LPVOID *>(&fileVersion), &fileVersionLength))
{
if (fileVersion)
plugin->setInstalledVersion(PluginVersion(fileVersion));
}
}
*/
}
else
{
delete[] buffer;
return FALSE;
}
delete[] buffer;
return TRUE;
}
void PluginList::waitForListsAvailable()
{
::WaitForSingleObject(_hListsAvailableEvent, INFINITE);
}
BOOL PluginList::listsAvailable()
{
DWORD result = ::WaitForSingleObject(_hListsAvailableEvent, 0);
if (result == WAIT_OBJECT_0)
return TRUE;
else
return FALSE;
}
PluginListContainer& PluginList::getInstalledPlugins()
{
return _installedPlugins;
}
PluginListContainer& PluginList::getAvailablePlugins()
{
return _availablePlugins;
}
PluginListContainer& PluginList::getUpdateablePlugins()
{
return _updateablePlugins;
}
VariableHandler* PluginList::getVariableHandler()
{
return _variableHandler;
}
Plugin* PluginList::getPlugin(tstring name)
{
Plugin* plugin = _plugins[name];
if (NULL == plugin)
{
plugin = _libraries[name];
}
return plugin;
}
BOOL PluginList::isInstallOrUpgrade(const tstring& name)
{
Plugin* plugin = _plugins[name];
if (NULL == plugin)
{
plugin = _libraries[name];
}
if (!plugin || (plugin->isInstalled() && plugin->getVersion() <= plugin->getInstalledVersion()))
return FALSE;
else
return TRUE;
}
std::shared_ptr< list<tstring> > PluginList::calculateDependencies(std::shared_ptr< list<Plugin*> > selectedPlugins)
{
set<tstring> toBeInstalled;
std::shared_ptr< list<tstring> > installDueToDepends(new list<tstring>);
// First add all selected plugins to a name map
list<Plugin*>::iterator pluginIter = selectedPlugins->begin();
while (pluginIter != selectedPlugins->end())
{
toBeInstalled.insert((*pluginIter)->getName());
++pluginIter;
}
// Now check all dependencies are in the name map
pluginIter = selectedPlugins->begin();
while(pluginIter != selectedPlugins->end())
{
if ((*pluginIter)->hasDependencies())
{
list<tstring> dependencies = (*pluginIter)->getDependencies();
list<tstring>::iterator depIter = dependencies.begin();
while(depIter != dependencies.end())
{
if (toBeInstalled.count(*depIter) == 0)
{
// if not already selected to be installed, then add it to the list
if (isInstallOrUpgrade(*depIter))
{
Plugin* dependsPlugin = getPlugin(*depIter);
if (NULL != dependsPlugin)
{
toBeInstalled.insert(*depIter);
selectedPlugins->push_back(dependsPlugin);
// Add the name to the list to show the message
installDueToDepends->push_back(*depIter);
}
}
}
++depIter;
}
}
++pluginIter;
}
return installDueToDepends;
}
void PluginList::downloadList()
{
// Work out the path of the Plugins.xml destination (in config dir)
TCHAR pluginConfig[MAX_PATH];
::SendMessage(_nppData->_nppHandle, NPPM_GETPLUGINSCONFIGDIR, MAX_PATH - 26, reinterpret_cast<LPARAM>(pluginConfig));
if (!::PathFileExists(pluginConfig))
{
DirectoryUtil::createDirectories(pluginConfig);
}
tstring pluginsListFilename(pluginConfig);
tstring pluginsListZipFilename(pluginConfig);
pluginsListFilename.append(_T("\\PluginManagerPlugins.xml"));
pluginsListZipFilename.append(_T("\\PluginManagerPlugins.zip"));
// Download the plugins.xml from the repository
CancelToken cancelToken;
DownloadManager downloadManager(cancelToken);
tstring contentType;
TCHAR hashBuffer[(MD5LEN * 2) + 1];
MD5::hash(pluginsListFilename.c_str(), hashBuffer, (MD5LEN * 2) + 1);
string serverMD5;
BOOL downloadSuccess = FALSE;
downloadManager.disableCache();
#ifdef ALLOW_OVERRIDE_XML_URL
BOOL downloadResult;
if (!g_options.downloadMD5Url.empty())
{
downloadResult = downloadManager.getUrl(g_options.downloadMD5Url.c_str(), serverMD5, &g_options.moduleInfo);
}
else
{
TCHAR *md5Url = getPluginsMd5Url();
downloadResult = downloadManager.getUrl(md5Url, serverMD5, &g_options.moduleInfo);
}
#else
TCHAR *md5Url = getPluginsMd5Url();
BOOL downloadResult = downloadManager.getUrl(md5Url, serverMD5, &g_options.moduleInfo);
#endif
std::shared_ptr<char> cHashBuffer = WcharMbcsConverter::tchar2char(hashBuffer);
if (downloadResult && serverMD5 == cHashBuffer.get()) {
// Server hash matches local hash, so we're ok to continue
downloadSuccess = TRUE;
}
else if (downloadResult && serverMD5 != cHashBuffer.get())
{
// If the build is allowing to override the download URL, then use the one from options
// Also, don't unzip it - assume if it's overridden, it's a test version and hence easier to treat it
// as a plain xml file
#ifdef ALLOW_OVERRIDE_XML_URL
if (!g_options.downloadUrl.empty())
{
downloadSuccess = downloadManager.getUrl(g_options.downloadUrl.c_str(), pluginsListFilename, contentType, &g_options.moduleInfo);
/*
tstring unzipPath(pluginConfig);
unzipPath.append(_T("\\"));
Decompress::unzip(pluginsListZipFilename, unzipPath);
*/
}
else
#endif
{
// OSes less than vista don't support SNI, which cloudflare uses to support HTTPS, so we have to use HTTP on old OSes
TCHAR *pluginsUrl = getPluginsUrl();
downloadSuccess = downloadManager.getUrl(pluginsUrl, pluginsListZipFilename, contentType, &g_options.moduleInfo);
if (downloadSuccess) {
// Unzip the plugins.zip to PluginManagerPlugins.xml
tstring unzipPath(pluginConfig);
unzipPath.append(_T("\\"));
Decompress::unzip(pluginsListZipFilename, unzipPath);
}
}
}
if (downloadSuccess) {
// Parse it
parsePluginFile(pluginsListFilename.c_str());
// Check for what is installed
checkInstalledPlugins();
::SetEvent(_hListsAvailableEvent);
} else {
MessageBox(_nppData->_nppHandle, _T("There was an error downloading the plugin list. Please check your internet connection, and your proxy settings in Internet Explorer, Edge or Chrome"),
_T("Download Error"), MB_ICONERROR);
}
}
TCHAR* PluginList::getPluginsMd5Url() {
if (g_options.useDevPluginList) {
return DEV_PLUGINS_MD5_URL;
}
if (g_options.forceHttp || g_winVer < WV_VISTA) {
return PLUGINS_HTTP_MD5_URL;
}
return PLUGINS_MD5_URL;
}
TCHAR* PluginList::getPluginsUrl() {
if (g_options.useDevPluginList) {
return DEV_PLUGINS_URL;
}
if (g_options.forceHttp || g_winVer < WV_VISTA) {
return PLUGINS_HTTP_URL;
}
return PLUGINS_URL;
}
TCHAR* PluginList::getValidateUrl() {
if (g_options.useDevPluginList) {
return DEV_VALIDATE_BASE_URL;
}
if (g_options.forceHttp || g_winVer < WV_VISTA) {
return VALIDATE_BASE_HTTP_URL;
}
return VALIDATE_BASE_URL;
}
void PluginList::reparseFile(const tstring& pluginsListFilename)
{
// Parse it
parsePluginFile(pluginsListFilename.c_str());
// Check for what is installed
TCHAR nppDirectory[MAX_PATH];
::SendMessage(_nppData->_nppHandle, NPPM_GETNPPDIRECTORY, MAX_PATH, reinterpret_cast<LPARAM>(nppDirectory));
checkInstalledPlugins();
}
TiXmlDocument* PluginList::getGpupDocument(const TCHAR* filename)
{
TiXmlDocument* forGpupDoc = new TiXmlDocument();
TiXmlElement* installElement = NULL;
// Load gpup doc if it already exists
if (::PathFileExists(filename))
{
forGpupDoc->LoadFile(filename);
installElement = forGpupDoc->FirstChildElement(_T("install"));
}
// If install element not there, then create it
if (!installElement)
{
installElement = new TiXmlElement(_T("install"));
forGpupDoc->LinkEndChild(installElement);
}
return forGpupDoc;
}
void PluginList::installPlugins(HWND hMessageBoxParent, ProgressDialog* progressDialog, PluginListView* pluginListView, BOOL isUpgrade, CancelToken& cancelToken)
{
// Check if Plugin Manager has an update, and the list is not only updating this plugin
// If not, then the user *really* ought to do that first, as the XML may have changed
// or, the URL for the XML may have changed
g_options.moduleInfo.setHParent(hMessageBoxParent);
std::shared_ptr< list<Plugin*> > selectedPlugins = pluginListView->getSelectedPlugins();
if (selectedPlugins.get() == NULL)
{
progressDialog->close();
return;
}
tstring pluginManagerName = _T("Plugin Manager");
Plugin* pluginManagerPlugin = getPlugin(pluginManagerName);
if (pluginManagerPlugin && pluginManagerPlugin->getInstalledVersion() < pluginManagerPlugin->getVersion())
{
// So there IS an upgrade to plugin manager, so check that it's the only thing in the list
if (selectedPlugins->size() != 1 || (*(selectedPlugins->begin()))->getName() != _T("Plugin Manager"))
{
int updatePM = ::MessageBox(hMessageBoxParent, _T("An update is available to Plugin Manager. ")
_T("It is *strongly* advised that the Plugin Manager is updated ")
_T("before any other plugin is installed or updated. Would you ")
_T("like to update the Plugin Manager now?"), _T("Plugin Manager"),
MB_ICONWARNING | MB_YESNOCANCEL);
switch(updatePM)
{
case IDYES:
selectedPlugins->clear();
selectedPlugins->push_back(pluginManagerPlugin);
isUpgrade = TRUE;
break;
case IDNO:
break;
case IDCANCEL:
progressDialog->close();
return;
}
}
}
tstring configDir = _variableHandler->getVariable(_T("CONFIGDIR"));
tstring basePath(configDir);
basePath.append(_T("\\plugin_install_temp"));
// Create the temp directory if it doesn't exist already
::CreateDirectory(basePath.c_str(), NULL);
basePath.append(_T("\\plugin"));
tstring gpupFile(configDir);
gpupFile.append(_T("\\PluginManagerGpup.xml"));
TiXmlDocument* forGpupDoc = getGpupDocument(gpupFile.c_str());
TiXmlElement* installElement = forGpupDoc->FirstChildElement(_T("install"));
std::shared_ptr< list<tstring> > installDueToDepends = calculateDependencies(selectedPlugins);
if (!installDueToDepends->empty())
{
bool dependentPluginsToInstall = false;
tstring dependsMessage = _T("The following plugin");
if (installDueToDepends->size() > 1)
dependsMessage.append(_T("s"));
dependsMessage.append(_T(" need to be installed to support your selection.\r\n\r\n"));
for(list<tstring>::iterator msgIter = installDueToDepends->begin(); msgIter != installDueToDepends->end(); ++msgIter)
{
Plugin *plugin = getPlugin(*msgIter);
if (plugin && !plugin->getIsLibrary())
{
dependsMessage.append(*msgIter);
dependsMessage.append(_T("\r\n"));
dependentPluginsToInstall = true;
}
}
dependsMessage.append(_T("\r\nThey will be installed automatically."));
// Only display the message if there are real plugin dependencies to install, and not just libraries
if (dependentPluginsToInstall)
{
::MessageBox(hMessageBoxParent, dependsMessage.c_str(), _T("Plugin Manager"), MB_OK | MB_ICONINFORMATION);
}
}
size_t installSteps = 0;
list<Plugin*>::iterator pluginIter = selectedPlugins->begin();
while(pluginIter != selectedPlugins->end())
{
installSteps += (*pluginIter)->getInstallStepCount();
++pluginIter;
}
progressDialog->setStepCount(installSteps);
pluginIter = selectedPlugins->begin();
tstring pluginDir = _variableHandler->getVariable(_T("PLUGINDIR"));
tstring pluginTemp;
int pluginCount = 1;
BOOL needRestart = FALSE;
BOOL somethingInstalled = FALSE;
TCHAR pluginCountChar[10];
bool needAdmin = false;
while(pluginIter != selectedPlugins->end())
{
BOOL directoryCreated = FALSE;
do
{
pluginTemp = basePath;
_itot_s(pluginCount, pluginCountChar, 10, 10);
pluginTemp.append(pluginCountChar);
directoryCreated = ::CreateDirectory(pluginTemp.c_str(), NULL);
++pluginCount;
} while(!directoryCreated && pluginCount < 500);
// Check if there's been no luck creating the temp directory
// Assume there's either no space or no permission
if (pluginCount >= 500)
{
::MessageBox(hMessageBoxParent, _T("Error creating temporary directory for plugin download. Ensure you have permission to your plugin config directory."), _T("Plugin Manager"), MB_ICONERROR);
progressDialog->close();
// nothing to clean up, any created temp directories will be cleaned up if necessary on next launch, once any successful installs have happened
return;
}
pluginTemp.append(_T("\\"));
/* If we're upgrading, and
either:
The current plugin is installed in appdata, and the new one will be installed in appdata
or:
The current plugin is installed for all users, and the new one will be installed for all users
If the old version is in all users, and the new one going to appdata, then we don't need to remove it,
so that a normal user can install an upgrade (when this feature is enabled by the admin)
N++ will use the plugin in AppData to override N++\plugins dir
*/
if (isUpgrade
&& ( ((*pluginIter)->getInstalledForAllUsers() == FALSE
&& g_options.installLocation == INSTALLLOC_APPDATA
)
||
((*pluginIter)->getInstalledForAllUsers() == TRUE
&& g_options.installLocation != INSTALLLOC_APPDATA
)
)
)
{
/* Remove the existing file if is an upgrade
* This will be done in gpup, but the copy will come afterwards, also in gpup
* So, if the filename is the same as the existing plugin, gpup will delete the old
* file, then copy in the new.
* If the filename is different, the new one will be copied in now, then
* the old file will be deleted in gpup. This is why it is important that
* replace="false" (default) on the actual plugin file copy step
*/
tstring fullFilename;
if ((*pluginIter)->getInstalledForAllUsers())
{
// If the old plugin is installed for all users, then we need admin rights to remove it
needAdmin = true;
fullFilename.append(_variableHandler->getVariable(_T("ALLUSERSPLUGINDIR")));
}
else
{
fullFilename.append(_variableHandler->getVariable(_T("USERPLUGINDIR")));
}
fullFilename.push_back(_T('\\'));
tstring pluginFilename = (*pluginIter)->getFilename();
tstring fullFilenameForExistanceTest = fullFilename;
fullFilenameForExistanceTest.append(pluginFilename);
if (::PathFileExists(fullFilenameForExistanceTest.c_str()))
{
TiXmlElement* removeElement = new TiXmlElement(_T("delete"));
removeElement->SetAttribute(_T("file"), fullFilenameForExistanceTest.c_str());
installElement->LinkEndChild(removeElement);
}
//since N++ 7.5.8 plugin dlls could be also at path with pluginname as dir name
//delete both plugin dlls if they exist before the update
tstring fullFilenameForExistanceTestInSubdir = fullFilename;
tstring pluginFilenameCopy = pluginFilename;
//erase ".dll" from plugin filename and use as subdir name
tstring pluginSubPath = pluginFilenameCopy.erase((pluginFilename.length() - 4), pluginFilename.length());
fullFilenameForExistanceTestInSubdir.append(pluginSubPath);
fullFilenameForExistanceTestInSubdir.push_back(_T('\\'));
fullFilenameForExistanceTestInSubdir.append(pluginFilename);
if (::PathFileExists(fullFilenameForExistanceTestInSubdir.c_str()))
{
TiXmlElement* removeSubDirElement = new TiXmlElement(_T("delete"));
removeSubDirElement->SetAttribute(_T("file"), fullFilenameForExistanceTestInSubdir.c_str());
installElement->LinkEndChild(removeSubDirElement);
}
}
InstallStatus status = (*pluginIter)->install(pluginTemp, installElement,
std::bind(&ProgressDialog::setCurrentStatus, progressDialog, _1),
std::bind(&ProgressDialog::setStepProgress, progressDialog, _1),
std::bind(&ProgressDialog::stepComplete, progressDialog),
&g_options.moduleInfo,
_variableHandler,
cancelToken);
switch(status)
{
case INSTALL_SUCCESS:
if (g_options.installLocation != INSTALLLOC_APPDATA)
{
needAdmin =true;
}
Utility::removeDirectory(pluginTemp.c_str());
somethingInstalled = TRUE;
break;
case INSTALL_NEEDRESTART:
if (g_options.installLocation != INSTALLLOC_APPDATA)
{
needAdmin =true;
}
needRestart = TRUE;
somethingInstalled = TRUE;
break;
case INSTALL_FAIL:
{
tstring message (_T("Installation of "));
message.append((*pluginIter)->getName());
message.append(_T(" failed."));
::MessageBox(hMessageBoxParent, message.c_str(), _T("Installation Error"), MB_OK | MB_ICONERROR);
Utility::removeDirectory(pluginTemp.c_str());
break;
}
}
++pluginIter;
}
progressDialog->close();
if (needRestart)
{
for(VariableHandler::iterator it = _variableHandler->begin(); it != _variableHandler->end(); ++it) {
TiXmlElement setVariable = TiXmlElement(_T("setVariable"));
setVariable.SetAttribute(_T("name"), it->first);
setVariable.SetAttribute(_T("value"), it->second);
installElement->InsertBeforeChild(installElement->FirstChild(), setVariable);
}
forGpupDoc->SaveFile(gpupFile.c_str());
delete forGpupDoc;
int restartNow = ::MessageBox(hMessageBoxParent, _T("Some installation steps still need to be completed. Notepad++ needs to be restarted in order to complete these steps. If you restart later, you will be prompted again. Would you like to restart now?"), _T("Plugin Manager"), MB_YESNO | MB_ICONINFORMATION);
if (restartNow == IDYES)
{
tstring gpupArguments(_T("-a \""));
gpupArguments.append(gpupFile);
gpupArguments.append(_T("\""));
Utility::startGpup(hMessageBoxParent, _variableHandler->getVariable(_T("NPPDIR")).c_str(), gpupArguments.c_str(), needAdmin);
}
}
else if (somethingInstalled)
{
delete forGpupDoc;
int restartNow = ::MessageBox(hMessageBoxParent, _T("Notepad++ needs to be restarted for changes to take effect. Would you like to do this now?"), _T("Plugin Manager"), MB_YESNO | MB_ICONINFORMATION);
if (restartNow == IDYES)
{
Utility::startGpup(hMessageBoxParent, _variableHandler->getVariable(_T("NPPDIR")).c_str(), _T(""), needAdmin);
}
}
else
{
delete forGpupDoc;
}
}
void PluginList::removePlugins(HWND hMessageBoxParent, ProgressDialog* progressDialog, PluginListView* pluginListView, CancelToken& cancelToken)
{
g_options.moduleInfo.setHParent(hMessageBoxParent);
tstring configDir = _variableHandler->getVariable(_T("CONFIGDIR"));
tstring gpupFile(configDir);
gpupFile.append(_T("\\PluginManagerGpup.xml"));
TiXmlDocument* forGpupDoc = getGpupDocument(gpupFile.c_str());
TiXmlElement* installElement = forGpupDoc->FirstChildElement(_T("install"));
std::shared_ptr< list<Plugin*> > selectedPlugins = pluginListView->getSelectedPlugins();
if (selectedPlugins.get() == NULL)
{
delete forGpupDoc;
progressDialog->close();
return;
}
size_t removeSteps = 0;
list<Plugin*>::iterator pluginIter = selectedPlugins->begin();
while(pluginIter != selectedPlugins->end())
{
removeSteps += (*pluginIter)->getRemoveStepCount();
++pluginIter;
}
progressDialog->setStepCount(removeSteps);
tstring pluginDir = _variableHandler->getVariable(_T("PLUGINDIR"));
tstring removeBasePath;
pluginIter = selectedPlugins->begin();
bool needAdmin = false;
while(pluginIter != selectedPlugins->end())
{
if ((*pluginIter)->getInstalledForAllUsers())
{
needAdmin = true;
}
(*pluginIter)->remove(removeBasePath, installElement,
std::bind(&ProgressDialog::setCurrentStatus, progressDialog, _1),
std::bind(&ProgressDialog::setStepProgress, progressDialog, _1),
std::bind(&ProgressDialog::stepComplete, progressDialog),
&g_options.moduleInfo,
_variableHandler,
cancelToken);
++pluginIter;
}
forGpupDoc->SaveFile(gpupFile.c_str());
delete forGpupDoc;
progressDialog->close();
int restartNow = ::MessageBox(hMessageBoxParent, _T("Notepad++ needs to be restarted in order to complete the removal. If you restart later, you will be prompted again. Would you like to restart now?"), _T("Plugin Manager"), MB_YESNO | MB_ICONINFORMATION);
if (restartNow == IDYES)
{
tstring gpupArguments(_T("-a \""));
gpupArguments.append(gpupFile);
gpupArguments.append(_T("\""));
Utility::startGpup(hMessageBoxParent, _variableHandler->getVariable(_T("NPPDIR")).c_str(), gpupArguments.c_str(), needAdmin);
}
else
{
pluginListView->removeSelected();
}
}
struct InstallParam
{
PluginList* pluginList;
PluginListView* pluginListView;
ProgressDialog* progressDialog;
HWND hMessageBoxParent;
BOOL isUpdate;
CancelToken cancelToken;
};
void PluginList::startInstall(HWND hMessageBoxParent,
ProgressDialog* progressDialog,
PluginListView *pluginListView,
BOOL isUpdate,
CancelToken& cancelToken)
{
InstallParam *ip = new InstallParam;
ip->pluginListView = pluginListView;
ip->progressDialog = progressDialog;
ip->pluginList = this;
ip->isUpdate = isUpdate;
ip->hMessageBoxParent = hMessageBoxParent;
ip->cancelToken = cancelToken;
(void)::CreateThread(0, 0, (LPTHREAD_START_ROUTINE)PluginList::installThreadProc,
(LPVOID)ip, 0, 0);
}
UINT PluginList::installThreadProc(LPVOID param)
{
InstallParam *ip = reinterpret_cast<InstallParam*>(param);
ip->pluginList->installPlugins(ip->hMessageBoxParent,
ip->progressDialog,
ip->pluginListView,
ip->isUpdate,
ip->cancelToken);
// clean up the parameter
delete ip;
return 0;
}
void PluginList::startRemove(HWND hMessageBoxParent,
ProgressDialog* progressDialog,
PluginListView *pluginListView,
CancelToken& cancelToken)
{
InstallParam *ip = new InstallParam;
ip->pluginListView = pluginListView;
ip->progressDialog = progressDialog;
ip->pluginList = this;
ip->hMessageBoxParent = hMessageBoxParent;
ip->cancelToken = cancelToken;
(void)::CreateThread(0, 0, (LPTHREAD_START_ROUTINE)PluginList::removeThreadProc,
(LPVOID)ip, 0, 0);
}
UINT PluginList::removeThreadProc(LPVOID param)
{
InstallParam *ip = reinterpret_cast<InstallParam*>(param);
ip->pluginList->removePlugins(ip->hMessageBoxParent,
ip->progressDialog,
ip->pluginListView,
ip->cancelToken);
// clean up the parameter
delete ip;
return 0;
}
void PluginList::clearPluginList()
{
PluginContainer::iterator iter = _plugins.begin();
while (iter != _plugins.end())
{
delete iter->second;
++iter;
}
_plugins.clear();
_installedPlugins.clear();
_updateablePlugins.clear();
_availablePlugins.clear();
_pluginRealNames.clear();
}
| [
"noreply@github.com"
] | noreply@github.com |
a8d12615c943abdb1714c14fc1f237aa1b080f7b | 3c8382b7db7c98cf61b2712ab3bfd6415987a37a | /R3D/src/R3D/Events/Event.h | 50c98071d592ceed81e84bf234ab291ca425123e | [
"MIT"
] | permissive | physteo/R3D | 26c537c62427279f510f086101c19afdf92853b6 | 4680537c95284538c454f830a70c9d9ab64e6f61 | refs/heads/master | 2021-07-01T10:27:15.616312 | 2021-05-16T10:02:10 | 2021-05-16T10:02:10 | 234,500,888 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,014 | h | #pragma once
#include <R3D/Core/Core.h>
#include "EventTypesAndCategories.h"
namespace r3d
{
#define EVENT_CLASS_TYPE(type) static EventType getStaticType() {return type;}\
virtual EventType getEventType() const override { return getStaticType(); }\
virtual const char* getName() const override { return #type; }
#define EVENT_CLASS_CATEGORY(category) virtual EventCategory getCategoryFlags() const override {return category;}
class Event
{
public:
virtual EventType getEventType() const = 0;
virtual const char* getName() const = 0;
virtual EventCategory getCategoryFlags() const = 0;
virtual std::string toString() const { return getName(); }
inline bool isInCategory(enum class EventCategory category) const
{
return static_cast<int>(getCategoryFlags()) & static_cast<int>(category);
}
bool handled = false;
};
/*
In the Listener class that receives an event, we create an EventDispatcher class that wraps that event's reference.
We use the dispatch method of this class with a function (usually defined in the listener). The dispatcher will try
to apply this function on the event, by checking if their type match.
This is useful because in our onEvent function in the listener, we dont have to do "if event matches, do this ..."
for all kinds of events.
*/
class EventDispatcher
{
template<typename T>
using EventFn = std::function<bool(T&)>;
public:
EventDispatcher(Event& event) : m_event(event)
{
}
template<typename T>
bool dispatch(EventFn<T> func)
{
if (m_event.getEventType() == T::getStaticType())
{
m_event.handled = func(*(T*)&m_event);
return m_event.handled;
}
return false;
}
private:
Event& m_event;
};
#define HANDLE_DISPATCH(dispatcher, eventClass, function) if( dispatcher.dispatch<eventClass>(std::bind(&function, this, std::placeholders::_1)) == true ) { return true; }
inline std::ostream& operator<<(std::ostream& os, const Event& e)
{
return os << e.toString();
}
}
| [
"matteo_campo91@live.it"
] | matteo_campo91@live.it |
81b09ddd02068e576c931e6aaf3f5c9267b6d9b8 | f6eaa40b6ece6c033eca8197c744b5b39e2b06b8 | /DC_Waveform.ino | 0e9bb1b9b35af65e5f0dbf924ab90e1b28340ff1 | [] | no_license | Tinker-Twins/Arduino_Function_Generator | 2b0c15f46615570352af9799af40d3ddcc3435e5 | 34f99b522025954b57072f175643c5f53a08fbcb | refs/heads/master | 2022-01-28T18:35:12.020086 | 2019-07-20T20:40:18 | 2019-07-20T20:40:18 | 197,955,487 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 285 | ino | #include <Wire.h>
#include <Adafruit_MCP4725.h>
Adafruit_MCP4725 dac;
uint32_t DAC_Output;
void setup(void) {
Serial.begin(9600);
dac.begin(0x60);
Serial.println("Generating a DC Waveform");
}
void loop(void) {
DAC_Output = 4095;
dac.setVoltage(DAC_Output, false);
}
| [
"noreply@github.com"
] | noreply@github.com |
a9d4ce2a21ff86231afed8d7865db33d0e5d8f54 | 696bc51f1a05101252b0a25782f915ea28ad548d | /DreamAuth2/LanguageSelect.cpp | 2079308b32001d59afacac6b58565dded4b19444 | [
"MIT"
] | permissive | ruijiexie/dreamdota | 4ae9a685960bb67c2511699868f7ca42a16803dd | 2d71c5ebe1b3fb2726bf20e514025dbe28152a35 | refs/heads/master | 2021-06-09T05:25:35.045791 | 2016-12-12T16:40:51 | 2016-12-12T16:40:51 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 856 | cpp | #include "stdafx.h"
#include "LanguageSelect.h"
#include "DialogLanguageSelect.h"
#include "Locale.h"
#include "LocaleString.h"
static void OnLanguageSelectHandler(LCID selected) {
Locale::SaveLCID(selected);
LocaleString::SetLocale(selected);
}
void LanguageSelect(bool force_reselect) {
if (Locale::IsLocaleSelected() && !force_reselect)
return;
const Locale::LocaleMapType& map = Locale::Map();
LCID select = Locale::GetPreferedLCID();
DialogLanguageSelect dlg;
const wchar_t* select_name = NULL;
for (Locale::LocaleMapType::const_iterator iter = map.begin(); iter != map.end(); ++iter) {
dlg.AddLocale(iter->second.name, iter->second.lcid);
if (iter->second.lcid == select)
select_name = iter->second.name;
}
dlg.SelectString(select_name);
dlg.onLanguageSelect += OnLanguageSelectHandler;
dlg.Show(true);
dlg.WaitClose();
} | [
"fluxxu@gmail.com"
] | fluxxu@gmail.com |
cb1dc471c1c6b9ba167c2f82ac82693d9a252717 | b85502a781bed6e2f746c0794bdcf48285ac906c | /trunk/tasks/TagGroupTH.h | d2aab0078ff0fae459fceaeb96d505eb51927a47 | [] | no_license | JazSingh/KrimpAll | 83329776a2fc575efea88ddb450d1e078630a09e | e66918430c9efd84f7b026e326d11db02d834410 | refs/heads/master | 2020-03-11T19:16:12.418395 | 2018-04-19T10:58:55 | 2018-04-19T10:58:55 | 130,202,166 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,694 | h | #ifndef __TAGGROUPTASKHANDLER_H
#define __TAGGROUPTASKHANDLER_H
#include "TaskHandler.h"
enum TGorder {
RandomTGorder,
AscLenTGorder,
DescLenTGorder,
CTTGorder,
};
class TagGroupTH : public TaskHandler {
public:
TagGroupTH (Config *conf);
virtual ~TagGroupTH ();
virtual void HandleTask();
virtual string BuildWorkingDir();
protected:
void FindTagGroups();
void EmulateFlickrClusters();
void ComputeGainForGivenFullCTandGroupDB(); // and write to gain.txt -- for use within another app
// --- Helpers for FindTagGroups() --
void SaveGroup(uint32 groupNum, double restCompressibility, double compressionGain);
uint32 FindBestCtElem(float &score);
uint32 *GetCandidates(uint32 &numCandidates);
void RejectCtElem(uint32 elemIdx);
Database *GetRestDB();
Database *GetDeltaDB(uint32 elemIdx);
void AddToGroup(const uint32 ctElemIdx);
void EmptyGroup();
// -- Member variables --
string mTGPath;
FILE *mFpCsv;
FILE *mFpGroups;
FILE *mFpItemSets;
Database *mGroupDB;
CodeTable *mGroupCT;
Config *mGroupConfig;
uint32 mGroupNumElems, mGroupNumRows, mGroupNumTrans, mSkipNumElems;
uint32 *mGroupElems, *mGroupRows, *mSkipElems;
ItemSet *mGroupElemsUnion;
bool *mElemInCandGroup;
bool mExclusiveGrowing;
uint32 mGroupNumValues;
uint16 *mGroupValues;
uint32 *mGroupValCounts;
uint16 *mNumOverlaps;
uint16 **mOverlaps;
uint32 mNumElems;
ItemSet **mCtElems;
uint32 **mCover;
uint32 *mCoverCounts;
uint32 *mRowCounts;
double mGain, mCompressibility;
Database *mDB;
Database *mFullDB;
CodeTable *mCT;
CodeTable *mFullCT;
};
#endif // __TAGGROUPTASKHANDLER_H
| [
"JazSingh@users.noreply.github.com"
] | JazSingh@users.noreply.github.com |
b38f38670a16f6dd27b4edacd290caca815393ee | 4f2dd8732d674a80208b37b04730785a3dd093a5 | /lbm/lid.cpp | 9987105e2b44ce73d6a22c58975dca84df14fdfb | [] | no_license | grasingerm/PL | 5fa05b1147e8a51cc1144ec392adf3b260fbb9fd | c271d3d4135f3b1dec28cdabbb4298c77a981c5f | refs/heads/master | 2022-11-10T23:05:48.931924 | 2022-09-26T03:58:43 | 2022-09-26T03:58:43 | 21,368,370 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,986 | cpp | #include <armadillo>
#include <iomanip>
#include <iostream>
#include <array>
using namespace arma;
using namespace std;
int main()
{
/* domain */
const double width = 100.;
const double height = 100.;
const int n_x = 100;
const int n_y = 100;
const double dx = width/n_x;
const double dy = height/n_y;
const double dt = 1.;
const int n_dir = 9;
/* init data */
mat rho(n_x+1,n_y+1);
mat u(n_x+1,n_y+1);
mat v(n_x+1,n_y+1);
array<mat,n_dir> f;
const double alpha = 0.01;
const double c_k = dx/dt;
const double c_sq = c_k*c_k;
const double omega = 1./(3.*alpha/(c_sq*dt)+0.5); /*!< collision freq */
const int num_tsteps = 40000;
const array<double,n_dir> w {{ 4./9., 1./9., 1./9., 1./9., 1./9., 1./36., 1./36.,
1./36., 1./36. }};
const array<int,n_dir> c_x {{ 0, 1, 0, -1, 0, 1, -1, -1, 1 }};
const array<int,n_dir> c_y {{ 0, 0, 1, 0, -1, 1, 1, -1, -1 }};
/* initial conditions */
const double u_o = 0.1;
const double rho_o = 5.;
const double Re = u_o*n_y / alpha;
/* lattice Reynold's number must match physical Reynold's number. For
* the physical problem the Re = U_lid * H/v = 6 m/s * 0.2 m / 0.00012 m^2/s
* = 1,000. NOTE: we are free to use any values for U_lid and viscosity
* provided that Re = 1000. Therefor flow velocity and alpha depend on
* number of lattice nodes and vice versa
*/
u.zeros();
v.zeros();
for (auto i = 1; i < n_x; i++) u(i,n_y) = u_o; /*!< lid driven cavity */
rho.fill(rho_o);
for (auto k = 0; k < n_dir; k++)
{
f[k] = mat(n_x+1,n_y+1);
for (auto i = 0; i <= n_x; i++)
for (auto j = 0; j <= n_y; j++)
f[k](i,j) = w[k]*rho(i,j);
}
cout << setw(20) << "lattices in x-dir = " << n_x << endl
<< setw(20) << "lattices in y-dir = " << n_y << endl
<< setw(20) << "alpha = " << alpha << endl
<< setw(20) << "u at lid = " << u_o << endl
<< setw(20) << "Re = " << Re << endl;
const auto report = 25;
/* main loop */
for (auto tstep = 1; tstep <= num_tsteps; ++tstep)
{
if (tstep % report == 0) cout << tstep << endl;
/* collision */
for (auto i = 0; i <= n_x; i++)
for (auto j = 0; j <= n_y; j++)
{
double u_sq = u(i,j)*u(i,j) + v(i,j)*v(i,j); /*!< u dot u */
for (auto k = 0; k < n_dir; k++)
{
double u_dot_c = u(i,j)*c_x[k] + v(i,j)*c_y[k]; /*!< u dot c */
double f_eq = w[k]*rho(i,j)* (1.0 + 3.0*u_dot_c +
4.5*u_dot_c*u_dot_c - 1.5*u_sq);
f[k](i,j) = omega*f_eq + (1.-omega)*f[k](i,j);
}
}
/* streaming */
for (auto j = 0; j <= n_y; ++j) /* horizontals */
{
for (auto i = n_x; i > 0; --i) f[1](i,j) = f[1](i-1,j);
for (auto i = 0; i < n_x; ++i) f[3](i,j) = f[3](i+1,j);
}
for (auto j = n_y; j > 0; j--) /* top to bottom */
{
for (auto i = 0; i <= n_x; ++i) f[2](i,j) = f[2](i,j-1);
for (auto i = n_x; i > 0; --i) f[5](i,j) = f[5](i-1,j-1);
for (auto i = 0; i < n_x; ++i) f[6](i,j) = f[6](i+1,j-1);
}
for (auto j = 0; j < n_y; j++) /* bottom to top */
{
for (auto i = 0; i <= n_x; ++i) f[4](i,j) = f[4](i,j+1);
for (auto i = 0; i < n_x; ++i) f[7](i,j) = f[7](i+1,j+1);
for (auto i = n_x; i > 0; --i) f[8](i,j) = f[8](i-1,j+1);
}
/* boundary conditions */
for (auto j = 0; j <= n_y; ++j) /* west bc bounce back */
{
f[1](0,j) = f[3](0,j);
f[5](0,j) = f[6](0,j);
f[8](0,j) = f[7](0,j);
}
for (auto j = 0; j <= n_y; ++j) /* east bc bounce back */
{
f[6](n_x,j) = f[8](n_x,j);
f[3](n_x,j) = f[1](n_x,j);
f[7](n_x,j) = f[5](n_x,j);
}
for (auto i = 0; i <= n_x; ++i) /* south bc bounce back */
{
f[2](i,0) = f[4](i,0);
f[5](i,0) = f[7](i,0);
f[6](i,0) = f[8](i,0);
}
for (auto i = 1; i < n_x; ++i) /* north bc, moving lid */
{
rho(i,n_y) = f[0](i,n_y) + f[1](i,n_y) + f[3](i,n_y) +
2. * (f[2](i,n_y) + f[6](i,n_y) + f[5](i,n_y));
f[4](i,n_y) = f[2](i,n_y);
f[8](i,n_y) = f[6](i,n_y) + rho(i,n_y)*u_o/6.0;
f[7](i,n_y) = f[5](i,n_y) - rho(i,n_y)*u_o/6.0;
}
/* calculate macroscopic density */
for (auto j = 0; j < n_y; ++j)
for (auto i = 0; i <= n_x; ++i)
{
double sum = 0.;
for (auto k = 0; k < n_dir; ++k) sum += f[k](i,j);
rho(i,j) = sum;
}
/* calculate macroscopic flow velocity */
for (auto i = 1; i <= n_x; ++i)
for (auto j = 1; j < n_y; ++j)
{
double usum = 0., vsum = 0.;
for (auto k = 0; k < n_dir; ++k)
{
usum += f[k](i,j)*c_x[k];
vsum += f[k](i,j)*c_y[k];
}
u(i,j) = usum/rho(i,j); /*!< momentum is sum f dot c */
v(i,j) = vsum/rho(i,j);
}
}
ofstream outfile;
outfile.open("lid.csv", ofstream::out);
cout << "Writing to lid.csv ... " << endl;
/* output data */
outfile << "x,y,rho,u,v" << endl;
for (auto i = 0; i <= n_x; ++i)
for (auto j = 0; j <= n_y; ++j)
outfile << dx*i << "," << dy*j << "," << rho(i,j) << "," << u(i,j)
<< "," << v(i,j) << endl;
cout << "... finished." << endl;
outfile.close();
return 0;
}
| [
"grasingerm@gmail.com"
] | grasingerm@gmail.com |
160d5a84bab3fb30977ca14518d18ea54333f9d2 | 444a6f3fb2c9d9dc042ffd54838bc3dc172ec531 | /example/alternative_namespaces/box_example.cpp | d22c9bc6c253a11457a54bf5baac2bc06a5928b6 | [
"MIT"
] | permissive | rtobar/units | ef5a86bdb73c896eac92698d9a8386e11c6dfe48 | 5dd9eaac87a50adc62b170987ebac2d1344d63c5 | refs/heads/master | 2022-09-11T17:37:57.868428 | 2020-05-24T20:49:53 | 2020-05-24T20:49:53 | 266,679,421 | 1 | 0 | MIT | 2020-05-25T04:03:18 | 2020-05-25T04:03:18 | null | UTF-8 | C++ | false | false | 2,311 | cpp |
#include "./length.h"
#include "./acceleration.h"
#include "./density.h"
#include "./force.h"
#include "./mass.h"
#include "./time.h"
#include "./volume.h"
#include <cassert>
using namespace units::experimental;
struct Box {
static constexpr auto air_density = density::kg_per_m3<>{1.225};
length::m<> length;
length::m<> width;
length::m<> height;
constexpr Box(const length::m<>& l, const length::m<>& w, const length::m<>& h) : length{l}, width{w}, height{h} {}
struct contents {
density::kg_per_m3<> density = air_density;
} contents;
constexpr force::N<> filled_weight() const
{
const volume::m3<> volume = length * width * height;
const mass::kg<> mass = contents.density * volume;
return mass * acceleration::g<>;
}
constexpr length::m<> fill_level(const mass::kg<>& measured_mass) const
{
return height * (measured_mass * acceleration::g<>) / filled_weight();
}
constexpr volume::m3<> spare_capacity(const mass::kg<>& measured_mass) const
{
return (height - fill_level(measured_mass)) * width * length;
}
constexpr void set_contents_density(const density::kg_per_m3<>& density_in)
{
assert(density_in > air_density);
contents.density = density_in;
}
};
#include <iostream>
using namespace units::physical::si::literals;
int main()
{
auto box = Box{1000.0q_mm, 500.0q_mm, 200.0q_mm};
box.set_contents_density(1000.0q_kg_per_m3);
auto fill_time = 200.0q_s; // time since starting fill
auto measured_mass = 20.0q_kg; // measured mass at fill_time
std::cout << "mpusz/units box example ( using experimental alternative syntax for defining quantities) ...\n";
std::cout << "fill height at " << fill_time << " = " << box.fill_level(measured_mass) << " ("
<< (box.fill_level(measured_mass) / box.height) * 100 << "% full)\n";
std::cout << "spare_capacity at " << fill_time << " = " << box.spare_capacity(measured_mass) << '\n';
std::cout << "input flow rate after " << fill_time << " = " << measured_mass / fill_time << '\n';
std::cout << "float rise rate = " << box.fill_level(measured_mass) / fill_time << '\n';
auto fill_time_left = (box.height / box.fill_level(measured_mass) - 1) * fill_time;
std::cout << "box full E.T.A. at current flow rate = " << fill_time_left << '\n';
}
| [
"mateusz.pusz@gmail.com"
] | mateusz.pusz@gmail.com |
9ddfca9806006a1187011bd2e3b4d8cf9844c89d | 79740791a3a0f5a7b1ffb4ad875ad615bf8bb552 | /763_Partition Labels.cpp | f82c8f65b0c52ec04c56317153a8e19e53661ff4 | [] | no_license | AlienYou/LeetCode | 61a187b7ce3c68f64f58450a4df1e934ef667d0c | cb09270cdaeda1c71ba26ed0d5e38f4b57d9a708 | refs/heads/master | 2021-07-02T12:29:49.420058 | 2021-06-08T17:10:33 | 2021-06-08T17:10:33 | 241,774,412 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 361 | cpp | vector<int> partitionLabels(string S) {
vector<int> charMap(26);
int length = S.length();
for (int i = 0; i < length; ++i){
charMap[S[i] - 'a'] = i;
}
vector<int> ans;
int anchor = 0, j = 0;
for (int i = 0; i < length; ++i){
j = max(charMap[S[i] - 'a'], j);
if (j == i)
{
ans.push_back(j - anchor + 1);
anchor = j + 1;
}
}
return ans;
} | [
"wx_239ea53202d441dc95714fabc8631353@git.code.tencent.com"
] | wx_239ea53202d441dc95714fabc8631353@git.code.tencent.com |
e661daace19a80ff08be7c70b0a73a4d60e7f994 | 0bd7870dd8f5ce6fe425a2cfdbb286c5f9feb883 | /Source/cmCurl.h | 26bf94e0904714bb12a1f8f579599d9d50eaaf51 | [
"BSD-3-Clause"
] | permissive | highattack30/CMake | d24ffffc85d3476391335df3b4ba0c15a38bcc85 | b9b3ec4d98b03c180b2e6b9ad8edba7f75576353 | refs/heads/master | 2020-12-25T03:40:14.429340 | 2016-06-29T04:01:05 | 2016-06-29T04:01:05 | 62,201,305 | 1 | 0 | null | 2016-06-29T06:26:33 | 2016-06-29T06:26:32 | null | UTF-8 | C++ | false | false | 745 | h | /*============================================================================
CMake - Cross Platform Makefile Generator
Copyright 2000-2015 Kitware, Inc., Insight Software Consortium
Distributed under the OSI-approved BSD License (the "License");
see accompanying file Copyright.txt for details.
This software is distributed WITHOUT ANY WARRANTY; without even the
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the License for more information.
============================================================================*/
#ifndef cmCurl_h
#define cmCurl_h
#include "cmStandardIncludes.h"
#include "cm_curl.h"
std::string cmCurlSetCAInfo(::CURL* curl, const char* cafile = CM_NULLPTR);
#endif
| [
"brad.king@kitware.com"
] | brad.king@kitware.com |
f483dfc9557aceb1aa464deb631f6b912c286183 | 35d27f8663fcdebccb13fabab06812af96acdc4b | /codeforces/101972/g/g.cpp | 8f0f26620890f8cf5066e39f94330388edbb4dca | [] | no_license | noooaah/solved_problem | 666490ca49e0001e3919ad7f29180d59caa0a16b | fbcebe223f063623f45415548f9f265e385ddac0 | refs/heads/master | 2023-03-17T18:27:05.712309 | 2019-09-05T13:10:01 | 2019-09-05T13:10:01 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,171 | cpp | #include <bits/stdc++.h>
#define F first
#define S second
#define ld long douroote
#define pb push_back
#define sz size
#define ll long long
#define ull unsigned long long
#define INF 0x7f7f7f7f
#define sc(a) scanf("%d",&a)
#define scll(a) scanf("%lld",&a)
#define scc(a) scanf(" %c",&a)
#define scs(a) scanf(" %s",a)
#define me(a,b) memset(a,b,sizeof a)
#define all(a) a.begin(),a.end()
#define allr(a,n) a,a+n
#define loop(a,s,e) for(ll a=s;a<=e;a++)
#define read_arr(a,s,n) for(int i=s;i<n+s;i++){sc(a[i]);}
#define read_arr_ll(a,s,n) for(int i=s;i<n+s;i++){scll(a[i]);}
#define err(a,s) cerr<<a<<s;
#define err_arr(a,s,n) for(int i=s;i<n+s;i++){cerr<<a[i]<<" ";}cerr<<endl;
#define prtll(x) printf("%lld",x);
#define prt(x) printf("%d",x);
using namespace std;
const int N=1e5+10,M=1e4+10;
int mx[512][512][4],a[512][512],u_l=0,u_r=1,d_l=2,d_r=3,n,m,t;
vector<int> tmp;
void build(){
me(mx,0);
for(int i=1;i<=n;i++){
for(int j=1;j<=m;j++){
mx[i][j][u_l]=max(mx[i-1][j][u_l],mx[i][j-1][u_l]);
mx[i][j][u_l]=max(mx[i][j][u_l],a[i][j]);
}
}
for(int i=n;i>=1;i--){
for(int j=1;j<=m;j++){
mx[i][j][d_l]=max(mx[i+1][j][d_l],mx[i][j-1][d_l]);
mx[i][j][d_l]=max(mx[i][j][d_l],a[i][j]);
}
}
for(int i=1;i<=n;i++){
for(int j=m;j>=1;j--){
mx[i][j][u_r]=max(mx[i-1][j][u_r],mx[i][j+1][u_r]);
mx[i][j][u_r]=max(mx[i][j][u_r],a[i][j]);
}
}
for(int i=n;i>=1;i--){
for(int j=m;j>=1;j--){
mx[i][j][d_r]=max(mx[i+1][j][d_r],mx[i][j+1][d_r]);
mx[i][j][d_r]=max(mx[i][j][d_r],a[i][j]);
}
}
}
int quere(int x,int y){
tmp.clear();
tmp.pb(mx[x-1][y-1][u_l]);
tmp.pb(mx[x+1][y-1][d_l]);
tmp.pb(mx[x-1][y+1][u_r]);
tmp.pb(mx[x+1][y+1][d_r]);
sort(all(tmp));
///for(auto x:tmp){cerr<<x<<" ";}cerr<<endl;
return (tmp[3]-tmp[0]);
}
int main(){
sc(t);
while(t--){
sc(n);sc(m);
loop(i,1,n){
loop(j,1,m){sc(a[i][j]);}
}
build();
int ans=1e9+10;
for(int i=2;i<n;i++){
for(int j=2;j<m;j++){
ans=min(ans,quere(i,j));
}
}
printf("%d\n",ans);
}
}
/**
2
4 4
22 7 3 11
3 1 8 9
5 2 4 3
13 5 6 9
3 4
1 2 3 4
5 6 7 8
9 10 11 12
**/
| [
"evoiz963@gmail.com"
] | evoiz963@gmail.com |
a46a1d6e9fcbfb90adae607f6d7e6c0dcd64738b | d0c44dd3da2ef8c0ff835982a437946cbf4d2940 | /cmake-build-debug/programs_tiling/function13760/function13760_schedule_7/function13760_schedule_7.cpp | 1cc8afeff68970f7201c9b18d603376dbd317af6 | [] | no_license | IsraMekki/tiramisu_code_generator | 8b3f1d63cff62ba9f5242c019058d5a3119184a3 | 5a259d8e244af452e5301126683fa4320c2047a3 | refs/heads/master | 2020-04-29T17:27:57.987172 | 2019-04-23T16:50:32 | 2019-04-23T16:50:32 | 176,297,755 | 1 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 1,544 | cpp | #include <tiramisu/tiramisu.h>
using namespace tiramisu;
int main(int argc, char **argv){
tiramisu::init("function13760_schedule_7");
constant c0("c0", 32768), c1("c1", 2048);
var i0("i0", 0, c0), i1("i1", 0, c1), i01("i01"), i02("i02"), i03("i03"), i04("i04");
input input00("input00", {i1}, p_int32);
input input01("input01", {i0}, p_int32);
input input02("input02", {i1}, p_int32);
input input03("input03", {i1}, p_int32);
input input04("input04", {i1}, p_int32);
input input05("input05", {i1}, p_int32);
computation comp0("comp0", {i0, i1}, input00(i1) - input01(i0) * input02(i1) - input03(i1) * input04(i1) + input05(i1));
comp0.tile(i0, i1, 128, 64, i01, i02, i03, i04);
comp0.parallelize(i01);
buffer buf00("buf00", {2048}, p_int32, a_input);
buffer buf01("buf01", {32768}, p_int32, a_input);
buffer buf02("buf02", {2048}, p_int32, a_input);
buffer buf03("buf03", {2048}, p_int32, a_input);
buffer buf04("buf04", {2048}, p_int32, a_input);
buffer buf05("buf05", {2048}, p_int32, a_input);
buffer buf0("buf0", {32768, 2048}, p_int32, a_output);
input00.store_in(&buf00);
input01.store_in(&buf01);
input02.store_in(&buf02);
input03.store_in(&buf03);
input04.store_in(&buf04);
input05.store_in(&buf05);
comp0.store_in(&buf0);
tiramisu::codegen({&buf00, &buf01, &buf02, &buf03, &buf04, &buf05, &buf0}, "../data/programs/function13760/function13760_schedule_7/function13760_schedule_7.o");
return 0;
} | [
"ei_mekki@esi.dz"
] | ei_mekki@esi.dz |
7151a5e9e2ebdc253c53fd7ab1a5ebd92c3b9f59 | e68c1f9134b44ddea144f7efa7523076f3f12d3a | /FinalCode/Tristram_Mystic_Idle.cpp | 7e3adbc157df4dab0ed8fcba37785a8b492e07d2 | [] | no_license | iso5930/Direct-3D-Team-Portfolio | 4ac710ede0c9176702595cba5579af42887611cf | 84e64eb4e91c7e5b4aed77212cd08cfee038fcd3 | refs/heads/master | 2021-08-23T08:15:00.128591 | 2017-12-04T06:14:39 | 2017-12-04T06:14:39 | 112,998,717 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 416 | cpp | #include "StdAfx.h"
#include "Tristram_Mystic_Idle.h"
CTristram_Mystic_Idle::CTristram_Mystic_Idle()
{
// StateType
m_eStateType = STATE_TYPE_TRISTRAM_MYSTIC_IDLE;
}
CTristram_Mystic_Idle::~CTristram_Mystic_Idle()
{
}
void CTristram_Mystic_Idle::Initialize()
{
// Initialize
CNPCState::Initialize();
// SetAnimation
m_pOwner->SetAnimation(0);
}
CNPCState* CTristram_Mystic_Idle::Action()
{
return NULL;
} | [
"iso5930@naver.com"
] | iso5930@naver.com |
a2c6c9d92fc285acc7d14ee18b1295c25da3e920 | 7b498b229e5a018a8169f17334f48fd048bf7977 | /FKChatClient/Source/XItemInfo.cpp | 1965d741a25ca905d9285f9c399bfb4a78510247 | [] | no_license | shuidong/FK2DGame | 582e3f07d24deb4d724462c9bcc3b941ada1701a | e392cf9b68a430fa17b368cffee538802e91ad31 | refs/heads/master | 2021-05-06T04:30:29.519504 | 2017-03-16T08:00:54 | 2017-03-16T08:00:54 | null | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 1,401 | cpp | /**
* created: 2012-6-28 2:24
* filename: XItemInfo
* author: FreeKnight
* Copyright (C):
* purpose:
*/
//------------------------------------------------------------------------
#include "../Include/XItemInfo.h"
//------------------------------------------------------------------------
XItemInfo::XItemInfo(void)
{
m_clrBack = WPixel(255, 0, 0);
}
//------------------------------------------------------------------------
XItemInfo::~XItemInfo(void)
{
}
//-------------------------------------------------------------------
// 描 述：设置文本的背景颜色
// 参 数：[输入] WPixel clrBack - 指定背景颜色
// 返回值：void
//-------------------------------------------------------------------
void XItemInfo::SetBackColor(WPixel clrBack)
{
m_clrBack = clrBack;
}
//------------------------------------------------------------------------
void XItemInfo::OnDraw(ICanvas *pCanvas, int x, int y, RECT &rcClip, int alpha)
{
RECT rcClient;
CopyRect(&rcClient, &rcClip);
if (rcClient.top < (rcClient.bottom - GetHeight()))
{
rcClient.top = rcClient.bottom - GetHeight();
}
rcClient.left = x;
rcClient.right = x + GetWidth() + 1;
pCanvas->DrawBox(rcClient, m_clrBack, BLIT_NORMAL, 255);
pCanvas->DrawClipText(m_pFont, x, y, m_strText.c_str(), m_clrText, rcClip, FONT_NOALPHA);
}
//------------------------------------------------------------------------ | [
"duzhi5368@163.com"
] | duzhi5368@163.com |
f0dd08d30e4a47579354be9f5d8606edcfeeeaa2 | 22a4bbacd6a80b3ce34d9f2f7796822be86219b3 | /Dialogs/SpectrometerCalibrationDlg.cpp | 5d2939dd9d49c8aaccc4357cbf7ad6995bcd00ca | [] | no_license | NOVACProject/NOVACProgram | a797d832d70cf6792fc79b52db5b28b2b11a69b7 | 4b600da4567b8150b6c72503812285efb52b7ad3 | refs/heads/master | 2022-12-22T05:54:53.240519 | 2022-12-18T17:19:39 | 2022-12-18T17:19:39 | 110,694,976 | 4 | 7 | null | 2022-12-18T17:19:40 | 2017-11-14T13:39:37 | C++ | UTF-8 | C++ | false | false | 1,651 | cpp | // CSpectrometerCalibrationDlg.cpp : implementation file
//
#include "StdAfx.h"
#include "SpectrometerCalibrationDlg.h"
#include "afxdialogex.h"
#include "../resource.h"
#include "CCalibratePixelToWavelengthDialog.h"
#include "CCalibrateReferencesDialog.h"
// CSpectrometerCalibrationDlg dialog
CSpectrometerCalibrationDlg::CSpectrometerCalibrationDlg()
: CPropertySheet()
{
m_calibratePixelToWavelength = new CCalibratePixelToWavelengthDialog();
m_calibratePixelToWavelength->Construct(IDD_CALIBRATE_WAVELENGTH_DIALOG);
m_calibrateReferences = new CCalibrateReferencesDialog();
m_calibrateReferences->Construct(IDD_CALIBRATE_REFERENCES);
AddPage(m_calibratePixelToWavelength);
AddPage(m_calibrateReferences);
}
CSpectrometerCalibrationDlg::~CSpectrometerCalibrationDlg()
{
delete m_calibratePixelToWavelength;
delete m_calibrateReferences;
}
void CSpectrometerCalibrationDlg::DoDataExchange(CDataExchange* pDX)
{
CPropertySheet::DoDataExchange(pDX);
}
BOOL CSpectrometerCalibrationDlg::OnInitDialog()
{
BOOL bResult = CPropertySheet::OnInitDialog();
// ------------ Get the buttons ---------------
CWnd* pApply = this->GetDlgItem(ID_APPLY_NOW);
CWnd* pCancel = this->GetDlgItem(IDCANCEL);
CWnd* pOk = this->GetDlgItem(IDOK);
// Remove each of the buttons
if (pApply) {
pApply->DestroyWindow();
}
if (pCancel) {
pCancel->DestroyWindow();
}
if (pOk) {
pOk->DestroyWindow();
}
return bResult;
}
BEGIN_MESSAGE_MAP(CSpectrometerCalibrationDlg, CPropertySheet)
END_MESSAGE_MAP()
// CSpectrometerCalibrationDlg message handlers
| [
"mattias42@gmail.com"
] | mattias42@gmail.com |
2b5c95ef8bd025d8eec1517558a6052d4b6df725 | 760b01315012811474e4dc296109bd2a7c6d798c | /snake/states/snake/player/player.hpp | 0ef64cafd3850028d1c72307d93ab04f1d8edcf4 | [] | no_license | HerbGlitch/SFML-Snake | 132aa64c67bc4c541b6af7de92fc6870adc6f611 | cd9a65eeb1903c428ba4d79859f9577c0db781da | refs/heads/master | 2023-01-03T20:24:45.275772 | 2020-10-27T08:07:48 | 2020-10-27T08:07:48 | 307,246,340 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 871 | hpp | #pragma once
#include <SFML/Graphics.hpp>
namespace herbglitch {
namespace game { struct Data; }
namespace snake {
enum class Rotation { UP, LEFT, RIGHT, DOWN };
class Player {
public:
Player(game::Data *data);
~Player();
void update();
void render();
private:
void GetKeyPress();
void Rotate();
bool AnimateRotation();
bool CanRotate();
void Move();
game::Data *data;
sf::Sprite head;
std::vector<sf::Sprite> body;
Rotation rotation = Rotation::UP;
Rotation previous = Rotation::UP;
float playerSpeed = 5.0f;
float currRotation = 0.0f;
float nextRotation = 0.0f;
bool rotating = false;
};
}
} | [
"heber.brau@gmail.com"
] | heber.brau@gmail.com |
083dfa6fe43e5cc5a295dcca3f6ef071c2df8dfd | 8860168786d04a3043ea3e06d06a27630b38f2b6 | /zebulon/projects/igvc/2011/ext/ransac/.svn/text-base/LineParamEstimator.cxx.svn-base | fe7cae55357d788e0af5149ff34866e44512e253 | [
"BSD-2-Clause",
"BSD-3-Clause",
"LicenseRef-scancode-unknown-license-reference"
] | permissive | ShowLove/Robotics_Club | 6785d8f5717f9f29ef7cb702f47f481767c8875b | 9c6b4b723a2732c1565913795c2a43b90902f011 | refs/heads/master | 2020-05-15T03:08:44.178211 | 2014-08-08T04:05:42 | 2014-08-08T04:05:42 | 14,319,218 | 4 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 4,826 | #include <math.h>
#include "LineParamEstimator.h"
#include <iostream> //cout used in the debugTest method
LineParamEstimator::LineParamEstimator(double delta) : ParameterEstimator<Point2D,double>(2), deltaSquared(delta*delta) {}
/*****************************************************************************/
/*
* Compute the line parameters [n_x,n_y,a_x,a_y]
*/
void LineParamEstimator::estimate(std::vector<Point2D *> &data,
std::vector<double> ¶meters)
{
parameters.clear();
if(data.size()<this->minForEstimate)
return;
double nx = data[1]->y - data[0]->y;
double ny = data[0]->x - data[1]->x;
double norm = sqrt(nx*nx + ny*ny);
parameters.push_back(nx/norm);
parameters.push_back(ny/norm);
parameters.push_back(data[0]->x);
parameters.push_back(data[0]->y);
}
/*****************************************************************************/
/*
* Compute the line parameters [n_x,n_y,a_x,a_y]
*/
void LineParamEstimator::leastSquaresEstimate(std::vector<Point2D *> &data,
std::vector<double> ¶meters)
{
double meanX, meanY, nx, ny, norm;
double covMat11, covMat12, covMat21, covMat22; // The entries of the symmetric covarinace matrix
int i, dataSize = data.size();
parameters.clear();
if(data.size()<this->minForEstimate)
return;
meanX = meanY = 0.0;
covMat11 = covMat12 = covMat21 = covMat22 = 0;
for(i=0; i<dataSize; i++) {
meanX +=data[i]->x;
meanY +=data[i]->y;
covMat11 +=data[i]->x * data[i]->x;
covMat12 +=data[i]->x * data[i]->y;
covMat22 +=data[i]->y * data[i]->y;
}
meanX/=dataSize;
meanY/=dataSize;
covMat11 -= dataSize*meanX*meanX;
covMat12 -= dataSize*meanX*meanY;
covMat22 -= dataSize*meanY*meanY;
covMat21 = covMat12;
if(covMat11<1e-12) {
nx = 1.0;
ny = 0.0;
}
else { //lamda1 is the largest eigen-value of the covariance matrix
//and is used to compute the eigne-vector corresponding to the smallest
//eigenvalue, which isn't computed explicitly.
double lamda1 = (covMat11 + covMat22 + sqrt((covMat11-covMat22)*(covMat11-covMat22) + 4*covMat12*covMat12)) / 2.0;
nx = -covMat12;
ny = lamda1 - covMat22;
norm = sqrt(nx*nx + ny*ny);
nx/=norm;
ny/=norm;
}
parameters.push_back(nx);
parameters.push_back(ny);
parameters.push_back(meanX);
parameters.push_back(meanY);
}
/*****************************************************************************/
/*
* Given the line parameters [n_x,n_y,a_x,a_y] check if
* [n_x, n_y] dot [data.x-a_x, data.y-a_y] < m_delta
*/
bool LineParamEstimator::agree(std::vector<double> ¶meters, Point2D &data)
{
double signedDistance = parameters[0]*(data.x-parameters[2]) + parameters[1]*(data.y-parameters[3]);
return ((signedDistance*signedDistance) < this->deltaSquared);
}
/*****************************************************************************/
void LineParamEstimator::debugTest(std::ostream &out)
{
std::vector<double> lineParameters;
LineParamEstimator lpEstimator(0.5);
std::vector<Point2D *> pointData;
pointData.push_back(new Point2D(7,7));
pointData.push_back(new Point2D(-1,-1));
lpEstimator.estimate(pointData,lineParameters);
out<<"[n_x,n_y,a_x,a_y] [ "<<lineParameters[0]<<", "<<lineParameters[1]<<", ";
out<<lineParameters[2]<<", "<<lineParameters[3]<<" ]"<<std::endl;
lpEstimator.leastSquaresEstimate(pointData,lineParameters);
out<<"[n_x,n_y,a_x,a_y] [ "<<lineParameters[0]<<", "<<lineParameters[1]<<", ";
out<<lineParameters[2]<<", "<<lineParameters[3]<<" ]"<<std::endl;
delete pointData[0];
delete pointData[1];
pointData.clear();
pointData.push_back(new Point2D(6,12));
pointData.push_back(new Point2D(6,6));
lpEstimator.estimate(pointData,lineParameters);
out<<"[n_x,n_y,a_x,a_y] [ "<<lineParameters[0]<<", "<<lineParameters[1]<<", ";
out<<lineParameters[2]<<", "<<lineParameters[3]<<" ]"<<std::endl;
lpEstimator.leastSquaresEstimate(pointData,lineParameters);
out<<"[n_x,n_y,a_x,a_y] [ "<<lineParameters[0]<<", "<<lineParameters[1]<<", ";
out<<lineParameters[2]<<", "<<lineParameters[3]<<" ]"<<std::endl;
delete pointData[0];
delete pointData[1];
pointData.clear();
pointData.push_back(new Point2D(7,9));
pointData.push_back(new Point2D(10,9));
lpEstimator.estimate(pointData,lineParameters);
out<<"[n_x,n_y,a_x,a_y] [ "<<lineParameters[0]<<", "<<lineParameters[1]<<", ";
out<<lineParameters[2]<<", "<<lineParameters[3]<<" ]"<<std::endl;
lpEstimator.leastSquaresEstimate(pointData,lineParameters);
out<<"[n_x,n_y,a_x,a_y] [ "<<lineParameters[0]<<", "<<lineParameters[1]<<", ";
out<<lineParameters[2]<<", "<<lineParameters[3]<<" ]"<<std::endl;
delete pointData[0];
delete pointData[1];
pointData.clear();
}
| [
"showlove@knights.ucf.edu"
] | showlove@knights.ucf.edu | |
4218ddac75eae25579d9eb398195a38c7c8676bd | a5d20c1d3d0f402b34f15081c8d41ec7291f292d | /src/chrono_vehicle/tracked_vehicle/track_wheel/DoubleTrackWheel.cpp | 5902fb97899af7149fd29b9e3f17873e864e2e5b | [
"BSD-3-Clause"
] | permissive | projectchrono/chrono | 3535b1a22b3f9ac55cd3bb6c3015f1ee7c78308e | 6a96ca61e232088d9eb5a286e5a12f5b7747ac16 | refs/heads/main | 2023-09-03T21:00:45.434375 | 2023-09-02T13:41:05 | 2023-09-02T13:41:05 | 12,567,717 | 1,874 | 460 | BSD-3-Clause | 2023-09-10T10:30:18 | 2013-09-03T15:34:23 | C++ | UTF-8 | C++ | false | false | 3,454 | cpp | // =============================================================================
// PROJECT CHRONO - http://projectchrono.org
//
// Copyright (c) 2014 projectchrono.org
// All rights reserved.
//
// Use of this source code is governed by a BSD-style license that can be found
// in the LICENSE file at the top level of the distribution and at
// http://projectchrono.org/license-chrono.txt.
//
// =============================================================================
// Authors: Radu Serban
// =============================================================================
//
// Double track-wheel model constructed with data from file (JSON format).
//
// =============================================================================
#include "chrono/assets/ChTriangleMeshShape.h"
#include "chrono_vehicle/ChVehicleModelData.h"
#include "chrono_vehicle/tracked_vehicle/track_wheel/DoubleTrackWheel.h"
#include "chrono_vehicle/utils/ChUtilsJSON.h"
#include "chrono_thirdparty/filesystem/path.h"
using namespace rapidjson;
namespace chrono {
namespace vehicle {
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
DoubleTrackWheel::DoubleTrackWheel(const std::string& filename) : ChDoubleTrackWheel(""), m_has_mesh(false) {
Document d; ReadFileJSON(filename, d);
if (d.IsNull())
return;
Create(d);
GetLog() << "Loaded JSON: " << filename.c_str() << "\n";
}
DoubleTrackWheel::DoubleTrackWheel(const rapidjson::Document& d) : ChDoubleTrackWheel(""), m_has_mesh(false) {
Create(d);
}
void DoubleTrackWheel::Create(const rapidjson::Document& d) {
// Invoke base class method.
ChPart::Create(d);
// Read wheel geometry and mass properties
assert(d.HasMember("Wheel"));
m_wheel_radius = d["Wheel"]["Radius"].GetDouble();
m_wheel_width = d["Wheel"]["Width"].GetDouble();
m_wheel_gap = d["Wheel"]["Gap"].GetDouble();
m_wheel_mass = d["Wheel"]["Mass"].GetDouble();
m_wheel_inertia = ReadVectorJSON(d["Wheel"]["Inertia"]);
// Read contact material data
assert(d.HasMember("Contact Material"));
m_mat_info = ReadMaterialInfoJSON(d["Contact Material"]);
// Read wheel visualization
if (d.HasMember("Visualization")) {
assert(d["Visualization"].HasMember("Mesh"));
m_meshFile = d["Visualization"]["Mesh"].GetString();
m_has_mesh = true;
}
}
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
void DoubleTrackWheel::CreateContactMaterial(ChContactMethod contact_method) {
m_material = m_mat_info.CreateMaterial(contact_method);
}
void DoubleTrackWheel::AddVisualizationAssets(VisualizationType vis) {
if (vis == VisualizationType::MESH && m_has_mesh) {
auto trimesh =
geometry::ChTriangleMeshConnected::CreateFromWavefrontFile(vehicle::GetDataFile(m_meshFile), true, true);
auto trimesh_shape = chrono_types::make_shared<ChTriangleMeshShape>();
trimesh_shape->SetMesh(trimesh);
trimesh_shape->SetName(filesystem::path(m_meshFile).stem());
trimesh_shape->SetMutable(false);
m_wheel->AddVisualShape(trimesh_shape);
} else {
ChDoubleTrackWheel::AddVisualizationAssets(vis);
}
}
} // end namespace vehicle
} // end namespace chrono
| [
"serban@wisc.edu"
] | serban@wisc.edu |
70f190879ea5c1eb598a2e1dbf34cf3c505c6510 | 6bd153870160c9ff989c3f3ebb35a92f10c62475 | /samples/detection-demo/postprocess/postprocess_classification.cpp | 87610797092ad3aff077454f600cefdce50faae9 | [
"LicenseRef-scancode-other-permissive",
"Apache-2.0"
] | permissive | CvRocker/CNStream | 21dbc282d686ce4b9b4fbae1c53fbd05304a7493 | fdbf95027ecb09006f0e3a234375abb86adf7ffd | refs/heads/master | 2020-09-25T14:18:16.260699 | 2019-11-05T08:33:12 | 2019-11-05T08:33:12 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,623 | cpp | /*************************************************************************
* Copyright (C) [2019] by Cambricon, Inc. All rights reserved
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*************************************************************************/
#include <memory>
#include <string>
#include <utility>
#include <vector>
#include "postproc.hpp"
namespace cnstream {
class PostprocClassification : public Postproc, virtual public libstream::ReflexObjectEx<Postproc> {
public:
int Execute(const std::vector<float*>& net_outputs, const std::shared_ptr<libstream::ModelLoader>& model,
const CNFrameInfoPtr& package) override;
DECLARE_REFLEX_OBJECT_EX(PostprocClassification, Postproc)
}; // classd PostprocClassification
IMPLEMENT_REFLEX_OBJECT_EX(PostprocClassification, Postproc)
int PostprocClassification::Execute(const std::vector<float*>& net_outputs,
const std::shared_ptr<libstream::ModelLoader>& model,
const CNFrameInfoPtr& package) {
if (net_outputs.size() != 1) {
LOG(ERROR) << "[Warning] classification neuron network only has one output,"
" but get " + std::to_string(net_outputs.size());
return -1;
}
auto data = net_outputs[0];
auto len = model->output_shapes()[0].hwc();
auto pscore = data;
float mscore = 0;
int label = 0;
for (decltype(len) i = 0; i < len; ++i) {
auto score = *(pscore + i);
if (score > mscore) {
mscore = score;
label = i;
}
}
if (0 == label) return -1;
DLOG(INFO) << "label = " << label + 1 << " score = " << mscore;
auto obj = std::make_shared<CNInferObject>();
obj->id = std::to_string(label);
obj->score = mscore;
package->objs.push_back(obj);
return 0;
}
} // namespace cnstream
| [
"zhupengdong@cambricon.com"
] | zhupengdong@cambricon.com |
5cd0364caab2343dc508fc886c58b821409a7100 | 4aa1205ad6ce00435e0a33a93dbd9aa74e886903 | /src/gc_graphics_redsquare.cpp | b59a1c8995c133fbc1d8bcf918e68dd02c25fc3f | [] | no_license | mkdir-not-war/sidescroll-prototype | 8a7d118ed5d4be3de5d9859639d1b1c66b8f890c | f6bec808bb1f879d0002f58bdb8b990ab84be862 | refs/heads/master | 2021-05-09T03:02:13.102048 | 2018-02-11T17:23:47 | 2018-02-11T17:23:47 | 119,229,056 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 235 | cpp | // gc_graphics_redsquare.cpp
#include "gc_graphics_redsquare.h"
GC_Graphics_RedSquare::GC_Graphics_RedSquare()
{
loadtex(tex_moving, "./../res/graphics/actors/red.jpg");
loadtex(tex_idle, "./../res/graphics/actors/player1.jpg");
}
| [
"gavin_gr@msn.com"
] | gavin_gr@msn.com |
d112e2b7f4ff169f13a4617039a1ac4eb3ac5cd3 | aef94ad2f39af9a763eba80dd4162e4e011dd718 | /src/objects/Backpack.h | bf962cfb6f73f8de9b3d1affe0969c1c343c5b52 | [] | no_license | piinguu/lostincornfield | fc37d7b56061acc0cc671d522912f6df8c040f76 | c38f864da4d56c16ac250f65ededb28fa168499c | refs/heads/master | 2020-07-02T00:27:49.525300 | 2014-05-29T09:22:21 | 2014-05-29T09:22:21 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 364 | h | #include "Object.h"
namespace licf
{
struct Backpack : public Object
{
double pack_volume, max_weight;
Backpack(double pv, double mw) : pack_volume(pv), max_weight(mw) {}
std::string description() const;
double weight() const { return 1; }
double volume() const { return 1; }
std::string type() const { return "ryggsäck"; }
};
}
| [
"markupet@csc.kth.se"
] | markupet@csc.kth.se |
e157149877bd490ed60ed1e40296221473560189 | 71e6fb64db228d984117c1231a9b066707ccb2b3 | /PowerShell-Native/src/libpsl-native/src/getlstat.cpp | 0517851fceb76b276ee887b680c97dc6e6439765 | [] | no_license | WeilerWebServices/Powershell | 3fd6e3ad8ddacfb85869d8ab4afb3532294151ab | 26193272f670d98985576bd6d123861f94863119 | refs/heads/master | 2023-01-15T03:07:06.215912 | 2020-11-15T08:18:36 | 2020-11-15T08:18:36 | 273,372,992 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 1,205 | cpp | // Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
//! @brief returns the stat of a file
#include "getlstat.h"
#include <errno.h>
#include <assert.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <pwd.h>
#include <string.h>
#include <unistd.h>
//! @brief GetStat returns the stat of a file. This simply delegates to the
//! stat() system call and maps errno to the expected values for GetLastError.
//!
//! GetStat
//!
//! @param[in] path
//! @parblock
//! A pointer to the buffer that contains the file name
//!
//! char* is marshaled as an LPStr, which on Linux is UTF-8.
//! @endparblock
//!
//! @param[in] stat
//! @parblock
//! A pointer to the buffer in which to place the stat information
//! @endparblock
//!
//! @retval 0 if successful
//! @retval -1 if failed
//!
// DO NOT use in managed code
// use externally defined structs in managed code has proven to be buggy
// (memory corruption issues due to layout difference between platforms)
// see https://github.com/dotnet/corefx/issues/29700#issuecomment-389313075
int32_t GetLStat(const char* path, struct stat* buf)
{
assert(path);
errno = 0;
return lstat(path, buf);
}
| [
"nateweiler84@gmail.com"
] | nateweiler84@gmail.com |
e4accf64ed1aaa71a2201e29692172517cd342ec | e1ee38b78d0b83ecb9e3424371afc3e11ca22f7c | /Beads/Beads.cpp | 7d0feaca5e82c2bbcc59391a0d3c5a5fb8dbc92a | [] | no_license | mohit-bansil/USACO | 7f5e2560a9f3f1c269ea823338c7ed74268882e4 | 02891d38c5fd42f0281e08a3d6910ff08cfaaec9 | refs/heads/master | 2023-08-11T07:41:06.153501 | 2021-09-28T22:21:01 | 2021-09-28T22:21:01 | 411,454,054 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,436 | cpp | /*
ID: paradox4
PROG: beads
LANG: C++
*/
#include<iostream>
#include<fstream>
#include<string>
using namespace std;
void permuteString(string& necklace)
{
char a = necklace[0];
necklace.erase(necklace.begin());
necklace += a;
}
int main()
{
ifstream Input("beads.in");
ofstream Output("beads.out");
int size;
string necklaceInput, necklace;
Input >> size >> necklaceInput;
necklace = necklaceInput + necklaceInput;
int currentIndex = 0;
int currentSize = 1;
int maxSize = 0;
char a = 'a';
for (int searchIndex = 2; searchIndex < size; searchIndex++)
{
currentSize = 1;
currentIndex = searchIndex;
a = necklace[currentIndex];
if (a == 'w')
{
for (int i = currentIndex + 1; i < size * 2; i++)
{
if (necklace[i] != 'w')
{
a = necklace[i];
break;
}
}
}
while (true)
{
if (currentIndex - searchIndex == size - 1)
break;
if (necklace[currentIndex + 1] == a || necklace[currentIndex + 1] == 'w')
{
currentSize++;
currentIndex++;
}
else
break;
}
while (true)
{
if (currentIndex - searchIndex == size - 1)
break;
if (necklace[currentIndex + 1] != a)
{
currentSize++;
currentIndex++;
}
else
break;
}
if (currentSize > maxSize)
maxSize = currentSize;
}
Output << maxSize << endl;
return 0;
} | [
"paradoxes42@gmail.com"
] | paradoxes42@gmail.com |
9a503e858fa631095b679f634adb0408df4579e5 | be9cd9a8e4fcfb0814efb458366af0a52dc7b2f4 | /Topic-Wise/Dynamic-Programming/C++/PathInMatrix.cpp | 9966e869055875e53a352acdbdb22e7665f8fb11 | [] | no_license | mdsarfarazulh/Interview-Preparation | 30bf371903bd6d9578b3bacef9fba372b6f8c7f9 | 7f0e438fb78f85caade54f102964fc564d275560 | refs/heads/master | 2020-05-07T10:29:51.544740 | 2019-06-12T04:38:23 | 2019-06-12T04:38:23 | 180,420,313 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,123 | cpp | /*
Problem: https://practice.geeksforgeeks.org/problems/path-in-matrix/0
Editorial: https://www.geeksforgeeks.org/maximum-path-sum-matrix/
*/
#include<bits/stdc++.h>
using namespace std;
#define LL long long int
int dr[] = {1, 1, 1};
int dc[] = {0, -1, 1};
void solve(){
int n;
cin>>n;
int arr[n][n];
for(int i=0;i<n;++i)
for(int j=0;j<n;++j)
cin>>arr[i][j];
int dp[n][n];
memset(dp, 0, sizeof(dp));
int r, c;
for(int i=0;i<n-1;++i){
for(int j=0;j<n;++j){
if(!i)
dp[i][j] = arr[i][j];
for(int k=0;k<3;++k){
r = i + dr[k];
c = j + dc[k];
if(r<n && c<n && c>=0){
dp[r][c] = max(dp[r][c], dp[i][j] + arr[r][c]);
}
}
}
}
int ans = 0;
for(int j=0;j<n;++j)
ans = max(ans, dp[n-1][j]);
cout<<ans<<endl;
}
int main(void){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int tcases;
cin>>tcases;
while(tcases--)
solve();
return 0;
} | [
"tstockroom@gmail.com"
] | tstockroom@gmail.com |
19148d2356a08e9752bcd532f71392a8f0cb5bac | 39241d24ac34343bd60391990f89051d5773567f | /tests/xtd.core.unit_tests/src/io/end_of_stream_exception.cpp | ee2e9e21c826fd6ac13b007bbeb3f253b7c79618 | [
"MIT"
] | permissive | fikarzlf/xtd | e0ddf7128a8ca6961a23d50a07ac204eed54e1f3 | 9879fd9eefbff3853cbcf74e7b6702dbee989894 | refs/heads/master | 2023-07-17T20:37:27.484556 | 2021-09-06T21:37:28 | 2021-09-06T21:37:28 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 18,610 | cpp | #include <xtd/io/end_of_stream_exception.h>
#include <xtd/xtd.tunit>
using namespace xtd;
using namespace xtd::io;
using namespace xtd::tunit;
namespace unit_tests {
class test_class_(test_end_of_stream_exception) {
public:
void test_method_(default_creator) {
end_of_stream_exception e;
assert::are_equal(std::system_category(), e.error_code().category(), csf_);
assert::is_false(e.inner_exception().has_value(), csf_);
assert::is_empty(e.file_path(), csf_);
assert::is_empty(e.help_link(), csf_);
assert::are_equal(0, e.error_code().value(), csf_);
assert::are_equal(0U, e.line_numer(), csf_);
assert::is_empty(e.member_name(), csf_);
assert::are_equal("Attempted to read past the end of the stream.", e.message(), csf_);
assert::are_equal("xtd::io::end_of_stream_exception", e.name(), csf_);
assert::is_empty(e.stack_trace(), csf_);
assert::are_equal("xtd::io::end_of_stream_exception : Attempted to read past the end of the stream.", e.to_string(), csf_);
assert::are_equal("Attempted to read past the end of the stream.", e.what(), csf_);
}
void test_method_(default_creator_with_current_stack_frame) {
auto info = current_stack_frame_;
end_of_stream_exception e(info);
assert::are_equal(std::system_category(), e.error_code().category(), csf_);
assert::is_false(e.inner_exception().has_value(), csf_);
assert::are_equal(info.get_file_name(), e.file_path(), csf_);
assert::is_empty(e.help_link(), csf_);
assert::are_equal(0, e.error_code().value(), csf_);
assert::are_equal(info.get_file_line_number(), e.line_numer(), csf_);
assert::are_equal(info.get_method(), e.member_name(), csf_);
assert::are_equal("Attempted to read past the end of the stream.", e.message(), csf_);
assert::are_equal("xtd::io::end_of_stream_exception", e.name(), csf_);
assert::are_equal(info.to_string(), e.stack_trace(), csf_);
assert::are_equal("xtd::io::end_of_stream_exception : Attempted to read past the end of the stream.\n" + info.to_string(), e.to_string(), csf_);
assert::are_equal("Attempted to read past the end of the stream.", e.what(), csf_);
}
void test_method_(creator_with_empty_message) {
end_of_stream_exception e("");
assert::are_equal(0, e.error_code().value(), csf_);
assert::are_equal(std::system_category(), e.error_code().category(), csf_);
assert::is_empty(e.file_path(), csf_);
assert::is_empty(e.help_link(), csf_);
assert::is_false(e.inner_exception().has_value(), csf_);
assert::are_equal(0U, e.line_numer(), csf_);
assert::is_empty(e.member_name(), csf_);
assert::are_equal("", e.message(), csf_);
assert::are_equal("xtd::io::end_of_stream_exception", e.name(), csf_);
assert::is_empty(e.stack_trace(), csf_);
assert::are_equal("xtd::io::end_of_stream_exception", e.to_string(), csf_);
assert::are_equal("xtd::io::end_of_stream_exception", e.what(), csf_);
}
void test_method_(creator_with_message_empty_and_stack_frame) {
auto info = current_stack_frame_;
end_of_stream_exception e("", info);
assert::are_equal(info.get_file_name(), e.file_path(), csf_);
assert::is_empty(e.help_link(), csf_);
assert::are_equal(0, e.error_code().value(), csf_);
assert::is_false(e.inner_exception().has_value(), csf_);
assert::are_equal(std::system_category(), e.error_code().category(), csf_);
assert::are_equal(info.get_file_line_number(), e.line_numer(), csf_);
assert::are_equal(info.get_method(), e.member_name(), csf_);
assert::are_equal("", e.message(), csf_);
assert::are_equal("xtd::io::end_of_stream_exception", e.name(), csf_);
assert::are_equal(info.to_string(), e.stack_trace(), csf_);
assert::are_equal("xtd::io::end_of_stream_exception\n" + info.to_string(), e.to_string(), csf_);
assert::are_equal("xtd::io::end_of_stream_exception", e.what(), csf_);
}
void test_method_(creator_with_message) {
end_of_stream_exception e("Test excpetion message.");
assert::are_equal(0, e.error_code().value(), csf_);
assert::are_equal(std::system_category(), e.error_code().category(), csf_);
assert::is_empty(e.file_path(), csf_);
assert::is_empty(e.help_link(), csf_);
assert::is_false(e.inner_exception().has_value(), csf_);
assert::are_equal(0U, e.line_numer(), csf_);
assert::is_empty(e.member_name(), csf_);
assert::are_equal("Test excpetion message.", e.message(), csf_);
assert::are_equal("xtd::io::end_of_stream_exception", e.name(), csf_);
assert::is_empty(e.stack_trace(), csf_);
assert::are_equal("xtd::io::end_of_stream_exception : Test excpetion message.", e.to_string(), csf_);
assert::are_equal("Test excpetion message.", e.what(), csf_);
}
void test_method_(creator_with_message_and_stack_frame) {
auto info = current_stack_frame_;
end_of_stream_exception e("Test excpetion message.", info);
assert::are_equal(info.get_file_name(), e.file_path(), csf_);
assert::is_empty(e.help_link(), csf_);
assert::are_equal(0, e.error_code().value(), csf_);
assert::is_false(e.inner_exception().has_value(), csf_);
assert::are_equal(std::system_category(), e.error_code().category(), csf_);
assert::are_equal(info.get_file_line_number(), e.line_numer(), csf_);
assert::are_equal(info.get_method(), e.member_name(), csf_);
assert::are_equal("Test excpetion message.", e.message(), csf_);
assert::are_equal("xtd::io::end_of_stream_exception", e.name(), csf_);
assert::are_equal(info.to_string(), e.stack_trace(), csf_);
assert::are_equal("xtd::io::end_of_stream_exception : Test excpetion message.\n" + info.to_string(), e.to_string(), csf_);
assert::are_equal("Test excpetion message.", e.what(), csf_);
}
void test_method_(creator_with_message_error_and_stack_frame) {
auto info = current_stack_frame_;
end_of_stream_exception e("Test excpetion message.", std::error_code(EBUSY, std::generic_category()), info);
assert::are_equal(EBUSY, e.error_code().value(), csf_);
assert::are_equal(std::generic_category(), e.error_code().category(), csf_);
assert::are_equal(info.get_file_name(), e.file_path(), csf_);
assert::is_empty(e.help_link(), csf_);
assert::is_false(e.inner_exception().has_value(), csf_);
assert::are_equal(info.get_file_line_number(), e.line_numer(), csf_);
assert::are_equal(info.get_method(), e.member_name(), csf_);
assert::are_equal("Test excpetion message.", e.message(), csf_);
assert::are_equal("xtd::io::end_of_stream_exception", e.name(), csf_);
assert::are_equal(info.to_string(), e.stack_trace(), csf_);
assert::are_equal("xtd::io::end_of_stream_exception : Test excpetion message.\n" + info.to_string(), e.to_string(), csf_);
assert::are_equal("Test excpetion message.", e.what(), csf_);
}
void test_method_(creator_with_message_help_link_and_stack_frame) {
auto info = current_stack_frame_;
end_of_stream_exception e("Test excpetion message.", "https://codedocs.xyz/gammasoft71/xtd_core/", info);
assert::are_equal(0, e.error_code().value(), csf_);
assert::are_equal(std::system_category(), e.error_code().category(), csf_);
assert::are_equal(info.get_file_name(), e.file_path(), csf_);
assert::are_equal("https://codedocs.xyz/gammasoft71/xtd_core/", e.help_link(), csf_);
assert::is_false(e.inner_exception().has_value(), csf_);
assert::are_equal(info.get_file_line_number(), e.line_numer(), csf_);
assert::are_equal(info.get_method(), e.member_name(), csf_);
assert::are_equal("Test excpetion message.", e.message(), csf_);
assert::are_equal("xtd::io::end_of_stream_exception", e.name(), csf_);
assert::are_equal(info.to_string(), e.stack_trace(), csf_);
assert::are_equal("xtd::io::end_of_stream_exception : Test excpetion message.\n" + info.to_string(), e.to_string(), csf_);
assert::are_equal("Test excpetion message.", e.what(), csf_);
}
void test_method_(creator_with_message_error_help_link_and_stack_frame) {
auto info = current_stack_frame_;
end_of_stream_exception e("Test excpetion message.", std::error_code(EBUSY, std::generic_category()), "https://codedocs.xyz/gammasoft71/xtd_core/", info);
assert::are_equal(EBUSY, e.error_code().value(), csf_);
assert::are_equal(std::generic_category(), e.error_code().category(), csf_);
assert::are_equal(info.get_file_name(), e.file_path(), csf_);
assert::are_equal("https://codedocs.xyz/gammasoft71/xtd_core/", e.help_link(), csf_);
assert::is_false(e.inner_exception().has_value(), csf_);
assert::are_equal(info.get_file_line_number(), e.line_numer(), csf_);
assert::are_equal(info.get_method(), e.member_name(), csf_);
assert::are_equal("Test excpetion message.", e.message(), csf_);
assert::are_equal("xtd::io::end_of_stream_exception", e.name(), csf_);
assert::are_equal(info.to_string(), e.stack_trace(), csf_);
assert::are_equal("xtd::io::end_of_stream_exception : Test excpetion message.\n" + info.to_string(), e.to_string(), csf_);
assert::are_equal("Test excpetion message.", e.what(), csf_);
}
void test_method_(creator_with_message_and_inner_exception) {
system_exception inner_exception;
end_of_stream_exception e("Test excpetion message.", inner_exception);
assert::are_equal(0, e.error_code().value(), csf_);
assert::are_equal(std::system_category(), e.error_code().category(), csf_);
assert::is_empty(e.file_path(), csf_);
assert::is_empty(e.help_link(), csf_);
assert::is_instance_of<xtd::system_exception>(e.inner_exception().value().get(), csf_);
assert::are_equal(inner_exception.what(), e.inner_exception().value().get().what(), csf_);
assert::are_equal(0U, e.line_numer(), csf_);
assert::is_empty(e.member_name(), csf_);
assert::are_equal("Test excpetion message.", e.message(), csf_);
assert::are_equal("xtd::io::end_of_stream_exception", e.name(), csf_);
assert::is_empty(e.stack_trace(), csf_);
assert::are_equal("xtd::io::end_of_stream_exception : Test excpetion message.", e.to_string(), csf_);
assert::are_equal("Test excpetion message.", e.what(), csf_);
}
void test_method_(creator_with_message_inner_exception_and_stack_frame) {
system_exception inner_exception;
auto info = current_stack_frame_;
end_of_stream_exception e("Test excpetion message.", inner_exception, info);
assert::are_equal(info.get_file_name(), e.file_path(), csf_);
assert::is_empty(e.help_link(), csf_);
assert::are_equal(0, e.error_code().value(), csf_);
assert::is_instance_of<xtd::system_exception>(e.inner_exception().value().get(), csf_);
assert::are_equal(inner_exception.what(), e.inner_exception().value().get().what(), csf_);
assert::are_equal(std::system_category(), e.error_code().category(), csf_);
assert::are_equal(info.get_file_line_number(), e.line_numer(), csf_);
assert::are_equal(info.get_method(), e.member_name(), csf_);
assert::are_equal("Test excpetion message.", e.message(), csf_);
assert::are_equal("xtd::io::end_of_stream_exception", e.name(), csf_);
assert::are_equal(info.to_string(), e.stack_trace(), csf_);
assert::are_equal("xtd::io::end_of_stream_exception : Test excpetion message.\n" + info.to_string(), e.to_string(), csf_);
assert::are_equal("Test excpetion message.", e.what(), csf_);
}
void test_method_(creator_with_message_inner_exception_error_and_stack_frame) {
system_exception inner_exception;
auto info = current_stack_frame_;
end_of_stream_exception e("Test excpetion message.", inner_exception, std::error_code(EBUSY, std::generic_category()), info);
assert::are_equal(EBUSY, e.error_code().value(), csf_);
assert::are_equal(std::generic_category(), e.error_code().category(), csf_);
assert::are_equal(info.get_file_name(), e.file_path(), csf_);
assert::is_empty(e.help_link(), csf_);
assert::is_instance_of<xtd::system_exception>(e.inner_exception().value().get(), csf_);
assert::are_equal(inner_exception.what(), e.inner_exception().value().get().what(), csf_);
assert::are_equal(info.get_file_line_number(), e.line_numer(), csf_);
assert::are_equal(info.get_method(), e.member_name(), csf_);
assert::are_equal("Test excpetion message.", e.message(), csf_);
assert::are_equal("xtd::io::end_of_stream_exception", e.name(), csf_);
assert::are_equal(info.to_string(), e.stack_trace(), csf_);
assert::are_equal("xtd::io::end_of_stream_exception : Test excpetion message.\n" + info.to_string(), e.to_string(), csf_);
assert::are_equal("Test excpetion message.", e.what(), csf_);
}
void test_method_(creator_with_message_inner_exception_help_link_and_stack_frame) {
system_exception inner_exception;
auto info = current_stack_frame_;
end_of_stream_exception e("Test excpetion message.", inner_exception, "https://codedocs.xyz/gammasoft71/xtd_core/", info);
assert::are_equal(0, e.error_code().value(), csf_);
assert::are_equal(std::system_category(), e.error_code().category(), csf_);
assert::are_equal(info.get_file_name(), e.file_path(), csf_);
assert::are_equal("https://codedocs.xyz/gammasoft71/xtd_core/", e.help_link(), csf_);
assert::is_instance_of<xtd::system_exception>(e.inner_exception().value().get(), csf_);
assert::are_equal(inner_exception.what(), e.inner_exception().value().get().what(), csf_);
assert::are_equal(info.get_file_line_number(), e.line_numer(), csf_);
assert::are_equal(info.get_method(), e.member_name(), csf_);
assert::are_equal("Test excpetion message.", e.message(), csf_);
assert::are_equal("xtd::io::end_of_stream_exception", e.name(), csf_);
assert::are_equal(info.to_string(), e.stack_trace(), csf_);
assert::are_equal("xtd::io::end_of_stream_exception : Test excpetion message.\n" + info.to_string(), e.to_string(), csf_);
assert::are_equal("Test excpetion message.", e.what(), csf_);
}
void test_method_(creator_with_message_inner_exception_error_help_link_and_stack_frame) {
system_exception inner_exception;
auto info = current_stack_frame_;
end_of_stream_exception e("Test excpetion message.", inner_exception, std::error_code(EBUSY, std::generic_category()), "https://codedocs.xyz/gammasoft71/xtd_core/", info);
assert::are_equal(EBUSY, e.error_code().value(), csf_);
assert::are_equal(std::generic_category(), e.error_code().category(), csf_);
assert::are_equal(info.get_file_name(), e.file_path(), csf_);
assert::are_equal("https://codedocs.xyz/gammasoft71/xtd_core/", e.help_link(), csf_);
assert::is_instance_of<xtd::system_exception>(e.inner_exception().value().get(), csf_);
assert::are_equal(inner_exception.what(), e.inner_exception().value().get().what(), csf_);
assert::are_equal(info.get_file_line_number(), e.line_numer(), csf_);
assert::are_equal(info.get_method(), e.member_name(), csf_);
assert::are_equal("Test excpetion message.", e.message(), csf_);
assert::are_equal("xtd::io::end_of_stream_exception", e.name(), csf_);
assert::are_equal(info.to_string(), e.stack_trace(), csf_);
assert::are_equal("xtd::io::end_of_stream_exception : Test excpetion message.\n" + info.to_string(), e.to_string(), csf_);
assert::are_equal("Test excpetion message.", e.what(), csf_);
}
void test_method_(copy_constructor) {
system_exception inner_exception;
auto info = current_stack_frame_;
end_of_stream_exception e = end_of_stream_exception("Test excpetion message.", inner_exception, std::error_code(EBUSY, std::generic_category()), "https://codedocs.xyz/gammasoft71/xtd_core/", info);
assert::are_equal(EBUSY, e.error_code().value(), csf_);
assert::are_equal(std::generic_category(), e.error_code().category(), csf_);
assert::are_equal(info.get_file_name(), e.file_path(), csf_);
assert::are_equal("https://codedocs.xyz/gammasoft71/xtd_core/", e.help_link(), csf_);
assert::is_instance_of<xtd::system_exception>(e.inner_exception().value().get(), csf_);
assert::are_equal(inner_exception.what(), e.inner_exception().value().get().what(), csf_);
assert::are_equal(info.get_file_line_number(), e.line_numer(), csf_);
assert::are_equal(info.get_method(), e.member_name(), csf_);
assert::are_equal("Test excpetion message.", e.message(), csf_);
assert::are_equal("xtd::io::end_of_stream_exception", e.name(), csf_);
assert::are_equal(info.to_string(), e.stack_trace(), csf_);
assert::are_equal("xtd::io::end_of_stream_exception : Test excpetion message.\n" + info.to_string(), e.to_string(), csf_);
assert::are_equal("Test excpetion message.", e.what(), csf_);
}
void test_method_(copy_operator) {
system_exception inner_exception;
auto info = current_stack_frame_;
end_of_stream_exception e;
e = end_of_stream_exception("Test excpetion message.", inner_exception, std::error_code(EBUSY, std::generic_category()), "https://codedocs.xyz/gammasoft71/xtd_core/", info);
assert::are_equal(EBUSY, e.error_code().value(), csf_);
assert::are_equal(std::generic_category(), e.error_code().category(), csf_);
assert::are_equal(info.get_file_name(), e.file_path(), csf_);
assert::are_equal("https://codedocs.xyz/gammasoft71/xtd_core/", e.help_link(), csf_);
assert::is_instance_of<xtd::system_exception>(e.inner_exception().value().get(), csf_);
assert::are_equal(inner_exception.what(), e.inner_exception().value().get().what(), csf_);
assert::are_equal(info.get_file_line_number(), e.line_numer(), csf_);
assert::are_equal(info.get_method(), e.member_name(), csf_);
assert::are_equal("Test excpetion message.", e.message(), csf_);
assert::are_equal("xtd::io::end_of_stream_exception", e.name(), csf_);
assert::are_equal(info.to_string(), e.stack_trace(), csf_);
assert::are_equal("xtd::io::end_of_stream_exception : Test excpetion message.\n" + info.to_string(), e.to_string(), csf_);
assert::are_equal("Test excpetion message.", e.what(), csf_);
}
};
}
| [
"gammasoft71@gmail.com"
] | gammasoft71@gmail.com |
67054ef3b1ad6e3a64aa43e86060d5bce16db325 | 443a77967733786dace6c8d67bae940d1b8bfdbc | /debugVisualizer/src/scene/controller/SceneController.cpp | e0eb4f39d0c4bafb7eefd91f4fa055084f3643af | [
"MIT"
] | permissive | whztt1989/UrchinEngine | c3f754d075e2c2ff8f85cf775fcca27eaa2dcb11 | f90ba990b09f3792899db63fb1cbd8adfe514373 | refs/heads/master | 2021-01-13T08:17:59.441361 | 2016-10-23T18:33:11 | 2016-10-23T18:33:11 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 960 | cpp | #include <stdexcept>
#include "SceneController.h"
#include "scene/controller/ActionReader.h"
namespace urchin
{
SceneController::SceneController() :
bHasDebugFileOpen(false)
{
}
SceneController::~SceneController()
{
}
void SceneController::openDebugFile(const std::string &filename, std::shared_ptr<GeometryEntityHandler> geometryEntityHandler)
{
this->geometryEntityHandler = geometryEntityHandler;
this->bHasDebugFileOpen = true;
ActionReader actionReader(filename);
actions = actionReader.readDebugFile();
actionsIt = actions.begin();
}
bool SceneController::hasDebugFileOpen()
{
return bHasDebugFileOpen;
}
void SceneController::executeNextAction()
{
if(actionsIt!=actions.end())
{
(*actionsIt)->execute(geometryEntityHandler);
actionsIt++;
}
}
void SceneController::reverseLastAction()
{
if(actionsIt!=actions.begin())
{
actionsIt--;
(*actionsIt)->reverse(geometryEntityHandler);
}
}
}
| [
"petitg1987@gmail.com"
] | petitg1987@gmail.com |
ecb5879db07a6b258e8852a8dd97dbc9748664e9 | 0bf1f7b901118b5cbe3d51bbc5885fcb634419c5 | /Cpp/SDK/UMG_ReviveFriendsWidget_classes.h | 70fab6ccd04b0cbd757e651d11448e26dbe41653 | [] | no_license | zH4x-SDK/zMCDungeons-SDK | 3a90a959e4a72f4007fc749c53b8775b7155f3da | ab9d8f0ab04b215577dd2eb067e65015b5a70521 | refs/heads/main | 2023-07-15T15:43:17.217894 | 2021-08-27T13:49:22 | 2021-08-27T13:49:22 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,359 | h | #pragma once
// Name: DBZKakarot, Version: 1.0.3
/*!!DEFINE!!*/
/*!!HELPER_DEF!!*/
/*!!HELPER_INC!!*/
#ifdef _MSC_VER
#pragma pack(push, 0x01)
#endif
namespace CG
{
//---------------------------------------------------------------------------
// Classes
//---------------------------------------------------------------------------
// WidgetBlueprintGeneratedClass UMG_ReviveFriendsWidget.UMG_ReviveFriendsWidget_C
// 0x0000
class UUMG_ReviveFriendsWidget_C : public UUserWidget
{
public:
static UClass* StaticClass()
{
static auto ptr = UObject::FindClass("WidgetBlueprintGeneratedClass UMG_ReviveFriendsWidget.UMG_ReviveFriendsWidget_C");
return ptr;
}
void UpdateNumDown();
void UpdateGraphics();
void SetAllLocalPlayerDown();
void GetAnyPlayerDown();
void SetAnyPlayerDown();
void SetPlayerController();
void BndEvt__UMG_PlayersDownPortraitRow_K2Node_ComponentBoundEvent_0_OnAnyPlayerDownChanged__DelegateSignature();
void Construct();
void BndEvt__UMG_PlayersDownPortraitRow_K2Node_ComponentBoundEvent_1_OnNumPlayersDownChanged__DelegateSignature();
void BndEvt__UMG_PlayersDownPortraitRow_K2Node_ComponentBoundEvent_3_OnAllLocalPlayerDownChanged__DelegateSignature();
void ExecuteUbergraph_UMG_ReviveFriendsWidget();
void OnAnyPlayersDownChanged__DelegateSignature();
};
}
#ifdef _MSC_VER
#pragma pack(pop)
#endif
| [
"zp2kshield@gmail.com"
] | zp2kshield@gmail.com |
20afdf7e4ad54c7007f8e1f46c28a48b64497761 | 88ac47d447720b208975cc1db60052f633ddb344 | /main.cpp | cde22dc3c3577ada0b680def3b2695b5a7346930 | [] | no_license | icprog/D5000_Develop | 0de196f201e5f51c8b97e4ace730314c8dd41ae0 | 809ae2af9c448f5d1c71a76cfa2ed7abf2f8bfc0 | refs/heads/master | 2020-04-04T15:39:44.819254 | 2015-06-24T16:24:49 | 2015-06-24T16:24:49 | 156,046,644 | 0 | 1 | null | 2018-11-04T03:43:03 | 2018-11-04T03:43:02 | null | GB18030 | C++ | false | false | 392,205 | cpp | #include <iostream>
#include <dcisg.h>
#include <rtdb_api.h>
#include <msg_api/message_inv.h>
#include <msg_api/messageheader.h>
#include <message_channel.h>
#include <proc_inv.h>
#include <message_type.h>
#include <priv_access_new.h>
#include <scada_api/scada_event_m.h>
#include <scada_api/scada_front_struct.h>
#include <scada_api/CScaComm.h>
#include <warn_service_message_m.h>
#include "dsbob.h"
#include "dsbob2.h"
#include "Nmd.h"
#include "Tp.h"
#include "dms_tcp.h"
#include "tinyxml.h"
#include "FDIRR2.h"
#include "comm.h"
//#include <commdata.h>
#include "INTROCI.h"
#include "DBPSBOB.h"
#include "DBDMS.h"
#include "DBFDIR.h"
#include "FHZG.h"
#include "typical.h"
#include <cmath>
#define pthread_attr_default NULL
#define pthread_mutexattr_default NULL
#define pthread_condattr_default NULL
#define pthread_addr_t void *
typedef void*(*pthread_startroutine_t)(void *);
using namespace std;
//#undef _ORACLE_
//////////////////////////////////////
//用于故障指示器信号为条件启动故障定位
map<long, long> g_map_fi_dv; //第一个string为故障指示器的ID，后一个string为该故障指示器对应的DV的ID
map<long, list<long> > g_map_trig_fi; //string为DV的ID，list<string>为该DV下所有有信号的故障指示器列表
//用于故障指示器信号为条件启动故障定位
//////////////////////////////////////
CPrivAccessNew g_Priv;
/////用于生成虚拟母线和进线开关
stack<NODE> g_lstPath;
list<long> g_lstFound;
bool bDebug = false;
const int max_record = 10;
map<long, list<stack<NODE> > > g_map_nd_path; //馈线首端节点到母线间的路径
///////////////////////////////////////////
map<long, list<long> > g_map_nd_bus, g_map_nd_switch;//保存nd和bus，nd和刀闸的关系，方便快速的通过nd的id查到关联的母线和刀闸20120918
list<long> lst_lwcbs;//保存联络开关的id，在读库的时候就保存出来
TCPClass *tcptools = NULL;
DSBOB2 *g_bob2 = NULL;
DSBOB *g_bob=NULL;
NMD *nmd = NULL;
DB_PSBOB *g_db_psbob = NULL;
DB_DMS *g_db_dms = NULL;
DB_FDIR *g_db_fdir = NULL;
//////////////////////////////////
//haozeyun 测试 添加
FHZG* fhzg = NULL;
int listenfd;
int numthread = 0;
GDI_THREAD pthread_id[MAX_THREAD];
CScaComm *g_sca_common;
time_t *model_chg_ntf;
time_t tmp_val0 = 0;
time_t last_model_chg_ntf;
pthread_mutex_t mutex;
pthread_mutex_t g_rq_mutex;
pthread_mutex_t mutex_array_fault;
char gdiservices[] = "tcp";
char hostname[256] = "127.0.0.1";
const char userid[] = "dmshan";
///////////////////////
//故障隔离、恢复
#define MAX_FAULT 20
#define GROUP_TIME 10
#define MAX_SQL_LEN 40960
// 母线电压下线值
#define MIN_BUS_VALUE 1.0
const char *key[] = {"分", "事故跳闸", "动作", "复归", "合"};
FDIR_CONFIG g_FdirConfig = { 0 };
FDIR_TASK_LIST g_lstTask;
FDIR_POINT_TRIG_LIST g_lstTrig;//和开关关联的过流信号列表
FDIR_POINT_TRIG_SECTION g_lstSecTrig;//线段上的过流信号列表
pthread_mutex_t task_list_mutex;
pthread_mutex_t trig_list_mutex;
pthread_mutex_t oci_mutex;
pthread_mutex_t simu_sync_mutex; //用于故障模拟，提示人机交互线程向人机返回报文
FDIR_R2 *g_fdir_r = NULL;
INTR_OCI *g_oci = NULL;
//bob_invocation *bob_inv = NULL;
proc_invocation *proc_inv = NULL;
char *sql = new char[MAX_SQL_LEN];
message_invocation *bob_inv = NULL;
int iMessage;
int iProcess;
//char sql[20480] = {0};
char sqltemp[1024] = {0};
FDIR_R2 *array_fdir_r[MAX_FAULT]; //故障数组，每个故障项对应数组中的一项
bool map_idle_fdir_r[MAX_FAULT]; //索引故障数组中的每个项的占用情况
bool g_is_write_to_lib = false; //故障模拟写库标志
//杨勇 用于存储开关电流平均值
std::map<long,float> g_mapIValue;
std::map<long,std::list<float> > g_mapTempIValue;
pthread_mutex_t avg_i_mutex;
//故障隔离、恢复
/////////////////////////
typedef struct
{
long point_id;
bool bOpen;
int stage;
}CB_CONTROL;
bool IsMaster(); //判断主备机
void write_fhzg_step(const char* groupid, const char* table_name, list<list<MAP_SO_NODE> > lst_step, FDIR_R2* fdir_r, list<FAULT_ITEM> &lst_ld, list<long> lstIsolate/*用于保存母线负荷转供时需要断开的进线开关*/, bool bStation);
void HandlerMessage(void *para);
void thread_get_ivalue(void *param);
void thread_simu_return(void* param);
void fill_fhzg_db(const long cb_id, const char *fhzg_id, FHZG *fhzg, bool has_fhzg_cb); //写负荷转供关系库表
int GetFHZGLeftStep(const char *FHZG_id, list<CB_CONTROL> &lstcb);
bool AddTask(FDIR_TASK *newtask);
bool RemoveTask(const char* fault_id);
bool RemoveTasks(const char *group_id);
void UpdateExtStatus(const char *group_id);
int GetStbyDv(long dvid, PSBOB::ST &st);
int GetDv(long devid, const char *devtb, PSBOB::DV &dv);
void form_fdir_txt(const FDIR_TASK fault);
int GetJxcbDv(long cbid, PSBOB::DV &dv);
void RecoTaskItem(const char* groupid);
void RecoTaskStep(const char* groupid);
void RecoMemTask(const char* groupid);
int data_verify(const char* groupid);
void write_fault_tree(const char* groupid, FDIR_R2* fdir_r);
void write_fault_up_dev(const char* fault_id, char *table_name, FDIR_R2* fdir_r, bool upiso_fail, list<FAULT_ITEM> &lst_ld);
void write_fault_dev(const char *fault_id, char *table_name, FDIR_R2* fdir_r);
bool invalid_recalc(const char *group_id);
void EraseSameInfo(list<FAULT_ITEM> &lst_cont, list<FAULT_ITEM> lst_remove);
void write_res_and_disableres_ld(const char *groupid, list<FAULT_ITEM> lst_lose, list<FAULT_ITEM> lst_res);
void form_jxcb_control_txt(const char *group_id, const long point_name, const bool bOpen);
bool IsInRegion(MLang::Long cb_id);
bool pid_to_id(long &id);
bool id_to_pid(long &id);
bool GetCode(const long id, string &code);
long IDTransfor(long &id);
int Notify(const char *grp_id, const long dv_id, const long st_id, char op=-1);
int AddToken(const char *fault_id, const long dev_id, int token_type);
typedef struct
{
char picturename[256];
char contextname[20];
char bobname[20];
char st[100];
char equipment_type[2];
} ORDER, *PORDER;
//故障模拟数据结构
typedef struct
{
char plan_id[50];
int type;
char plan_name[20];
char machine_name[50];
char usr_id[50];
}SIMU_PLAN;
typedef struct
{
long cb_id;
int status;
float Ia;
float Ib;
float Ic;
float p;
float q;
}CHECK_DATA;
typedef std::list<CHECK_DATA> CHECK_LIST;
typedef struct
{
char plan_id[50];
long sig_id;
char sig_name[64];
int status;
int type;
int sig_delay;
char comment[50];
}SIMU_SIGNAL;
typedef std::list<SIMU_SIGNAL> SIMU_SIG_LIST;
typedef map<std::string, FDIR_POINT_TRIG_LIST> MACHINE_TRIG_MAP;
MACHINE_TRIG_MAP simu_mac_trig;
//设备着色响应报文头
const char head_xml[] = "<?xml version = \"1.0\" encoding=\"ISO-8859-1\" ?>\r\n\
<Message>\r\n\
<Header type = \"Equipment_Color\"/>\r\n\
<Body>\r\n";
//设备着色响应报文头
const char head_xml4[] = "<?xml version = \"1.0\" encoding=\"ISO-8859-1\" ?>\r\n\
<Message>\r\n\
<Header type = \"study_fdir\"/>\r\n\
<Body>\r\n";
//响应故障执行步骤方案
const char head_xml5[] = "<?xml version = \"1.0\" encoding=\"ISO-8859-1\" ?>\r\n\
<Message>\r\n\
<Header type = \"FDIR_STEP\"/>\r\n\
<Body>\r\n";
//响应典型运行方式报文
const char head_xml6[] = "<?xml version = \"1.0\" encoding=\"ISO-8859-1\" ?>\r\n\
<Message>\r\n\
<Header type = \"typical\"/>\r\n\
<Body>\r\n";
//响应数据校验报文
const char head_xml7[] = "<?xml version = \"1.0\" encoding=\"ISO-8859-1\" ?>\r\n\
<Message>\r\n\
<Header type = \"check_data\"/>\r\n\
<Body>\r\n";
//响应故障重新计算报文
const char head_xml8[] = "<?xml version = \"1.0\" encoding=\"ISO-8859-1\" ?>\r\n\
<Message>\r\n\
<Header type = \"recalc\"/>\r\n\
<Body>\r\n";
//设备着色响应报文尾
const char tail_xml[] = "</Order>\r\n\
</Body>\r\n\
</Message>\r\n\
";
//防误闭锁判断响应报文头
const char head_xml2[] = "<?xml version=\"1.0\" encoding=\"ISO-8859-1\" ?>\r\n\
<Message>\r\n\
<Header type=\"misoperation\"/>\r\n\
<Body>\r\n";
const char head_xml3[] = "<?xml version = \"1.0\" encoding=\"ISO-8859-1\" ?>\r\n\
<Message>\r\n\
<Header type = \"FHZG\"/>\r\n\
<Body>\r\n";
//防误闭锁判断响应报文尾
const char tail_xml2[] = "</Body>\r\n\
</Message>\r\n\
";
//测试数据
const char test_misoperation[] = "<?xml version=\"1.0\" encoding=\"ISO-8859-1\" ?>\
<Message>\
<Header type=\"misoperation\" />\
<Body>\
<operation pictureName=\"FUJIAN/可视化测试/0001.epp\" contextname=\"realtime\" bobname=\"dms\">\
<order cb=\"KSLCBKL44\" op_type=\"1\" />\
</operation>\
</Body>\
</Message>";
//故障模拟保存方案报文头
const char head_xml_simu_save[] = "<?xml version = \"1.0\" encoding=\"ISO-8859-1\" ?>\r\n\
<Message>\r\n\
<Header type = \"fault_simu_save\"/>\r\n\
<Body>\r\n";
//故障模拟保存方案报文尾
const char tail_xml_simu[] = "</Simu_Plan>\r\n\
</Body>\r\n\
</Message>\r\n\
";
//故障模拟保存方案报文头
const char head_xml_simu_exec[] = "<?xml version = \"1.0\" encoding=\"ISO-8859-1\" ?>\r\n\<Message>\r\n\<Header type = \"fault_simu_exec\"/>\r\n\<Body>\r\n";
///////////////////////////////////////////////////////////////////////////////
int GetRecsByAttr(const TB_DESCR* tb_descr, const char* attr_name, const char* attr_value, void* buf, long len_buf)
{
int field_no[2] = { 0 };
int fieldnum = 0;
int ret_code = GetFieldNoByName(const_cast<TB_DESCR*>(tb_descr), const_cast<char*>(attr_name), field_no, &fieldnum);
if (ret_code < 0)
{
return ret_code;
}
char* buf_ptr = NULL;
ret_code = GetRecsByAttr(const_cast<TB_DESCR*>(tb_descr), field_no[0], EQU, const_cast<char*>(attr_value), 0, &buf_ptr);
if (0 >= ret_code)
{
if (NULL != buf_ptr)
{
BufFree(buf_ptr);
buf_ptr = NULL;
}
return ret_code;
}
if(ret_code > len_buf)
{
BufFree(buf_ptr);
buf_ptr = NULL;
return -1;
}
memcpy(buf, buf_ptr, ret_code);
BufFree(buf_ptr);
buf_ptr = NULL;
return ret_code;
}
int FindCB(PSBOB::CB* buf, const long nd)
{
int cnt = 0;
int ret = GetRecsByAttr(g_db_psbob->GetTB("breaker"), "ind", (const char*)&nd, buf, sizeof(PSBOB::CB) * max_record);//buf, "ind", (char*)&nd, const_cast<TB_DESCR*>(g_db_psbob->GetTB("breaker")), sizeof(CB) * max_record);
if (ret > 0)
{
cnt = ret / sizeof(PSBOB::CB);
}
ret = GetRecsByAttr(g_db_psbob->GetTB("breaker"), "jnd", (const char*)&nd, buf + cnt, sizeof(PSBOB::CB) * (max_record - cnt));
if (ret > 0)
{
cnt += ret / sizeof(PSBOB::CB);
}
return cnt;
}
int FindSWITCH(PSBOB::SWITCH* buf, const long nd)
{
int cnt = 0;
int ret = GetRecsByAttr(g_db_psbob->GetTB("disconnector"), "ind", (const char*)&nd, buf, sizeof(PSBOB::SWITCH) * max_record);
if (ret > 0)
{
cnt = ret / sizeof(PSBOB::SWITCH);
}
ret = GetRecsByAttr(g_db_psbob->GetTB("disconnector"), "jnd", (const char*)&nd, buf + cnt, sizeof(PSBOB::SWITCH) * (max_record - cnt));
if (ret > 0)
{
cnt += ret / sizeof(PSBOB::SWITCH);
}
return cnt;
}
int FindLD(PSBOB::LD* buf, const long nd)
{
int cnt = 0;
int ret = GetRecsByAttr(g_db_psbob->GetTB("energyconsumer"), "nd", (const char*)&nd, buf, sizeof(PSBOB::LD) * max_record);
if (ret > 0)
{
cnt = ret / sizeof(PSBOB::LD);
}
return cnt;
}
int FindSEC(PSBOB::SEC* buf, const long nd)
{
int cnt = 0;
MyBufManager bf_end(max_record * sizeof(PSBOB::ACLINEEND));
int ret = GetRecsByAttr(g_db_psbob->GetTB("aclineend"), "nd", (const char*) &nd, (void*)bf_end, sizeof(PSBOB::ACLINEEND) * max_record);
if (ret > 0)
{
int max = ret / sizeof(PSBOB::SEC);
PSBOB::ACLINEEND *p = (void*) (bf_end);
PSBOB::SEC* pbuf = buf;
for (int i = 0; i < max; i++)
{
if (GetRecByID(const_cast<TB_DESCR*>(g_db_psbob->GetTB("aclinesegment")), (char*) &p->aclnseg_id, sizeof(PSBOB::SEC), (char*) pbuf) >= 0)
{
pbuf++;
cnt++;
}
else
{
printf("aclinesegment中找不着ID为%ld的记录\r\n", p->aclnseg_id);
}
p++;
}
}
// ret = GetRecsByAttr(g_db_psbob->GetTB("aclinesegment"), "jnd", (const char*)&nd, buf + cnt, sizeof(SEC) * (max_record - cnt));
//
// if (ret > 0)
// {
// cnt += ret / sizeof(SEC);
// }
return cnt;
}
int FindBUS(PSBOB::BUS* buf, const long nd)
{
int cnt = 0;
MyBufManager bf_bus(max_record * sizeof(PSBOB::BUS));
int ret = GetRecsByAttr(g_db_psbob->GetTB("busbarsection"), "nd", (const char*)&nd, (void*)bf_bus, sizeof(PSBOB::BUS) * max_record);
if(ret > 0)
{
cnt = ret / sizeof(PSBOB::BUS);
int j = 0;
for (int i = 0; i < cnt; i++)
{
PSBOB::ST psbob_st = { 0 };
if (oodbread_rk(&psbob_st, &(((PSBOB::BUS*) bf_bus)[i].st_id), const_cast<TB_DESCR*>(g_db_psbob->GetTB("substation")), sizeof(psbob_st)) > 0)
{
if (HasMask(g_db_psbob->GetTB("substation"), "st_type", psbob_st.st_type , MENU_FAC_TYPE_CABLEBRANCHBOX)) continue;
if (HasMask(g_db_psbob->GetTB("substation"), "st_type", psbob_st.st_type , MENU_FAC_TYPE_DISTRIBUTEBOX)) continue;
if (HasMask(g_db_psbob->GetTB("substation"), "st_type", psbob_st.st_type , MENU_FAC_TYPE_RINGMAINUNIT)) continue;
if (HasMask(g_db_psbob->GetTB("substation"), "st_type", psbob_st.st_type , MENU_FAC_TYPE_SWITCHING)) continue;
}
else
{
continue;
}
memcpy(&buf[j], &((PSBOB::BUS*) bf_bus)[i], sizeof(PSBOB::BUS));
j++;
}
cnt = j;
}
return cnt;
}
void Find(const long nd, const long org_nd, NODE &data)
{
//assert(nd > 0 && id > 0);
NODE node = { 0 };
g_lstPath.push(data);
MyBufManager bf_bus(max_record * sizeof(PSBOB::BUS));
MyBufManager bf_cb(max_record * sizeof(PSBOB::CB));
MyBufManager bf_ld(max_record * sizeof(PSBOB::LD));
MyBufManager bf_sec(max_record * sizeof(PSBOB::SEC));
MyBufManager bf_switch(max_record * sizeof(PSBOB::SWITCH));
int cnt = 0, i = 0;
//碰到终止条件
if (nd <= 0 /*|| FindBUS(bf_bus, nd) > 0 || FindLD(bf_ld, nd) > 0*/)
{
if (bDebug)
{
if (g_lstPath.top().type == _BUS)
printf("POP->%ld[%s]\r\n", g_lstPath.top().data.bus.id, g_lstPath.top().data.bus.name);
else if (g_lstPath.top().type == _LD)
printf("POP->%ld[%s]\r\n", g_lstPath.top().data.ld.id, g_lstPath.top().data.ld.name);
else if (g_lstPath.top().type == _SWITCH)
printf("POP->%ld[%s]\r\n", g_lstPath.top().data.disconnector.id, g_lstPath.top().data.disconnector.name);
else if (g_lstPath.top().type == _CB)
printf("POP->%ld[%s]\r\n", g_lstPath.top().data.cb.id, g_lstPath.top().data.cb.name);
else
printf("POP->%ld[%s]\r\n", g_lstPath.top().data.sec.id, g_lstPath.top().data.sec.name);
}
g_lstPath.pop();
return;
}
//BUS
cnt = FindBUS(bf_bus, nd);
PSBOB::BUS *pbus = (PSBOB::BUS*)bf_bus;
if (cnt > 0)
{
TRACE("通过结点%ld找到母线%ld[%s]\r\n", nd, pbus->id, pbus->name);
}
//考虑一个节点连接一条母线
if ((cnt > 0) && !HasMask(g_db_psbob->GetTB("busbarsection"), "bs_type", pbus->bs_type, MENU_BS_TYPE_ANCILLBUS))
{
memcpy(&node.data.bus, pbus, sizeof(PSBOB::BUS));
node.type = _BUS;
g_lstPath.push(node);
g_map_nd_path[org_nd].push_back(g_lstPath);
g_lstPath.pop(); //弹出母线
g_lstPath.pop(); //弹出其它设备
return;
}
//SEC
cnt = FindSEC(bf_sec, nd);
PSBOB::SEC *psec = (PSBOB::SEC*)bf_sec;
for (i = 0; i < cnt; i++, psec++)
{
if(!is_substn_dev(psec->ist_id) && !is_substn_dev(psec->jst_id)) continue;
if (std::find(g_lstFound.begin(), g_lstFound.end(), psec->id) == g_lstFound.end())
{
if (bDebug)
printf("PUSH->sec %-20ld[%-30s]%-20ld%-20ld[%-20ld]\r\n", psec->id, psec->name, psec->ind, psec->jnd, nd);
g_lstFound.push_back(psec->id);
memcpy(&node.data.sec, psec, sizeof(PSBOB::SEC));
node.type = _SEC;
if (nd == psec->ind)
{
Find(psec->jnd, org_nd, node);
}
else
{
Find(psec->ind, org_nd, node);
}
}
}
//CB
cnt = FindCB(bf_cb, nd);
PSBOB::CB *pcb = (PSBOB::CB*)bf_cb;
for (i = 0; i < cnt; i++, pcb++)
{
if(!is_substn_dev(pcb->st_id)) continue;
if (std::find(g_lstFound.begin(), g_lstFound.end(), pcb->id) == g_lstFound.end())
{
if (bDebug)
printf("PUSH->cb %-20ld[%-30s]%-20ld%-20ld[%-20ld]\r\n", pcb->id, pcb->name, pcb->ind, pcb->jnd, nd);
g_lstFound.push_back(pcb->id);
memcpy(&node.data.cb, pcb, sizeof(PSBOB::CB));
node.type = _CB;
if (nd == pcb->ind)
{
Find(pcb->jnd, org_nd, node);
}
else
{
Find(pcb->ind, org_nd, node);
}
}
}
//SWITCH
cnt = FindSWITCH(bf_switch, nd);
PSBOB::SWITCH *pswitch = (PSBOB::SWITCH*)bf_switch;
for (i = 0; i < cnt; i++, pswitch++)
{
if(!is_substn_dev(pswitch->st_id)) continue;
if (std::find(g_lstFound.begin(), g_lstFound.end(), pswitch->id) == g_lstFound.end())
{
if (bDebug)
printf("PUSH->swh %-20ld[%-30s]%-20ld%-20ld[%-20ld]\r\n", pswitch->id, pswitch->name, pswitch->ind, pswitch->jnd, nd);
g_lstFound.push_back(pswitch->id);
memcpy(&node.data.cb, pswitch, sizeof(PSBOB::SWITCH));
node.type = _SWITCH;
if (nd == pswitch->ind)
{
Find(pswitch->jnd, org_nd, node);
}
else
{
Find(pswitch->ind, org_nd, node);
}
}
}
if (bDebug)
{
if (g_lstPath.top().type == _BUS)
printf("POP->%ld[%s]\r\n", g_lstPath.top().data.bus.id, g_lstPath.top().data.bus.name);
else if (g_lstPath.top().type == _LD)
printf("POP->%ld[%s]\r\n", g_lstPath.top().data.ld.id, g_lstPath.top().data.ld.name);
else if (g_lstPath.top().type == _SWITCH)
printf("POP->%ld[%s]\r\n", g_lstPath.top().data.disconnector.id, g_lstPath.top().data.disconnector.name);
else if (g_lstPath.top().type == _CB)
printf("POP->%ld[%s]\r\n", g_lstPath.top().data.cb.id, g_lstPath.top().data.cb.name);
else
printf("POP->%ld[%s]\r\n", g_lstPath.top().data.sec.id, g_lstPath.top().data.sec.name);
}
g_lstPath.pop();
return;
}
//根据馈线首端节点ID建立映射
void build_map2()
{
char *buf = NULL;
int ret = GetTableRecs(const_cast<TB_DESCR*>(g_db_psbob->GetTB("subcontrolarea")), 1/*读取有效记录*/, &buf);
if (ret > 0)
{
int size = sizeof(PSBOB::DV);
int cnt = ret / size;
PSBOB::DV dv = { 0 };
for (int i = 0; i < cnt; i++)
{
while (g_lstPath.size() > 0)
{
g_lstPath.pop();
}
memcpy(&dv, buf + i * size, size);
if (HasMask(g_db_psbob->GetTB("subcontrolarea"), "dtype", dv.dtype , MENU_DV_TYPE_FD))
{
if (dv.nd_id > 0)
{
NODE data = { 0 };
data.type = _LD;
data.data.ld.nd = dv.nd_id;
TRACE("建立结点%ld与母线的映射关系…\r\n", dv.nd_id);
Find(dv.nd_id, dv.nd_id, data);
}
}
}
BufFree(buf);
}
}
//根据进线开关负荷建立映射
void build_map()
{
char *buf = NULL;
int ret = GetTableRecs(const_cast<TB_DESCR*>(g_db_psbob->GetTB("energyconsumer")), 1/*读取有效记录*/, &buf);
if (ret > 0)
{
int size = sizeof(PSBOB::LD);
int cnt = ret / size;
PSBOB::LD ld = { 0 };
PSBOB::ST st = { 0 };
for (int i = 0; i < cnt; i++)
{
while(g_lstPath.size() > 0)
{
g_lstPath.pop();
}
memcpy(&ld, buf + i * size, size);
if (GetRecByID(const_cast<TB_DESCR*>(g_db_psbob->GetTB("substation")), (char*) &ld.st_id, sizeof(st), (char*) &st) >= 0)
{
if(HasMask(g_db_psbob->GetTB("substation"), "st_type", st.st_type , MENU_FAC_TYPE_SUBSTN))
{
NODE data = { 0 };
data.type = _LD;
memcpy(&data.data.ld, &ld, size);
Find(ld.nd, ld.nd, data);
}
}
}
BufFree(buf);
}
}
/////////////////////////////////////////////////////////////////////
int ExecSQL(const char *sql)
{
#ifndef _FAST_DEBUG
//备机不写关系库
if (!IsMaster())
{
cout << "备机不写关系库！" << endl;
return 0;
}
#endif
cout << sql << endl;
pthread_mutex_lock(&oci_mutex);
int ret = g_oci->Exec_noBind(sql);
pthread_mutex_unlock(&oci_mutex);
usleep(50);
if (ret == OCI_ERROR)
{
cout << "\033[31m********************ExecSQL failed**************\033[0m" << endl;
}
return ret;
}
void splitstring(const char *str, const char ch, list<long> *plist)
{
assert(str != NULL && plist != NULL);
if(str == NULL || plist == NULL) return;
plist->clear();
const char *pstart = str;
const char *pend = NULL;
while(true)
{
pend = strchr(pstart, ch);
if(pend != NULL)
{
int len = pend- pstart;
char *tmp = new char[len + 1];
strncpy(tmp, pstart, len);
tmp[len] = 0;
if(tmp[0] != 0)
{
plist->push_back(atol(tmp));
}
pstart = pend + 1;
delete []tmp;
}
else
{
if(pstart[0] != 0)
{
plist->push_back(atol(pstart));
}
break;
}
}
}
bool DoConvert()
{
// char *buf = NULL;
// int rec_num, attr_num;
// struct ORA_ATTR *attrs = NULL;
//
// //////tianyq
// pthread_mutex_lock(&oci_mutex);
// int ret = g_oci->ReadWithBind("select id,zone_cb from fdir_fdirect", &buf, &rec_num, &attr_num, &attrs);
// pthread_mutex_unlock(&oci_mutex);
//
// if (ret != OCI_ERROR)
// {
// if (rec_num > 0)
// {
// int attr_len = 0;
//
// for (int j = 0; j < attr_num; j++)
// {
// attr_len += attrs[j].col_width;
// }
//
// char id[60], cb_id[500];
// int izone;
//
// for (int i = 0; i < rec_num; i++)
// {
//
// list<long> lst_cb;
//
// bzero(id, sizeof(id));
// bzero(cb_id, sizeof(cb_id));
//
// strncpy(id, buf + i * attr_len, attrs[0].col_width);
// strncpy(cb_id, buf + i * attr_len + attrs[0].col_width, attrs[1].col_width);
//
// splitstring(cb_id, ';', &lst_cb);
//
// izone = g_fdir_r->GetZoneByCB(lst_cb);
//
// if (izone >= 0)
// {
//
// list<int> lstfaultzone;
// list<FAULT_ITEM> devs;
//
// g_fdir_r->getlstfaultzone(izone, lstfaultzone);
// map<string, string> faultzone_cb;
// faultzone_cb.clear();
// for (list<int>::iterator list_it = lstfaultzone.begin(); list_it != lstfaultzone.end(); list_it++)
// {
// g_fdir_r->get_zone_devs((*list_it), devs);
//
// for (list<FAULT_ITEM>::iterator it = devs.begin(); it != devs.end(); it++)
// {
// if (strcmp(it->table.c_str(), "CB") == 0)
// {
// if (faultzone_cb.find(it->id) != faultzone_cb.end())
// {
// //设置边界开关
// printf("update FDIR_FAULT_DEV set edge = 0 where id = \'%s\' and dev_id = \'%s\';\r\n", id, it->id.c_str());
// }
// else
// {
// faultzone_cb[it->id] = "CB";
// printf("INSERT INTO FDIR_FAULT_DEV (ID, DEV_ID, DEV_TABLE, EDGE) VALUES (\'%s\', \'%s\', \'%s\', %d);\r\n", id, it->id.c_str(), it->table.c_str(), 1);
// }
// }
// else
// {
// printf("INSERT INTO FDIR_FAULT_DEV (ID, DEV_ID, DEV_TABLE, EDGE) VALUES (\'%s\', \'%s\', \'%s\', %d);\r\n", id, it->id.c_str(), it->table.c_str(), 0);
// }
//
// }
// }
//
// }
// }
// }
//
// g_oci->Readdata_Free();
// }
//
// //////tianyq
//
// pthread_mutex_lock(&oci_mutex);
// ret = g_oci->ReadWithBind("select id,cb_id,so_id from fhzg_zone", &buf, &rec_num, &attr_num, &attrs);
// pthread_mutex_unlock(&oci_mutex);
//
// if (ret != OCI_ERROR)
// {
// if (rec_num > 0)
// {
// int attr_len = 0;
//
// for (int j = 0; j < attr_num; j++)
// {
// attr_len += attrs[j].col_width;
// }
//
// char id[60], cb_id[500], so_id[50];
// int izone;
//
// for (int i = 0; i < rec_num; i++)
// {
//
// list<string> lst_cb;
//
// bzero(id, sizeof(id));
// bzero(cb_id, sizeof(cb_id));
// bzero(so_id, sizeof(so_id));
//
// strncpy(id, buf + i * attr_len, attrs[0].col_width);
// strncpy(cb_id, buf + i * attr_len + attrs[0].col_width, attrs[1].col_width);
// strncpy(so_id, buf + i * attr_len + attrs[0].col_width + attrs[1].col_width, attrs[2].col_width);
//
// strcat(cb_id, ";");
//
// splitstring(cb_id, ';', &lst_cb);
//
//// cout << cb_id << endl;
//
// izone = g_fdir_r->GetZoneByCB(lst_cb);
//
// if (izone >= 0)
// {
//
// list<FAULT_ITEM> devs;
//
// g_fdir_r->get_zone_devs(izone, devs);
//
// for (list<FAULT_ITEM>::iterator it = devs.begin(); it != devs.end(); it++)
// {
// printf("Insert into FHZG_ZONE(ID, IZONE, SO_ID, DEV_ID, DEV_TABLE, EDGE) Values(\'%s\', %d, \'%s\', \'%s\', \'%s\', 0);\r\n", id, izone, so_id, it->id.c_str(),
// it->table.c_str());
// }
// }
// }
// }
//
// g_oci->Readdata_Free();
// }
//
// pthread_mutex_lock(&oci_mutex);
// ret = g_oci->ReadWithBind("select id,cb_id,so_id from fhzg_so_zone", &buf, &rec_num, &attr_num, &attrs);
// pthread_mutex_unlock(&oci_mutex);
//
// if (ret != OCI_ERROR)
// {
// if (rec_num > 0)
// {
// int attr_len = 0;
//
// for (int j = 0; j < attr_num; j++)
// {
// attr_len += attrs[j].col_width;
// }
//
// char id[60], cb_id[500], so_id[50];
// int izone;
//
// for (int i = 0; i < rec_num; i++)
// {
//
// list<string> lst_cb;
//
// bzero(id, sizeof(id));
// bzero(cb_id, sizeof(cb_id));
// bzero(so_id, sizeof(so_id));
//
// strncpy(id, buf + i * attr_len, attrs[0].col_width);
// strncpy(cb_id, buf + i * attr_len + attrs[0].col_width, attrs[1].col_width);
// strncpy(so_id, buf + i * attr_len + attrs[0].col_width + attrs[1].col_width, attrs[2].col_width);
//
// if(strcmp(cb_id, "02200013860020;LSSCBL1441;LSSCBL1454;LSSCBL1491;LYLCBLL141") == 0)
// {
// sleep(0);
// }
// strcat(cb_id, ";");
//
// splitstring(cb_id, ';', &lst_cb);
//
//// cout << cb_id << endl;
//
// izone = g_fdir_r->GetZoneByCB(lst_cb);
//
// if (izone >= 0)
// {
//
// list<FAULT_ITEM> devs;
//
// g_fdir_r->get_zone_devs(izone, devs);
//
// for (list<FAULT_ITEM>::iterator it = devs.begin(); it != devs.end(); it++)
// {
// printf("Insert into fhzg_so_zone(ID, IZONE, SO_ID, DEV_ID, DEV_TABLE, EDGE) Values(\'%s\', %d, \'%s\', \'%s\', \'%s\', 0);\r\n", id, izone, so_id, it->id.c_str(),
// it->table.c_str());
// }
// }
// }
// }
//
// g_oci->Readdata_Free();
// }
//
//// pthread_mutex_lock(&oci_mutex);
//// ret = g_oci->ReadWithBind("select id,cb_id,so_id from fhzg_so_zone", &buf, &rec_num, &attr_num, &attrs);
//// pthread_mutex_unlock(&oci_mutex);
////
//// if (ret != OCI_ERROR)
//// {
//// if (rec_num > 0)
//// {
//// int attr_len = 0;
////
//// for (int j = 0; j < attr_num; j++)
//// {
//// attr_len += attrs[j].col_width;
//// }
////
//// char id[60], cb_id[500], so_id[50];
//// int izone;
////
//// for (int i = 0; i < rec_num; i++)
//// {
////
//// list<string> lst_cb;
////
//// bzero(id, sizeof(id));
//// bzero(cb_id, sizeof(cb_id));
//// bzero(so_id, sizeof(so_id));
////
//// strncpy(id, buf + i * attr_len, attrs[0].col_width);
//// strncpy(cb_id, buf + i * attr_len + attrs[0].col_width, attrs[1].col_width);
//// strncpy(so_id, buf + i * attr_len + attrs[0].col_width + attrs[1].col_width, attrs[2].col_width);
////
//// strcat(cb_id, ";");
////
//// splitstring(cb_id, ';', &lst_cb);
////
//// cout << cb_id << endl;
////
//// izone = g_fdir_r->GetZoneByCB(lst_cb);
////
//// if (izone >= 0)
//// {
////
//// list<FAULT_ITEM> devs;
////
//// g_fdir_r->get_zone_devs(izone, devs);
////
//// for (list<FAULT_ITEM>::iterator it = devs.begin(); it != devs.end(); it++)
//// {
//// printf("Insert into fhzg_so_zone(ID, IZONE, SO_ID, DEV_ID, DEV_TABLE, EDGE) Values(\'%s\', %d, \'%s\', \'%s\', \'%s\', 0);\r\n", id, izone, so_id, it->id.c_str(),
//// it->table.c_str());
//// }
//// }
//// }
//// }
////
//// g_oci->Readdata_Free();
//// }
//
//// pthread_mutex_lock(&oci_mutex);
//// ret = g_oci->ReadWithBind("select id from FDIR_FDIRECT group by id", &buf, &rec_num, &attr_num, &attrs);
//// pthread_mutex_unlock(&oci_mutex);
////
//// if (ret != OCI_ERROR)
//// {
//// if (rec_num > 0)
//// {
//// int attr_len = 0;
////
//// for (int j = 0; j < attr_num; j++)
//// {
//// attr_len += attrs[j].col_width;
//// }
////
//// char id[60], izone[10], so_id[50];
////
//// for (int i = 0; i < rec_num; i++)
//// {
//// bzero(id, sizeof(id));
////
//// strncpy(id, buf + i * attr_len, attrs[0].col_width);
////
//// printf("update FDIR_FAULT_DEV set edge = 1 where id = \'%s\' and dev_id in (select dev_id from (select dev_id,count(dev_id) as num from FDIR_FAULT_DEV where id = \'%s\' and dev_table='CB' group by dev_id) where num =1);\r\n", id, id);
//// }
//// }
////
//// g_oci->Readdata_Free();
//// }
//
// pthread_mutex_lock(&oci_mutex);
// ret = g_oci->ReadWithBind("select id,so_id from fhzg_zone group by id,so_id", &buf, &rec_num, &attr_num, &attrs);
// pthread_mutex_unlock(&oci_mutex);
//
// if (ret != OCI_ERROR)
// {
// if (rec_num > 0)
// {
// int attr_len = 0;
//
// for (int j = 0; j < attr_num; j++)
// {
// attr_len += attrs[j].col_width;
// }
//
// char id[60], izone[10], so_id[50];
//
// for (int i = 0; i < rec_num; i++)
// {
// bzero(id, sizeof(id));
// bzero(so_id, sizeof(so_id));
//
// strncpy(id, buf + i * attr_len, attrs[0].col_width);
// strncpy(so_id, buf + i * attr_len + attrs[0].col_width, attrs[1].col_width);
//
// printf(
// "update fhzg_zone set edge = 1 where id = \'%s\' and so_id = \'%s\' and dev_id in (select dev_id from (select dev_id,count(dev_id) as num from FHZG_ZONE where id = \'%s\' and so_id = \'%s\' and dev_table='CB' group by dev_id) where num =1);\r\n",
// id, so_id, id, so_id);
// }
// }
//
// g_oci->Readdata_Free();
// }
//
// pthread_mutex_lock(&oci_mutex);
// ret = g_oci->ReadWithBind("select id,so_id from fhzg_so_zone group by id,so_id", &buf, &rec_num, &attr_num, &attrs);
// pthread_mutex_unlock(&oci_mutex);
//
// if (ret != OCI_ERROR)
// {
// if (rec_num > 0)
// {
// int attr_len = 0;
//
// for (int j = 0; j < attr_num; j++)
// {
// attr_len += attrs[j].col_width;
// }
//
// char id[60], izone[10], so_id[50];
//
// for (int i = 0; i < rec_num; i++)
// {
// bzero(id, sizeof(id));
// bzero(so_id, sizeof(so_id));
//
// strncpy(id, buf + i * attr_len, attrs[0].col_width);
// strncpy(so_id, buf + i * attr_len + attrs[0].col_width, attrs[1].col_width);
//
// printf(
// "update fhzg_so_zone set edge = 1 where id = \'%s\' and so_id = \'%s\' and dev_id in (select dev_id from (select dev_id,count(dev_id) as num from fhzg_so_zone where id = \'%s\' and so_id = \'%s\' and dev_table='CB' group by dev_id) where num =1);\r\n",
// id, so_id, id, so_id);
// }
// }
//
// g_oci->Readdata_Free();
// }
//
return true;
}
//从关系库读取dv的damode配置信息
int GetDvDamode(long dv_id)
{
char *buf = NULL;
int rec_num, attr_num, fdir_mode;
struct ORA_ATTR *attrs = NULL;
sprintf(sql,"SELECT DAMODE FROM ems.subcontrolarea WHERE ID=\'%ld\'", dv_id);
TRACE("sql is %s\r\n",sql);
pthread_mutex_lock(&oci_mutex);
int ret = g_oci->ReadWithBind(sql, &buf, &rec_num, &attr_num, &attrs);
pthread_mutex_unlock(&oci_mutex);
if (ret != OCI_ERROR)
{
fdir_mode = -1;
if (rec_num > 0)
{
char tmp[100];
char *pbuf = buf;
memcpy(tmp, pbuf, attrs[0].col_width);
fdir_mode = *(int*)(tmp);
TRACE("the dv is %ld damode is %d\n", dv_id, fdir_mode);
g_oci->Readdata_Free();
}
return fdir_mode;
}
else
{
return -1;
}
}
/*
* 从关系库获取故障隔离恢复的配置信息
*/
bool GetFdirConfig(FDIR_CONFIG &config)
{
char *buf = NULL;
int rec_num, attr_num;
struct ORA_ATTR *attrs = NULL;
pthread_mutex_lock(&oci_mutex);
int ret = g_oci->ReadWithBind("SELECT FDIR_MODE, USER2AUTO, TIMEOUT_CONTROL, TIMEOUT_FAULT, TIMEOUT_PROTPNT, TIMEOUT_AUTO, SIMULATE, TIMEOUT_JD_BUS, OP_USER, OP_NODE FROM FDIR_CONFIG", &buf, &rec_num, &attr_num, &attrs);
pthread_mutex_unlock(&oci_mutex);
if (ret != OCI_ERROR)
{
if (rec_num > 0)
{
char tmp[100];
char *pbuf = buf;
bzero(tmp, sizeof(tmp));
bzero(&config, sizeof(config));
memcpy(tmp, pbuf, attrs[0].col_width);
config.FDIR_MODE = *(int*)tmp;
memcpy(tmp, pbuf += attrs[0].col_width, attrs[1].col_width);
config.USER2AUTO = *(int*)tmp;
memcpy(tmp, pbuf += attrs[1].col_width, attrs[2].col_width);
config.TIMEOUT_CONTROL = *(int*)tmp;
memcpy(tmp, pbuf += attrs[2].col_width, attrs[3].col_width);
config.TIMEOUT_FAULT = *(int*)tmp;
memcpy(tmp, pbuf += attrs[3].col_width, attrs[4].col_width);
config.TIMEOUT_PROTPNT = *(int*)tmp;
memcpy(tmp, pbuf += attrs[4].col_width, attrs[5].col_width);
config.TIMEOUT_AUTO = *(int*)tmp;
memcpy(tmp, pbuf += attrs[5].col_width, attrs[6].col_width);
config.SIMULATE = *(int*)tmp;
memcpy(tmp, pbuf += attrs[6].col_width, attrs[7].col_width);
config.TIMEOUT_JD_FAULT = *(int*)tmp;
memcpy(config.OP_USER, pbuf += attrs[7].col_width, attrs[8].col_width);
memcpy(config.OP_NODE, pbuf += attrs[8].col_width, attrs[9].col_width);
// printf("读取配置信息成功:%d, %d, %ds, %ds, %ds, %ds, %d, %d\r\n" ,config.FDIR_MODE, config.USER2AUTO
// , config.TIMEOUT_CONTROL, config.TIMEOUT_FAULT, config.TIMEOUT_PROTPNT, config.TIMEOUT_AUTO, config.SIMULATE, config.TIMEOUT_JD_FAULT);
}
else
{
TRACE(">>>>>>>>>>>>>>>>>关系库里无配置信息\r\n");
return false;
}
g_oci->Readdata_Free();
}
else
{
return false;
}
return true;
}
//判断一个开关是否在责任区内，在责任区内返回true,否则返回false
bool IsInRegion(MLang::Long cbid)
{
PSBOB::ST psbob_st = { 0 };
PSBOB::CB psbob_cb = { 0 };
if (oodbread_rk(&psbob_cb, &cbid, const_cast<TB_DESCR*>(g_db_psbob->GetTB("breaker")), sizeof(PSBOB::CB)) == OO_FAIL)
{
TRACE("读取id为%ld的开关记录失败\r\n", cbid);
return false;
}
if (oodbread_rk(&psbob_st, &psbob_cb.st_id, const_cast<TB_DESCR*>(g_db_psbob->GetTB("substation")), sizeof(PSBOB::ST)) == OO_FAIL)
{
TRACE("读取id为%ld的厂站记录失败\r\n", psbob_cb.st_id);
return false;
}
int ret = g_Priv.HasGivenRegion(g_FdirConfig.OP_USER, "", g_FdirConfig.OP_NODE, psbob_st.name, "st", 0);
return ret == P_NORMAL;
}
//判断主备机，主机返回true，备机返回false
bool IsMaster()
{
if(version == VERSION_STUDY)
{
return true;
}
//D5000判断主备机
CServicesManage sermanager;
COdbSystem odbsystem;
#ifdef _SCADA
return sermanager.IsOnDuty(odbsystem.GetAppNoByName("scada_dms")) != 0;
#else
return sermanager.IsOnDuty(odbsystem.GetAppNoByName("dscada_dms")) != 0;
#endif
}
void abrt(int param)
{
cout << "程序即将退出…" << param << endl;
cout << "进程ID：" << getpid() << endl;
//g_bob2->WriteReDB(NULL, NULL, NULL);
delete g_db_dms;
delete g_db_fdir;
delete g_db_psbob;
rte_disconnect();
delete bob_inv;
delete proc_inv;
// if (bob_inv != NULL)
// {
//// bob_inv->bob_exit();
//
// delete bob_inv;
// bob_inv = NULL;
// }
exit(0);
}
//清除关系库指定故障的数据
void ClearFdirDB(const char *group_id)
{
if (!IsMaster())
{
cout << "备机不写关系库！" << endl;
return;
}
Notify(group_id, 0, 0, 0);
assert(group_id != NULL);
sprintf(sql,"PMS_PARAM.FIN_HIS(\'%s\')",group_id);
ExecSQL(sql);
}
bool FormFdirStep(const char *group_id)
{
assert(group_id != NULL);
char *buf = NULL;
int rec_num, attr_num;
struct ORA_ATTR *attrs = NULL;
int pnt_column = GetPntIDColumn();
int istep = 1, i;
list<string> lst_fault_id, lst_manual_restore;
char cb_id[MAX_CB_ID_LEN + 10];
list<string>::iterator it;
char machine[100];
gethostname(machine, sizeof(machine));
sprintf(sql, "delete from fdir_step where id=\'%s\' and status=%d", group_id, STATUS_FDIR_STEP_WAIT);
ExecSQL(sql);
sprintf(sql, "select step from fdir_step where id=\'%s\'order by step desc", group_id);
pthread_mutex_lock(&oci_mutex);
int ret = g_oci->ReadWithBind(sql, &buf, &rec_num, &attr_num, &attrs);
pthread_mutex_unlock(&oci_mutex);
cout << sql << endl;
if (ret != OCI_ERROR)
{
if(rec_num > 0)
{
char step[50];
bzero(step, sizeof(step));
memcpy(step, buf, attrs[0].col_width);
istep = *(int*)step + 1;
}
else
{
istep = 1;
}
g_oci->Readdata_Free();
}
else
{
istep = 1;
}
sprintf(sql, "update fdir_fdirect set userid=\'%s\',machine=\'%s\' where groupid=\'%s\'", userid, machine, group_id);
ExecSQL(sql);
sprintf(sql, "select id,manual_restore from fdir_fdirect where groupid=\'%s\'", group_id);
pthread_mutex_lock(&oci_mutex);
ret = g_oci->ReadWithBind(sql, &buf, &rec_num, &attr_num, &attrs);
pthread_mutex_unlock(&oci_mutex);
cout << sql << endl;
if (ret != OCI_ERROR)
{
for (i = 0; i < rec_num; i++)
{
char fault_id[100], manual_restore[1000];
bzero(fault_id, sizeof(fault_id));
bzero(manual_restore, sizeof(manual_restore));
memcpy(fault_id, buf + i * (attrs[0].col_width + attrs[1].col_width), attrs[0].col_width);
memcpy(manual_restore, buf + i * (attrs[0].col_width + attrs[1].col_width) + attrs[0].col_width, attrs[1].col_width);
lst_fault_id.push_back(fault_id);
if (manual_restore[0] != 0)
{
char *p1, *p2;
p1 = p2 = manual_restore;
while ((p2 = strchr(p1, ';')) != NULL)
{
bzero(cb_id, sizeof(cb_id));
memcpy(cb_id, p1, p2 - p1);
if((p1 = strstr(cb_id, "[0]")) != NULL)
{
*p1 = 0;
lst_manual_restore.push_back(cb_id);
}
p1 = p2 + 1;
}
}
}
g_oci->Readdata_Free();
}
//插入隔离步骤到方案表
char Temp[1024] = { 0 };
for (it = lst_fault_id.begin(); it != lst_fault_id.end(); it++)
{
if (it == lst_fault_id.begin())
{
strcat(Temp, "id=\'");
}
else
{
strcat(Temp, "or id=\'");
}
strcat(Temp, it->c_str());
strcat(Temp, "\' ");
}
sprintf(sql, "update fdir_isolate set userid=\'%s\',machine=\'%s\' where (%s) and ctrl_type=0", userid, machine, Temp);
ExecSQL(sql);
sprintf(sql, "select cb from fdir_isolate where (%s) and ctrl_type=0 order by id,step asc", Temp);
cout << sql << endl;
pthread_mutex_lock(&oci_mutex);
ret = g_oci->ReadWithBind(sql, &buf, &rec_num, &attr_num, &attrs);
pthread_mutex_unlock(&oci_mutex);
// cout << sql << endl;
if (ret != OCI_ERROR)
{
for (i = 0; i < rec_num; i++)
{
bzero(cb_id, sizeof(cb_id));
memcpy(cb_id, buf + i * attrs[0].col_width, attrs[0].col_width);
long id = *(long*) cb_id;
KEY_STRU ks = { 0 };
CCommon::long_to_keyid(id, &ks);
ks.field_id = pnt_column;
unsigned long pt_id = 0;
CCommon::keyid_to_long(&ks, &pt_id);
sprintf(sql, "Insert into FDIR_STEP (ID, CB_ID, OPERATION, STEP, STATUS, CONTROL, STAGE) Values(\'%s\', \'%ld\', %d, %d, 0, %d, %d)", group_id, pt_id, 2, istep, 1, 1);
ExecSQL(sql);
istep++;
}
g_oci->Readdata_Free();
}
//插入转供步骤
sprintf(sql, "select cb_id, operation, so_id, control from FHZG_STEP where id=\'%s_0\' order by step asc", group_id);
cout << sql << endl;
pthread_mutex_lock(&oci_mutex);
ret = g_oci->ReadWithBind(sql, &buf, &rec_num, &attr_num, &attrs);
pthread_mutex_unlock(&oci_mutex);
// cout << sql << endl;
if (ret != OCI_ERROR)
{
for (i = 0; i < rec_num; i++)
{
char /*cb_id[100], */operation[100], so_id[100], control[100];
bzero(cb_id, sizeof(cb_id));
bzero(operation, sizeof(cb_id));
bzero(so_id, sizeof(so_id));
bzero(control, sizeof(control));
memcpy(cb_id, buf + i * (attrs[0].col_width + attrs[1].col_width + attrs[2].col_width + attrs[3].col_width), attrs[0].col_width);
memcpy(operation, buf + i * (attrs[0].col_width + attrs[1].col_width + attrs[2].col_width + attrs[3].col_width) + attrs[0].col_width, attrs[1].col_width);
memcpy(so_id, buf + i * (attrs[0].col_width + attrs[1].col_width + attrs[2].col_width + attrs[3].col_width) + attrs[0].col_width + attrs[1].col_width, attrs[2].col_width);
memcpy(control, buf + i * (attrs[0].col_width + attrs[1].col_width + attrs[2].col_width + attrs[3].col_width) + attrs[0].col_width + attrs[1].col_width + attrs[2].col_width,
attrs[3].col_width);
long id = *(long*) cb_id;
KEY_STRU ks = { 0 };
CCommon::long_to_keyid(id, &ks);
ks.field_id = pnt_column;
unsigned long pt_id = 0;
CCommon::keyid_to_long(&ks, &pt_id);
sprintf(sql, "Insert into FDIR_STEP (ID, CB_ID, OPERATION, STEP, STATUS, CONTROL, STAGE) Values(\'%s\', \'%ld\', %d, %d, 0, %d, %d)", group_id, pt_id, *(int*)operation == 1 ? 2 : 1, istep,
*(int*)control, so_id[0] == 0 ? 3 : 4);
ExecSQL(sql);
istep++;
}
g_oci->Readdata_Free();
}
//插入恢复步骤
for (it = lst_manual_restore.begin(); it != lst_manual_restore.end(); it++)
{
long id = atol(it->c_str());
KEY_STRU ks = { 0 };
CCommon::long_to_keyid(id, &ks);
ks.field_id = pnt_column;
unsigned long pt_id = 0;
CCommon::keyid_to_long(&ks, &pt_id);
sprintf(sql, "Insert into FDIR_STEP (ID, CB_ID, OPERATION, STEP, STATUS, CONTROL, STAGE) Values(\'%s\', \'%ld\', %d, %d, 0, %d, %d)", group_id, pt_id, 1, istep, 1, 5);
ExecSQL(sql);
istep++;
}
//更新fhzg_so中的select_status为1
sprintf(sql, "update fhzg_so set select_status=1 where id=\'%s_0\'", group_id);
ExecSQL(sql);
UpdateExtStatus(group_id);
return true;
}
void UpdateExtStatus(const char *group_id)
{
assert(group_id != NULL);
int cnt_total, cnt_wait, cnt_exec, cnt_succeed, cnt_failed;
char status[100];
char *buf = NULL;
int rec_num, attr_num;
struct ORA_ATTR *attrs = NULL;
list<string> lst_point; //该组故障中跳闸的开关
//更新隔离状态
sprintf(sql, "SELECT STATUS FROM FDIR_STEP WHERE ID=\'%s\' AND (STAGE=%d OR STAGE=%d) AND CONTROL=1", group_id, STAGE_FDIR_STEP_ISOLATE, STAGE_FDIR_STEP_RE_ISOLATE);
cout << sql << endl;
pthread_mutex_lock(&oci_mutex);
int ret = g_oci->ReadWithBind(sql, &buf, &rec_num, &attr_num, &attrs);
pthread_mutex_unlock(&oci_mutex);
if (ret != OCI_ERROR)
{
cnt_total = rec_num;
cnt_wait = cnt_exec = cnt_succeed = cnt_failed = 0;
for (int i = 0; i < rec_num; i++)
{
bzero(status, sizeof(status));
memcpy(status, buf + i * attrs[0].col_width, attrs[0].col_width);
switch (*(int*)status)
{
case STATUS_FDIR_STEP_WAIT:
cnt_wait++;
break;
case STATUS_FDIR_STEP_EXEC:
cnt_exec++;
break;
case STATUS_FDIR_STEP_FAIL:
cnt_failed++;
break;
case STATUS_FDIR_STEP_PASS:
case STATUS_FDIR_STEP_OK:
cnt_succeed++;
break;
default:
break;
}
}
g_oci->Readdata_Free();
printf("cnt_total:%d, cnt_wait:%d, cnt_exec:%d, cnt_succeed:%d, cnt_failed:%d\r\n", cnt_total, cnt_wait, cnt_exec, cnt_succeed, cnt_failed);
if (cnt_total <= 0)
{
sprintf(sql, "UPDATE FDIR_FDIRECT SET STATUS_ISOLATE=%d WHERE GROUPID=\'%s\'", -1, group_id);
}
else
{
if (cnt_wait > 0 || cnt_exec > 0)
{
sprintf(sql, "UPDATE FDIR_FDIRECT SET STATUS_ISOLATE=%d WHERE GROUPID=\'%s\'", EXT_STATUS_FDIRECT_WAIT, group_id);
}
else
{
if (cnt_failed > 0)
{
sprintf(sql, "UPDATE FDIR_FDIRECT SET STATUS_ISOLATE=%d WHERE GROUPID=\'%s\'", EXT_STATUS_FDIRECT_RECALC, group_id);
}
else
{
sprintf(sql, "UPDATE FDIR_FDIRECT SET STATUS_ISOLATE=%d WHERE GROUPID=\'%s\'", EXT_STATUS_FDIRECT_SUCCEED, group_id);
}
}
}
ExecSQL(sql);
}
else
{
}
//更新转供状态
sprintf(sql, "SELECT STATUS FROM FDIR_STEP WHERE ID=\'%s\' AND (STAGE=%d OR STAGE=%d) AND CONTROL=1", group_id, STAGE_FDIR_STEP_CUT_LD, STAGE_FDIR_STEP_TRANSFER);
cout << sql << endl;
pthread_mutex_lock(&oci_mutex);
ret = g_oci->ReadWithBind(sql, &buf, &rec_num, &attr_num, &attrs);
pthread_mutex_unlock(&oci_mutex);
if (ret != OCI_ERROR)
{
cnt_total = rec_num;
cnt_wait = cnt_exec = cnt_succeed = cnt_failed = 0;
for (int i = 0; i < rec_num; i++)
{
bzero(status, sizeof(status));
memcpy(status, buf + i * attrs[0].col_width, attrs[0].col_width);
switch (*(int*)status)
{
case STATUS_FDIR_STEP_WAIT:
cnt_wait++;
break;
case STATUS_FDIR_STEP_EXEC:
cnt_exec++;
break;
case STATUS_FDIR_STEP_FAIL:
cnt_failed++;
break;
case STATUS_FDIR_STEP_PASS:
case STATUS_FDIR_STEP_OK:
cnt_succeed++;
break;
default:
break;
}
}
g_oci->Readdata_Free();
printf("cnt_total:%d, cnt_wait:%d, cnt_exec:%d, cnt_succeed:%d, cnt_failed:%d\r\n", cnt_total, cnt_wait, cnt_exec, cnt_succeed, cnt_failed);
if (cnt_total <= 0)
{
sprintf(sql, "UPDATE FDIR_FDIRECT SET STATUS_FHZG=%d WHERE GROUPID=\'%s\'", -1, group_id);
}
else
{
if (cnt_wait > 0 || cnt_exec > 0)
{
sprintf(sql, "UPDATE FDIR_FDIRECT SET STATUS_FHZG=%d WHERE GROUPID=\'%s\'", EXT_STATUS_FDIRECT_WAIT, group_id);
}
else
{
if (cnt_failed > 0)
{
sprintf(sql, "UPDATE FDIR_FDIRECT SET STATUS_FHZG=%d WHERE GROUPID=\'%s\'", EXT_STATUS_FDIRECT_RECALC, group_id);
}
else
{
sprintf(sql, "UPDATE FDIR_FDIRECT SET STATUS_FHZG=%d WHERE GROUPID=\'%s\'", EXT_STATUS_FDIRECT_SUCCEED, group_id);
}
}
}
ExecSQL(sql);
}
else
{
}
//更新恢复上游开关状态
sprintf(sql, "SELECT STATUS FROM FDIR_STEP WHERE ID=\'%s\' AND STAGE=%d AND CONTROL=1", group_id, STAGE_FDIR_STEP_RESTORE);
cout << sql << endl;
pthread_mutex_lock(&oci_mutex);
ret = g_oci->ReadWithBind(sql, &buf, &rec_num, &attr_num, &attrs);
pthread_mutex_unlock(&oci_mutex);
if (ret != OCI_ERROR)
{
cnt_total = rec_num;
cnt_wait = cnt_exec = cnt_succeed = cnt_failed = 0;
for (int i = 0; i < rec_num; i++)
{
bzero(status, sizeof(status));
memcpy(status, buf + i * attrs[0].col_width, attrs[0].col_width);
switch (*(int*)status)
{
case STATUS_FDIR_STEP_WAIT:
cnt_wait++;
break;
case STATUS_FDIR_STEP_EXEC:
cnt_exec++;
break;
case STATUS_FDIR_STEP_FAIL:
cnt_failed++;
break;
case STATUS_FDIR_STEP_PASS:
case STATUS_FDIR_STEP_OK:
cnt_succeed++;
break;
default:
break;
}
}
g_oci->Readdata_Free();
printf("cnt_total:%d, cnt_wait:%d, cnt_exec:%d, cnt_succeed:%d, cnt_failed:%d\r\n", cnt_total, cnt_wait, cnt_exec, cnt_succeed, cnt_failed);
if (cnt_total <= 0)
{
sprintf(sql, "UPDATE FDIR_FDIRECT SET STATUS_RESTORE=%d WHERE GROUPID=\'%s\'", -1, group_id);
}
else
{
if (cnt_wait > 0 || cnt_exec > 0)
{
sprintf(sql, "UPDATE FDIR_FDIRECT SET STATUS_RESTORE=%d WHERE GROUPID=\'%s\'", EXT_STATUS_FDIRECT_WAIT, group_id);
}
else
{
if (cnt_failed > 0)
{
sprintf(sql, "UPDATE FDIR_FDIRECT SET STATUS_RESTORE=%d WHERE GROUPID=\'%s\'", EXT_STATUS_FDIRECT_RECALC, group_id);
}
else
{
sprintf(sql, "UPDATE FDIR_FDIRECT SET STATUS_RESTORE=%d WHERE GROUPID=\'%s\'", EXT_STATUS_FDIRECT_SUCCEED, group_id);
}
}
}
g_oci->Readdata_Free();
ExecSQL(sql);
}
else
{
}
}
//遥控成功
bool ControlSucceed(const char *group_id, const long point_name, const int stage, bool jxcb)
{
assert(group_id != NULL);
TRACE("故障组%s遥控%ld成功！\r\n", group_id, point_name);
KEY_STRU ks = {0};
CCommon::long_to_keyid(point_name, &ks);
ks.field_id = (ks.field_id == 0 ? 40 : 0);
MLang::ULong uid = 0;
CCommon::keyid_to_long(&ks, &uid);
//写成功状态到库
switch (stage)
{
case STAGE_FDIR_STEP_ISOLATE:
{
MLang::ULong dev_id;
ks.field_id = 0;
CCommon::keyid_to_long(&ks, &dev_id);
if (AddToken(group_id, dev_id, 0) < 0)
{
TRACE("为故障%s的隔离开关%ld挂牌失败！\r\n", group_id, point_name);
}
sprintf(sql, "update FDIR_ISOLATE set status=%d where id=\'%s\' and (cb=\'%ld\' or cb=\'%ld\') and ctrl_type=0", STATUS_ISOLATE_OK, group_id, point_name, uid);
ExecSQL(sql);
if (!jxcb)
{
//更新开关状态，校验时需要
sprintf(sql, "update FDIR_CB_STATUS set status=%d where id=\'%s\' and (pt_id=\'%ld\' or pt_id=\'%ld\')", 0, group_id, point_name, uid);
ExecSQL(sql);
}
break;
}
case STAGE_FDIR_STEP_RE_ISOLATE:
{
sprintf(sql, "update FDIR_ISOLATE set status=%d where id=\'%s\' and (cb=\'%ld\' or cb=\'%ld\') and ctrl_type=0", STATUS_ISOLATE_OK, group_id, point_name, uid);
ExecSQL(sql);
if (!jxcb)
{
//更新开关状态，校验时需要
sprintf(sql, "update FDIR_CB_STATUS set status=%d where id=\'%s\' and (pt_id=\'%ld\' or pt_id=\'%ld\')", 0, group_id, point_name, uid);
ExecSQL(sql);
}
break;
}
case STAGE_FDIR_STEP_CUT_LD:
{
sprintf(sql, "update FHZG_STEP set status=%d where id like \'%s%%\' and (cb_id=\'%ld\' or cb_id=\'%ld\')", STATUS_FDIR_STEP_OK, group_id, point_name, uid);
ExecSQL(sql);
if (!jxcb)
{
//更新开关状态，校验时需要
sprintf(sql, "update FDIR_CB_STATUS set status=%d where id=\'%s\' and (pt_id=\'%ld\' or pt_id=\'%ld\')", 0, group_id, point_name, uid);
ExecSQL(sql);
}
break;
}
case STAGE_FDIR_STEP_TRANSFER:
{
sprintf(sql, "update FHZG_STEP set status=%d where id like \'%s%%\' and (cb_id=\'%ld\' or cb_id=\'%ld\')", STATUS_FDIR_STEP_OK, group_id, point_name, uid);
ExecSQL(sql);
if (!jxcb)
{
//更新开关状态，校验时需要
sprintf(sql, "update FDIR_CB_STATUS set status=%d where id=\'%s\' and (pt_id=\'%ld\' or pt_id=\'%ld\')", 1, group_id, point_name, uid);
ExecSQL(sql);
}
break;
}
case STAGE_FDIR_STEP_RESTORE:
{
sprintf(sql, "update FHZG_STEP set status=%d where id like \'%s%%\' and (cb_id=\'%ld\' or cb_id=\'%ld\')", STATUS_FDIR_STEP_OK, group_id, point_name, uid);
ExecSQL(sql);
if (!jxcb)
{
//更新开关状态，校验时需要
sprintf(sql, "update FDIR_CB_STATUS set status=%d where id=\'%s\' and (pt_id=\'%ld\' or pt_id=\'%ld\')", 1, group_id, point_name, uid);
ExecSQL(sql);
}
sprintf(sql, "update fdir_fdirect set manual_restore=replace(manual_restore,\'%ld[0]\',\'%ld[3]\') where groupid =\'%s\' and (manual_restore like \'%%%ld[_]%%\' or manual_restore like \'%%%ld[_]%%\')", uid, uid, group_id,
point_name, uid);
ExecSQL(sql);
sprintf(sql, "update fdir_fdirect set manual_restore=replace(manual_restore,\'%ld[1]\',\'%ld[3]\') where groupid =\'%s\' and (manual_restore like \'%%%ld[_]%%\' or manual_restore like \'%%%ld[_]%%\')", uid, uid, group_id,
point_name, uid);
ExecSQL(sql);
break;
}
default:
break;
}
sprintf(sql, "update FDIR_STEP set status=%d,endtime=sysdate where id=\'%s\' and (cb_id=\'%ld\' or cb_id=\'%ld\') and stage=%d and status=%d", STATUS_FDIR_STEP_OK, group_id, point_name, uid, stage, STATUS_FDIR_STEP_EXEC);
ExecSQL(sql);
UpdateExtStatus(group_id);
return true;
}
extern stack<NODE> get_virtual_path(long nd);
//遥控失败
bool ControlFailed(const char *group_id, const long point_name/*D5000后面的%s要改为%ld*/, const int stage)
{
cout << __FUNCTION__ << endl;
assert(group_id != NULL);
KEY_STRU ks = { 0 };
CCommon::long_to_keyid(point_name, &ks);
ks.field_id = (ks.field_id == 0 ? 40 : 0);
MLang::ULong uid = 0;
CCommon::keyid_to_long(&ks, &uid);
//合上游跳闸失败不用重新计算方案
if (stage < STAGE_FDIR_STEP_RESTORE)
{
int i;
//查询出该组故障的故障跳闸开关，获取开关的最新状态，并将跳闸开关设置为合闸
char *buf = NULL;
int rec_num, attr_num;
struct ORA_ATTR *attrs = NULL;
list<long> lst_point; //该组故障中跳闸的开关
list<long> lst_up_point;//故障上游的主干开关
list<FAULT_ITEM> lst_cb_item;
sprintf(sql, "SELECT RECV_POINT FROM FDIR_FDIRECT WHERE GROUPID=\'%s\'", group_id);
pthread_mutex_lock(&oci_mutex);
int ret = g_oci->ReadWithBind(sql, &buf, &rec_num, &attr_num, &attrs);
pthread_mutex_unlock(&oci_mutex);
cout << sql << endl;
if (ret != OCI_ERROR)
{
if (rec_num > 0)
{
for (i = 0; i < rec_num; i++)
{
char recv_point[1000];
bzero(recv_point, sizeof(recv_point));
memcpy(recv_point, buf + i * attrs[0].col_width, attrs[0].col_width);
cout << recv_point << endl;
char *pbuf1, *pbuf2; // = recv_point;
pbuf1 = pbuf2 = recv_point;
while ((pbuf2 = strchr(pbuf1, ';')) != NULL)
{
char cb[MAX_CB_ID_LEN + 5] = { 0 };
bzero(cb, sizeof(cb));
memcpy(cb, pbuf1, pbuf2 - pbuf1);
char *pTemp = strstr(cb, "[CB]");
if (pTemp != NULL)
{
*pTemp = 0;
lst_point.push_back(atol(cb));
cout << "读取到跳闸开关：" << cb << endl;
}
pbuf1 = pbuf2 + 1;
}
}
}
g_oci->Readdata_Free();
}
else
{
return false;
}
//如果故障所在馈线的上游主干开关变化，合主干变化的开关
sprintf(sql, "SELECT PT_ID FROM FDIR_CB_STATUS WHERE ID=\'%s\' AND ISFAULTUP=1 AND STATUS=0", group_id);
pthread_mutex_lock(&oci_mutex);
ret = g_oci->ReadWithBind(sql, &buf, &rec_num, &attr_num, &attrs);
pthread_mutex_unlock(&oci_mutex);
cout << sql << endl;
if (ret != OCI_ERROR)
{
if (rec_num > 0)
{
for (i = 0; i < rec_num; i++)
{
long cb;
cb = *(long*)(buf + i * attrs[0].col_width);
// memcpy(recv_point, buf + i * attrs[0].col_width, attrs[0].col_width);
// strncpy(cb, buf + i * attrs[0].col_width, attrs[0].col_width);
cout << cb << endl;
lst_up_point.push_back(cb);
}
}
g_oci->Readdata_Free();
}
else
{
return false;
}
int lv_cb = g_bob->cb_tb->GetCount();
CLS_CB *cb = g_bob->cb_tb->GetTable();
for (i = 0; i < lv_cb; i++)
{
if (cb->q & CB_VIRTUAL)
{
if (get_virtual_path(cb->nd).size() > 0)
{
cb->q &= ~CB_OPEN;
}
else
{
cb->q |= CB_OPEN;
}
}
else
{
PSBOB::CB psbob_cb = { 0 };
//读取开关对应的遥信信息 oodbread_ap为逻辑读属性 idigital为开关测点号
if (oodbread_rk(&psbob_cb, &(cb + i)->pid, const_cast<TB_DESCR*>(g_db_psbob->GetTB("breaker")), sizeof(psbob_cb)) == OO_FAIL)
{
TRACE("读取开关%ld记录失败\r\n", (cb + i)->pid);
return false;
}
(cb + i)->q &= ~CB_OPEN;
if (psbob_cb.point == 0)
(cb + i)->q |= CB_OPEN;
}
for (list<long>::iterator it = lst_point.begin(); it != lst_point.end(); it++)
{
if (g_bob->cb_tb->Data[i].pid == *it)
{
if ((cb + i)->q & CB_OPEN)
{
printf("合跳闸开关，cb:%ld, pointid:%s, point_name:%ld\r\n", (cb + i)->id, (cb + i)->descr, *it);
(cb + i)->q &= ~CB_OPEN;
lst_cb_item.push_back(FAULT_ITEM(*it, g_bob->cb_tb->Data[i].pid, "CB", g_bob->cb_tb->Data[i].descr));
break;
}
}
}
for (list<long>::iterator it_point = lst_up_point.begin(); it_point != lst_up_point.end(); it_point++)
{
if (g_bob->cb_tb->Data[i].pid == *it_point)
{
printf("合故障上游主干线开关，cb:%ld, pointid:%s, point_name:%ld\r\n", (cb + i)->id, (cb + i)->descr, *it_point);
(cb + i)->q &= ~CB_OPEN;
break;
}
}
}
//把计算失败的故障树重新建立
RecoTaskItem(group_id);
//设置失败的故障为待重新计算方案状态
for (FDIR_TASK_LIST::iterator it = g_lstTask.begin(); it != g_lstTask.end(); it++)
{
if (it->rq_type == TASK_TYPE_FAULT)
{
if (strcmp(it->task_data.fault.head.group_id, group_id) == 0)
{
it->task_data.fault.fdir_r->lst_point = lst_cb_item;
it->task_data.fault.next_step = TASK_FAULT_STATUS_RE_CALC;
it->task_data.fault.fail_point = point_name;
//更新FDIR_R对象fdir_cb里开关的状态
CLS_FDIR_CB *fdir_cb = it->task_data.fault.fdir_r->fdir_cb_tb->GetTable();
for (i = 0; i < lv_cb; i++)
{
if ((cb + i)->q & CB_OPEN)
{
(fdir_cb + i)->topflags |= FDIR_CB_OPEN0;
(fdir_cb + i)->topflags |= FDIR_CB_OPEN;
}
else
{
(fdir_cb + i)->topflags &= ~FDIR_CB_OPEN0;
(fdir_cb + i)->topflags &= ~FDIR_CB_OPEN;
}
}
// it->task_data.fault.fdir_r->lst_failed.push_back(point_name);
}
}
}
}
else
{
for (FDIR_TASK_LIST::iterator it = g_lstTask.begin(); it != g_lstTask.end(); it++)
{
if (it->rq_type == TASK_TYPE_FAULT)
{
if (strcmp(it->task_data.fault.head.group_id, group_id) == 0)
{
//删除上游需要恢复的区域
sprintf(sql, "DELETE FROM FDIR_UP_ZONE WHERE ID LIKE \'%s%%\'", it->task_data.fault.head.group_id);
ExecSQL(sql);
break;
}
}
}
}
//写失败状态到库
switch (stage)
{
case STAGE_FDIR_STEP_ISOLATE:
{
sprintf(sql, "update FDIR_FDIRECT set status=%d,status_isolate=%d where groupid=\'%s\'", STATUS_FDIRECT_RE_ISO, EXT_STATUS_FDIRECT_FAILED, group_id);
ExecSQL(sql);
sprintf(sql, "update FDIR_ISOLATE set status=%d where id=\'%s\' and (cb=\'%ld\' or cb=\'%ld\') and ctrl_type=0", STATUS_ISOLATE_FAIL, group_id, point_name, uid);
ExecSQL(sql);
break;
}
case STAGE_FDIR_STEP_RE_ISOLATE:
{
sprintf(sql, "update FDIR_FDIRECT set status=%d,status_isolate=%d where groupid=\'%s\'", STATUS_FDIRECT_RE_ISO, EXT_STATUS_FDIRECT_FAILED, group_id);
ExecSQL(sql);
sprintf(sql, "update FDIR_ISOLATE set status=%d where id=\'%s\' and (cb=\'%ld\' or cb=\'%ld\') and ctrl_type=0", STATUS_ISOLATE_FAIL, group_id, point_name, uid);
ExecSQL(sql);
break;
}
case STAGE_FDIR_STEP_CUT_LD:
{
sprintf(sql, "update FDIR_FDIRECT set status=%d,status_fhzg=%d where groupid=\'%s\'", STATUS_FDIRECT_RE_TRANSFER, EXT_STATUS_FDIRECT_FAILED, group_id);
ExecSQL(sql);
sprintf(sql, "update FHZG_STEP set status=%d where id like \'%s%%\' and (cb_id=\'%ld\' or cb_id=\'%ld\')", STATUS_FDIR_STEP_FAIL, group_id, point_name, uid);
ExecSQL(sql);
break;
}
case STAGE_FDIR_STEP_TRANSFER:
{
sprintf(sql, "update FHZG_STEP set status=%d where id like \'%s%%\' and (cb_id=\'%ld\' or cb_id=\'%ld\')", STATUS_FDIR_STEP_FAIL, group_id, point_name, uid);
ExecSQL(sql);
sprintf(sql, "update FDIR_FDIRECT set status=%d,status_fhzg=%d where groupid=\'%s\'", STATUS_FDIRECT_RE_TRANSFER, EXT_STATUS_FDIRECT_FAILED, group_id);
ExecSQL(sql);
break;
}
case STAGE_FDIR_STEP_RESTORE:
{
sprintf(sql, "update FHZG_STEP set status=%d where id like \'%s%%\' and (cb_id=\'%ld\' or cb_id=\'%ld\')", STATUS_FDIR_STEP_FAIL, group_id, point_name, uid);
ExecSQL(sql);
sprintf(sql, "update fdir_fdirect set status_restore=%d where groupid =\'%s\'", EXT_STATUS_FDIRECT_FAILED, group_id);
ExecSQL(sql);
sprintf(sql, "update fdir_fdirect set manual_restore=replace(manual_restore,\'%ld[0]\',\'%ld[2]\') where groupid =\'%s\' and (manual_restore like \'%%%ld[_]%%\' or manual_restore like \'%%%ld[_]%%\')"
, uid, uid, group_id, point_name, uid);
ExecSQL(sql);
sprintf(sql, "update fdir_fdirect set manual_restore=replace(manual_restore,\'%ld[1]\',\'%ld[2]\') where groupid =\'%s\' and (manual_restore like \'%%%ld[_]%%\' or manual_restore like \'%%%ld[_]%%\')"
, uid, uid, group_id, point_name, uid);
ExecSQL(sql);
break;
}
default:
break;
}
sprintf(sql, "update FDIR_STEP set status=%d,endtime=sysdate where id=\'%s\' and (cb_id=\'%ld\' or cb_id=\'%ld\') and stage=%d and status=%d", STATUS_FDIR_STEP_FAIL, group_id, point_name, uid, stage, STATUS_FDIR_STEP_EXEC);
ExecSQL(sql);
return true;
}
//往任务列表中添加遥控等待项
bool AddReturnControl(const char *group_id, const long point_name, const bool bOpen, const int stage)
{
assert(group_id != NULL && point_name > 0);
FDIR_TASK data_task;
//bzero(&data_task, sizeof(data_task));
data_task.rq_type = TASK_TYPE_CB_CTRL;
gettimeofday(&data_task.tv_creat, NULL);
data_task.task_data.control.head.type = 0;
data_task.task_data.control.head.size = sizeof(FDIR_TASK_DATA_CONTROL);
strcpy(data_task.task_data.control.head.group_id, group_id);
data_task.task_data.control.status = TASK_CTL_STATUS_RUN;
data_task.task_data.control.bLast = false;
data_task.task_data.control.point_name = point_name;
data_task.task_data.control.bOpen = bOpen;
data_task.task_data.control.stage = stage;
switch (stage)
{
case STAGE_FDIR_STEP_ISOLATE:
{
sprintf(sql, "update fdir_fdirect set status=(case status when %d then %d else status end) where groupid=\'%s\'", STATUS_FDIRECT_DIRECT_OK, STATUS_FDIRECT_ISO, group_id);
ExecSQL(sql);
sprintf(sql, "update FDIR_ISOLATE set status=%d where id=\'%s\' and cb=\'%ld\' and ctrl_type=0", STATUS_ISOLATE_EXEC, group_id, point_name);
ExecSQL(sql);
break;
}
case STAGE_FDIR_STEP_RE_ISOLATE:
{
sprintf(sql, "update FDIR_FDIRECT set status=%d where groupid=\'%s\'", STATUS_FDIRECT_RE_ISO, group_id);
ExecSQL(sql);
sprintf(sql, "update FDIR_ISOLATE set status=%d where id=\'%s\' and cb=\'%ld\' and ctrl_type=0", STATUS_ISOLATE_EXEC, group_id, point_name);
ExecSQL(sql);
break;
}
case STAGE_FDIR_STEP_CUT_LD:
{
sprintf(sql, "update FDIR_FDIRECT set status=%d where groupid=\'%s\'", STATUS_FDIRECT_RES, group_id);
ExecSQL(sql);
sprintf(sql, "update FHZG_STEP set status=%d where id like \'%s%%\' and cb_id=\'%ld\'", STATUS_FDIR_STEP_EXEC, group_id, point_name);
ExecSQL(sql);
break;
}
case STAGE_FDIR_STEP_TRANSFER:
{
sprintf(sql, "update FDIR_FDIRECT set status=%d where groupid=\'%s\'", STATUS_FDIRECT_RES, group_id);
ExecSQL(sql);
sprintf(sql, "update FHZG_STEP set status=%d where id like \'%s%%\' and cb_id=\'%ld\'", STATUS_FDIR_STEP_EXEC, group_id, point_name);
ExecSQL(sql);
break;
}
case STAGE_FDIR_STEP_RESTORE:
{
sprintf(sql, "update FDIR_FDIRECT set status=%d where groupid=\'%s\'", STATUS_FDIRECT_RES, group_id);
ExecSQL(sql);
sprintf(sql, "update FHZG_STEP set status=%d where id like \'%s%%\' and cb_id=\'%ld\'", STATUS_FDIR_STEP_EXEC, group_id, point_name);
ExecSQL(sql);
sprintf(sql, "update fdir_fdirect set manual_restore=replace(manual_restore,\'%ld[0]\',\'%ld[1]\') where groupid =\'%s\' and manual_restore like \'%%%ld[_]%%\'", point_name, point_name, group_id, point_name);
ExecSQL(sql);
break;
}
default:
break;
}
sprintf(sql, "update FDIR_STEP set status=%d,starttime=sysdate where id=\'%s\' and cb_id=\'%ld\' and stage=%d and status=%d", STATUS_FDIR_STEP_EXEC, group_id, point_name, stage, STATUS_FDIR_STEP_WAIT);
ExecSQL(sql);
printf("故障组：%s 开关:%ld 操作:%s\r\n", group_id, point_name, bOpen ? "分闸" : "合闸");
PSBOB::CB cb = { 0 };
if (oodbread_rk(&cb, &point_name, const_cast<TB_DESCR*>(g_db_psbob->GetTB("breaker")), sizeof(PSBOB::CB)) < 0)
{
TRACE("oodbread_rk(%s) failed\r\n", point_name);
return false;
}
else
{
if (!IsInRegion(cb.id))
{
TRACE("开关%ld[%s]不在用户%s的责任区内！\r\n", cb.id, cb.name, g_FdirConfig.OP_USER);
//把进线开关遥控生成文件
form_jxcb_control_txt(group_id, point_name, bOpen);
data_task.task_data.control.status = TASK_CTL_STATUS_RUN;
}
else
{
}
}
printf("添加新的遥控任务项\r\n");
g_lstTask.push_front(data_task);
printf("OK!\r\n");
return true;
}
bool SetPassControl(const char *group_id, const long point_name, int op_type, const int stage)
{
assert(group_id != NULL && point_name > 0);
switch (stage)
{
case STAGE_FDIR_STEP_ISOLATE:
{
sprintf(sql, "update fdir_fdirect set status=(case status when %d then %d else status end) where groupid=\'%s\'", STATUS_FDIRECT_DIRECT_OK, STATUS_FDIRECT_ISO, group_id);
ExecSQL(sql);
sprintf(sql, "update FDIR_ISOLATE set status=%d where id=\'%s\' and cb=\'%ld\' and ctrl_type=0", op_type, group_id, point_name);
ExecSQL(sql);
break;
}
case STAGE_FDIR_STEP_RE_ISOLATE:
{
sprintf(sql, "update FDIR_FDIRECT set status=%d where groupid=\'%s\'", STATUS_FDIRECT_RE_ISO, group_id);
ExecSQL(sql);
sprintf(sql, "update FDIR_ISOLATE set status=%d where id=\'%s\' and cb=\'%ld\' and ctrl_type=0", op_type, group_id, point_name);
ExecSQL(sql);
break;
}
case STAGE_FDIR_STEP_CUT_LD:
{
sprintf(sql, "update FDIR_FDIRECT set status=%d where groupid=\'%s\'", STATUS_FDIRECT_RES, group_id);
ExecSQL(sql);
sprintf(sql, "update FHZG_STEP set status=%d where id like \'%s%%\' and cb_id=\'%ld\'", op_type, group_id, point_name);
ExecSQL(sql);
break;
}
case STAGE_FDIR_STEP_TRANSFER:
{
sprintf(sql, "update FDIR_FDIRECT set status=%d where groupid=\'%s\'", STATUS_FDIRECT_RES, group_id);
ExecSQL(sql);
sprintf(sql, "update FHZG_STEP set status=%d where id like \'%s%%\' and cb_id=\'%ld\'", op_type, group_id, point_name);
ExecSQL(sql);
break;
}
case STAGE_FDIR_STEP_RESTORE:
{
sprintf(sql, "update FDIR_FDIRECT set status=%d where groupid=\'%s\'", STATUS_FDIRECT_RES, group_id);
ExecSQL(sql);
sprintf(sql, "update FHZG_STEP set status=%d where id like \'%s%%\' and cb_id=\'%ld\'", op_type, group_id, point_name);
ExecSQL(sql);
sprintf(sql, "update fdir_fdirect set manual_restore=replace(manual_restore,\'%ld[0]\',\'%ld[4]\') where groupid =\'%s\' and manual_restore like \'%%%ld[_]%%\'", point_name, point_name, group_id, point_name);
ExecSQL(sql);
sprintf(sql, "update fdir_fdirect set manual_restore=replace(manual_restore,\'%ld[1]\',\'%ld[4]\') where groupid =\'%s\' and manual_restore like \'%%%ld[_]%%\'", point_name, point_name, group_id, point_name);
ExecSQL(sql);
break;
}
default:
break;
}
sprintf(sql, "update FDIR_STEP set status=%d,starttime=sysdate,endtime=sysdate where id=\'%s\' and cb_id=\'%ld\' and stage=%d", op_type, group_id, point_name, stage);
ExecSQL(sql);
return true;
}
//往任务列表中添加新的遥控项
bool AddControlItem(const char *group_id, const long point_name, const bool bOpen, const int stage)
{
assert(group_id != NULL);
for (FDIR_TASK_LIST::iterator it = g_lstTask.begin(); it != g_lstTask.end(); it++)
{
if (it->rq_type == TASK_TYPE_FAULT)
{
if (strcmp(it->task_data.fault.head.group_id, group_id) == 0)
{
it->task_data.fault.next_step = TASK_FAULT_STATUS_PROCESS;
}
}
}
FDIR_TASK data_task;
// bzero(&data_task, sizeof(data_task));
data_task.rq_type = TASK_TYPE_CB_CTRL;
gettimeofday(&data_task.tv_creat, NULL);
data_task.task_data.control.head.type = 0;
data_task.task_data.control.head.size = sizeof(FDIR_TASK_DATA_CONTROL);
strcpy(data_task.task_data.control.head.group_id, group_id);
data_task.task_data.control.status = TASK_CTL_STATUS_WAIT;
data_task.task_data.control.bLast = false;
data_task.task_data.control.point_name= point_name;
data_task.task_data.control.bOpen = bOpen;
data_task.task_data.control.stage = stage;
switch (stage)
{
case STAGE_FDIR_STEP_ISOLATE:
{
sprintf(sql, "update fdir_fdirect set status=(case status when %d then %d else status end) where groupid=\'%s\'", STATUS_FDIRECT_DIRECT_OK, STATUS_FDIRECT_ISO, group_id);
ExecSQL(sql);
sprintf(sql, "update FDIR_ISOLATE set status=%d where id=\'%s\' and cb=\'%ld\' and ctrl_type=0", STATUS_ISOLATE_EXEC, group_id, point_name);
ExecSQL(sql);
break;
}
case STAGE_FDIR_STEP_RE_ISOLATE:
{
sprintf(sql, "update FDIR_FDIRECT set status=%d where groupid=\'%s\'", STATUS_FDIRECT_RE_ISO, group_id);
ExecSQL(sql);
sprintf(sql, "update FDIR_ISOLATE set status=%d where id=\'%s\' and cb=\'%ld\' and ctrl_type=0", STATUS_ISOLATE_EXEC, group_id, point_name);
ExecSQL(sql);
break;
}
case STAGE_FDIR_STEP_CUT_LD:
{
sprintf(sql, "update FDIR_FDIRECT set status=%d where groupid=\'%s\'", STATUS_FDIRECT_RES, group_id);
ExecSQL(sql);
sprintf(sql, "update FHZG_STEP set status=%d where id like \'%s%%\' and cb_id=\'%ld\'", STATUS_FDIR_STEP_EXEC, group_id, point_name);
ExecSQL(sql);
break;
}
case STAGE_FDIR_STEP_TRANSFER:
{
sprintf(sql, "update FDIR_FDIRECT set status=%d where groupid=\'%s\'", STATUS_FDIRECT_RES, group_id);
ExecSQL(sql);
sprintf(sql, "update FHZG_STEP set status=%d where id like \'%s%%\' and cb_id=\'%ld\'", STATUS_FDIR_STEP_EXEC, group_id, point_name);
ExecSQL(sql);
break;
}
case STAGE_FDIR_STEP_RESTORE:
{
sprintf(sql, "update FDIR_FDIRECT set status=%d where groupid=\'%s\'", STATUS_FDIRECT_RES, group_id);
ExecSQL(sql);
sprintf(sql, "update FHZG_STEP set status=%d where id like \'%s%%\' and cb_id=\'%ld\'", STATUS_FDIR_STEP_EXEC, group_id, point_name);
ExecSQL(sql);
sprintf(sql, "update fdir_fdirect set manual_restore=replace(manual_restore,\'%ld[0]\',\'%ld[1]\') where groupid =\'%s\' and manual_restore like \'%ld%%[_]%%\'", point_name, point_name, group_id, point_name);
ExecSQL(sql);
break;
}
default:
break;
}
sprintf(sql, "update FDIR_STEP set status=%d,starttime=sysdate where id=\'%s\' and cb_id=\'%ld\' and stage=%d and status=%d", STATUS_FDIR_STEP_EXEC, group_id, point_name, stage, STATUS_FDIR_STEP_WAIT);
ExecSQL(sql);
printf("故障组：%s 开关:%ld 操作:%s\r\n", group_id, point_name, bOpen ? "分闸" : "合闸");
if (version == VERSION_REALTIME)
{
PSBOB::CB cb = { 0 };
if (oodbread_rk(&cb, &point_name, const_cast<TB_DESCR*>(g_db_psbob->GetTB("breaker")), sizeof(PSBOB::CB)) < 0)
{
TRACE("oodbread_rk(%ld) failed\r\n", point_name);
return false;
}
else
{
if (!IsInRegion(cb.id))
{
TRACE("开关%ld[%s]不在用户%s的责任区内！\r\n", cb.id, cb.name, g_FdirConfig.OP_USER);
//把进线开关遥控生成文件
form_jxcb_control_txt(group_id, point_name, bOpen);
data_task.task_data.control.status = TASK_CTL_STATUS_RUN;
}
else
{
}
}
}
cout << "添加新的遥控任务项";
g_lstTask.push_front(data_task);
cout << "OK!" << endl;
return true;
}
//进线开关形成遥控文件传给EMS
void form_jxcb_control_txt(const char *group_id, const long point_name, const bool bOpen)
{
char *filename = new char[1024];
char *jxcb_msg = new char[1024*1024];
char *str = new char[1024];
char *cmd = new char[1024];
sprintf(jxcb_msg, "<?xml version = \"1.0\" encoding = \"ISO-8859-1\" ?>\r\n<Message>\r\n");
sprintf(str, "<fault id=\"%s\" jxcb=\"%ld\" type=\"%d\"/>\r\n", group_id, point_name, bOpen==true ? 0:1);
strcat(jxcb_msg, str);
strcat(jxcb_msg, "</Message>\r\n");
timeval tm_now;
gettimeofday(&tm_now, NULL);
sprintf(filename, "%s/dms_txt/%ld_%ld.txt", getenv("HOME"), tm_now.tv_sec, point_name);
FILE *fp = fopen(filename, "wb+");
if (fp == NULL)
{
TRACE("写入遥控进线开关信息失败,file:%s\r\n", filename);
}
else
{
fwrite(jxcb_msg, 1, strlen(jxcb_msg), fp);
fclose(fp);
}
KEY_STRU ks;
unsigned long uid;
CCommon::long_to_keyid(point_name, &ks);
ks.field_id = 0;
CCommon::keyid_to_long(&ks, &uid);
PSBOB::CB psbob_cb = {0};
if(oodbread_rk(&psbob_cb, &uid, const_cast<TB_DESCR*>(g_db_psbob->GetTB(ks.table_no)), sizeof(psbob_cb)) == OO_FAIL)
{
TRACE("读取关键字为%ld的开关记录失败！\r\n", uid);
}
sprintf(sql, "insert into pms_param.jxcb_control (pnt_id, opter, descr, st_id) values(%ld, %d, \'%s\', %ld)", point_name, !bOpen, psbob_cb.name, psbob_cb.st_id);
ExecSQL(sql);
// sprintf(cmd, "scp %s d5000@ems:/home/d5000", filename);
// system(cmd);
delete filename;
delete jxcb_msg;
delete str;
delete cmd;
}
void SetFdirectStatus(const char *group_id)
{
assert(group_id != NULL);
char *buf = NULL;
char *pbuf = NULL;
char *id = new char[50];
int status = 0;
int rec_num, attr_num;
struct ORA_ATTR *attrs = NULL;
sprintf(sql, "SELECT ID,STATUS FROM FDIR_FDIRECT WHERE GROUPID=\'%s\' ", group_id);
cout << sql << endl;
//读取未执行的隔离步骤
pthread_mutex_lock(&oci_mutex);
int ret = g_oci->ReadWithBind(sql, &buf, &rec_num, &attr_num, &attrs);
pthread_mutex_unlock(&oci_mutex);
if (ret != OCI_ERROR)
{
pbuf = buf;
for (int i = 0; i < rec_num; i++)
{
memset(id, 0, sizeof(50));
memcpy(id, pbuf, attrs[0].col_width);
pbuf = pbuf + attrs[0].col_width;
status = *(int*)pbuf;
pbuf = pbuf + attrs[1].col_width;
if ((status == STATUS_FDIRECT_POSSIBLE) || (status == STATUS_FDIRECT_NONE)|| (status == STATUS_FDIRECT_WINK))
{
sprintf(sql, "UPDATE FDIR_FDIRECT_HIS SET STATUS=%d WHERE ID=\'%s\'", status+4, id);
if (ExecSQL(sql) != OCI_ERROR)
{
sprintf(sql, "UPDATE FDIR_FDIRECT SET STATUS=%d WHERE ID=\'%s\'", STATUS_FDIRECT_STOP, id);
ExecSQL(sql);
}
}
}
g_oci->Readdata_Free();
// if ((status == STATUS_FDIRECT_POSSIBLE) || (status == STATUS_FDIRECT_NONE) || (status == STATUS_FDIRECT_WINK))
// {
// sprintf(sql, "UPDATE FDIR_FDIRECT_HIS SET STATUS=%d WHERE GROUPID=\'%s\'", status+4, group_id);
// if (ExecSQL(sql) != OCI_ERROR)
// {
// sprintf(sql, "UPDATE FDIR_FDIRECT SET STATUS=%d WHERE GROUPID=\'%s\'", STATUS_FDIRECT_STOP, group_id);
// ExecSQL(sql);
// }
// }
}
else
{
delete id;
return ;
}
delete id;
}
//获取指定故障尚未执行的遥控
int GetLeftStep(const char *group_id, list<CB_CONTROL> &lstcb)
{
assert(group_id != NULL);
lstcb.clear();
cout << "本次故障还未完成的操作步骤：" << endl;
char *buf = NULL;
int rec_num, attr_num;
struct ORA_ATTR *attrs = NULL;
CB_CONTROL control = { 0 };
sprintf(sql, "SELECT CB_ID, OPERATION, STAGE FROM FDIR_STEP WHERE ID=\'%s\' AND STATUS=%d AND CONTROL=%d ORDER BY STEP ASC", group_id, STATUS_FDIR_STEP_WAIT, 1/*可遥控*/);
cout << sql << endl;
//读取未执行的隔离步骤
pthread_mutex_lock(&oci_mutex);
int ret = g_oci->ReadWithBind(sql, &buf, &rec_num, &attr_num, &attrs);
pthread_mutex_unlock(&oci_mutex);
if (ret != OCI_ERROR)
{
for (int i = 0; i < rec_num; i++)
{
char bOpen[50], stage[50], point_id[50];
bzero(&control, sizeof(control));
bzero(bOpen, sizeof(bOpen));
bzero(stage, sizeof(stage));
bzero(point_id, sizeof(point_id));
memcpy(point_id, buf + (i * (attrs[0].col_width + attrs[1].col_width + attrs[2].col_width)), attrs[0].col_width);
control.point_id = *(long*)point_id;
memcpy(bOpen, buf + (i * (attrs[0].col_width + attrs[1].col_width + attrs[2].col_width)) + attrs[0].col_width, attrs[1].col_width);
control.bOpen = *(int*)bOpen - 1;
memcpy(stage, buf + (i * (attrs[0].col_width + attrs[1].col_width + attrs[2].col_width)) + attrs[0].col_width + attrs[1].col_width, attrs[2].col_width);
control.stage = *(int*)stage;
lstcb.push_back(control);
printf("point:%ld, operation:%s, stage:%d\r\n", control.point_id, control.bOpen ? "分" : "合", control.stage);
}
g_oci->Readdata_Free();
}
else
{
return -1;
}
return lstcb.size();
}
int Test_Oci()
{
return 0;
// OCI_TOOLS oci;
// _list_bind *first_bind = NULL, *next_bind = NULL;
//
// int ret = oci.Connect("PSBOB_REALTIME", "psbob", "scd1");
//
// if (ret > 0)
// {
// ret = oci.ORA_BindWithReturn(&first_bind, "select * from cp");
//
// if (ret > 0)
// {
// next_bind = first_bind;
//
// for (int i = 0; i < ret; i++)
// {
// cout << next_bind->bindbuf[0] << endl;
//
// next_bind = next_bind->next;
// }
//
// oci.Free_list_bind(first_bind);
// }
//
// ret = oci.Disconnect();
// }
//
// return 0;
}
long GetTokenID()
{
char *buf = NULL;
int rec_num, attr_num;
struct ORA_ATTR *attrs = NULL;
long token_id = 0;
sprintf(sql, "SELECT max(token_id)+1 from ems.ems.token_info");
pthread_mutex_lock(&oci_mutex);
int ret = g_oci->ReadWithBind(sql, &buf, &rec_num, &attr_num, &attrs);
pthread_mutex_unlock(&oci_mutex);
if (ret != OCI_ERROR)
{
token_id = *(long*) buf;
}
g_oci->Readdata_Free();
return token_id;
}
int AddToken(const char *fault_id, const long dev_id, int token_type)
{
//研究态无法挂牌
if (version == VERSION_STUDY)
{
return 0;
}
TRACE("%s…\r\n", __FUNCTION__);
#if 0
long st_id;
PSBOB::CB psbob_cb = { 0 };
int ret = GetRecByID(const_cast<TB_DESCR*>(g_db_psbob->GetTB("breaker")), (char*) &dev_id, sizeof(PSBOB::CB), (char*) &psbob_cb);
if (ret < 0)
{
TRACE("获取ID为%ld的断路器信息失败！\r\n", dev_id);
return ret;
}
token_info_dscada token = { 0 };
char *buf = NULL;
ret = GetTableRecs(const_cast<TB_DESCR*>(g_db_psbob->GetTB("token_define")), 1, &buf);
if (ret < 0)
{
TRACE("读取标志牌定义表失败！\r\n");
return ret;
}
token_define_dscada *p = (token_define_dscada *) buf;
for (int i = 0; i < ret / sizeof(token_define_dscada); i++)
{
if (strcmp(p->name, "故障隔离") == 0)
{
token.token_no = p->token_no;
break;
}
p++;
}
BufFree(buf);
if (token.token_no == 0)
{
TRACE("故障隔离牌未定义，请在标志牌定义表里添加\r\n");
return -1;
}
token.token_id = GetTokenID();
token.device_id = dev_id;
token.record_app = AP_DSCADA;
token.st_id = psbob_cb.st_id;
token.if_display = 1;
token.father_token_id = -1;
ret = InsertRec(const_cast<TB_DESCR*>(g_db_psbob->GetTB("token_info")), 1, sizeof(token_info_dscada), (char*) &token, 1);
if (ret < 0)
{
TRACE("插入挂牌信息失败\r\n");
return ret;
}
sprintf(sql, "insert into ems.ems.token_info (token_id, device_id, token_no, record_app,st_id) values (%ld,%ld,%ld,%d,%ld)", token.token_id, token.device_id, token.token_no, token.record_app,
psbob_cb.st_id);
ExecSQL(sql);
sprintf(sql, "insert into pms_param.fdir_token (id, dev_id, st_id,token_type,add_flag,del_flag,token_id) values (\'%s\',%ld,%ld,%d,0,0,%ld)", fault_id, dev_id, psbob_cb.st_id, token_type,
token.token_id);
ExecSQL(sql);
#else
TScaTokenOp token_op = { 0 };
bzero(&token_op, sizeof(TScaTokenOp));
token_op.dev_id = dev_id;
token_op.father_token_id = -1;
token_op.op_time = time(NULL);
token_info_dscada token = { 0 };
char *buf = NULL;
int ret = GetTableRecs(const_cast<TB_DESCR*>(g_db_psbob->GetTB("token_define")), 1, &buf);
if (ret < 0)
{
TRACE("读取标志牌定义表失败！\r\n");
return ret;
}
token_define_dscada *p = (token_define_dscada *) buf;
for (int i = 0; i < ret / sizeof(token_define_dscada); i++)
{
if (strcmp(p->name, "故障隔离") == 0)
{
token_op.token_type_id = p->token_no;
break;
}
p++;
}
BufFree(buf);
if (token_op.token_type_id == 0)
{
TRACE("故障隔离牌未定义，请在标志牌定义表里添加\r\n");
return -1;
}
Message msg = { 0 };
msg.header.event = SCADA_OPT_TAG_SET;
msg.header.serv = D_CH_SCADA_OP_CHANNEL;
msg.header.ctxt = 1;
memcpy(msg.Msg_buf, &token_op, sizeof(token_op));
ret = bob_inv->messageSend(&msg, sizeof(token_op), NULL);
TRACE("send_event %d ,fault_id:%s, dev_id:%ld, return:%d\r\n", msg.header.event, fault_id, dev_id, ret);
#endif
return 0;
}
//通知人机推故障
int Notify(const char *grp_id, const long dv_id, const long st_id, char op)
{
if(version==VERSION_STUDY)
{
return 0;
}
assert(grp_id != NULL);
if(grp_id == NULL) return -1;
FDIR_MSG_ISO_REC data = { 0 };
data.operate = op;
strcpy(data.fault_id, grp_id);
data.dv_id = dv_id;
data.st_id = st_id;
Message msg = { 0 };
msg.header.event = EVPS_FDIR_MSG_ISO_REC;
msg.header.serv = WARN_INFORM_CHANNEL;
msg.header.ctxt = 1;
memcpy(msg.Msg_buf, &data, sizeof(data));
int ret = bob_inv->messageSend(&msg, sizeof(data), NULL);
TRACE("send_event %d ,group_id:%s, dv_id:%ld, st_id:%ld, return:%d\r\n", msg.header.event, grp_id, dv_id, st_id, ret);
return ret;
}
//发送遥控命令
int DoControl(const long cb_id, bool bPre, bool bOpen)
{
if (!g_FdirConfig.SIMULATE)
{
TScaBaseOp op = {0};
op.op_time = time(NULL);
strcpy(op.op_user_name, g_FdirConfig.OP_USER);
strcpy(op.op_node_name, g_FdirConfig.OP_NODE);
strcpy(op.gua_node_name, g_FdirConfig.OP_NODE);
strcpy(op.gua_user_name, g_FdirConfig.OP_USER);
KEY_STRU ks = {0};
op.id = cb_id;
id_to_pid(op.id);
CCommon::long_to_keyid(op.id, &ks);
ks.field_id = 1;
//获取遥信值所在域号
FIELD_PARA_STRU *pfps = NULL;
int ret = GetFieldsPara(const_cast<TB_DESCR*>(g_db_psbob->GetTB("breaker")), &pfps);
if (ret >= 0)
{
int cnt = ret / sizeof(FIELD_PARA_STRU);
for (int i = 0; i < cnt; i++)
{
if (strcmp(pfps[i].field_name_eng, "point") == 0)
{
ks.field_id = pfps[i].column_id;
break;
}
}
BufFree(pfps);
}
unsigned long uid = op.id;
CCommon::keyid_to_long(&ks, &uid);
op.data_type = 4;
op.int_value = bOpen ? 0 : 1;
op.id = uid;
Message msg = { 0 };
msg.header.event = bPre ? SCADA_OPT_CTRL_PREV : SCADA_OPT_CTRL_EXEC;
#ifdef _SCADA
msg.header.serv = CH_SCADA_OP_CHANNEL;
#else
msg.header.serv = D_CH_SCADA_OP_CHANNEL;
#endif
msg.header.ctxt = 1;
memcpy(msg.Msg_buf, &op, sizeof(op));
ret = bob_inv->messageSend(&msg, sizeof(op), NULL);
TRACE("send_event %d ,key_id:%ld, return:%d\r\n", msg.header.event, uid, ret);
}
else
{
Message message = { 0 };
ChangeYx yx = { cb_id, bOpen, bOpen, 0, 0 };
// M_CODE(yx, message.Msg_buf, sizeof(yx));
message.header.event = MT_YX_CHANGE;
message.header.serv = CH_UP_REAL_DATA;
memcpy(message.Msg_buf, &yx, sizeof(yx));
cout << "bob_inv->messageSend,return:" << bob_inv->messageSend(&message, sizeof(message.header) + sizeof(yx), NULL) << endl;
PSBOB::CB psbob_cb;
psbob_cb.id = cb_id;
psbob_cb.point = !bOpen;
oodbupdate_ak(&psbob_cb.point, &psbob_cb.id, "point", const_cast<TB_DESCR*>(g_db_psbob->GetTB("breaker")), sizeof(psbob_cb.id));
}
//D5000
return 0;
}
//故障模拟程序
//校验开关信息
bool Check_Simu_Data(CHECK_LIST& lst_data)
{
if (lst_data.size() > 0)
{
for (std::list<CHECK_DATA>::iterator it_chk = lst_data.begin(); it_chk != lst_data.end(); )
{
long cb_id = it_chk->cb_id;
PSBOB::CB chk_cb;
if (oodbread_rk(&chk_cb, &cb_id, const_cast<TB_DESCR*>(g_db_psbob->GetTB("breaker")), sizeof(PSBOB::CB)) > 0)
{
//还未添加挂牌信息的校验，待人机开始开发后商议
if (chk_cb.point == it_chk->status && fabs(chk_cb.i_a_value - it_chk->Ia) < 0.01 && fabs(chk_cb.i_b_value - it_chk->Ib) < 0.01
&& fabs(chk_cb.i_c_value - it_chk->Ic) < 0.01 && fabs(chk_cb.p - it_chk->p) < 0.01 && fabs(chk_cb.q - it_chk->q) < 0.01)
{
std::list<CHECK_DATA>::iterator it_chk_tmp = it_chk;
it_chk++;
lst_data.erase(it_chk_tmp);
continue;
}
else
{
it_chk->status = chk_cb.point;
it_chk->Ia = chk_cb.i_a_value;
it_chk->Ib = chk_cb.i_b_value;
it_chk->Ic = chk_cb.i_c_value;
it_chk->p = chk_cb.p;
it_chk->q = chk_cb.q;
it_chk++;
}
}
else
{
TRACE("在断路器表中查找关键字为%ld的记录失败！\r\n", cb_id);
continue;
}
}
return true;
}
else
{
TRACE("模拟信号对应的开关列表为空！校验失败！\r\n");
return false;
}
}
bool get_cb_info(CB_INFO &cb)
{
PSBOB::CB tmp_cb_info;
bzero(&tmp_cb_info, sizeof(PSBOB::CB));
DSBOB *dsbob = g_fdir_r->get_dsbob();
//CLS_CB *tempcb = dsbob->cb_tb->Find(CLS_CB(cb.id));
long pid = cb.id;
id_to_pid(pid);
if (oodbread_rk(&tmp_cb_info, &pid, const_cast<TB_DESCR*>(g_db_psbob->GetTB("breaker")), sizeof(PSBOB::CB)) <= 0)
{
TRACE("%s(%d):读取开关%ld记录信息失败，错误号:%d\r\n", __FUNCTION__, __LINE__, pid, _oodb_errno);
return false;
}
if (tmp_cb_info.point > 0)
{
cb.status = TYPICAL_OPEN;
}
else
{
cb.status = TYPICAL_CLOSE;
}
//获取父节点的电流值等信息
if (tmp_cb_info.brk_type == MENU_BRK_TYPE_JX)
{
cb.type = JXCB;
}
else if (tmp_cb_info.brk_type == MENU_BRK_TYPE_LW)
{
cb.type = LWCB;
}
else
{
cb.type = NORMAL_CB;
}
cb.Ia = tmp_cb_info.i_a_value;
cb.Ib = tmp_cb_info.i_b_value;
cb.Ic = tmp_cb_info.i_c_value;
return true;
}
int get_dv_cb(int izone, const long fathercb, TreeNode<CB_INFO> *father, Tree<CB_INFO> &tree_cb, map<long, Tree<CB_INFO> >& m_map_dv_cb)
{
assert(izone != -1);
int i, nextzone, ret, icb;
CB_INFO cbnode;
TreeNode<CB_INFO> *tmp_father;
CLS_CB *cb;
DSBOB *dsbob = g_fdir_r->get_dsbob();
CLS_FDIR_ZONE_CB* fdir_zone_cb = g_fdir_r->fdir_zone_cb_tb->GetTable();
CLS_FDIR_ZONE* fdir_zone = g_fdir_r->fdir_zone_tb->GetTable();
CLS_FDIR_CB* fdir_cb = g_fdir_r->fdir_cb_tb->GetTable();
//int lv_fdir_cb = g_fdir_r->fdir_cb_tb->GetCount();
//int lv_fdir_zone = g_fdir_r->fdir_zone_tb->GetCount();
//PSBOB::CB psbob_cb = {0};
ret = -1;
icb = -1;
TRACE("the izone is %d\n",izone);
//获取父节点的电流值等信息
cbnode.id = fathercb;
get_cb_info(cbnode);
tmp_father = tree_cb.TreeAddLeaf(father, cbnode);
for (i = 0; i < (fdir_zone + izone)->cbnum; i++)
{
icb = (fdir_zone_cb + (fdir_zone + izone)->cbptr + i)->icb; //此处的icb为开关的物理号，在FDIR_ZONE_CB表中
cb = dsbob->cb_tb->Find(CLS_CB((fdir_cb + icb)->cb_id));
TRACE("发现开关：%s, ID:%ld\r\n", cb->descr, cb->pid);
//判断开关有没有被处理过
if((fdir_cb + icb)->q & FDIR_CB_UNPROC)
{
//如果是进线开关停止搜索树,并且把进线开关作为这棵树的节点
if(cb->q & CB_FDHCB)
{
//TreeNode<CB_INFO> *newroot = tmp_father;
memset(&cbnode, 0, sizeof(cbnode));
cbnode.id = cb->pid;
get_cb_info(cbnode);
tree_cb.TreeAddLeaf(tmp_father, cbnode);
(fdir_cb + icb)->q &= ~FDIR_CB_UNPROC;
}
else
{
//如果是联络开关添加联络开关到树，并且以联络开关开始建立一个新的树
if(cb->q & CB_LWCB)
{
memset(&cbnode, 0, sizeof(cbnode));
cbnode.id = cb->pid;
get_cb_info(cbnode);
tree_cb.TreeAddLeaf(tmp_father, cbnode);
//联络开关对应另外一端首先判断是否被处理过，如果没被处理过获取dv信息建立新树
if(izone == (fdir_cb + icb)->ind)
{
nextzone = (fdir_cb + icb)->iznd;
}
else
{
nextzone = (fdir_cb + icb)->ind;
}
if(nextzone == -1)
{
(fdir_cb + icb)->q &= ~FDIR_CB_UNPROC;
continue;
}
PSBOB::DV dv = { 0 };
g_fdir_r->GetDVByZone(nextzone, dv);
if(dv.id <= 0)
{
(fdir_cb + icb)->q &= ~FDIR_CB_UNPROC;
TRACE("\033[31m********************LWCB id is %ld getdv failed**************\033[0m\n",cb->id);
continue;
}
if((fdir_zone + nextzone)->q & FDIR_ZONE_UNPROC)
{
if(m_map_dv_cb.find(dv.id) != m_map_dv_cb.end())
{
continue;
}
(fdir_zone + nextzone)->q &= ~FDIR_ZONE_UNPROC;
(fdir_cb + icb)->q &= ~FDIR_CB_UNPROC;
ret = get_dv_cb(nextzone, cb->id, m_map_dv_cb[dv.id].root, m_map_dv_cb[dv.id], m_map_dv_cb);
if(ret == -1)
{
return -1;
}
}
}
//普通开关递归调用遍历所有相连的开关
else
{
(fdir_cb + icb)->q &= ~FDIR_CB_UNPROC;
if(izone == (fdir_cb + icb)->ind)
{
nextzone = (fdir_cb + icb)->iznd;
}
else
{
nextzone = (fdir_cb + icb)->ind;
}
if((fdir_zone + nextzone)->q & FDIR_ZONE_UNPROC)
{
(fdir_zone + nextzone)->q &= ~FDIR_ZONE_UNPROC;
ret = get_dv_cb(nextzone, cb->id, tmp_father, tree_cb, m_map_dv_cb);
if(ret == -1)
{
return -1;
}
}
}
}
}
}
return 0;
}
bool save_simu_cb_info(long sig_id, char* plan_id)
{
PSBOB::PROTECT protect = {0};
PSBOB::CB sig_cb = {0};
if (oodbread_rk(&protect, &sig_id, const_cast<TB_DESCR*>(g_db_psbob->GetTB("relaysig")), sizeof(PSBOB::PROTECT)) > 0 ||
oodbread_rk(&sig_cb, &sig_id, const_cast<TB_DESCR*>(g_db_psbob->GetTB("breaker")), sizeof(PSBOB::CB)) > 0)
{
long cb_id = 0;
if (protect.id > 0)
{
cb_id = protect.oo_dev;
}
else
{
cb_id = sig_cb.id;
}
map<long, Tree<CB_INFO> > m_map_dv_cb;
int i, icb = -1, izone;
map<string, Tree<CB_INFO> > temp_map;
PSBOB::DV dv = { 0 };
DSBOB *dsbob = g_fdir_r->get_dsbob();
CLS_FDIR_ZONE* fdir_zone = g_fdir_r->fdir_zone_tb->GetTable();
CLS_FDIR_CB* fdir_cb = g_fdir_r->fdir_cb_tb->GetTable();
int lv_fdir_cb = g_fdir_r->fdir_cb_tb->GetCount();
int lv_fdir_zone = g_fdir_r->fdir_zone_tb->GetCount();
//将所有的区段设置为未处理状态
for (i = 0; i < lv_fdir_cb; i++)
{
(fdir_cb + i)->q |= FDIR_CB_UNPROC;
}
for (i = 0; i < lv_fdir_zone; i++)
{
(fdir_zone + i)->q |= FDIR_ZONE_UNPROC;
}
long id = cb_id;
pid_to_id(id);
icb = dsbob->cb_tb->FindPos(CLS_CB(id));
TRACE("获取到开关:%ld的记录 获取到的icb: %d %d \n", id,icb,(fdir_zone + (fdir_cb + icb)->ind)->type);
if (icb == -1)
{
TRACE("没有获取到开关:%ld的记录\n", id);
return false;
}
//cout<<"======"<<(fdir_cb + icb)->id<<(fdir_cb + icb)->descr <<"--"<<(fdir_zone + (fdir_cb + icb)->ind)->type <<endl;
//获取开关的下游区段
if ((fdir_zone + (fdir_cb + icb)->ind)->type == _FDIR_ZN)
{
izone = (fdir_cb + icb)->ind;
(fdir_zone + (fdir_cb + icb)->iznd)->q &= ~FDIR_ZONE_UNPROC;
}
else
{
izone = (fdir_cb + icb)->iznd;
(fdir_zone + (fdir_cb + icb)->ind)->q &= ~FDIR_ZONE_UNPROC;
}
(fdir_cb + icb)->q &= ~FDIR_CB_UNPROC;
if (izone != -1)
{
//设置此区段izone为已经处理过的，并调用处理函数
(fdir_zone + izone)->q &= ~FDIR_ZONE_UNPROC;
//获取馈线ID
g_fdir_r->GetDVByZone(izone, dv);
if (dv.id <= 0)
{
TRACE("\033[31m********************LWCB id is %s getdv failed**************\033[0m\r\n",cb_id);
return false;
}
int ret = get_dv_cb(izone, id, m_map_dv_cb[dv.id].root, m_map_dv_cb[dv.id], m_map_dv_cb);
if (ret >= 0)
{
//把馈线和开关信息写入关系库
for (std::map<long, Tree<CB_INFO> >::iterator it_dv = m_map_dv_cb.begin(); it_dv != m_map_dv_cb.end(); it_dv++)
{
PSBOB::DV simu_dv = {0};
long dv_id = it_dv->first;
if (oodbread_rk(&simu_dv, &dv_id, const_cast<TB_DESCR*>(g_db_psbob->GetTB("subcontrolarea")), sizeof(PSBOB::DV)) > 0)
{
sprintf(sql, "INSERT INTO PMS_PARAM.FDIR_SIG_DV (ID, DV_ID, DV_NAME, LMTNORM) VALUES (\'%s\', %ld, \'%s\', %f)",
plan_id, dv_id, simu_dv.name, simu_dv.lmtnorm);
ExecSQL(sql);
}
list<TreeNode<CB_INFO>*> so_tree;
list<TreeNode<CB_INFO>*>::iterator it_tree;
it_dv->second.DepthFirstErgodic(it_dv->second.root, so_tree);
for (it_tree = so_tree.begin(); it_tree != so_tree.end(); it_tree++)
{
long brk_id = (*it_tree)->data.id;
id_to_pid(brk_id);
PSBOB::CB tree_cb = {0};
if (oodbread_rk(&tree_cb, &brk_id, const_cast<TB_DESCR*>(g_db_psbob->GetTB("breaker")), sizeof(PSBOB::CB)) > 0)
{
sprintf(sql, "INSERT INTO PMS_PARAM.FDIR_SIG_BREAKER(ID, CB_ID, CB_NAME, STATUS, IA, IB, IC, P, Q) VALUES (\'%s\', %ld, \'%s\', %d, %f, %f, %f, %f, %f)",
plan_id, brk_id, tree_cb.name, tree_cb.point, tree_cb.i_a_value, tree_cb.i_b_value, tree_cb.i_c_value, tree_cb.p, tree_cb.q);
ExecSQL(sql);
//添加挂牌信息
TOKEN_INFO_DSCADA token_info = {0};
if (oodbread_ra(&token_info, "device_id", &brk_id, const_cast<TB_DESCR*>(g_db_psbob->GetTB("token_info")), sizeof(TOKEN_INFO_DSCADA)) > 0)
{
int token_type = 0;
TOKEN_DEFINE_DSCADA token_def = {0};
if (oodbread_rk(&token_def, &token_info.token_no, const_cast<TB_DESCR*>(g_db_psbob->GetTB("token_define")), sizeof(TOKEN_INFO_DSCADA)) > 0)
{
sprintf(sql, "INSERT INTO PMS_PARAM.FDIR_SIG_TOKEN(ID, CB_ID, TOKEN_TYPE, TOKEN_NAME)VALUES(\'%s\', %ld, %d, \'%s\')", plan_id, brk_id, token_def.token_type, token_def.name);
ExecSQL(sql);
}
}
}
}
}
}
}
else
{
TRACE("获取进线开关的下游区段失败\n");
return false;
}
}
else
{
TRACE("查询保护信号表和断路器表关键字为%ld的记录失败！\r\n", sig_id);
return false;
}
return true;
}
void thread_alarm_process(void *param)
{
bool bCanScan = true; //判断正在定位的故障是否定位完成，是否可以开始新一轮的扫描
while (true)
{
bCanScan = true;
pthread_mutex_lock(&task_list_mutex);
//TRACE("$$$$$$$$$NO deadlock!!!\r\n");
for (FDIR_TASK_LIST::iterator it = g_lstTask.begin(); it != g_lstTask.end(); it++)
{
//存在未定位完成的故障
if (it->rq_type == TASK_TYPE_FAULT)
{
if ((it->task_data.fault.next_step == TASK_FAULT_STATUS_CALC) || (it->task_data.fault.next_step == TASK_FAULT_STATUS_SLEEP))
{
bCanScan = false;
break;
}
}
}
pthread_mutex_unlock(&task_list_mutex);
if (bCanScan)
{
pthread_mutex_lock(&trig_list_mutex);
for (FDIR_POINT_TRIG_LIST::iterator it = g_lstTrig.begin(); it != g_lstTrig.end(); it++)
{
//发现未被定位的故障信号(故障跳闸，动作,母线)
if (it->lst_fault.size() == 0/* && (strcmp(it->alarm.fault_info, key[1]) == 0 || strcmp(it->alarm.fault_info, key[2]) == 0)*/) //D5000暂时只收集事故跳闸
{
if(it->alarm.dev == ALARM_SGZ || it->alarm.dev == ALARM_FAULTINFO_JD || it->alarm.dev == ALARM_FAULTINFO_DL || it->alarm.dev == ALARM_BUS//母线故障、事故总动作、故障指示器动作
/* ||it->alarm.type == SG_WARN_TYPE*/ || it->alarm.type == D_SG_WARN_TYPE || strcmp(it->alarm.tabname,"bus") == 0) //开关事故跳闸
{
}
else //不是故障启动信号
{
continue;
}
//线程上锁，不让后台返回模拟故障执行报文
//pthread_mutex_lock(&simu_sync_mutex);
GetFdirConfig(g_FdirConfig);
//启动一个故障
FDIR_TASK data_task;
data_task.rq_type = TASK_TYPE_FAULT;
memcpy(&data_task.tv_creat, &it->tm_add, sizeof(timeval));
data_task.task_data.fault.next_step = TASK_FAULT_STATUS_SLEEP;
if (g_FdirConfig.AUTO_DEAL_HIS)
{
data_task.task_data.fault.bAuto = 2;
}
else
{
data_task.task_data.fault.bAuto = it->damode == FDIR_MODE_AUTO ? 1 : 0;
}
//20150514 标记模拟出的故障信号
if (it->trig_type == TRIG_TYPE_SIMU)
{
data_task.task_data.fault.simu_plan_id = it->simu_plan_id;
data_task.task_data.fault.signal_type = TRIG_TYPE_SIMU;
}
//D5000暂时只收集事故跳闸
// if (it->alarm.datatype & (POINT_BPCB | POINT_GCB | POINT_BPDS | POINT_GDS))
// {
// data_task.task_data.fault.type = TASK_FAULT_LD;
// }
if (strcmp(it->alarm.tabname, "bus") == 0)
{
cout << "发现故障母线" << it->alarm.key_id << endl;
data_task.task_data.fault.type = TASK_FAULT_BUS;
}
else
data_task.task_data.fault.type = TASK_FAULT_LD;
data_task.task_data.fault.head.type = 0;
data_task.task_data.fault.head.size = sizeof(FDIR_TASK_DATA_FAULT);
data_task.task_data.fault.point_name = it->psbob_data.point.id;
data_task.task_data.fault.dv = it->dv_id;
data_task.task_data.fault.st = it->alarm.st_id;
tm *ptm = localtime(&it->tm_add.tv_sec);
sprintf(data_task.task_data.fault.head.fault_id, "%04d/%02d/%02d %02d:%02d:%02d.%06ld", 1900 + ptm->tm_year, ptm->tm_mon + 1, ptm->tm_mday, ptm->tm_hour, ptm->tm_min, ptm->tm_sec,
it->tm_add.tv_usec);
TRACE("报警ID:%ld,启动故障,故障ID:%s\r\n", it->alarm.key_id, data_task.task_data.fault.head.fault_id);
AddTask(&data_task);
// rte_disconnect();
// pthread_mutex_unlock(&trig_list_mutex);
// return;
break;
}
}
pthread_mutex_unlock(&trig_list_mutex);
//pthread_mutex_unlock(&simu_sync_mutex);
}
else
{
cout << "有未定位完成的故障，不能启动新的故障定位" << endl;
}
sleep(1);
}
}
//扫描母线及其进线开关，判断其是否为母线故障
void thread_scan_bus(void *param)
{
// cout<<"开启扫描故障母线线程"<<endl;
int i;
char *buf = NULL;
int rec_num, attr_num;
struct ORA_ATTR *attrs = NULL;
PSBOB::ST psbob_st = { 0 };
PSBOB::DV psbob_dv = { 0 };
while (true)
{
int lv_bus = g_bob->bus_tb->GetCount();
CLS_BUS* bus = g_bob->bus_tb->GetTable();
for (i = 0; i < lv_bus; i++)
{
int ind = g_bob->bus_tb->Data[i].ind;
if (ind < 0)
continue;
PSBOB::BUS psbob_bus = {0};
if (oodbread_rk(&psbob_bus, &g_bob->bus_tb->Data[i].pid, const_cast<TB_DESCR*>(g_db_psbob->GetTB("busbarsection")), sizeof(PSBOB::BUS)) <= 0)
{
cout << "读取母线" << g_bob->bus_tb->Data[i].id << "电压信息失败,errno:" << _oodb_errno << endl;
continue;
}
if (psbob_bus.v < MIN_BUS_VALUE)
{
CLS_FDIR_ZONE *fdir_zone = g_fdir_r->fdir_zone_tb->GetTable();
int lv_fdir_zone = g_fdir_r->fdir_zone_tb->GetCount();
//如果fdir_fdirect表中已经存在此母线故障，并且此故障并未处理，则不再生成这条母线的故障信息，首先判断母线是否被定位过
sprintf(sql, "SELECT ID FROM PMS_PARAM.FDIR_FDIRECT WHERE STUDY_EQ = \'%ld\' AND TYPE = 0 AND STATUS in (0,-1,1,2,3,6,7,9,10,11,12,13,14,15,17,18,19)", (bus + i)->pid);
strcat(sql, "\0");
pthread_mutex_lock(&oci_mutex);
int ret = g_oci->ReadWithBind(sql, &buf, &rec_num, &attr_num, &attrs);
pthread_mutex_unlock(&oci_mutex);
if (ret != OCI_ERROR)
{
if (rec_num > 0)
{
g_oci->Readdata_Free();
// cout<<"发现故障失压母线"<<(bus + i)->pid<<"已经被定位处理"<<endl;
continue;
}
g_oci->Readdata_Free();
}
else
{
continue;
}
for (int j = 0; j < lv_fdir_zone; j++)
{
if ((fdir_zone + j)->zn_id == (bus + i)->id) // zn_id和 bus的id对应不上
{
int cbptr = (fdir_zone + j)->cbptr;
int cbnum = (fdir_zone + j)->cbnum;
int jxcbnum = 0;
int num = 0;
for (int k = 0; k < cbnum; k++)
{
int icb = g_fdir_r->fdir_zone_cb_tb->GetDataByPos(cbptr + k)->icb;
CLS_CB *cb = g_bob->cb_tb->GetDataByPos(icb);
if (cb->q & CB_FDHCB)
{
jxcbnum++;
float max_value;
PSBOB::CB psbob_cb = { 0 };
long cb_id = cb->pid;
if (oodbread_rk(&psbob_cb, &cb_id, const_cast<TB_DESCR*>(g_db_psbob->GetTB("breaker")), sizeof(PSBOB::CB)) <= 0)
{
printf("%s(%ld):读取开关%ld记录信息失败，错误号:%ld\r\n", __FUNCTION__, __LINE__, cb_id, _oodb_errno);
jxcbnum--;
continue;
}
max_value = max(max(psbob_cb.i_a_value, psbob_cb.i_b_value), psbob_cb.i_c_value);
if (max_value <= 0)
{
num++;
}
}
}
if (num > jxcbnum / 2)
{
FDIR_POINT_TRIG data_trig;
data_trig.alarm.st_id = psbob_bus.st_id;
if (GetDv(data_trig.alarm.st_id, "st", psbob_dv) == OO_FAIL)
{
TRACE("获取厂站%ld的馈线信息失败！\r\n", data_trig.alarm.st_id);
continue;
}
data_trig.dv_id = psbob_dv.id;
data_trig.damode = GetDvDamode(psbob_dv.id);
gettimeofday(&data_trig.tm_add, NULL);
if (psbob_dv.damode == FDIR_MODE_FORBID)
{
TRACE("馈线%ld(%s)为禁止DA处理(%d)\r\n", psbob_dv.id, psbob_dv.name, psbob_dv.damode);
continue;
}
// 填充一些字段表示母线故障信息
data_trig.alarm.dev = ALARM_BUS;
data_trig.alarm.key_id = (bus + i)->id;
strcpy(data_trig.alarm.fault_info,"母线故障");
data_trig.alarm.name = (bus + i)->descr;
data_trig.psbob_data.point.id = (bus + i)->pid;
strcpy(data_trig.alarm.tabname, "bus");
strcpy(data_trig.alarm.fault_info, "母线失压");
//将该母线加入过流开关列表
pthread_mutex_lock(&trig_list_mutex);
g_lstTrig.push_back(data_trig);
pthread_mutex_unlock(&trig_list_mutex);
cout << "g_lstTrig.size()=" << g_lstTrig.size() << endl;
sleep(30);
}
break;
}
}
}
}
sleep(60);
}
}
//清除信号列表中过时的故障信号
//逻辑是：先在任务列表中找到一个发生时间最早的故障，然后在故障信号列表中
//找到该故障的启动信号，最后删除该启动信号前面30秒外的故障信号
void clear_timeout_trig()
{
timeval tm_anchor = { -1 };
FDIR_TASK_LIST::iterator it = g_lstTask.begin();
for (; it != g_lstTask.end(); it++)
{
if (it->rq_type == TASK_TYPE_FAULT)
{
tm_anchor.tv_sec = it->tv_creat.tv_sec;
tm_anchor.tv_usec = it->tv_creat.tv_usec;
break;
}
}
if (tm_anchor.tv_sec >= 0)
{
pthread_mutex_lock(&trig_list_mutex);
FDIR_POINT_TRIG_LIST::iterator it_trig_list;
for (it_trig_list = g_lstTrig.begin(); it_trig_list != g_lstTrig.end(); it_trig_list++)
{
//找到该故障的启动故障信号在故障信号列表中的位置
if (it_trig_list->tm_add.tv_sec == it->tv_creat.tv_sec
&& it_trig_list->tm_add.tv_usec == it->tv_creat.tv_usec)
{
break;
}
}
if (it_trig_list != g_lstTrig.end())
{
//前30秒
FDIR_POINT_TRIG_LIST::iterator itTemp = it_trig_list;
while (itTemp != g_lstTrig.begin())
{
itTemp--;
int span = it_trig_list->tm_add.tv_sec - itTemp->tm_add.tv_sec;
if (span > g_FdirConfig.TIMEOUT_PROTPNT)
{
break;
}
else
{
}
}
//删除信号列表中往前30秒外的故障信号
if (itTemp != g_lstTrig.begin())
{
g_lstTrig.erase(g_lstTrig.begin(), itTemp);
TRACE("删除故障列表中最早发生的故障30s前的故障信号\r\n");
}
}
else
{
//TRACE("未找到故障启动信号：%s\r\n", it->task_data.fault.head.fault_id);
}
pthread_mutex_unlock(&trig_list_mutex);
}
else
{
// TRACE("任务列表里无故障项！\r\n");
}
}
//写遥控日志信息
int conlog(const char *pointid, bool bOpen, const char *faultid, const char *operstyle)
{
//D5000遥控日志
return 1;
// assert(pointid != NULL);
// assert(faultid != NULL);
// assert(operstyle != NULL);
//
// timeval tv = { 0 };
// char groupid[100] = { 0 };
// struct tm fault_tm = { 0 };
// PSBOB::POINT point;
//
// TRACE("%s faultid:%s\r\n", __FUNCTION__, faultid);
//
// sscanf(faultid, "%04d/%02d/%02d %02d:%02d:%02d.%06ld", &fault_tm.tm_year, &fault_tm.tm_mon, &fault_tm.tm_mday, &fault_tm.tm_hour, &fault_tm.tm_min, &fault_tm.tm_sec, &tv.tv_usec);
// sprintf(groupid, "%04d%02d%02d%02d%02d%02d_%s", fault_tm.tm_year, fault_tm.tm_mon, fault_tm.tm_mday, fault_tm.tm_hour, fault_tm.tm_min, fault_tm.tm_sec, pointid);
//
// if (oodbread_rk(&point, const_cast<char*>(pointid), const_cast<TB_DESCR*>(g_db_psbob->GetTB("point")), sizeof(point)) <= 0)
// {
// TRACE("读取PSBOB-POINT表关键字为%s的记录失败，错误号：%d\r\n", pointid, _oodb_errno);
// return OO_FAIL;
// }
//
// gettimeofday(&tv, NULL);
// tm *ptm = localtime(&tv.tv_sec);
//
// sprintf(sql,
// "Insert into hisdb.VIORECORD (OPERTIME, OPERUSER, OPERNODE, CONTENT, POINTID, ENVIRONMENT, OPERNAME, OPERSTYLE, OPERMODE, OPERTYPE, OPERGUARDIAN, GROUPID) Values ('%04d-%02d-%02d %02d:%02d:%02d', '%s', '%s', '%s%s%s', '%s', '%s', '%s', '%s', NULL, 0, NULL, '%s')",
// ptm->tm_year + 1900, ptm->tm_mon + 1, ptm->tm_mday, ptm->tm_hour, ptm->tm_min, ptm->tm_sec, userid, hostname, point.descr, operstyle, bOpen ? "由闭合--拉开" : "由拉开--闭合", pointid,
// "realtime,scada,psbobpoint", "遥控", operstyle, groupid);
//
// return ExecSQL(sql);
}
int conlog(const char *pointid, const char *content, const char *faultid, const char *operstyle)
{
//D5000遥控日志
return 1;
// assert(pointid != NULL);
// assert(faultid != NULL);
// assert(operstyle != NULL);
// assert(content != NULL);
//
// timeval tv = { 0 };
// char groupid[100] = { 0 };
// struct tm fault_tm = { 0 };
// PSBOB::POINT point;
//
// TRACE("%s faultid:%s\r\n", __FUNCTION__, faultid);
//
// sscanf(faultid, "%04d/%02d/%02d %02d:%02d:%02d.%06ld", &fault_tm.tm_year, &fault_tm.tm_mon, &fault_tm.tm_mday, &fault_tm.tm_hour, &fault_tm.tm_min, &fault_tm.tm_sec, &tv.tv_usec);
// sprintf(groupid, "%04d%02d%02d%02d%02d%02d_%s", fault_tm.tm_year, fault_tm.tm_mon, fault_tm.tm_mday, fault_tm.tm_hour, fault_tm.tm_min, fault_tm.tm_sec, pointid);
//
// if (oodbread_rk(&point, const_cast<char*>(pointid), const_cast<TB_DESCR*>(g_db_psbob->GetTB("point")), sizeof(point)) <= 0)
// {
// TRACE("读取PSBOB-POINT表关键字为%s的记录失败，错误号：%d\r\n", pointid, _oodb_errno);
// return OO_FAIL;
// }
//
// gettimeofday(&tv, NULL);
// tm *ptm = localtime(&tv.tv_sec);
//
// sprintf(sql,
// "Insert into hisdb.VIORECORD (OPERTIME, OPERUSER, OPERNODE, CONTENT, POINTID, ENVIRONMENT, OPERNAME, OPERSTYLE, OPERMODE, OPERTYPE, OPERGUARDIAN, GROUPID) Values ('%04d-%02d-%02d %02d:%02d:%02d', '%s', '%s', '%s', '%s', '%s', '%s', '%s', NULL, 0, NULL, '%s')",
// ptm->tm_year + 1900, ptm->tm_mon + 1, ptm->tm_mday, ptm->tm_hour, ptm->tm_min, ptm->tm_sec, userid, hostname, content, pointid, "realtime,scada,psbobpoint", "遥控", operstyle, groupid);
//
// return ExecSQL(sql);
}
void restart_timer(int sig)
{
TRACE("进入重启定时器，程序重启！\r\n");
exit(0);
}
bool SetRestartTimer(int nsec)
{
struct itimerval value = { 0 }, ovalue = { 0 };
//////////////////////////
//取消已有定时器
if (setitimer(ITIMER_REAL, &value, &ovalue) == -1)
{
signal(SIGALRM, SIG_DFL );
return false;
}
if (signal(SIGALRM, SIG_DFL ) == SIG_ERR )
{
return false;
}
//////////////////////////////////
//设置新的定时器
if (signal(SIGALRM, restart_timer) == SIG_ERR )
{
return false;
}
//距离下次整点的秒数
value.it_value.tv_sec = nsec;
value.it_value.tv_usec = 0;
//1小时
value.it_interval.tv_sec = nsec;
value.it_interval.tv_usec = 0;
if (setitimer(ITIMER_REAL, &value, &ovalue) == -1)
{
signal(SIGALRM, SIG_DFL );
return false;
}
TRACE("将重启定时器设置在%d秒后……\r\n", value.it_value.tv_sec);
return true;
}
void thread_process(void *param)
{
cout << "命令处理线程启动……" << endl;
while (true)
{
//模型结构发生变化后，程序退出，然后等待守护进程去重新启动。
if (*model_chg_ntf != last_model_chg_ntf && *model_chg_ntf != 0)
{
TRACE("\033[31m模型结构变化。%ld\033[0m\r\n", *model_chg_ntf);
last_model_chg_ntf = *model_chg_ntf;
//exit(0);
SetRestartTimer(5 * 60);
}
pthread_mutex_lock(&task_list_mutex);
pthread_mutex_lock(&simu_sync_mutex);
if (g_lstTask.size() > 0)
{
if (version == VERSION_REALTIME)
{
clear_timeout_trig();
}
FDIR_TASK_LIST::iterator it = g_lstTask.begin();
for (; it != g_lstTask.end(); it++)
{
timeval tm_now;
gettimeofday(&tm_now, NULL);
float cost = tm_now.tv_sec * 1000 * 1000 + tm_now.tv_usec - (it->tv_creat.tv_sec * 1000 * 1000 + it->tv_creat.tv_usec);
cost = cost / 1000 / 1000;
switch (it->rq_type)
{
//做遥控
case TASK_TYPE_CB_CTRL:
{
int ph = -1;
if (it->task_data.control.status == TASK_CTL_STATUS_WAIT)
{
if (version == VERSION_REALTIME)
{
DoControl(it->task_data.control.point_name, true, it->task_data.control.bOpen);
// if ((ph = oodbget_ph(const_cast<TB_DESCR*>(g_db_psbob->GetTB("point")), it->task_data.control.point_name)) == OO_FAIL)
// {
// printf("%s 获取%s物理号失败，errno:%d, line:%d\r\n", __FUNCTION__, it->task_data.control.point_name, _oodb_errno, __LINE__);
//
// pthread_mutex_unlock(&task_list_mutex);
//
// continue;
// }
//
// if (it->task_data.control.bOpen) //故障隔离
// {
// //发真实遥控指令
// if (!g_FdirConfig.SIMULATE)
// {
// PS_TEL_DIGCTRL sel_cb = { 0 };
//
// strcpy(sel_cb.id, it->task_data.control.point_name);
// sel_cb.op = 2;
// sel_cb.op_type = 2;
// sel_cb.src_flag = 255;
//
// printf("send_event(%d) %s return %d\r\n", EVPS_TEL_DIGCTRL_SELECT, sel_cb.id, bob_inv->send_event(EVPS_TEL_DIGCTRL_SELECT, (char *) &sel_cb, sizeof(sel_cb)));
// }
// //发遥信变位事件,模拟遥控
// else
// {
// COM_POINT_DATA data = { ph, 0, 1, 0 };
//
// printf("send_event(%d) return %d\r\n", EVPS_CPNTCHG, bob_inv->send_event(EVPS_CPNTCHG, (char *) &data, sizeof(data)));
// }
// }
// else
// {
// //发真实遥控指令
// if (!g_FdirConfig.SIMULATE)
// {
// PS_TEL_DIGCTRL sel_cb = { 0 };
//
// strcpy(sel_cb.id, it->task_data.control.point_name);
// sel_cb.op = 1;
// sel_cb.op_type = 2;
// sel_cb.src_flag = 255;
//
// printf("send_event(%d) %s return %d\r\n", EVPS_TEL_DIGCTRL_SELECT, sel_cb.id, bob_inv->send_event(EVPS_TEL_DIGCTRL_SELECT, (char *) &sel_cb, sizeof(sel_cb)));
// }
// //发遥信变位事件,模拟遥控
// else
// {
// COM_POINT_DATA data = { ph, 1, 1, 0 };
//
// printf("send_event(%d) return %d\r\n", EVPS_CPNTCHG, bob_inv->send_event(EVPS_CPNTCHG, (char *) &data, sizeof(data)));
// }
// }
//
it->task_data.control.status = TASK_CTL_STATUS_RUN;
}
else
{
PSBOB::CB psbob_cb = { 0 };
if (oodbread_rk(&psbob_cb, &it->task_data.control.point_name, const_cast<TB_DESCR*>(g_db_psbob->GetTB("breaker")), sizeof(psbob_cb)) <= 0)
{
it->task_data.control.status = TASK_CTL_STATUS_RUN;
printf("%s(%d):读取PSBOB库POINT表关键字为%ld的记录失败，错误号：%d\r\n", __FUNCTION__, __LINE__, it->task_data.control.point_name, _oodb_errno);
}
else
{
if (HasMask(g_db_psbob->GetTB("breaker"), "status", psbob_cb.status , MENU_STATE_DEV_MANUAL))
{
it->task_data.control.status = TASK_CTL_STATUS_RUN;
}
else
{
if (it->task_data.control.bOpen)
{
psbob_cb.point = 0;
}
else
{
psbob_cb.point = 1;
}
if (oodbupdate_rk(&psbob_cb, &it->task_data.control.point_name, const_cast<TB_DESCR*>(g_db_psbob->GetTB("breaker")), sizeof(psbob_cb)) == OO_FAIL)
{
it->task_data.control.status = TASK_CTL_STATUS_RUN;
printf("%s(%d):更新PSBOB库POINT表关键字为%ld的记录失败，错误号：%d\r\n", __FUNCTION__, __LINE__, it->task_data.control.point_name, _oodb_errno);
}
else
{
ControlSucceed(it->task_data.control.head.group_id, it->task_data.control.point_name, it->task_data.control.stage, false);
list<CB_CONTROL> lstCB;
FDIR_TASK_LIST::iterator it_fault;
char fault_id[FAULT_ID_LENGTH] = { 0 };
strcpy(fault_id, it->task_data.control.head.group_id);
if (GetLeftStep(fault_id, lstCB) == 0)
{
ClearFdirDB(fault_id);
sprintf(sql, "UPDATE FDIR_FDIRECT_HIS SET STATUS=%d WHERE groupid=\'%s\'", STATUS_FDIRECT_FINISH, fault_id);
if (ExecSQL(sql) != OCI_ERROR)
{
sprintf(sql, "UPDATE FDIR_FDIRECT SET STATUS=%d WHERE groupid=\'%s\'", STATUS_FDIRECT_FINISH, fault_id);
ExecSQL(sql);
}
RemoveTasks(fault_id);
printf("故障组%s处理完成！！！！\r\n", fault_id);
}
else
{
for (it_fault = g_lstTask.begin(); it_fault != g_lstTask.end(); it_fault++)
{
if (it_fault->rq_type == TASK_TYPE_FAULT)
{
if (strcmp(it_fault->task_data.fault.head.group_id, it->task_data.control.head.group_id) == 0)
{
it_fault->status = 1;
if (it_fault->task_data.fault.bAuto == 1)
AddControlItem(fault_id, lstCB.begin()->point_id, lstCB.begin()->bOpen, lstCB.begin()->stage);
else
{
printf("遥控%ld所在故障组%s非自动执行模式！！\r\n", it->task_data.control.point_name, it->task_data.control.head.group_id);
}
for (FDIR_TASK_LIST::iterator it_temp = it_fault; it_temp != g_lstTask.end(); it_temp++)
{
if ((it_temp->rq_type == TASK_TYPE_FAULT) && (strcmp(it_temp->task_data.fault.head.group_id, it->task_data.control.head.group_id) == 0))
{
it_temp->status = 1;
}
}
break;
}
}
}
if (it_fault == g_lstTask.end())
{
printf("未找到遥控%ld所在故障组%s对应的故障项，无法判断其是否为自动执行模式！！！\r\n", it->task_data.control.point_name, it->task_data.control.head.group_id);
}
}
g_lstTask.erase(it);
it = g_lstTask.begin();
}
}
}
}
}
else if (it->task_data.control.status == TASK_CTL_STATUS_RUN)
{
if (cost > g_FdirConfig.TIMEOUT_CONTROL)
{
printf("[%.2fs]故障%s遥控%ld超时，从任务列表删除\r\n", cost, it->task_data.control.head.fault_id, it->task_data.control.point_name);
ControlFailed(it->task_data.control.head.group_id, it->task_data.control.point_name, it->task_data.control.stage);
g_lstTask.erase(it);
it = g_lstTask.begin();
}
else
{
PSBOB::CB psbob_cb = { 0 };
if (oodbread_rk(&psbob_cb, &it->task_data.control.point_name, const_cast<TB_DESCR*>(g_db_psbob->GetTB("breaker")), sizeof(psbob_cb)) <= 0)
{
TRACE("读取breaker表关键字为%ld的记录失败！\r\n", it->task_data.control.point_name);
}
else
{
//开关已经为遥控目标状态
if ((psbob_cb.point > 0 && !it->task_data.control.bOpen) || (psbob_cb.point <= 0 && it->task_data.control.bOpen)
|| !IsInRegion(psbob_cb.id)) //进线开关为主网开关，无法遥控
{
ControlSucceed(it->task_data.control.head.group_id, it->task_data.control.point_name, it->task_data.control.stage, false);
list<CB_CONTROL> lstCB;
FDIR_TASK_LIST::iterator it_fault;
char fault_id[FAULT_ID_LENGTH] = { 0 };
strcpy(fault_id, it->task_data.control.head.group_id);
if (GetLeftStep(fault_id, lstCB) == 0)
{
ClearFdirDB(fault_id);
sprintf(sql, "UPDATE FDIR_FDIRECT_HIS SET STATUS=%d WHERE groupid=\'%s\'", STATUS_FDIRECT_FINISH, fault_id);
if (ExecSQL(sql) != OCI_ERROR)
{
sprintf(sql, "UPDATE FDIR_FDIRECT SET STATUS=%d WHERE groupid=\'%s\'", STATUS_FDIRECT_FINISH, fault_id);
ExecSQL(sql);
}
RemoveTasks(fault_id);
printf("故障组%s处理完成！！！！\r\n", fault_id);
}
else
{
for (it_fault = g_lstTask.begin(); it_fault != g_lstTask.end(); it_fault++)
{
if (it_fault->rq_type == TASK_TYPE_FAULT)
{
if (strcmp(it_fault->task_data.fault.head.group_id, it->task_data.control.head.group_id) == 0)
{
it_fault->status = 1;
if (it_fault->task_data.fault.bAuto == 1)
AddControlItem(fault_id, lstCB.begin()->point_id, lstCB.begin()->bOpen, lstCB.begin()->stage);
else
{
printf("遥控%ld所在故障组%s非自动执行模式！！\r\n", it->task_data.control.point_name, it->task_data.control.head.group_id);
}
for (FDIR_TASK_LIST::iterator it_temp = it_fault; it_temp != g_lstTask.end(); it_temp++)
{
if ((it_temp->rq_type == TASK_TYPE_FAULT) && (strcmp(it_temp->task_data.fault.head.group_id, it->task_data.control.head.group_id) == 0))
{
it_temp->status = 1;
}
}
break;
}
}
}
if (it_fault == g_lstTask.end())
{
printf("未找到遥控%ld所在故障组%s对应的故障项，无法判断其是否为自动执行模式！！！\r\n", it->task_data.control.point_name, it->task_data.control.head.group_id);
}
}
it->task_data.control.status = TASK_CTL_STATUS_FINISH;
}
}
}
}
//以遥信变位作为遥控执行完成的条件
else if (it->task_data.control.status == TASK_CTL_STATUS_FINISH)
{
//接收所有返回消息超时
if (cost > g_FdirConfig.TIMEOUT_CONTROL)
{
printf("[%.2fs]故障%s遥控%ld接收消息时限已到，从任务列表删除\r\n", cost, it->task_data.control.head.fault_id, it->task_data.control.point_name);
g_lstTask.erase(it);
it = g_lstTask.begin();
}
}
break;
}
//故障项
case TASK_TYPE_FAULT:
{
switch (it->task_data.fault.next_step)
{
case TASK_FAULT_STATUS_CALC:
{
if(it->task_data.fault.type == TASK_FAULT_LD || it->task_data.fault.type == TASK_FAULT_JXCB)
{
PSBOB::CB psbob_cb = {0};
if(oodbread_rk(&psbob_cb, &it->task_data.fault.point_name, const_cast<TB_DESCR*>(g_db_psbob->GetTB("breaker")), sizeof(psbob_cb)) <= 0)
{
printf("%s(%d):读取PSBOB库断路器表关键字为%ld的记录失败，错误号为:%d\r\n", __FUNCTION__, __LINE__, it->task_data.fault.point_name, _oodb_errno);
}
//跳闸开关已经合闸，故障已经恢复
if (it->task_data.fault.type == TASK_FAULT_JXCB)
{
if (psbob_cb.point == 1)
{
printf("+++++++++++++跳闸开关%ld已经合闸，故障已经恢复\n", it->task_data.fault.point_name);
RemoveTask(it->task_data.fault.head.fault_id);
it = g_lstTask.begin();
printf("point.value is %d\n", psbob_cb.point);
break;
}
}
}
string lst_cb;
it->task_data.fault.fdir_r->data_start.type = it->task_data.fault.type;
it->task_data.fault.fdir_r->data_start.source.bus_id= it->task_data.fault.point_name;
cout << "定位故障:" << it->task_data.fault.head.fault_id << "，并计算隔离恢复方案。" << endl;
gettimeofday(&it->tv_start, NULL);
switch (it->task_data.fault.fdir_r->FaultDetection())
{
case FDIR_R_SUCCEED:
{
printf("故障定位成功\n");
//将故障使用过的故障信号使用次数加1
pthread_mutex_lock(&trig_list_mutex);
for (FDIR_POINT_TRIG_SECTION::iterator it_used_trig = g_lstSecTrig.begin(); it_used_trig != g_lstSecTrig.end(); it_used_trig++)
{
printf("故障信号：key_id:%ld, st_id:%ld使用次数加1\r\n", (*it_used_trig)->alarm.key_id, (*it_used_trig)->alarm.st_id);
(*it_used_trig)->lst_fault.push_back(it->task_data.fault.head.fault_id);
it->task_data.fault.trig_list.push_back(**it_used_trig);
}
pthread_mutex_unlock(&trig_list_mutex);
printf("故障定位成功\n");
//为多重故障分组，故障先只计算到定位这一步
it->task_data.fault.next_step = TASK_FAULT_STATUS_CALC_ISO;
//生成故障描述文本文件
form_fdir_txt(*it);
//为多重故障分组，故障先只计算到定位这一步
it->task_data.fault.next_step = TASK_FAULT_STATUS_CALC_ISO;
break;
}
case FDIR_FAIL_DIRECT:
{
//将故障使用过的故障信号使用次数加1
pthread_mutex_lock(&trig_list_mutex);
for (FDIR_POINT_TRIG_SECTION::iterator it_used_trig = g_lstSecTrig.begin(); it_used_trig != g_lstSecTrig.end(); it_used_trig++)
{
printf("故障信号：key_id:%ld, st_id:%ld使用次数加1\r\n", (*it_used_trig)->alarm.key_id, (*it_used_trig)->alarm.st_id);
(*it_used_trig)->lst_fault.push_back(it->task_data.fault.head.fault_id);
it->task_data.fault.trig_list.push_back(**it_used_trig);
}
pthread_mutex_unlock(&trig_list_mutex);
TRACE("it->task_data.fault.point_name:%ld\r\n", it->task_data.fault.point_name);
PSBOB::DV dv = { 0 };
oodbread_rk(&dv, &it->task_data.fault.dv, const_cast<TB_DESCR*>(g_db_psbob->GetTB("subcontrolarea")), sizeof(PSBOB::DV));
// PSBOB::ST st_info = { 0 };
//
// if (dv.id != 0)
// {
// GetStbyDv(dv.id, st_info);
// }
// if (st_info.id == 0)
// {
// printf("读取st失败，dv为：%ld, line:%d\r\n", dv.id, __LINE__);
// }
//写故障信号表
TRACE("写故障信号表！\r\n");
int pos = 0;
for (FDIR_POINT_TRIG_LIST::iterator it_trig_list = it->task_data.fault.trig_list.begin(); it_trig_list != it->task_data.fault.trig_list.end(); it_trig_list++, pos++)
{
sprintf(sql, "INSERT INTO PMS_PARAM.FDIR_ALARM (ID, TM_ADD, OCCUR_TIME, MSEC, KEY_ID, NAME, ST_ID, TYPE, STATUS) VALUES (\'%s\',%ld, %ld, %d, %ld, \'%s\', %ld, %d, %d)", it->task_data.fault.head.fault_id
,it_trig_list->tm_add.tv_sec, it_trig_list->alarm.occur_time, it_trig_list->alarm.msec, it_trig_list->alarm.key_id, it_trig_list->alarm.name.c_str(), it_trig_list->alarm.st_id, it_trig_list->alarm.type, it_trig_list->alarm.status);
ExecSQL(sql);
}
sprintf(sql, "Insert into PMS_PARAM.FDIR_FDIRECT (ID, GROUPID, STATUS, TYPE, STUDY_EQ, FD, FD_DESCR, ST_ID) Values (\'%s\', \'%s\', 0, 0, \'%ld\', \'%ld\', \'%s\', \'%ld\')",
it->task_data.fault.head.fault_id, it->task_data.fault.head.fault_id, it->task_data.fault.point_name, dv.id, dv.name, it->task_data.fault.st);
ExecSQL(sql);
//写模拟态故障信号表
TRACE("写入故障模拟关系库！\r\n");
if ((it->task_data.fault.signal_type) == TRIG_TYPE_SIMU)
{
sprintf(sql, "UPDATE PMS_PARAM.FDIR_SIG_SUMMARY SET RUN_TIME=(SELECT RUN_TIME FROM PMS_PARAM.FDIR_SIG_SUMMARY WHERE ID=\'%s\')+1, \"INDEX\"=(SELECT RUN_TIME FROM PMS_PARAM.FDIR_SIG_SUMMARY WHERE ID=\'%s\')+1 WHERE ID=\'%s\' ",
it->task_data.fault.simu_plan_id.c_str(), it->task_data.fault.simu_plan_id.c_str(), it->task_data.fault.simu_plan_id.c_str());
ExecSQL(sql);
sprintf(sql, "SELECT ID FROM PMS_PARAM.FDIR_SIG_FAULT WHERE ID LIKE \'%s\'",
it->task_data.fault.simu_plan_id.c_str());
char *buf = NULL;
int rec_num, attr_num;
struct ORA_ATTR *attrs = NULL;
pthread_mutex_lock(&oci_mutex);
int ret = g_oci->ReadWithBind(sql, &buf, &rec_num, &attr_num, &attrs);
pthread_mutex_unlock(&oci_mutex);
if (ret != OCI_ERROR)
{
if (rec_num == 0)
{
sprintf(sql, "INSERT INTO PMS_PARAM.FDIR_SIG_FAULT(ID, FAULT_INDEX, FAULT_ID)VALUES(\'%s\', 0, \'%s\')",
it->task_data.fault.simu_plan_id.c_str(), it->task_data.fault.head.fault_id);
ExecSQL(sql);
}
}
sprintf(sql, "INSERT INTO PMS_PARAM.FDIR_SIG_FAULT(ID, FAULT_INDEX, FAULT_ID)VALUES(\'%s\', (select max(FAULT_INDEX) from pms_param.fdir_sig_fault where id like \'%s%\')+1, \'%s\')",
it->task_data.fault.simu_plan_id.c_str(), it->task_data.fault.simu_plan_id.c_str(), it->task_data.fault.head.fault_id);
ExecSQL(sql);
g_is_write_to_lib = true;
pthread_mutex_unlock(&simu_sync_mutex);
}
TRACE("故障%s定位失败，将从任务列表中删除\r\n", it->task_data.fault.head.fault_id);
if (version == VERSION_REALTIME)
{
//D5000发故障隔离恢复事件
Notify(it->task_data.fault.head.fault_id, it->task_data.fault.dv, it->task_data.fault.st);
}
else if (version == VERSION_STUDY)
{
}
// g_lstTask.erase(it);
RemoveTask(it->task_data.fault.head.fault_id);
it = g_lstTask.begin();
break;
}
default:
break;
}
// it->task_data.fault.next_step = TASK_FAULT_STATUS_ISO;
break;
}
case TASK_FAULT_STATUS_WAIT:
{
if (cost > g_FdirConfig.TIMEOUT_FAULT) //故障启动超时，可能进线开关重合闸成功
{
printf("[%.2fs]故障%s启动超时，从任务列表删除，可能进线开关重合闸成功\r\n", cost, it->task_data.fault.head.fault_id);
// g_lstTask.erase(it);
// it = g_lstTask.begin();
RemoveTask(it->task_data.fault.head.fault_id);
it = g_lstTask.begin();
}
break;
}
case TASK_FAULT_STATUS_ISO:
{
if ((cost > g_FdirConfig.TIMEOUT_AUTO && g_FdirConfig.USER2AUTO) || it->task_data.fault.bAuto == 1)
{
//超时，允许转自动
if (/*g_FdirConfig.USER2AUTO && */it->task_data.fault.bAuto == 0)
{
printf("[%.2fs]执行隔离恢复超时，转自动继续执行。\r\n", cost);
it->task_data.fault.bAuto = 1;
FormFdirStep(it->task_data.fault.head.group_id);
list<CB_CONTROL> lstcb;
GetLeftStep(it->task_data.fault.head.fault_id, lstcb);
//还有步骤未执行
if (lstcb.size() > 0)
{
AddControlItem(it->task_data.fault.head.fault_id, lstcb.begin()->point_id, lstcb.begin()->bOpen, lstcb.begin()->stage);
}
else
{
}
}
}
break;
}
case TASK_FAULT_STATUS_PROCESS:
{
// cout << "故障:" << it->task_data.fault.head.fault_id << "正在恢复" << endl;
break;
}
case TASK_FAULT_STATUS_SLEEP:
{
pthread_mutex_lock(&trig_list_mutex);
FDIR_POINT_TRIG_LIST::iterator it_trig_list;
for (it_trig_list = g_lstTrig.begin(); it_trig_list != g_lstTrig.end(); it_trig_list++)
{
//找到该故障的启动故障信号在故障信号列表中的位置
if (it_trig_list->tm_add.tv_sec == it->tv_creat.tv_sec && it_trig_list->tm_add.tv_usec == it->tv_creat.tv_usec)
{
break;
}
}
if (it_trig_list != g_lstTrig.end())
{
int sleeptime = g_FdirConfig.TIMEOUT_PROTPNT;
#ifdef _QingHai_
if (strcmp(it_trig_list->psbob_data.point.devtype, "faultinfo") == 0)
{
PSBOB::FAULTINFO fault =
{ 0};
if (oodbread_rk(&fault, it_trig_list->psbob_data.point.classid, const_cast<TB_DESCR*>(g_db_psbob->GetTB("faultinfo")), sizeof(PSBOB::FAULTINFO)) == OO_FAIL)
{
cout<<"读取故障指示器记录失败,故障指示器point id ： "<<it_trig_list->psbob_data.point.id<<" ,"<<__FUNCTION__<<endl;
}
else
{
if (strcmp(fault.jdpointid, it_trig_list->psbob_data.point.id) == 0)
{
sleeptime += g_FdirConfig.TIMEOUT_JD_FAULT;
}
}
}
#endif
if (cost > sleeptime) //故障启动超时，可能进线开关重合闸成功
{
printf("[%.2fs]故障%s所有开关过流信号已经送达\r\n", cost, it->task_data.fault.head.fault_id);
//将故障启动信号前后30秒的故障信号准备好
g_lstSecTrig.clear();
//后30秒
FDIR_POINT_TRIG_LIST::iterator itTemp = it_trig_list;
while (itTemp != g_lstTrig.end())
{
int span = itTemp->tm_add.tv_sec - it_trig_list->tm_add.tv_sec;
if (span > g_FdirConfig.TIMEOUT_PROTPNT)
{
break;
}
else
{
printf("故障信号：key_id:%ld, st_id:%ld添加到定位信号列表[-%ds]\r\n", itTemp->alarm.key_id, itTemp->alarm.st_id, span);
g_lstSecTrig.push_back(&(*itTemp));
}
itTemp++;
};
//前30秒
itTemp = it_trig_list;
while (itTemp != g_lstTrig.begin())
{
itTemp--;
int span = it_trig_list->tm_add.tv_sec - itTemp->tm_add.tv_sec;
if (span > g_FdirConfig.TIMEOUT_PROTPNT)
{
break;
}
else
{
g_lstSecTrig.push_back(&(*itTemp));
printf("故障信号：key_id:%ld, st_id:%ld添加到定位信号列表[%ds]\r\n", itTemp->alarm.key_id, itTemp->alarm.st_id, span);
}
}
it->task_data.fault.next_step = TASK_FAULT_STATUS_CALC;
}
else
{
printf("[%.2fs]故障%s正在等待所有开关过流信号送达\r\n", cost, it->task_data.fault.head.fault_id);
}
}
pthread_mutex_unlock(&trig_list_mutex);
break;
}
case TASK_FAULT_STATUS_CALC_ISO:
{
//研究态下的分组
if (version == VERSION_STUDY)
{
if (GroupFault(g_lstTask) == FDIR_R_SUCCEED)
{
printf("分组完成\n");
}
break;
}
bool bCanGroup = false; //是否可以开始分组了
bool bhas_unused_trig = false; //是否存在未定位完成的故障信号
pthread_mutex_lock(&trig_list_mutex);
for (FDIR_POINT_TRIG_LIST::iterator it_trig = g_lstTrig.begin(); it_trig != g_lstTrig.end(); it_trig++)
{
//先在信号列表中找到该故障的启动故障信号,该故障信号即为故障的启动故障信号
if (it_trig->tm_add.tv_sec == it->tv_creat.tv_sec && it_trig->tm_add.tv_usec == it->tv_creat.tv_usec)
{
printf("key_id:%ld,st_id:%ld为故障%s的启动信号！！！！！\r\n", it_trig->alarm.key_id, it_trig->alarm.st_id, it->task_data.fault.head.fault_id);
//以该信号为锚点
timeval tm_anchor = { it_trig->tm_add.tv_sec, it_trig->tm_add.tv_usec };
//检查该故障收集信号的30秒内是否有未定位的故障和其它故障
FDIR_POINT_TRIG_LIST::iterator it_trig_tmp = it_trig;
int span = 0;
while (true)
{
if ((++it_trig_tmp) == g_lstTrig.end())
{
break;
}
//先判断该信号是否在30秒区间内
span = it_trig_tmp->tm_add.tv_sec - tm_anchor.tv_sec;
if (span > g_FdirConfig.TIMEOUT_PROTPNT)
{
break;
}
//存在未定位完成的故障信号，需要等待该故障信号定位完成
if ((it_trig_tmp->lst_fault.size() <= 0) /*&& (strcmp(it_trig_tmp->alarm.fault_info, key[1]) == 0 || strcmp(it_trig_tmp->alarm.fault_info, key[2]) == 0)*/)
{
bhas_unused_trig = true;
break;
}
//30秒内有其它故障B，重新检查故障B收集信号的30秒
if (it_trig_tmp->lst_fault.size() > 0)
{
if (strcmp(it_trig_tmp->lst_fault.back().c_str(), it->task_data.fault.head.fault_id) != 0)
{
tm_anchor.tv_sec = it_trig_tmp->tm_add.tv_sec;
tm_anchor.tv_usec = it_trig_tmp->tm_add.tv_usec;
}
}
}
if (!bhas_unused_trig)
{
bCanGroup = true;
}
break;
}
}
pthread_mutex_unlock(&trig_list_mutex);
if (bCanGroup)
{
TRACE("开始进行分组\r\n");
if (GroupFault(g_lstTask) == FDIR_R_SUCCEED)
{
printf("分组完成\n");
}
}
printf("TASK_FAULT_STATUS_CALC_ISO out\n");
break;
}
case TASK_FAULT_STATUS_GROUPED:
{
FDIR_TASK_LIST::iterator itTemp;
list<FDIR_R2*> lst_fdir_r2;
map<FDIR_R2*, FDIR_TASK*> map_fdir_task;
printf("开始计算组号为%s的操作方案，该组的故障有：\r\n", it->task_data.fault.head.group_id);
for (itTemp = g_lstTask.begin(); itTemp != g_lstTask.end(); itTemp++)
{
if (itTemp->rq_type != TASK_TYPE_FAULT)
continue;
if (strcmp(itTemp->task_data.fault.head.group_id, it->task_data.fault.head.group_id) == 0)
{
lst_fdir_r2.push_back(itTemp->task_data.fault.fdir_r);
map_fdir_task[itTemp->task_data.fault.fdir_r] = &(*itTemp);
itTemp->task_data.fault.next_step = TASK_FAULT_STATUS_CALC_STEP;
cout << it->task_data.fault.head.group_id << "->" << itTemp->task_data.fault.head.fault_id << endl;
}
}
list<list<MAP_SO_NODE> > lst_steps,lst_steps2;
int calc_ret = calc_restore_step(lst_fdir_r2, lst_steps); //计算主站遥控方案
int calc_ret2 = calc_restore_step(lst_fdir_r2, lst_steps2, false); //计算最小停电方案
char *table_name = new char[10];
bzero(table_name, 10);
if (it->task_data.fault.bAuto == 2)
{
sprintf(table_name, "_HIS");
}
////故障组中由于隔离或者跳闸导致失电的负荷，最终保存非故障不可恢复的负荷
list<FAULT_ITEM> lst_group_ld;
////故障组中由于隔离或者跳闸导致失电，存在恢复方案，可以恢复的负荷
list<FAULT_ITEM> lst_able_res;
//首先把故障定位信息写入数据库中,隔离和恢复步骤根据返回结果分别写入
for (map<FDIR_R2*, FDIR_TASK*>::iterator it_map_fdir_task = map_fdir_task.begin(); it_map_fdir_task != map_fdir_task.end(); it_map_fdir_task++)
{
lst_group_ld.splice(lst_group_ld.end(), it_map_fdir_task->first->m_ld);
string lst_cb;
char fault_area[1024] = { 0 };
// PSBOB::ST st = { 0 };
PSBOB::DV dv = { 0 };
int faultzones = it_map_fdir_task->first->getfaultzone();
// it_map_fdir_task->first->GetDVByZone(faultzones, dv);
oodbread_rk(&dv, &(it_map_fdir_task->second->task_data.fault.dv), const_cast<TB_DESCR*>(g_db_psbob->GetTB("subcontrolarea")), sizeof(PSBOB::DV));
if (dv.id == 0)
{
printf("读取DV失败:故障区段为%d，errno:%d,line:%d\r\n", faultzones, _oodb_errno, __LINE__);
}
else
{
// if (GetStbyDv(dv.id, st) != 0)
// {
// printf("读取ST失败:DV为%ld，errno:%d,line:%d\r\n", dv.id, _oodb_errno, __LINE__);
// }
}
it_map_fdir_task->first->get_zone_cb(it_map_fdir_task->first->getfaultzone(), lst_cb);
//设置故障区域起始设备
FAULT_ITEM head;
list<FAULT_ITEM> tail;
it_map_fdir_task->first->get_fault_area(head, tail);
//负荷单点故障的故障设备只需写入负荷自己而已
if (it_map_fdir_task->first->b_ld_fault)
{
sprintf(sql, "INSERT INTO FDIR_FAULT_DEV (ID, DEV_ID, DEV_TABLE, EDGE, FLAG) VALUES (\'%s\', \'%ld\', \'%s\', %d, 1)",
it_map_fdir_task->second->task_data.fault.head.fault_id, head.eq_id, head.table.c_str(), 1);
ExecSQL(sql);
}
else
{
//故障区域设备写入数据库中
write_fault_dev(it_map_fdir_task->second->task_data.fault.head.fault_id, table_name, it_map_fdir_task->first);
}
//将故障信号、误报信号 、漏报信号拼接成字符串
string str_point, str_err_point, str_mis_point;
list<FAULT_ITEM>::iterator it_recv_point;
for (it_recv_point = it_map_fdir_task->first->lst_point.begin(); it_recv_point != it_map_fdir_task->first->lst_point.end(); it_recv_point++)
{
char str_fault_item[100];
if (strcmp(it_recv_point->table.c_str(), "FI") == 0)
{
sprintf(str_fault_item, "%ld[%s]", it_recv_point->id, it_recv_point->table.c_str());
}
else
{
sprintf(str_fault_item, "%ld[%s]", it_recv_point->eq_id, it_recv_point->table.c_str());
}
str_point += str_fault_item;
str_point += ";";
}
list<long>::iterator it_point;
char err_point[30];
char mis_point[30];
for (it_point = it_map_fdir_task->first->lst_err_point.begin(); it_point != it_map_fdir_task->first->lst_err_point.end(); it_point++)
{
sprintf(err_point, "%ld", *it_point);
str_err_point += err_point;
str_err_point += ";";
}
for (it_point = it_map_fdir_task->first->lst_mis_point.begin(); it_point != it_map_fdir_task->first->lst_mis_point.end(); it_point++)
{
sprintf(mis_point, "%ld", *it_point);
str_mis_point += mis_point;
str_mis_point += ";";
}
string manual_restore;
for (it_point = it_map_fdir_task->first->lst_restore.begin(); it_point != it_map_fdir_task->first->lst_restore.end(); it_point++)
{
char sz_manual_point[30];
sprintf(sz_manual_point, "%ld", *it_point);
PSBOB::CB point = { 0 };
manual_restore += sz_manual_point;
if (is_controllable(*it_point))
manual_restore += "[0];";
else
manual_restore += ";";
}
//西宁配网直接将故障区段开关转化为fault_area
fault_area[0] = 0;
long fault_cb = it_map_fdir_task->first->getfaultcb();
sprintf(fault_area, "%ld[%s]", head.eq_id, head.table.c_str());
for (list<FAULT_ITEM>::iterator it_tail = tail.begin(); it_tail != tail.end(); it_tail++)
{
char tmp[256] = { 0 };
sprintf(tmp, ";%ld[%s]", it_tail->eq_id, it_tail->table.c_str());
strcat(fault_area, tmp);
}
//写故障信号表
TRACE("写故障信号表！\r\n");
int pos = 0;
for (FDIR_POINT_TRIG_LIST::iterator it_trig_list = it_map_fdir_task->second->task_data.fault.trig_list.begin();
it_trig_list != it_map_fdir_task->second->task_data.fault.trig_list.end(); it_trig_list++, pos++)
{
sprintf(sql, "INSERT INTO PMS_PARAM.FDIR_ALARM (ID, TM_ADD, OCCUR_TIME, MSEC, KEY_ID, NAME, ST_ID, TYPE, STATUS) VALUES (\'%s\', %ld, %ld, %d, %ld, \'%s\', %ld, %d, %d)", it_map_fdir_task->second->task_data.fault.head.fault_id
,it_trig_list->tm_add.tv_sec, it_trig_list->alarm.occur_time, it_trig_list->alarm.msec, it_trig_list->alarm.key_id, it_trig_list->alarm.name.c_str(), it_trig_list->alarm.st_id, it_trig_list->alarm.type, it_trig_list->alarm.status);
ExecSQL(sql);
}
//写不能隔离、不能跳闸、老数据等开关
TRACE("写不能隔离、不能跳闸、老数据等开关！\r\n");
for (list<FDIR_CB_INFO>::iterator it_cb_info = it_map_fdir_task->first->lst_cb_info.begin(); it_cb_info != it_map_fdir_task->first->lst_cb_info.end(); it_cb_info++)
{
sprintf(sql,
"INSERT INTO PMS_PARAM.FDIR_CB_INFO(ID, CB_ID, CB_DESCR, PT_ID, CB_Q, CB_STATUS, PT_CONTROL, PT_TIMEXC, PT_QUALITY, TYPE) VALUES(\'%s\', \'%ld\', \'%s\', \'%ld\', %d, %d, %d, %d, %d, %d)",
it_map_fdir_task->second->task_data.fault.head.fault_id, it_cb_info->cb_id, it_cb_info->cb_descr, it_cb_info->pt_id, it_cb_info->cb_q, it_cb_info->cb_status,
it_cb_info->pt_control, it_cb_info->pt_timexc, it_cb_info->pt_quality, (int) it_cb_info->reason);
ExecSQL(sql);
}
//专家意见，有漏报故障信号的故障由需要由自动处理转为手动处理
if(it_map_fdir_task->first->lst_mis_point.size() > 0)
{
it_map_fdir_task->second->task_data.fault.bAuto = 0;
}
//将漏报信息写入关系库PMS_PARAM.FDIR_DEV_STATUS表中，DEV_STATUS字段为0时为漏报
for (it_point = it_map_fdir_task->first->lst_mis_point.begin(); it_point != it_map_fdir_task->first->lst_mis_point.end(); it_point++)
{
long lPrtId = *it_point;
string strDevTable;
string strDevDescr;
PSBOB::CB misCb;
PSBOB::FI misFi;
if (oodbread_rk(&misCb, &lPrtId, const_cast<TB_DESCR*>(g_db_psbob->GetTB("breaker")), sizeof(PSBOB::CB)) > 0)
{
strDevTable = "CB";
std::string strCb = string(misCb.name);
strDevDescr = strCb.append(string("故障信号"));
}
else if(oodbread_rk(&misFi, &lPrtId, const_cast<TB_DESCR*>(g_db_psbob->GetTB("faultinfo")), sizeof(PSBOB::FI)) > 0)
{
strDevTable = "FI";
strDevDescr = string(misFi.name) + "故障信号";
}
else
{
strDevTable = "未能识别的故障信号";
}
//将漏报信号写入实时库
sprintf(sql, "INSERT into PMS_PARAM.FDIR_DEV_STATUS (FAULT_ID, DEV_ID, DEV_TABLE, DEV_STATUS, DEV_DESCR) VALUES (\'%s\', %ld, \'%s\', %d, \'%s\')",
it_map_fdir_task->second->task_data.fault.head.fault_id, lPrtId, strDevTable.c_str(), 0, strDevDescr.c_str());
ExecSQL(sql);
}
//获取实时库psbob的版本号
PSBOB::GLOBAL global = { 0 };
if (oodbread_rp(&global, 0, const_cast<TB_DESCR*>(g_db_psbob->GetTB("secinfo")), 1, sizeof(global)) <= 0)
{
TRACE("读取global记录失败\r\n");
}
//写故障定位表
int type = -1; //故障类型
switch (it_map_fdir_task->first->fault_type)
{
case FAULT_TYPE_NONE:
type = STATUS_FDIRECT_NONE;
break;
case FAULT_TYPE_SURE:
type = STATUS_FDIRECT_DIRECT_OK;
break;
case FAULT_TYPE_WINK:
type = STATUS_FDIRECT_WINK;
break;
case FAULT_TYPE_POSSIBLE:
type = STATUS_FDIRECT_POSSIBLE;
break;
case FAULT_TYPE_BUS:
type = STATUS_FDIRECT_DIRECT_OK;
break;
default:
break;
}
//杨勇 20141216 修改故障汇总表数据来源，解决进线开关故障推不到馈线图和不能推环网图的问题
long lStId = 0;
long lDVId = 0;
std::string strDVDescr;
if (it->task_data.fault.fdir_r->lFaultStId > 0)
{
PSBOB::ST faultSt = {0};
lStId = it->task_data.fault.fdir_r->lFaultStId;
int iRet = oodbread_rk(&faultSt, &lStId, const_cast<TB_DESCR*>(g_db_psbob->GetTB("substation")), sizeof(PSBOB::ST));
if (iRet > 0)
{
lDVId = faultSt.subarea_id;
PSBOB::DV faultDV = {0};
iRet = oodbread_rk(&faultDV, &lDVId, const_cast<TB_DESCR*>(g_db_psbob->GetTB("subcontrolarea")),sizeof(PSBOB::DV));
if (iRet <= 0)
{
TRACE("在区域表中查找关键字为%ld的记录失败啦！\r\n", lDVId);
}
else
{
TRACE("查询到的DVId：%ld\r\n", faultDV.id);
strDVDescr = faultDV.name;
}
}
}
if (lStId > 0 && lDVId > 0)
{
TRACE("New DV!!!!!!!!!!!!!!\r\n");
sprintf(sql,
"Insert into PMS_PARAM.FDIR_FDIRECT%s (ID, GROUPID, FD, FD_DESCR, ZONE, ST_ID, CB_ID, STATUS, STARTTYPE, ZONE_CB, FAULT_AREA, RECV_POINT, ERR_POINT, MIS_POINT, type, MANUAL_RESTORE, STUDY_EQ, AUTO_DEAL,EXT_STATUS,JXCB,DB_VERSION) "
"Values (\'%s\'/*ID*/, \'%s\'/*GROUPID*/, \'%ld\'/*FD*/, \'%s\'/*FD_DESCR*/, \'%d\'/*ZONE*/, \'%ld\'/*ST_ID*/, \'%ld\'/*CB_ID*/, %d/*STATUS*/, %d/*STARTTYPE*/, \'%s\'/*ZONE_CB*/, \'%s\'/*FAULT_AREA*/, \'%s\'/*RECV_POINT*/, \'%s\'/*ERR_POINT*/, \'%s\'/*MIS_POINT*/, %d/*type*/, \'%s\'/*MANUAL_RESTORE*/, \'%ld\'/*STUDY_EQ*/,%d/*AUTO_DEAL*/,%d/*EXT_STATUS*/,%d/*JXCB*/,%d/*DB_VERSION*/)",
table_name, it_map_fdir_task->second->task_data.fault.head.fault_id, it_map_fdir_task->second->task_data.fault.head.group_id, lDVId, strDVDescr.c_str(),
it_map_fdir_task->first->getfaultzone(), lStId, fault_cb, version == VERSION_REALTIME ? type : 1, 0, lst_cb.c_str(), fault_area, str_point.c_str(),
str_err_point.c_str(), str_mis_point.c_str(), version == VERSION_REALTIME ? 0 : 1, manual_restore.c_str(), it_map_fdir_task->second->task_data.fault.point_name,
it->task_data.fault.bAuto == 2 ? 1 : 0, version == VERSION_REALTIME ? type : 1, it_map_fdir_task->first->getfaultjxcb(), global.sec_no);
}
else
{
sprintf(sql,
"Insert into PMS_PARAM.FDIR_FDIRECT%s (ID, GROUPID, FD, FD_DESCR, ZONE, ST_ID, CB_ID, STATUS, STARTTYPE, ZONE_CB, FAULT_AREA, RECV_POINT, ERR_POINT, MIS_POINT, type, MANUAL_RESTORE, STUDY_EQ, AUTO_DEAL,EXT_STATUS,JXCB,DB_VERSION) "
"Values (\'%s\'/*ID*/, \'%s\'/*GROUPID*/, \'%ld\'/*FD*/, \'%s\'/*FD_DESCR*/, \'%d\'/*ZONE*/, \'%ld\'/*ST_ID*/, \'%ld\'/*CB_ID*/, %d/*STATUS*/, %d/*STARTTYPE*/, \'%s\'/*ZONE_CB*/, \'%s\'/*FAULT_AREA*/, \'%s\'/*RECV_POINT*/, \'%s\'/*ERR_POINT*/, \'%s\'/*MIS_POINT*/, %d/*type*/, \'%s\'/*MANUAL_RESTORE*/, \'%ld\'/*STUDY_EQ*/,%d/*AUTO_DEAL*/,%d/*EXT_STATUS*/,%d/*JXCB*/,%d/*DB_VERSION*/)",
table_name, it_map_fdir_task->second->task_data.fault.head.fault_id, it_map_fdir_task->second->task_data.fault.head.group_id, dv.id, dv.name,
it_map_fdir_task->first->getfaultzone(), it->task_data.fault.st, fault_cb, version == VERSION_REALTIME ? type : 1, 0, lst_cb.c_str(), fault_area, str_point.c_str(),
str_err_point.c_str(), str_mis_point.c_str(), version == VERSION_REALTIME ? 0 : 1, manual_restore.c_str(), it_map_fdir_task->second->task_data.fault.point_name,
it->task_data.fault.bAuto == 2 ? 1 : 0, version == VERSION_REALTIME ? type : 1, it_map_fdir_task->first->getfaultjxcb(), global.sec_no);
}
ExecSQL(sql);
list<DEV_STATUS>::iterator it_dev;
for (it_dev = it_map_fdir_task->first->lst_warning.begin(); it_dev != it_map_fdir_task->first->lst_warning.end(); it_dev++)
{
sprintf(sql, "INSERT into PMS_PARAM.FDIR_DEV_STATUS (FAULT_ID, DEV_ID, DEV_TABLE, DEV_STATUS) VALUES (\'%s\', \'%ld\', \'%s\', %d)",
it_map_fdir_task->second->task_data.fault.head.fault_id, it_dev->id, it_dev->table.c_str(), it_dev->status);
ExecSQL(sql);
}
if (it_map_fdir_task->first->lst_dev.size() > 0)
{
for (it_dev = it_map_fdir_task->first->lst_dev.begin(); it_dev != it_map_fdir_task->first->lst_dev.end(); it_dev++)
{
sprintf(sql, "INSERT into PMS_PARAM.FDIR_DEV_STATUS (FAULT_ID, DEV_ID, DEV_TABLE, DEV_STATUS) VALUES (\'%s\', \'%ld\', \'%s\', %d)",
it_map_fdir_task->second->task_data.fault.head.fault_id, it_dev->id, it_dev->table.c_str(), it_dev->status);
ExecSQL(sql);
}
}
}
lst_group_ld.sort();
lst_group_ld.unique();
TRACE("lst中负荷的个数是：%d\r\n", lst_group_ld.size());
//恢复方案计算成功，把恢复方案、隔离方案、定位信息写入表中
if (calc_ret == FDIR_R_SUCCEED)
{
for (map<FDIR_R2*, FDIR_TASK*>::iterator it_map_fdir_task = map_fdir_task.begin(); it_map_fdir_task != map_fdir_task.end(); it_map_fdir_task++)
{
//保存故障馈线开关信息，做数据校验用
write_fault_tree(it_map_fdir_task->second->task_data.fault.head.group_id, it_map_fdir_task->first);
}
//写负荷转供步骤和负荷转供区段
write_fhzg_step(it->task_data.fault.head.group_id, table_name, lst_steps, map_fdir_task.begin()->first, lst_able_res, list<long>(), true);
for (map<FDIR_R2*, FDIR_TASK*>::iterator it_map_fdir_task_temp = map_fdir_task.begin(); it_map_fdir_task_temp != map_fdir_task.end(); it_map_fdir_task_temp++)
{
//写上游恢复区域设备
write_fault_up_dev(it_map_fdir_task_temp->second->task_data.fault.head.fault_id, table_name, it_map_fdir_task_temp->first, false, lst_able_res);
//写故障隔离步骤表
PSBOB::CB psbob_point = { 0 };
const TTable<CLS_FDIR_ISOLATE>* isolate = it_map_fdir_task_temp->first->getisolate();
int i = 0;
for (i = 0; i < isolate->GetCount(); i++)
{
int up_isolate = 0;
if (isolate->Data[i].q & FDIR_ISOLATE_NO_SO)
{
TRACE("隔离开关%ld下游无可转供电源，不隔离！\r\n", isolate->Data[i].cb);
continue; //下游不可恢复的开关不需要隔离
}
if (isolate->Data[i].q & FDIR_ISOLATE_UP)
{
up_isolate = 1;
}
bzero(&psbob_point, sizeof(psbob_point));
if (oodbread_rk(&psbob_point, &isolate->Data[i].cb, const_cast<TB_DESCR*>(g_db_psbob->GetTB("breaker")), sizeof(psbob_point)) <= 0)
{
TRACE("读取PSBOB库POINT表ID为%ld的记录失败，错误号：%d\r\n", isolate->Data[i].cb, _oodb_errno);
}
sprintf(sql,
"Insert into PMS_PARAM.FDIR_ISOLATE%s (ID, STEP, ICB, CB, CB_DESCR, IMODE, CTRL_TYPE, CONTROL, UP_ISOLATE) Values (\'%s\', %d, %d, \'%ld\', \'%s\', %d, 0, %d, %d)",
table_name, it_map_fdir_task_temp->second->task_data.fault.head.fault_id/*故障标识符*/, i/*故障隔离序号*/, isolate->Data[i].icb/*要执行的开关逻辑号*/,
isolate->Data[i].cb/*要执行的开关id*/, isolate->Data[i].cb_desc/*要执行的开关描述*/, it_map_fdir_task_temp->second->task_data.fault.bAuto == 1/*自动*/? 4 : 3,
is_controllable(psbob_point.id) ? 1 : 0, up_isolate);
ExecSQL(sql);
}
}
//写模拟态故障信号表
TRACE("写入故障模拟关系库！\r\n");
if ((it->task_data.fault.signal_type) == TRIG_TYPE_SIMU)
{
sprintf(sql, "UPDATE PMS_PARAM.FDIR_SIG_SUMMARY SET RUN_TIME=(SELECT RUN_TIME FROM PMS_PARAM.FDIR_SIG_SUMMARY WHERE ID=\'%s\')+1, FAULT_INDEX=(SELECT RUN_TIME FROM PMS_PARAM.FDIR_SIG_SUMMARY WHERE ID=\'%s\')+1 WHERE ID=\'%s\' ",
it->task_data.fault.simu_plan_id.c_str(), it->task_data.fault.simu_plan_id.c_str(), it->task_data.fault.simu_plan_id.c_str());
ExecSQL(sql);
sprintf(sql, "SELECT ID FROM PMS_PARAM.FDIR_SIG_FAULT WHERE ID LIKE \'%s\'",
it->task_data.fault.simu_plan_id.c_str());
char *buf = NULL;
int rec_num, attr_num;
struct ORA_ATTR *attrs = NULL;
pthread_mutex_lock(&oci_mutex);
int ret = g_oci->ReadWithBind(sql, &buf, &rec_num, &attr_num, &attrs);
pthread_mutex_unlock(&oci_mutex);
if (ret != OCI_ERROR)
{
if (rec_num == 0)
{
sprintf(sql, "INSERT INTO PMS_PARAM.FDIR_SIG_FAULT(ID, FAULT_INDEX, FAULT_ID)VALUES(\'%s\', 0, \'%s\')",
it->task_data.fault.simu_plan_id.c_str(), it->task_data.fault.head.fault_id);
ExecSQL(sql);
}
}
g_oci->Readdata_Free();
sprintf(sql, "INSERT INTO PMS_PARAM.FDIR_SIG_FAULT(ID, FAULT_INDEX, FAULT_ID)VALUES(\'%s\', (select max(FAULT_INDEX) from pms_param.fdir_sig_fault where id like \'%s%\')+1, \'%s\')",
it->task_data.fault.simu_plan_id.c_str(), it->task_data.fault.simu_plan_id.c_str(), it->task_data.fault.head.fault_id);
ExecSQL(sql);
g_is_write_to_lib = true;
pthread_mutex_unlock(&simu_sync_mutex);
}
}
else if (calc_ret == FDIR_FAIL_RESTORE) //恢复方案计算失败，把隔离和定位信息写入表中
{
for (map<FDIR_R2*, FDIR_TASK*>::iterator it_map_fdir_task = map_fdir_task.begin(); it_map_fdir_task != map_fdir_task.end(); it_map_fdir_task++)
{
//写上游恢复区段表
//获取上游要恢复的区段号
write_fault_up_dev(it_map_fdir_task->second->task_data.fault.head.fault_id, table_name, it_map_fdir_task->first, false, lst_able_res);
//写故障隔离步骤表
PSBOB::CB psbob_point = { 0 };
const TTable<CLS_FDIR_ISOLATE>* isolate = it_map_fdir_task->first->getisolate();
int i = 0;
for (i = 0; i < isolate->GetCount(); i++)
{
int up_isolate = 0;
if (isolate->Data[i].q & FDIR_ISOLATE_NO_SO)
{
TRACE("隔离开关%ld下游无可转供电源，不隔离！\r\n", isolate->Data[i].cb);
continue; //下游不可恢复的开关不需要隔离
}
if (isolate->Data[i].q & FDIR_ISOLATE_UP)
{
up_isolate = 1;
}
bzero(&psbob_point, sizeof(psbob_point));
if (oodbread_rk(&psbob_point, &isolate->Data[i].cb, const_cast<TB_DESCR*>(g_db_psbob->GetTB("breaker")), sizeof(psbob_point)) <= 0)
{
TRACE("读取PSBOB库POINT表ID为%ld的记录失败\r\n", isolate->Data[i].cb);
}
sprintf(sql,
"Insert into PMS_PARAM.FDIR_ISOLATE%s (ID, STEP, ICB, CB, CB_DESCR, IMODE, CTRL_TYPE, CONTROL, UP_ISOLATE) Values (\'%s\', %d, %d, \'%ld\', \'%s\', %d, 0, %d, %d)",
table_name, it_map_fdir_task->second->task_data.fault.head.fault_id/*故障标识符*/, i/*故障隔离序号*/, isolate->Data[i].icb/*要执行的开关逻辑号*/,
isolate->Data[i].cb/*要执行的开关id*/, isolate->Data[i].cb_desc/*要执行的开关描述*/, it_map_fdir_task->second->task_data.fault.bAuto == 1/*自动*/? 4 : 3,
is_controllable(psbob_point.id) ? 1 : 0, up_isolate);
ExecSQL(sql);
}
}
}
else if (calc_ret == FDIR_FAIL_ISOLATE) //故障定位成功后计算隔离方案失败,把定位信息写入表中
{
}
//最小停电恢复方案计算成功，把恢复方案、隔离方案、定位信息写入表中
if (calc_ret2 == FDIR_R_SUCCEED)
{
//写负荷转供步骤和负荷转供区段
write_fhzg_step(it->task_data.fault.head.group_id, table_name, lst_steps2, map_fdir_task.begin()->first, lst_able_res, list<long>(), false);
for (map<FDIR_R2*, FDIR_TASK*>::iterator it_map_fdir_task_temp = map_fdir_task.begin(); it_map_fdir_task_temp != map_fdir_task.end(); it_map_fdir_task_temp++)
{
//写上游恢复区域设备
// write_fault_up_dev(it_map_fdir_task_temp->second->task_data.fault.head.fault_id, table_name, it_map_fdir_task_temp->first, false, lst_able_res);
//写故障隔离步骤表
PSBOB::CB psbob_point = { 0 };
const TTable<CLS_FDIR_ISOLATE>* isolate = it_map_fdir_task_temp->first->getisolate2();
int i = 0;
for (i = 0; i < isolate->GetCount(); i++)
{
int up_isolate = 0;
if (isolate->Data[i].q & FDIR_ISOLATE_NO_SO)
{
TRACE("隔离开关%ld下游无可转供电源，不隔离！\r\n", isolate->Data[i].cb);
continue; //下游不可恢复的开关不需要隔离
}
if (isolate->Data[i].q & FDIR_ISOLATE_UP)
{
up_isolate = 1;
}
bzero(&psbob_point, sizeof(psbob_point));
if (oodbread_rk(&psbob_point, &isolate->Data[i].cb, const_cast<TB_DESCR*>(g_db_psbob->GetTB("breaker")), sizeof(psbob_point)) <= 0)
{
TRACE("读取PSBOB库POINT表ID为%ld的记录失败，错误号：%d\r\n", isolate->Data[i].cb, _oodb_errno);
}
sprintf(sql,
"Insert into PMS_PARAM.FDIR_ISOLATE%s (ID, STEP, ICB, CB, CB_DESCR, IMODE, CTRL_TYPE, CONTROL, UP_ISOLATE) Values (\'%s\', %d, %d, \'%ld\', \'%s\', %d, 1, %d, %d)",
table_name, it_map_fdir_task_temp->second->task_data.fault.head.fault_id/*故障标识符*/, i/*故障隔离序号*/, isolate->Data[i].icb/*要执行的开关逻辑号*/,
isolate->Data[i].cb/*要执行的开关id*/, isolate->Data[i].cb_desc/*要执行的开关描述*/, it_map_fdir_task_temp->second->task_data.fault.bAuto == 1/*自动*/? 4 : 3,
is_controllable(psbob_point.id) ? 1 : 0, up_isolate);
ExecSQL(sql);
}
}
}
else if (calc_ret2 == FDIR_FAIL_RESTORE) //恢复方案计算失败，把隔离和定位信息写入表中
{
for (map<FDIR_R2*, FDIR_TASK*>::iterator it_map_fdir_task = map_fdir_task.begin(); it_map_fdir_task != map_fdir_task.end(); it_map_fdir_task++)
{
//写上游恢复区段表
//获取上游要恢复的区段号
// write_fault_up_dev(it_map_fdir_task->second->task_data.fault.head.fault_id, table_name, it_map_fdir_task->first, false, lst_able_res);
//写故障隔离步骤表
PSBOB::CB psbob_point = { 0 };
const TTable<CLS_FDIR_ISOLATE>* isolate = it_map_fdir_task->first->getisolate2();
int i = 0;
for (i = 0; i < isolate->GetCount(); i++)
{
int up_isolate = 0;
if (isolate->Data[i].q & FDIR_ISOLATE_NO_SO)
{
TRACE("隔离开关%ld下游无可转供电源，不隔离！\r\n", isolate->Data[i].cb);
continue; //下游不可恢复的开关不需要隔离
}
if (isolate->Data[i].q & FDIR_ISOLATE_UP)
{
up_isolate = 1;
}
bzero(&psbob_point, sizeof(psbob_point));
if (oodbread_rk(&psbob_point, &isolate->Data[i].cb, const_cast<TB_DESCR*>(g_db_psbob->GetTB("breaker")), sizeof(psbob_point)) <= 0)
{
TRACE("读取PSBOB库POINT表ID为%ld的记录失败\r\n", isolate->Data[i].cb);
}
sprintf(sql,
"Insert into PMS_PARAM.FDIR_ISOLATE%s (ID, STEP, ICB, CB, CB_DESCR, IMODE, CTRL_TYPE, CONTROL, UP_ISOLATE) Values (\'%s\', %d, %d, \'%ld\', \'%s\', %d, 1, %d, %d)",
table_name, it_map_fdir_task->second->task_data.fault.head.fault_id/*故障标识符*/, i/*故障隔离序号*/, isolate->Data[i].icb/*要执行的开关逻辑号*/,
isolate->Data[i].cb/*要执行的开关id*/, isolate->Data[i].cb_desc/*要执行的开关描述*/, it_map_fdir_task->second->task_data.fault.bAuto == 1/*自动*/? 4 : 3,
is_controllable(psbob_point.id) ? 1 : 0, up_isolate);
ExecSQL(sql);
}
}
}
else if (calc_ret == FDIR_FAIL_ISOLATE) //故障定位成功后计算隔离方案失败,把定位信息写入表中
{
}
lst_able_res.sort();
lst_able_res.unique();
EraseSameInfo(lst_group_ld, lst_able_res);
//写入故障后可恢复的负荷和不可恢复的负荷
write_res_and_disableres_ld(it->task_data.fault.head.group_id, lst_group_ld, lst_able_res);
delete table_name;
for (map<FDIR_R2*, FDIR_TASK*>::iterator it_fdir_task = map_fdir_task.begin(); it_fdir_task != map_fdir_task.end(); it_fdir_task++)
{
it_fdir_task->second->task_data.fault.next_step = TASK_FAULT_STATUS_ISO;
}
//向人机发送故障隔离恢复事件
if (it->task_data.fault.bAuto == 0)
{
if (version == VERSION_REALTIME)
{
//D5000向人机发送故障隔离恢复事件
Notify(it->task_data.fault.head.group_id, it->task_data.fault.dv, it->task_data.fault.st);
// FDIR_MSG_ISO_REC fdata = { 0 };
//
// strcpy(fdata.fault_id, it->task_data.fault.head.group_id);
// strcpy(fdata.st_id, "INSERT");
//
// printf("send_event(%d) group_id:%s,return %d\r\n", EVPS_FDIR_MSG_ISO_REC, fdata.fault_id, bob_inv->send_event(EVPS_FDIR_MSG_ISO_REC, (char *) &fdata, sizeof(fdata)));
//计算完成后把故障从任务列表的内存中删除，在执行的时候再把内存数据恢复
//允许超时转自动的情况得保留故障在内存中，否则无法判断是否超时
if (!g_FdirConfig.USER2AUTO)
{
RemoveTasks(it->task_data.fault.head.group_id);
it = g_lstTask.begin();
}
}
//研究态时写完库，在接收报文的地方释放内存，为了更新模拟故障机器名
else if (version == VERSION_STUDY)
{
}
}
else
{
if (g_FdirConfig.AUTO_DEAL_HIS == 0)
{
FormFdirStep(it->task_data.fault.head.group_id);
list<CB_CONTROL> lst_cb;
if (GetLeftStep(it->task_data.fault.head.group_id, lst_cb) > 0)
{
AddControlItem(it->task_data.fault.head.group_id, lst_cb.begin()->point_id, lst_cb.begin()->bOpen, lst_cb.begin()->stage);
}
}
else //自动归档
{
}
}
break;
}
case TASK_FAULT_STATUS_RE_CALC:
{
FDIR_TASK_LIST::iterator itTemp;
list<FDIR_R2*> lst_fdir_r2;
map<FDIR_R2*, FDIR_TASK*> map_fdir_task;
TRACE("开始计算组号为%s的操作方案，该组的故障有：\r\n", it->task_data.fault.head.group_id);
for (itTemp = g_lstTask.begin(); itTemp != g_lstTask.end(); itTemp++)
{
if (itTemp->rq_type != TASK_TYPE_FAULT)
continue;
if (strcmp(itTemp->task_data.fault.head.group_id, it->task_data.fault.head.group_id) == 0)
{
lst_fdir_r2.push_back(itTemp->task_data.fault.fdir_r);
map_fdir_task[itTemp->task_data.fault.fdir_r] = &(*itTemp);
itTemp->task_data.fault.next_step = TASK_FAULT_STATUS_CALC_STEP;
//后台自动执行失败后转为前台人工执行
itTemp->task_data.fault.bAuto = 0;
cout << it->task_data.fault.head.group_id << "->" << itTemp->task_data.fault.head.fault_id << endl;
}
}
list<list<MAP_SO_NODE> > lst_steps;
//判断执行失败的开关是否是上游隔离开关，如果是上游隔离开关，上游恢复区域失效
bool up_iso_fail = false;
const TTable<CLS_FDIR_ISOLATE>* old_isolate = it->task_data.fault.fdir_r->getisolate();
for (int i = 0; i < old_isolate->GetCount(); i++)
{
if (old_isolate->Data[i].q & FDIR_ISOLATE_UP)
{
if (old_isolate->Data[i].cb == it->task_data.fault.fail_point)
{
up_iso_fail = true;
}
}
}
////故障组中由于隔离或者跳闸导致失电的负荷，最终保存非故障不可恢复的负荷
list<FAULT_ITEM> re_lst_group_ld;
////故障组中由于隔离或者跳闸导致失电，存在恢复方案，可以恢复的负荷
list<FAULT_ITEM> re_lst_able_res;
it->task_data.fault.fdir_r->Init();
if (re_calc_restore_step(it->task_data.fault.head.group_id, lst_fdir_r2, lst_steps) == FDIR_R_SUCCEED)
{
//删除旧的恢复方案
sprintf(sql, "DELETE FROM FHZG_ZONE WHERE ID LIKE \'%s%%\'", it->task_data.fault.head.group_id);
ExecSQL(sql);
sprintf(sql, "DELETE FROM FHZG_SO_ZONE WHERE ID LIKE \'%s%%\'", it->task_data.fault.head.group_id);
ExecSQL(sql);
sprintf(sql, "DELETE FROM FHZG_STEP WHERE ID LIKE \'%s%%\'", it->task_data.fault.head.group_id);
ExecSQL(sql);
sprintf(sql, "DELETE FROM FHZG_SO WHERE ID LIKE \'%s%%\'", it->task_data.fault.head.group_id);
ExecSQL(sql);
sprintf(sql, "DELETE FROM FHZG_CUT_ZONE WHERE ID LIKE \'%s%%\'", it->task_data.fault.head.group_id);
ExecSQL(sql);
sprintf(sql, "DELETE FROM FHZG_LOAD WHERE ID LIKE \'%s%%\'", it->task_data.fault.head.group_id);
ExecSQL(sql);
sprintf(sql, "DELETE FROM FHZG_ZONE WHERE ID LIKE \'%s%%\'", it->task_data.fault.head.group_id);
ExecSQL(sql);
sprintf(sql, "UPDATE FDIR_FDIRECT SET USERID=NULL,MACHINE=NULL WHERE GROUPID=\'%s\'", it->task_data.fault.head.group_id);
ExecSQL(sql);
//删除选定的执行方案中未执行的步骤
sprintf(sql, "DELETE FROM FDIR_STEP WHERE ID=\'%s\' AND STATUS=%d", it->task_data.fault.head.group_id, STATUS_FDIR_STEP_WAIT);
ExecSQL(sql);
sprintf(sql, "DELETE FROM FDIR_CB_STATUS WHERE ID=\'%s\' AND ISFAULTDV=0", it->task_data.fault.head.group_id);
ExecSQL(sql);
sprintf(sql, "DELETE FROM FDIR_DISABLE_RES WHERE ID=\'%s\'", it->task_data.fault.head.group_id);
ExecSQL(sql);
sprintf(sql, "DELETE FROM FDIR_ENABLE_RES WHERE ID=\'%s\'", it->task_data.fault.head.group_id);
ExecSQL(sql);
//string fault_cb = it->task_data.fault.fdir_r->getfaultcb();
for (map<FDIR_R2*, FDIR_TASK*>::iterator it_fdir_r = map_fdir_task.begin(); it_fdir_r != map_fdir_task.end(); it_fdir_r++)
{
re_lst_group_ld.splice(re_lst_group_ld.end(), it_fdir_r->first->m_ld);
if (up_iso_fail)
{
sprintf(sql, "DELETE FROM FDIR_UP_ZONE WHERE ID LIKE \'%s%%\'", it->task_data.fault.head.group_id);
ExecSQL(sql);
string manual_restore;
for (list<long>::iterator it_point = it_fdir_r->second->task_data.fault.fdir_r->lst_restore.begin();
it_point != it_fdir_r->second->task_data.fault.fdir_r->lst_restore.end(); it_point++)
{
PSBOB::CB point = { 0 };
char tmp[50];
sprintf(tmp, "%ld", *it_point);
manual_restore += tmp;
if (is_controllable(*it_point))
manual_restore += "[0];";
else
manual_restore += ";";
}
//更新上游开关
sprintf(sql, "update FDIR_FDIRECT set MANUAL_RESTORE = \'%s\' where id = \'%s\'", manual_restore.c_str(), it_fdir_r->second->task_data.fault.head.fault_id);
ExecSQL(sql);
//have_up_iso标志故障区域是否有上游隔离开关，如果没上游隔离，则上游没有可以恢复的区域
bool have_up_iso = false;
const TTable<CLS_FDIR_ISOLATE>* new_isolate = it_fdir_r->first->getisolate();
for (int i = 0; i < new_isolate->GetCount(); i++)
{
if (new_isolate->Data[i].q & FDIR_ISOLATE_UP)
{
have_up_iso = true;
}
}
if (have_up_iso)
{
write_fault_up_dev(it->task_data.fault.head.group_id, "", it_fdir_r->first, true, re_lst_able_res);
}
}
}
re_lst_group_ld.sort();
re_lst_group_ld.unique();
//写入新的恢复方案
write_fhzg_step(it->task_data.fault.head.group_id, "", lst_steps, map_fdir_task.begin()->first, re_lst_able_res, list<long>(), true);
EraseSameInfo(re_lst_group_ld, re_lst_able_res);
//写入故障后可恢复的负荷和不可恢复的负荷
write_res_and_disableres_ld(it->task_data.fault.head.group_id, re_lst_group_ld, re_lst_able_res);
for (map<FDIR_R2*, FDIR_TASK*>::iterator it_map_fdir_task = map_fdir_task.begin(); it_map_fdir_task != map_fdir_task.end(); it_map_fdir_task++)
{
sprintf(sql, "DELETE FROM FDIR_ISOLATE WHERE ID=\'%s\' and STATUS in(%d,%d) and ctrl_type=0", it_map_fdir_task->second->task_data.fault.head.fault_id, STATUS_ISOLATE_FAIL,
STATUS_ISOLATE_WAIT);
ExecSQL(sql);
sprintf(sql, "select count(cb) from fdir_isolate where id=\'%s\'", it_map_fdir_task->second->task_data.fault.head.fault_id);
char *buf = NULL;
int rec_num, attr_num;
struct ORA_ATTR *attrs = NULL;
int step_num = 0;
pthread_mutex_lock(&oci_mutex);
int ret = g_oci->ReadWithBind(sql, &buf, &rec_num, &attr_num, &attrs);
pthread_mutex_unlock(&oci_mutex);
if (ret != OCI_ERROR)
{
step_num = *(int*)(buf);
}
g_oci->Readdata_Free();
//写故障隔离步骤表
PSBOB::CB psbob_point = { 0 };
const TTable<CLS_FDIR_ISOLATE>* isolate = it_map_fdir_task->first->getisolate();
int i = 0;
for (i = 0; i < isolate->GetCount(); i++)
{
int up_isolate = 0;
if (isolate->Data[i].q & FDIR_ISOLATE_NO_SO)
{
TRACE("隔离开关%ld下游无可转供电源，不隔离！\r\n", isolate->Data[i].cb);
continue; //下游不可恢复的开关不需要隔离
}
if (isolate->Data[i].q & FDIR_ISOLATE_UP)
{
up_isolate = 1;
}
bzero(&psbob_point, sizeof(psbob_point));
if (oodbread_rk(&psbob_point, &isolate->Data[i].cb, const_cast<TB_DESCR*>(g_db_psbob->GetTB("breaker")), sizeof(psbob_point)) <= 0)
{
TRACE("读取PSBOB库POINT表ID为%ld的记录失败\r\n", isolate->Data[i].cb);
}
sprintf(sql,
"Insert into PMS_PARAM.FDIR_ISOLATE (ID, STEP, ICB, CB, CB_DESCR, IMODE, CTRL_TYPE, CONTROL, UP_ISOLATE) Values (\'%s\', %d, %d, \'%ld\', \'%s\', %d, 0, %d, %d)",
it_map_fdir_task->second->task_data.fault.head.fault_id/*故障标识符*/, step_num + i/*故障隔离序号*/, isolate->Data[i].icb/*要执行的开关逻辑号*/,
isolate->Data[i].cb/*要执行的开关id*/, isolate->Data[i].cb_desc/*要执行的开关描述*/, it_map_fdir_task->second->task_data.fault.bAuto == 1/*自动*/? 4 : 3,
is_controllable(psbob_point.id) ? 1 : 0, up_isolate);
ExecSQL(sql);
}
}
}
//向人机发送故障隔离恢复事件
if (it->task_data.fault.bAuto == 0)
{
if (version == VERSION_REALTIME)
{
//D5000向人机发送故障隔离恢复事件
Notify(it->task_data.fault.head.group_id, it->task_data.fault.dv, it->task_data.fault.st);
// FDIR_MSG_ISO_REC fdata = { 0 };
//
// strcpy(fdata.fault_id, it->task_data.fault.head.group_id);
// strcpy(fdata.st_id, "UPDATE");
//
// printf("send_event(%d) group_id:%s,return %d\r\n", EVPS_FDIR_MSG_ISO_REC, fdata.fault_id, bob_inv->send_event(EVPS_FDIR_MSG_ISO_REC, (char *) &fdata, sizeof(fdata)));
}
//计算完成后把故障从任务列表的内存中删除，在执行的时候再把内存数据恢复
RemoveTasks(it->task_data.fault.head.group_id);
it = g_lstTask.begin();
}
else
{
if (g_FdirConfig.AUTO_DEAL_HIS == 0)
{
FormFdirStep(it->task_data.fault.head.group_id);
list<CB_CONTROL> lst_cb;
if (GetLeftStep(it->task_data.fault.head.group_id, lst_cb) > 0)
{
AddControlItem(it->task_data.fault.head.group_id, lst_cb.begin()->point_id, lst_cb.begin()->bOpen, lst_cb.begin()->stage);
}
}
}
break;
}
case TASK_FAULT_STATUS_INVALID_RECALC:
{
FDIR_TASK_LIST::iterator itTemp;
list<FDIR_R2*> lst_fdir_r2;
map<FDIR_R2*, FDIR_TASK*> map_fdir_task;
TRACE("开始计算组号为%s的操作方案，该组的故障有：\r\n", it->task_data.fault.head.group_id);
for (itTemp = g_lstTask.begin(); itTemp != g_lstTask.end(); itTemp++)
{
if (itTemp->rq_type != TASK_TYPE_FAULT)
continue;
if (strcmp(itTemp->task_data.fault.head.group_id, it->task_data.fault.head.group_id) == 0)
{
lst_fdir_r2.push_back(itTemp->task_data.fault.fdir_r);
map_fdir_task[itTemp->task_data.fault.fdir_r] = &(*itTemp);
itTemp->task_data.fault.next_step = TASK_FAULT_STATUS_CALC_STEP;
//后台自动执行失败后转为前台人工执行
itTemp->task_data.fault.bAuto = 0;
cout << it->task_data.fault.head.group_id << "->" << itTemp->task_data.fault.head.fault_id << endl;
}
}
list<list<MAP_SO_NODE> > lst_steps;
////故障组中由于隔离或者跳闸导致失电的负荷，最终保存非故障不可恢复的负荷
list<FAULT_ITEM> in_re_lst_group_ld;
////故障组中由于隔离或者跳闸导致失电，存在恢复方案，可以恢复的负荷
list<FAULT_ITEM> in_re_lst_able_res;
it->task_data.fault.fdir_r->Init();
if (re_calc_restore_step(it->task_data.fault.head.group_id, lst_fdir_r2, lst_steps) == FDIR_R_SUCCEED)
{
//删除旧的恢复方案
sprintf(sql, "DELETE FROM FHZG_ZONE WHERE ID LIKE \'%s%%\'", it->task_data.fault.head.group_id);
ExecSQL(sql);
sprintf(sql, "DELETE FROM FHZG_SO_ZONE WHERE ID LIKE \'%s%%\'", it->task_data.fault.head.group_id);
ExecSQL(sql);
sprintf(sql, "DELETE FROM FHZG_STEP WHERE ID LIKE \'%s%%\'", it->task_data.fault.head.group_id);
ExecSQL(sql);
sprintf(sql, "DELETE FROM FHZG_SO WHERE ID LIKE \'%s%%\'", it->task_data.fault.head.group_id);
ExecSQL(sql);
sprintf(sql, "DELETE FROM FHZG_CUT_ZONE WHERE ID LIKE \'%s%%\'", it->task_data.fault.head.group_id);
ExecSQL(sql);
sprintf(sql, "DELETE FROM FHZG_LOAD WHERE ID LIKE \'%s%%\'", it->task_data.fault.head.group_id);
ExecSQL(sql);
sprintf(sql, "DELETE FROM FHZG_ZONE WHERE ID LIKE \'%s%%\'", it->task_data.fault.head.group_id);
ExecSQL(sql);
sprintf(sql, "UPDATE FDIR_FDIRECT SET USERID=NULL,MACHINE=NULL,STATUS_ISOLATE=-1,STATUS_FHZG=-1,STATUS_RESTORE=-1 WHERE GROUPID=\'%s\'", it->task_data.fault.head.group_id);
ExecSQL(sql);
sprintf(sql, "DELETE FROM FDIR_CB_STATUS WHERE ID=\'%s\'", it->task_data.fault.head.group_id);
ExecSQL(sql);
//删除选定的执行方案中未执行的步骤
sprintf(sql, "DELETE FROM FDIR_STEP WHERE ID=\'%s\' AND STATUS=%d", it->task_data.fault.head.group_id, STATUS_FDIR_STEP_WAIT);
ExecSQL(sql);
sprintf(sql, "DELETE FROM FDIR_DISABLE_RES WHERE ID=\'%s\'", it->task_data.fault.head.group_id);
ExecSQL(sql);
sprintf(sql, "DELETE FROM FDIR_ENABLE_RES WHERE ID=\'%s\'", it->task_data.fault.head.group_id);
ExecSQL(sql);
for (map<FDIR_R2*, FDIR_TASK*>::iterator it_fdir_r = map_fdir_task.begin(); it_fdir_r != map_fdir_task.end(); it_fdir_r++)
{
in_re_lst_group_ld.splice(in_re_lst_group_ld.end(), it_fdir_r->first->m_ld);
sprintf(sql, "DELETE FROM FDIR_UP_ZONE WHERE ID LIKE \'%s%%\'", it->task_data.fault.head.group_id);
ExecSQL(sql);
string manual_restore;
for (list<long>::iterator it_point = it_fdir_r->second->task_data.fault.fdir_r->lst_restore.begin();
it_point != it_fdir_r->second->task_data.fault.fdir_r->lst_restore.end(); it_point++)
{
char tmp[50];
sprintf(tmp, "%ld", *it_point);
manual_restore += tmp;
if (is_controllable(*it_point))
manual_restore += "[0];";
else
manual_restore += ";";
}
//更新上游开关
sprintf(sql, "update FDIR_FDIRECT set MANUAL_RESTORE = \'%s\' where id = \'%s\'", manual_restore.c_str(), it_fdir_r->second->task_data.fault.head.fault_id);
ExecSQL(sql);
write_fault_up_dev(it->task_data.fault.head.group_id, "", it_fdir_r->first, false, in_re_lst_able_res);
//保存故障馈线开关信息，做数据校验用
write_fault_tree(it->task_data.fault.head.group_id, it_fdir_r->first);
}
in_re_lst_group_ld.sort();
in_re_lst_group_ld.unique();
//写入新的恢复方案
write_fhzg_step(it->task_data.fault.head.group_id, "", lst_steps, map_fdir_task.begin()->first, in_re_lst_able_res, list<long>(), true);
EraseSameInfo(in_re_lst_group_ld, in_re_lst_able_res);
//写入故障后可恢复的负荷和不可恢复的负荷
write_res_and_disableres_ld(it->task_data.fault.head.group_id, in_re_lst_group_ld, in_re_lst_able_res);
for (map<FDIR_R2*, FDIR_TASK*>::iterator it_map_fdir_task = map_fdir_task.begin(); it_map_fdir_task != map_fdir_task.end(); it_map_fdir_task++)
{
sprintf(sql, "DELETE FROM FDIR_ISOLATE WHERE ID=\'%s\' and STATUS in(%d,%d,%d) and ctrl_type=0", it_map_fdir_task->second->task_data.fault.head.fault_id, STATUS_ISOLATE_FAIL,
STATUS_ISOLATE_WAIT, STATUS_ISOLATE_EXEC);
ExecSQL(sql);
sprintf(sql, "select count(cb) from fdir_isolate where id=\'%s\'", it_map_fdir_task->second->task_data.fault.head.fault_id);
char *buf = NULL;
int rec_num, attr_num;
struct ORA_ATTR *attrs = NULL;
int step_num = 0;
pthread_mutex_lock(&oci_mutex);
int ret = g_oci->ReadWithBind(sql, &buf, &rec_num, &attr_num, &attrs);
pthread_mutex_unlock(&oci_mutex);
if (ret != OCI_ERROR)
{
step_num = *(int*)(buf);
}
g_oci->Readdata_Free();
//写故障隔离步骤表
const TTable<CLS_FDIR_ISOLATE>* isolate = it_map_fdir_task->first->getisolate();
int i = 0;
for (i = 0; i < isolate->GetCount(); i++)
{
int up_isolate = 0;
if (isolate->Data[i].q & FDIR_ISOLATE_NO_SO)
{
TRACE("隔离开关%ld下游无可转供电源，不隔离！\r\n", isolate->Data[i].cb);
continue; //下游不可恢复的开关不需要隔离
}
if (isolate->Data[i].q & FDIR_ISOLATE_UP)
{
up_isolate = 1;
}
sprintf(sql,
"Insert into PMS_PARAM.FDIR_ISOLATE (ID, STEP, ICB, CB, CB_DESCR, IMODE, CTRL_TYPE, CONTROL, UP_ISOLATE) Values (\'%s\', %d, %d, \'%ld\', \'%s\', %d, 0, %d, %d)",
it_map_fdir_task->second->task_data.fault.head.fault_id/*故障标识符*/, step_num + i/*故障隔离序号*/, isolate->Data[i].icb/*要执行的开关逻辑号*/,
isolate->Data[i].cb/*要执行的开关id*/, isolate->Data[i].cb_desc/*要执行的开关描述*/, it_map_fdir_task->second->task_data.fault.bAuto == 1/*自动*/? 4 : 3,
is_controllable(isolate->Data[i].cb) ? 1 : 0, up_isolate);
ExecSQL(sql);
}
}
}
//向人机发送故障隔离恢复事件
if (it->task_data.fault.bAuto == 0)
{
if (version == VERSION_REALTIME)
{
//D5000向人机发送故障隔离恢复事件
Notify(it->task_data.fault.head.group_id, it->task_data.fault.dv, it->task_data.fault.st);
// FDIR_MSG_ISO_REC fdata = { 0 };
//
// strcpy(fdata.fault_id, it->task_data.fault.head.group_id);
// strcpy(fdata.st_id, "UPDATE");
//
// printf("send_event(%d) group_id:%s,return %d\r\n", EVPS_FDIR_MSG_ISO_REC, fdata.fault_id, bob_inv->send_event(EVPS_FDIR_MSG_ISO_REC, (char *) &fdata, sizeof(fdata)));
}
//计算完成后把故障从任务列表的内存中删除，在执行的时候再把内存数据恢复
RemoveTasks(it->task_data.fault.head.group_id);
it = g_lstTask.begin();
}
else
{
if (g_FdirConfig.AUTO_DEAL_HIS == 0)
{
FormFdirStep(it->task_data.fault.head.group_id);
list<CB_CONTROL> lst_cb;
if (GetLeftStep(it->task_data.fault.head.group_id, lst_cb) > 0)
{
AddControlItem(it->task_data.fault.head.group_id, lst_cb.begin()->point_id, lst_cb.begin()->bOpen, lst_cb.begin()->stage);
}
}
}
break;
}
default:
break;
}
break;
}
//转自动
case TASK_TYPE_SET_AUTO:
break;
default:
break;
}
}
}
pthread_mutex_unlock(&task_list_mutex);
pthread_mutex_unlock(&simu_sync_mutex);
sleep(1);
}
}
//根据遥信ID获取该开关的目标开合状态
//-1: 获取失败 1: 开 0: 合
int get_op_type(const long id)
{
assert(id > 0);
int op_type = -1;
pthread_mutex_lock(&task_list_mutex);
for (FDIR_TASK_LIST::iterator it = g_lstTask.begin(); it != g_lstTask.end(); it++)
{
if (it->rq_type != TASK_TYPE_CB_CTRL)
continue;
if ((it->task_data.control.point_name == id)
&& (TASK_CTL_STATUS_RUN == it->task_data.control.status))
{
op_type = it->task_data.control.bOpen ? 1 : 0;
break;
}
}
pthread_mutex_unlock(&task_list_mutex);
return op_type;
}
//根据遥信ID获取该开关遥控所属的故障ID
const char * get_group_id(const long id)
{
assert(id > 0);
pthread_mutex_lock(&task_list_mutex);
for (FDIR_TASK_LIST::iterator it = g_lstTask.begin(); it != g_lstTask.end(); it++)
{
if (it->rq_type != TASK_TYPE_CB_CTRL)
continue;
if ((it->task_data.control.point_name == id) &&
((TASK_CTL_STATUS_RUN == it->task_data.control.status) || (TASK_CTL_STATUS_FINISH == it->task_data.control.status)))
{
pthread_mutex_unlock(&task_list_mutex);
return it->task_data.control.head.group_id;
}
}
pthread_mutex_unlock(&task_list_mutex);
return NULL;
}
void thread_recv_rte(void *param)
{
//D5000 这个函数需要根据D5000的故障事件重写
int len = 0;
const int sca_breaker_table_no = 407;
KEY_STRU ks = { 0 };
PSBOB::ST psbob_st = { 0 };
PSBOB::DV psbob_dv = { 0 };
PSBOB::CB psbob_cb = { 0 };
FDIR_POINT_TRIG data_trig = { 0 };
FDIR_TASK_LIST::iterator it;
///////////////////
///开始循环接收RTE事件
while (true)
{
Message msg;
len = bob_inv->messageReceive(&msg, NULL, 0);
if (len < 0)
{
cout << "messageReceive fail!" << endl;
pthread_exit(0);
return;
}
else if (len == 0)
{
usleep(10);
continue;
}
else
{
GetFdirConfig(g_FdirConfig);
switch (msg.header.event)
{
case WARN_INFORM_TYPE:
{
break;
}
case MT_YX_CHANGE:
{
// int cnt = msg.header.len / sizeof(ChangeYx);
// int pos = 1;
//
// ChangeYx *yx = (ChangeYx *) msg.Msg_buf;
//
// do
// {
// cout << "MT_YX_CHANGE,id:" << yx->keyid << endl;
// ///////////////////首先判断是否遥控返回////////////////
// pthread_mutex_lock(&task_list_mutex);
// FDIR_TASK_LIST::iterator it = g_lstTask.begin();
// bool breturn = false; //是否遥控返回项
//
// for (; it != g_lstTask.end(); it++)
// {
// if (it->rq_type == TASK_TYPE_CB_CTRL) //为遥控项
// {
// if (it->task_data.control.point_name == yx->keyid)
// {
// breturn = true;
// printf("遥控%ld返回报警事件：", yx->keyid);
//
// cout << "成功！" << endl;
//
// ControlSucceed(it->task_data.control.head.group_id, yx->keyid, it->task_data.control.stage);
//
// list<CB_CONTROL> lstCB;
// FDIR_TASK_LIST::iterator it_fault;
// char fault_id[FAULT_ID_LENGTH] = { 0 };
//
// strcpy(fault_id, it->task_data.control.head.group_id);
//
// if (GetLeftStep(fault_id, lstCB) == 0)
// {
// ClearFdirDB(fault_id);
// sprintf(sql, "UPDATE FDIR_FDIRECT_HIS SET STATUS=%d WHERE groupid=\'%s\'", STATUS_FDIRECT_FINISH, fault_id);
// if (ExecSQL(sql) != OCI_ERROR)
// {
// sprintf(sql, "UPDATE FDIR_FDIRECT SET STATUS=%d WHERE groupid=\'%s\'", STATUS_FDIRECT_FINISH, fault_id);
// ExecSQL(sql);
// }
//
// RemoveTasks(fault_id);
// printf("故障组%s处理完成！！！！\r\n", fault_id);
// }
// else
// {
// for (it_fault = g_lstTask.begin(); it_fault != g_lstTask.end(); it_fault++)
// {
// if (it_fault->rq_type == TASK_TYPE_FAULT)
// {
// if (strcmp(it_fault->task_data.fault.head.group_id, it->task_data.control.head.group_id) == 0)
// {
// if (it_fault->task_data.fault.bAuto)
// AddControlItem(fault_id, lstCB.begin()->point_id, lstCB.begin()->bOpen, lstCB.begin()->stage);
// else
// {
// printf("遥控%ld所在故障组%s非自动执行模式！！\r\n", it->task_data.control.point_name, it->task_data.control.head.group_id);
// }
//
// break;
// }
// }
// }
//
// if (it_fault == g_lstTask.end())
// {
// printf("未找到遥控%ld所在故障组%s对应的故障项，无法判断其是否为自动执行模式！！！\r\n", it->task_data.control.point_name, it->task_data.control.head.group_id);
// }
// }
//
// g_lstTask.erase(it);
//
// break;
// }
// }
// }
//
// if (breturn)
// {
// pthread_mutex_unlock(&task_list_mutex);
// break;
// }
//
// pthread_mutex_unlock(&task_list_mutex);
//
// yx++;
// pos++;
// } while (pos < cnt);
//
break;
}
case SCADA_OPT_PREV_ANSWER:
{
TScaOpAnswer *tsa = (TScaOpAnswer*)msg.Msg_buf;
TRACE("key_id:%ld, time:%ld, ctrl_result:%i\r\n", tsa->key_id, tsa->time, tsa->ctrl_result);
if(tsa->ctrl_result == 0){
TRACE("遥控返校成功！\r\n");
int op_type = get_op_type(tsa->key_id);
switch(op_type){
case 0:
case 1:
DoControl(tsa->key_id, false, op_type);
break;
default:
TRACE("不是期望的遥控返回项！\r\n");
break;
}
}
break;
}
case MT_YK_REPLY:
case MT_TAP_REPLY:
{
// TRACE("遥控telbob返校事件！\r\n");
break;
}
case APP_TO_WARN_SERVICE_TYPE:
{
APP_TO_WARN_SERVICE_MESSAGE_STRU r_Dev;
M_DECODE(r_Dev, msg.Msg_buf, msg.header.len);
int len = r_Dev.seq_warn_message.length();
for (int i = 0; i < len; i++)
{
TRACE("--------------------warntype:%d,app:%d\r\n", r_Dev.seq_warn_message[i].warn_type, r_Dev.seq_warn_message[i].app_no);
if (r_Dev.seq_warn_message[i].warn_type == D_YX_BW_WARN_TYPE
/*|| r_Dev.seq_warn_message[i].warn_type == YX_BW_WARN_TYPE*/
|| r_Dev.seq_warn_message[i].warn_type == D_SG_WARN_TYPE
/*|| r_Dev.seq_warn_message[i].warn_type == SG_WARN_TYPE*/) //平台报警有问题，暂时报不上D_SG_WARN_TYPE事件，先收SG_WARN_TYPE做容错
{
if(r_Dev.seq_warn_message[i].app_no != AP_DSCADA) continue;
data_trig.alarm.type = r_Dev.seq_warn_message[i].warn_type;
data_trig.alarm.occur_time = r_Dev.seq_warn_message[i].seq_field_info[0].c_time();
data_trig.alarm.msec = r_Dev.seq_warn_message[i].seq_field_info[1].c_short();
data_trig.alarm.key_id = r_Dev.seq_warn_message[i].seq_field_info[2].c_long();
data_trig.alarm.respid = r_Dev.seq_warn_message[i].seq_field_info[3].c_int();
data_trig.alarm.st_id = r_Dev.seq_warn_message[i].seq_field_info[4].c_long();
data_trig.alarm.bayid = r_Dev.seq_warn_message[i].seq_field_info[5].c_long();
data_trig.alarm.status = r_Dev.seq_warn_message[i].seq_field_info[6].c_int();
data_trig.alarm.str = r_Dev.seq_warn_message[i].seq_field_info[7].c_string();
data_trig.alarm.bvid = r_Dev.seq_warn_message[i].seq_field_info[8].c_long();
if (data_trig.alarm.msec == -1)
{
//研究态
data_trig.trig_type = TRIG_TYPE_SIMU;
}
if (GetDv(data_trig.alarm.st_id, "st", psbob_dv) == OO_FAIL)
{
TRACE("获取厂站%ld的馈线信息失败！\r\n", data_trig.alarm.st_id);
continue;
}
data_trig.dv_id = psbob_dv.id;
data_trig.damode = GetDvDamode(psbob_dv.id);
gettimeofday(&data_trig.tm_add, NULL);
if (data_trig.damode <= FDIR_MODE_FORBID)
{
TRACE("馈线%ld(%s)为禁止DA处理(%d)\r\n", psbob_dv.id, psbob_dv.name, psbob_dv.damode);
continue;
}
KEY_STRU ks = { 0 };
CCommon::long_to_keyid(data_trig.alarm.key_id, &ks);
ks.field_id = 0;
CCommon::keyid_to_long(&ks, &data_trig.alarm.key_id);
TB_DESCR *tb_descr = const_cast<TB_DESCR*>(g_db_psbob->GetTB(ks.table_no));
if (ks.table_no == g_db_psbob->GetTB("breaker")->table_id)
{
data_trig.alarm.dev = ALARM_BREAKER;
if (oodbread_rk(&data_trig.psbob_data.point, &data_trig.alarm.key_id, tb_descr, sizeof(data_trig.psbob_data.point)) == OO_FAIL)
{
TRACE("读取开关表关键字为%ld的记录失败！\r\n", data_trig.alarm.key_id);
continue;
}
else
{
if (MENU_WARN_YX_BW_ON == data_trig.alarm.status)
{
TRACE("开关[%s]合闸(%d)\r\n", data_trig.psbob_data.point.name, data_trig.alarm.status);
}
else
{
if(r_Dev.seq_warn_message[i].warn_type == D_SG_WARN_TYPE
/*||r_Dev.seq_warn_message[i].warn_type == SG_WARN_TYPE*/)
{
TRACE("开关[%s]事故跳闸(%d)\r\n", data_trig.psbob_data.point.name, data_trig.alarm.status);
}
else
{
TRACE("开关[%s]分闸(%d)\r\n", data_trig.psbob_data.point.name, data_trig.alarm.status);
}
data_trig.alarm.name = data_trig.psbob_data.point.name;
//将该开关加入过流开关列表
pthread_mutex_lock(&trig_list_mutex);
g_lstTrig.push_back(data_trig);
pthread_mutex_unlock(&trig_list_mutex);
}
}
}
else if (ks.table_no == g_db_psbob->GetTB("relaysig")->table_id)
{
PSBOB::PROTECT protect = { 0 };
if (oodbread_rk(&protect, &data_trig.alarm.key_id, tb_descr, sizeof(protect)) == OO_FAIL)
{
TRACE("读取保护信号表关键字为%ld的记录失败！\r\n", data_trig.alarm.key_id);
continue;
}
else
{
// 暂时修改读取保护信号策略，增加动作信号
if (HasMask(tb_descr, "pnt_type", protect.pnt_type , MENU_TYPE_RELAY_SGZ) || HasMask(tb_descr, "pnt_type", protect.pnt_type , MENU_TYPE_RELAY_ACT))
{
data_trig.alarm.dev = ALARM_SGZ;
if (MENU_WARN_YX_ACT_ON == data_trig.alarm.status)
{
unsigned long id = 0;
CCommon::long_to_keyid(protect.oo_dev, &ks);
ks.field_id = 0;
CCommon::keyid_to_long(&ks, &id);
if (oodbread_rk(&data_trig.psbob_data.point, &id, const_cast<TB_DESCR*>(g_db_psbob->GetTB("breaker")), sizeof(data_trig.psbob_data.point)) == OO_FAIL)
{
TRACE("读取开关表关键字为%ld的记录失败！\r\n", id);
continue;
}
else
{
TRACE("事故总[%s]动作(%d)\r\n", protect.name, data_trig.alarm.status);
data_trig.alarm.name = protect.name;
//将该开关加入过流开关列表
pthread_mutex_lock(&trig_list_mutex);
g_lstTrig.push_back(data_trig);
pthread_mutex_unlock(&trig_list_mutex);
}
}
else
{
TRACE("事故总[%s]复归(%d)\r\n", protect.name, data_trig.alarm.status);
}
}
else if(HasMask(tb_descr, "pnt_type", protect.pnt_type , MENU_TYPE_RELAY_JD)
|| HasMask(tb_descr, "pnt_type", protect.pnt_type , MENU_TYPE_RELAY_DL))
{
data_trig.alarm.dev = HasMask(tb_descr, "pnt_type", protect.pnt_type, MENU_TYPE_RELAY_DL) ? ALARM_FAULTINFO_DL : ALARM_FAULTINFO_JD;
if (MENU_WARN_YX_ACT_ON == data_trig.alarm.status)
{
unsigned long id = 0;
CCommon::long_to_keyid(protect.oo_dev, &ks);
ks.field_id = 0;
CCommon::keyid_to_long(&ks, &id);
if (oodbread_rk(&data_trig.psbob_data.faultinfo, &id, const_cast<TB_DESCR*>(g_db_psbob->GetTB("faultinfo")), sizeof(data_trig.psbob_data.faultinfo)) == OO_FAIL)
{
TRACE("读取故障指示器表关键字为%ld的记录失败！\r\n", id);
continue;
}
else
{
TRACE("故障指示器[%s]动作(%d)\r\n", protect.name, data_trig.alarm.status);
data_trig.alarm.name = protect.name;
//将该开关加入过流开关列表
pthread_mutex_lock(&trig_list_mutex);
g_lstTrig.push_back(data_trig);
pthread_mutex_unlock(&trig_list_mutex);
}
}
else
{
TRACE("故障指示器[%s]复归(%d)\r\n", protect.name, data_trig.alarm.status);
}
}
else
{
TRACE("%s(%d)\r\n", protect.name, protect.pnt_type);
}
}
}
else
{
TRACE("未处理的报警设备%s(%d)\r\n", tb_descr->table_name, tb_descr->table_id);
}
//TRACE("(%ld %d %ld %d %ld %ld %d %ld)\r\n", tmp_sec, tmp_msec, tmp_keyid, tmp_respid, tmp_facid, tmp_bayid, tmp_status, tmp_bvid);
}
else
{
#if 0
int lenVal = r_Dev.seq_warn_message[i].seq_field_info.length();
for (int j = 0; j < lenVal; j++)
{
short datatype = r_Dev.seq_warn_message[i].seq_field_info[j]._d();
switch (datatype)
{
case C_DATATYPE_LONG:
{
unsigned long kid = r_Dev.seq_warn_message[i].seq_field_info[j].c_long();
TRACE("warn_type:%d, app_no:%d, key_id:%ld\r\n", r_Dev.seq_warn_message[i].warn_type, r_Dev.seq_warn_message[i].app_no, kid);
KEY_STRU ks;
CCommon::long_to_keyid(kid, &ks);
if (ks.table_no == g_db_psbob->GetTB("measpoint")->table_id)
{
PSBOB::POINT point = { 0 };
if (oodbread_rk(&point, &kid, const_cast<TB_DESCR*>(g_db_psbob->GetTB("measpoint")), sizeof(point)) == OO_FAIL)
{
}
else
{
TRACE("%s(%ld)遥信变位！\r\n", point.name, point.id);
}
}
break;
}
case C_DATATYPE_INT:
TRACE("warn_type:%d, app_no:%d, int:%d\r\n", r_Dev.seq_warn_message[i].warn_type, r_Dev.seq_warn_message[i].app_no,
r_Dev.seq_warn_message[i].seq_field_info[j].c_int());
break;
case C_DATATYPE_SHORT:
TRACE("warn_type:%d, app_no:%d, short:%d\r\n", r_Dev.seq_warn_message[i].warn_type, r_Dev.seq_warn_message[i].app_no,
r_Dev.seq_warn_message[i].seq_field_info[j].c_short());
break;
case C_DATATYPE_UCHAR:
TRACE("warn_type:%d, app_no:%d, uchar:%d\r\n", r_Dev.seq_warn_message[i].warn_type, r_Dev.seq_warn_message[i].app_no,
r_Dev.seq_warn_message[i].seq_field_info[j].c_uchar());
break;
case C_DATATYPE_DATETIME:
TRACE("warn_type:%d, app_no:%d, time:%ld\r\n", r_Dev.seq_warn_message[i].warn_type, r_Dev.seq_warn_message[i].app_no,
r_Dev.seq_warn_message[i].seq_field_info[j].c_time());
break;
case C_DATATYPE_STRING:
TRACE("warn_type:%d, app_no:%d, string:%ld\r\n", r_Dev.seq_warn_message[i].warn_type, r_Dev.seq_warn_message[i].app_no,
r_Dev.seq_warn_message[i].seq_field_info[j].c_string());
break;
default:
TRACE("unknow datatype:%d\r\n", datatype);
break;
}
}
#endif
}
}
break;
}
//可用alarm_simu_tool命令模拟
case MT_FAULT_EVENT:
{
break;
#if 0
TransEventPkg receive_mes;
M_DECODE(receive_mes, msg.Msg_buf, msg.header.len);
for (int i = 0; i < receive_mes.trans_head.data_num; i++)
{
cout << "MT_FAULT_EVENT:key_id:" << receive_mes.event_info[i].key_id << ",stid:" << receive_mes.event_info[i].st_id << endl;
long key_id = receive_mes.event_info[i].key_id;
CCommon::long_to_keyid(key_id, &ks);
if (ks.table_no != sca_breaker_table_no)
{
TRACE("不是开关事件！\r\n");
continue;
}
if (GetDv(key_id, "cb", psbob_dv) < 0)
{
TRACE("获取开关%ld的DV信息失败！\r\n", key_id);
continue;
}
if (psbob_dv.damode == FDIR_MODE_FORBID)
{
TRACE("馈线%ld(%s)为禁止DA处理(%d)\r\n", psbob_dv.id, psbob_dv.name, psbob_dv.damode);
continue;
}
if (oodbread_rk(&data_trig.psbob_data.point, &key_id, const_cast<TB_DESCR*>(g_db_psbob->GetTB("breaker")), sizeof(PSBOB::CB)) <= 0)
{
TRACE("读取开关%ld信息失败！\r\n", key_id);
continue;
}
gettimeofday(&data_trig.tm_add, NULL);
data_trig.damode = psbob_dv.damode;
data_trig.dv_id = psbob_dv.id;
data_trig.lst_fault.clear();
memcpy(&data_trig.alarm, &receive_mes.event_info[i], sizeof(OneEventStru));
data_trig.alarm.st_id = data_trig.psbob_data.point.st_id;
//将该开关加入过流开关列表
pthread_mutex_lock(&trig_list_mutex);
g_lstTrig.push_back(data_trig);
pthread_mutex_unlock(&trig_list_mutex);
}
break;
#endif
}
case MT_YC_EVENT:
{
// TransEventPkg receive_mes;
//
// M_DECODE(receive_mes, msg.Msg_buf, msg.header.len);
//
// for (int i = 0; i < receive_mes.trans_head.data_num; i++)
// {
// cout << "MT_YC_EVENT:" << receive_mes.event_info[i].key_id << "," << receive_mes.event_info[i].st_id << endl;
// }
break;
}
case MT_YX_EVENT:
{
// TransEventPkg receive_mes;
//
// M_DECODE(receive_mes, msg.Msg_buf, msg.header.len);
//
// for (int i = 0; i < receive_mes.trans_head.data_num; i++)
// {
// cout << "MT_YX_EVENT:" << receive_mes.event_info[i].key_id << "," << receive_mes.event_info[i].st_id << endl;
//
// long key_id = receive_mes.event_info[i].key_id;
// CCommon::long_to_keyid(key_id, &ks);
//
// switch (ks.table_no)
// {
// case sca_breaker_table_no:
// {
// if (oodbread_rk(&psbob_cb, &key_id, const_cast<TB_DESCR*>(g_db_psbob->GetTB("breaker")), sizeof(PSBOB::CB)) <= 0)
// {
// TRACE("读取开关%ld数据失败\r\n", key_id);
// continue;
// }
//
// if(psbob_cb.point > 0) //开关为合闸状态
// {
// pthread_mutex_lock(&trig_list_mutex);
// for (FDIR_POINT_TRIG_LIST::iterator itTrig = g_lstTrig.begin(); itTrig != g_lstTrig.end(); itTrig++)
// {
// if (itTrig->id.cb_id == key_id)
// {
// g_lstTrig.erase(itTrig);
// TRACE("从过流开关列表中删除%ld(%s)的过流项。\r\n", key_id, psbob_cb.name);
// break;
// }
// }
// pthread_mutex_unlock(&trig_list_mutex);
// }
// else //开关为分闸状态
// {
// data_trig.bjxcb = (HasMask(NULL, "brk_type", psbob_cb.brk_type , MENU_BRK_TYPE_JX));
// gettimeofday(&data_trig.tm_add, NULL);
// data_trig.b_alarm_cb = true;
// data_trig.id.cb_id = key_id;
//
// //将该开关加入过流开关列表
// pthread_mutex_lock(&trig_list_mutex);
// g_lstTrig.push_back(data_trig);
// pthread_mutex_unlock(&trig_list_mutex);
//
// TRACE("将开关%ld(%s)加入到故障信号列表\r\n", key_id, psbob_cb.name);
// }
// break;
// }
// default:
// {
// break;
// }
// }
// }
break;
}
default:
{
// cout << "unknow message:" << msg.header.event << endl;
// printf("msg.header.len:%d\r\n", msg.header.len);
// printf("msg.header.serv:%d\r\n", msg.header.serv);
// printf("msg.header.seq:%d\r\n", msg.header.seq);
// printf("msg.header.event:%d\r\n", msg.header.event);
// printf("msg.header.domain:%d\r\n", msg.header.domain);
// printf("msg.header.ctxt:%d\r\n", msg.header.ctxt);
// printf("msg.header.stid:%d\r\n", msg.header.stid);
// printf("msg.header.dtid:%d\r\n", msg.header.dtid);
// printf("msg.header.ver_coding:%d\r\n", msg.header.ver_coding);
// printf("msg.header.remain:%d\r\n", msg.header.remain);
// cout << endl;
break;
}
}
}
}
}
//恢复故障的步骤列表，为自动执行时提供数据
void RecoTaskStep(const char* groupid)
{
assert(groupid != NULL);
char *buf = NULL;
int rec_num, attr_num;
struct ORA_ATTR *attrs = NULL;
list<FDIR_TASK>::iterator it;
for (it = g_lstTask.begin(); it != g_lstTask.end(); it++)
{
if (it->rq_type == TASK_TYPE_FAULT)
{
if (strcmp(it->task_data.fault.head.group_id, groupid) == 0)
{
//获取每条故障的隔离信息
sprintf(sql, "select cb,up_isolate from fdir_isolate where id=\'%s\'", it->task_data.fault.head.fault_id);
cout << sql << endl;
pthread_mutex_lock(&oci_mutex);
int ret = g_oci->ReadWithBind(sql, &buf, &rec_num, &attr_num, &attrs);
pthread_mutex_unlock(&oci_mutex);
if (ret != OCI_ERROR)
{
list<FDIR_ISO_CB> lst_iso;
for (int i = 0; i < rec_num; i++)
{
FDIR_ISO_CB fdir_cb;
bzero(&fdir_cb,sizeof(fdir_cb));
int isup = 0;
fdir_cb.cb = *(long*) (buf+(i*(attrs[0].col_width+attrs[1].col_width)));//, attrs[0].col_width);
isup = *(int*)(buf+(i*(attrs[0].col_width+attrs[1].col_width))+attrs[0].col_width);
if (isup == 1)
{
fdir_cb.q |= FDIR_ISOLATE_UP;
}
else
{
fdir_cb.q &= ~FDIR_ISOLATE_UP;
}
lst_iso.push_back(fdir_cb);
TRACE("隔离开关id是：%ld\r\n", fdir_cb.cb);
}
if (lst_iso.size() > 0)
{
///把隔离步骤添加到内存的isolate里
it->task_data.fault.fdir_r->setisolate(lst_iso);
}
}
g_oci->Readdata_Free();
it->task_data.fault.fdir_r->setfaultzone(it->task_data.fault.fault_zone);
}
}
}
}
//恢复故障的详细信息，主要是故障的进线开关，以进线开关为根节点的树，为重新计算方案时使用
void RecoTaskItem(const char* groupid)
{
assert(groupid != NULL);
char *buf = NULL;
int rec_num, attr_num;
struct ORA_ATTR *attrs = NULL;
for (FDIR_TASK_LIST::iterator it = g_lstTask.begin(); it != g_lstTask.end(); it++)
{
if (it->rq_type == TASK_TYPE_FAULT)
{
if (strcmp(it->task_data.fault.head.group_id, groupid) == 0)
{
//获取故障馈线的进线开关和故障信号，把分闸的开关合闸，并且建立以进线开关为根节点的树
sprintf(sql, "select JXCB from fdir_fdirect where id=\'%s\'", it->task_data.fault.head.fault_id);
cout << sql << endl;
int jxcb = -1;
pthread_mutex_lock(&oci_mutex);
int ret = g_oci->ReadWithBind(sql, &buf, &rec_num, &attr_num, &attrs);
pthread_mutex_unlock(&oci_mutex);
if (ret != OCI_ERROR)
{
if (rec_num < 0)
{
TRACE("获取故障记录数为0，故障id是：%s\r\n",it->task_data.fault.head.fault_id);
return;
}
else
{
jxcb = *(int*)buf;
it->task_data.fault.fdir_r->setfaultjxcb(jxcb);
}
}
g_oci->Readdata_Free();
//从接收的故障信号中把分闸的开关找出来，并且把分闸设置成合闸，重新形成电流流入方向，重新建树
sprintf(sql, "select dev_id from fdir_alarm where id=\'%s\'", it->task_data.fault.head.fault_id);
cout << sql << endl;
//数据初始化
// it->task_data.fault.fdir_r->RecalcInit();
pthread_mutex_lock(&oci_mutex);
ret = g_oci->ReadWithBind(sql, &buf, &rec_num, &attr_num, &attrs);
pthread_mutex_unlock(&oci_mutex);
if (ret != OCI_ERROR)
{
if (rec_num > 0)
{
for (int i = 0; i < rec_num; i++)
{
unsigned long pid = 0;
pid =*(long*) (buf+(i*attrs[0].col_width));
KEY_STRU ks = {0};
CCommon::long_to_keyid(pid, &ks);
if(ks.table_no != g_db_psbob->GetTB("breaker")->table_id) continue;
long id = pid;
pid_to_id(id);
CLS_CB *cb = g_bob->cb_tb->Find(CLS_CB(id));
cb->q &= ~CB_OPEN;
TRACE("合闸开关%ld(%s)\r\n", cb->pid, cb->descr);
}
}
g_oci->Readdata_Free();
}
it->task_data.fault.fdir_r->FormIcbOfZone();
it->task_data.fault.fdir_r->ReBuildFaultTree(it->task_data.fault.head.fault_id);
//故障起始和结束设备的恢复
it->task_data.fault.fdir_r->ReCoHeadTail(it->task_data.fault.head.fault_id);
}
}
}
}
void RecoMemTask(const char* groupid)
{
assert(groupid != NULL);
char *buf = NULL;
int rec_num, attr_num;
struct ORA_ATTR *attrs = NULL;
list<long> lst_bus;
//启动一个故障
FDIR_TASK data_task;
//获取报警信号中的报警源
sprintf(sql, "SELECT KEY_ID FROM PMS_PARAM.FDIR_ALARM WHERE ID IN (SELECT ID FROM PMS_PARAM.FDIR_FDIRECT WHERE GROUPID=\'%s\')AND DEV_TABLE =\'bus\' ", groupid);
cout << sql << endl;
pthread_mutex_lock(&oci_mutex);
int ret = g_oci->ReadWithBind(sql, &buf, &rec_num, &attr_num, &attrs);
pthread_mutex_unlock(&oci_mutex);
if (ret != OCI_ERROR)
{
for (int i = 0; i < rec_num; i++)
{
char bus_id[MAX_BUS_ID_LEN+10];
bzero(bus_id,sizeof(bus_id));
strncpy(bus_id, buf + i * (attrs[0].col_width), attrs[0].col_width);
// strcat(bus_id, '\0');
lst_bus.push_back(atol(bus_id));
}
g_oci->Readdata_Free();
}
sprintf(sql, "select id,study_eq,fd,zone from fdir_fdirect where groupid=\'%s\'", groupid);
cout << sql << endl;
pthread_mutex_lock(&oci_mutex);
ret = g_oci->ReadWithBind(sql, &buf, &rec_num, &attr_num, &attrs);
pthread_mutex_unlock(&oci_mutex);
if (ret != OCI_ERROR)
{
for (int i = 0; i < rec_num; i++)
{
//启动一个故障
// FDIR_TASK data_task;
data_task.rq_type = TASK_TYPE_FAULT;
data_task.task_data.fault.next_step = TASK_FAULT_STATUS_ISO;
data_task.task_data.fault.bAuto = 0;
data_task.task_data.fault.type = TASK_FAULT_LD;
strncpy(data_task.task_data.fault.head.fault_id, buf, attrs[0].col_width), buf += attrs[0].col_width;
strcpy(data_task.task_data.fault.head.group_id, groupid);
data_task.task_data.fault.head.type = 0;
data_task.task_data.fault.head.size = sizeof(FDIR_TASK_DATA_FAULT);
data_task.task_data.fault.point_name = *(long*) (buf), buf += attrs[1].col_width;
data_task.task_data.fault.dv = *(long*) (buf), buf += attrs[2].col_width;
data_task.task_data.fault.fault_zone = *(long*) (buf), buf += attrs[3].col_width;
data_task.task_data.fault.st = *(long*) (buf), buf += attrs[4].col_width;
struct tm tm_fault = {0};
sscanf(data_task.task_data.fault.head.fault_id, "%04d/%02d/%02d %02d:%02d:%02d.%06ld", &tm_fault.tm_year, &tm_fault.tm_mon, &tm_fault.tm_mday, &tm_fault.tm_hour, &tm_fault.tm_min, &tm_fault.tm_sec, &data_task.tv_creat.tv_usec);
tm_fault.tm_year = tm_fault.tm_year - 1900;
tm_fault.tm_mon = tm_fault.tm_mon - 1;
data_task.tv_creat.tv_sec = mktime(&tm_fault);
TRACE("恢复故障到内存中故障ID:%s\r\n", data_task.task_data.fault.head.fault_id);
AddTask(&data_task);
for (FDIR_TASK_LIST::iterator it = g_lstTask.begin(); it != g_lstTask.end(); it++)
{
if (it->rq_type == TASK_TYPE_FAULT)
{
if (strcmp(it->task_data.fault.head.fault_id, data_task.task_data.fault.head.fault_id) == 0)
{
it->task_data.fault.fdir_r->lst_loss_vl_bus.clear();
for (list<long>::iterator it1 = lst_bus.begin(); it1 != lst_bus.end(); it1++)
{
it->task_data.fault.fdir_r->lst_loss_vl_bus.push_back(*it1);
}
it->task_data.fault.fdir_r->Init();
}
}
}
}
g_oci->Readdata_Free();
}
}
bool AddTask(FDIR_TASK *newtask)
{
assert(newtask != NULL);
assert(newtask->rq_type == TASK_TYPE_FAULT);
int i;
pthread_mutex_lock(&mutex_array_fault);
for (i = 0; i < MAX_FAULT; i++)
{
if (!map_idle_fdir_r[i])
{
newtask->task_data.fault.fdir_r = array_fdir_r[i];
map_idle_fdir_r[i] = true;
printf("\033[42m故障%s使用第%d号故障处理器[0x%x]！\033[0m\r\n", newtask->task_data.fault.head.fault_id, i, array_fdir_r[i]);
break;
}
}
pthread_mutex_unlock(&mutex_array_fault);
if(i < MAX_FAULT)
{
g_lstTask.push_back(*newtask);
TRACE("故障列表中开关名字%ld\n",g_lstTask.back().task_data.fault.point_name);
return true;
}
else
{
TRACE("查找故障处理器失败,释放部分处理器后重新查找\n");
//释放创建时间比较早的，而且不是执行中的故障
FDIR_TASK_LIST::iterator it = g_lstTask.begin();
FDIR_TASK_LIST::iterator it_find;
for (; it != g_lstTask.end(); it++)
{
if (it->rq_type == TASK_TYPE_FAULT && it->status == 0)
{
it_find = it;
break;
}
}
for (; it != g_lstTask.end(); it++)
{
if (it->rq_type == TASK_TYPE_FAULT && it->status == 0)
{
if (it->tv_creat.tv_sec < it_find->tv_creat.tv_sec)
{
it_find = it;
}
}
}
if (it_find != g_lstTask.end())
{
printf("释放故障groupid是：%s\r\n", it_find->task_data.fault.head.group_id);
if (!RemoveTasks(it_find->task_data.fault.head.group_id))
{
return false;
}
printf("自动归档故障groupid是：%s的故障组，并且把归档位置位1\r\n", it_find->task_data.fault.head.group_id);
ClearFdirDB(it_find->task_data.fault.head.group_id);
sprintf(sql, "UPDATE FDIR_FDIRECT_HIS SET STATUS=%d, AUTO_DEAL=1 WHERE GROUPID=\'%s\'", STATUS_FDIRECT_STOP, it_find->task_data.fault.head.group_id);
if (ExecSQL(sql) != OCI_ERROR)
{
sprintf(sql, "UPDATE FDIR_FDIRECT SET STATUS=%d WHERE GROUPID=\'%s\'", STATUS_FDIRECT_STOP, it_find->task_data.fault.head.group_id);
ExecSQL(sql);
}
}
else
{
TRACE("查找故障处理器失败,没有可以调度释放的处理器\n");
return false;
}
if (AddTask(newtask))
{
return true;
}
else
{
return false;
}
}
}
bool RemoveTask(const char *faultid)
{
assert(faultid != NULL);
int i;
FDIR_TASK_LIST::iterator it = g_lstTask.begin();
for(;it != g_lstTask.end();it++)
{
if(strcmp(it->task_data.fault.head.fault_id, faultid) == 0)
{
break;
}
}
if(it == g_lstTask.end())
{
return false;
}
else
{
pthread_mutex_lock(&mutex_array_fault);
for (i = 0; i < MAX_FAULT; i++)
{
if (it->task_data.fault.fdir_r == array_fdir_r[i])
{
map_idle_fdir_r[i] = false;
it->task_data.fault.fdir_r = NULL;
printf("\033[42m第%d号故障处理器[0x%x]被释放！\033[0m\r\n", i,
array_fdir_r[i]);
break;
}
}
pthread_mutex_unlock(&mutex_array_fault);
g_lstTask.erase(it);
if(i < MAX_FAULT)
{
return true;
}
else
{
printf("\033[42m故障处理器释放失败,故障id是%s！\033[0m\r\n",faultid);
return false;
}
}
}
bool RemoveTasks(const char *grpid)
{
assert(grpid != NULL);
int i;
FDIR_TASK_LIST::iterator it = g_lstTask.begin();
for(;it != g_lstTask.end();)
{
if(strcmp(it->task_data.fault.head.group_id, grpid) == 0)
{
pthread_mutex_lock(&mutex_array_fault);
for (i = 0; i < MAX_FAULT; i++)
{
if (it->task_data.fault.fdir_r == array_fdir_r[i])
{
map_idle_fdir_r[i] = false;
it->task_data.fault.fdir_r = NULL;
printf("\033[42m第%d号故障处理器[0x%x]被释放！\033[0m\r\n", i,array_fdir_r[i]);
break;
}
}
pthread_mutex_unlock(&mutex_array_fault);
g_lstTask.erase(it);
it = g_lstTask.begin();
if(i < MAX_FAULT)
{
}
else
{
printf("\033[42m释放故障组号为%s的故障号为%s的故障处理器失败！\033[0m\r\n", it->task_data.fault.head.group_id,it->task_data.fault.head.fault_id);
return false;
}
}
else
{
it++;
}
}
return true;
}
int rte_connect(int argc, char **argv)
{
cout << "开始连接RTE..." << endl;
//D5000连接消息总线
iProcess = proc_inv->proc_init(argv[1], argv[2], argv[3]);
if (iProcess >= 0)
{
TRACE("进程管理初始化成功，本进程号为:%d\r\n", iProcess);
iMessage = bob_inv->messageInit(argv[1], argv[2], argv[3]);
if (iMessage >= 0)
{
//for (int i = 0; i <= 255; i++)
// bob_inv->messageSubscribe(i);
bob_inv->messageSubscribe(APP_TO_WARN_CHANNEL);
bob_inv->messageSubscribe(WARN_INFORM_CHANNEL);
}
else
{
TRACE("连接消息总线失败！\r\n");
return OO_FAIL;
}
}
else
{
TRACE("进程管理初始化失败！\r\n");
return OO_FAIL;
}
return OO_SUCCEED;
}
void rte_disconnect()
{
for (int i = 0; i <= 255; i++)
bob_inv->messageUnSubscribe(i);
bob_inv->messageExit(iMessage);
proc_inv->proc_exit(iProcess);
}
int build_fi_dv_map(map<long, long> &map_fi_dv)
{
//D5000还没建故障指示器表
return 0;
// map_fi_dv.clear();
//
// int count = oodbget_recnum(const_cast<TB_DESCR*>(g_db_psbob->GetTB("point")));
//
// PSBOB::POINT point = { 0 };
//// PSBOB::FAULTINFO faultinfo = { 0 };
//// PSBOB::DV dv = { 0 };
// PSBOB::OO_R_ST_POINT oo_r_st_point = { 0 };
// PSBOB::OO_R_DV_ST oo_r_dv_st = { 0 };
//
// int size = sizeof(point);
//
// for (int index = 0; index < count; index++)
// {
// bzero(&point, size);
//
// if (oodbread_rp(&point, index, const_cast<TB_DESCR*>(g_db_psbob->GetTB("point")), 1, size) == OO_FAIL)
// {
// printf("%s:读取PSBOB库表POINT记录失败，错误号：%d，LINE：%d\r\n", __FILE__, _oodb_errno, __LINE__);
// return OO_FAIL;
// }
//
// if ((point.datatype & POINT_PPFT) || (point.datatype & POINT_TFS) || (point.datatype & POINT_GDFT))
// {
//#if 0
// //该故障指示器在线段上
// if (point.groupid[0] == 0)
// {
//
// }
// //该故障指示器在开关上
// else
// {
//
// }
//#endif
// if (oodbread_rph(&oo_r_st_point, point.oo_st, const_cast<TB_DESCR*>(g_db_psbob->GetTB("oo_r_st_point")), sizeof(oo_r_st_point)) == OO_FAIL)
// {
// printf("%s:读取PSBOB库表oo_r_st_point物理号为%d的记录失败，错误号：%d，LINE:%d\r\n", __FILE__, point.oo_st, _oodb_errno, __LINE__);
// return OO_FAIL;
// }
//
// if (oodbread_ra(&oo_r_dv_st, "st_id", oo_r_st_point.st_id, const_cast<TB_DESCR*>(g_db_psbob->GetTB("oo_r_dv_st")), sizeof(oo_r_dv_st)) == OO_FAIL)
// {
// printf("%s:读取PSBOB库表oo_r_dv_st[st]为%s的记录失败，错误号：%d，LINE:%d\r\n", __FILE__, oo_r_st_point.st_id, _oodb_errno, __LINE__);
// return OO_FAIL;
// }
//
// map_fi_dv[point.id] = oo_r_dv_st.dv_id;
//
//// printf("%s,%s\r\n", point.id, oo_r_dv_st.dv_id);
// }
// else
// {
// continue;
// }
// }
//
// printf("map_fi_dv.size() = %d\r\n", map_fi_dv.size());
//
// return 0;
}
bool IsRunning(const char *process_name)
{
assert(process_name != NULL);
char szFile[260];
sprintf(szFile, "/var/tmp/%s.pid", process_name);
int fd = open(szFile, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR | S_IROTH | S_IRGRP);
if (-1 == fd)
{
TRACE("创建进程锁文件%s失败: %s\n", szFile, strerror(errno));
return true;
}
if (0 == flock(fd, LOCK_EX | LOCK_NB))
{
return false;
}
close(fd);
return true;
}
void* log(void *param)
{
const int buf_size = 1024 * 1024; //1M
int pipefd[2];
char *buf = new char[buf_size];
char *p = NULL;
char ch;
tm last = { 0 };
FILE *fp = NULL;
char szLogPath[260];
sprintf(szLogPath, "%s/var/log/dmshanlog", getenv("HOME"));
struct stat st;
if (stat(szLogPath, &st) == -1)
{
if (mkdir(szLogPath, S_IRWXU | S_IRWXG | S_IRWXO) != 0)
{
delete[] buf;
return 0;
}
}
cout << "注意：屏幕输出已写入日志文件，请用cat命令查看" << szLogPath << "目录下相应文件。" << endl;
pipe(pipefd);
//将输出缓存设置为行缓存模式
setvbuf(stdout, NULL, _IOLBF, BUFSIZ);
setvbuf(stderr, NULL, _IOLBF, BUFSIZ);
dup2(pipefd[1], STDOUT_FILENO);
dup2(pipefd[1], STDERR_FILENO);
p = buf;
while (true)
{
int ret = read(pipefd[0], p, 1);
if (*p == '\n')
{
p++;
time_t now = time(NULL);
tm *ptm = localtime(&now);
//如果是新的一天，则重新建立新的日志文件
if (ptm->tm_mday != last.tm_mday)
{
memcpy(&last, ptm, sizeof(tm));
if (fp != NULL)
{
fclose(fp);
}
char szFile[260] = { 0 };
if (version == VERSION_STUDY)
{
sprintf(szFile, "%s/dmshan_study_%04d%02d%02d.log", szLogPath, ptm->tm_year + 1900, ptm->tm_mon + 1, ptm->tm_mday);
}
else
{
sprintf(szFile, "%s/dmshan_realtime_%04d%02d%02d.log", szLogPath, ptm->tm_year + 1900, ptm->tm_mon + 1, ptm->tm_mday);
}
fp = fopen(szFile, "a+");
if (fp == NULL)
{
delete[] buf;
return 0;
}
}
char szTime[50] = { 0 };
sprintf(szTime, "[%04d/%02d/%02d %02d:%02d:%02d]:", ptm->tm_year + 1900, ptm->tm_mon + 1, ptm->tm_mday, ptm->tm_hour, ptm->tm_min, ptm->tm_sec);
fwrite(szTime, 1, strlen(szTime), fp);
fwrite(buf, 1, p - buf, fp);
fflush(fp);
p = buf;
bzero(buf, buf_size);
}
else
{
p++;
}
if (p - buf >= buf_size)
{
//单行文本过长
}
}
delete[] buf;
return NULL;
}
int main(int _argc, char *_argv[])
{
if (getopt(_argc, _argv, "c:") == 'c')
{
long dv = atol(optarg);
KEY_STRU ks = { 0 };
CCommon::long_to_keyid(dv, &ks);
g_db_psbob = new DB_PSBOB();
g_db_dms = new DB_DMS;
if (g_db_psbob->Init("psbob", "realtime", "dscada") == OO_FAIL || g_db_dms->Init("pwrflow", "realtime", "dscada_dms") == OO_FAIL)
{
return -1;
}
if (dv > 0 && ks.table_no != g_db_psbob->GetTB("subcontrolarea")->table_id)
{
TRACE("参数区域ID不正确!\r\n");
return -1;
}
build_map2();
DSBOB2 bob2;
if (!bob2.ReadPSBOB(dv))
{
return -1;
}
return 0;
}
//唯 一实例
if (version == VERSION_STUDY)
{
if (IsRunning("dmshan_study"))
{
TRACE("进程已经在运行中！\r\n");
return 0;
}
}
else
{
if (IsRunning("dmshan"))
{
TRACE("进程已经在运行中！\r\n");
return 0;
}
}
gethostname(hostname, 256);
cout << "hostname:" << hostname << endl;
#ifdef _LOG_
//将屏幕输出都写入到日志文件
pthread_t pt_log;
if (pthread_create(&pt_log, pthread_attr_default, (pthread_startroutine_t) log, NULL) < 0)
{
return -1;
}
#endif
if(version == VERSION_STUDY)
cout << "模拟态程序版本！"<<endl;
else
cout << "非模拟态程序版本！"<<endl;
#ifndef _NO_RTE_
#ifndef _FAST_DEBUG
if (version == VERSION_REALTIME && _argc < 4)
{
cout << "Your input is wrong. The right input should be:" << endl;
cout << "dmshan system_name(context_name) subsystem_name bobtemplate_name [sync_flag 0 1] CR>" << endl;
cout << "eg. :dmshan realtime rts_scd1 dabob" << endl;
return -1;
}
#endif
#endif
#ifdef _NO_RTE_
cout << "以非RTE事件调试模式启动程序"<<endl;
#endif
signal(SIGABRT, abrt);
signal(SIGINT, abrt);
// signal(SIGSEGV, abrt);
signal(SIGPIPE, SIG_IGN);
signal(SIGCONT, SIG_IGN);
// signal(SIGTERM, SIG_IGN);
g_db_psbob = new DB_PSBOB;
g_db_dms = new DB_DMS;
g_db_fdir = new DB_FDIR;
if (version == VERSION_STUDY)
{
#ifdef _SCADA
if (g_db_psbob->Init("psbob", "study", "scada") == OO_FAIL || g_db_dms->Init("pwrflow", "study", "scada_dms") == OO_FAIL || g_db_fdir->Init("fdir", "study", "scada_fdir") == OO_FAIL)
#else
if (g_db_psbob->Init("psbob", "study", "dscada") == OO_FAIL || g_db_dms->Init("pwrflow", "study", "dscada_dms") == OO_FAIL || g_db_fdir->Init("fdir", "study", "dscada_fdir") == OO_FAIL)
#endif
{
delete g_db_psbob;
delete g_db_dms;
delete g_db_fdir;
return -1;
}
}
else
{
#ifdef _SCADA
if (g_db_psbob->Init("psbob", "realtime", "scada") == OO_FAIL || g_db_dms->Init("pwrflow", "realtime", "scada_dms") == OO_FAIL || g_db_fdir->Init("pwrflow", "realtime", "scada_fdir") == OO_FAIL)
#else
if (g_db_psbob->Init("psbob", "realtime", "dscada") == OO_FAIL || g_db_dms->Init("pwrflow", "realtime", "dscada_dms") == OO_FAIL || g_db_fdir->Init("pwrflow", "realtime", "dscada_fdir") == OO_FAIL)
#endif
{
delete g_db_psbob;
delete g_db_dms;
delete g_db_fdir;
return -1;
}
}
if (build_fi_dv_map(g_map_fi_dv) == OO_FAIL)
{
delete g_db_psbob;
delete g_db_dms;
delete g_db_fdir;
return -1;
}
// PSBOB::POINT t_point;
//
// oodbread_rp(&t_point, 0, const_cast<TB_DESCR*>(g_db_psbob->GetTB("point")), 1, sizeof(PSBOB::POINT));
//
// delete g_db_psbob;
g_oci = new INTR_OCI;
if (g_oci->connect(getenv("DMS_OCI_USER"), getenv("DMS_OCI_PWD"), getenv("DMS_OCI_SRV")) == OCI_ERROR)
{
TRACE("连接数据库失败！user:%s,pwd:%s,srv:%s\r\n", getenv("DMS_OCI_USER"), getenv("DMS_OCI_PWD"), getenv("DMS_OCI_SRV"));
return -1;
}
GetFdirConfig(g_FdirConfig);
//建立馈线首端节点与母线的路径
build_map2();
TRACE("共建立%d对路径映射关系！\r\n", g_map_nd_path.size());
#ifndef _FAST_DEBUG
g_bob2 = new DSBOB2;
if (!g_bob2->ReadPSBOB())
// if(!g_bob2->ReadReDB(NULL, NULL, NULL))
{
cout << "读取PSBOB库失败!" << endl;
return -1;
}
// g_bob2->WriteReDB2(NULL, NULL, NULL);
nmd = new NMD(g_bob2);
if (!nmd->DoValidate())
{
cout << __LINE__<<":NMD 检验失败！" << endl;
return -1;
}
//建立ZN表
MAP_SO_PATH so_path;
if (!nmd->find_so(0, NULL, so_path, FIND_TYPE_BUILD_ZN))
{
cout << __LINE__<<":建立ZN失败！" << endl;
return -1;
}
#if 0
if (!nmd->update_cb_state()|| !nmd->add_so())
{
cout << "自动添加电源失败！" << endl;
delete g_bob2;
delete nmd;
return 10;
}
#endif
//故障恢复
g_bob = new DSBOB;
g_bob->ReadFromDsbob2(g_bob2);
if (!g_bob2->WriteReDB2(NULL, NULL, NULL))
{
cout << "写入DMS库失败！" << endl;
return -1;
}
#endif
// if (!g_bob->ReadReDB(NULL, NULL, NULL))
// {
// cout << "DSBOB读取DMS库失败!" << endl;
//
// return -1;
// }
#ifndef _FAST_DEBUG
// TP tp(g_bob);
//
// if (tp.tp_allnew() == TP_FAIL)
// {
// return -1;
// }
//
// if (!g_bob->WriteReDB(NULL, NULL, NULL))
// {
// return -1;
// }
#endif
#if 0
if (fdir_r->FormFdirDB() == FDIR_R_FAIL)
{
cout <<"FormFdirDB failed!"<<endl;
return -1;
}
if (fdir_r->FormIcbOfZone() == FDIR_R_FAIL)
{
cout <<"FormIcbOfZone failed!"<<endl;
delete g_bob;
delete g_bob2;
delete nmd;
delete fdir_r;
return 8;
}
if (!fdir_r->WriteRtdb())
{
cout << "fdir_r->WriteRtdb失败！" << endl;
return -1;
}
#endif
CScaCommonFactory *scacommFactory;
GetScaCommonFactory(&scacommFactory);
g_sca_common = scacommFactory->CreateScaCommon();
scacommFactory->Release();
model_chg_ntf = &tmp_val0;
CContext::SetContextNo(_argc, _argv, AC_REALTIME_NO);
g_sca_common->DbNotifyAt(SMNG_MODEL_NO, &model_chg_ntf, AP_DSCADA);
last_model_chg_ntf = *model_chg_ntf;
pthread_attr_t attr;
size_t size_stack = 2 * 1024 * 1024; //2M
pthread_attr_init(&attr);
size_t size_org_stack = 0;
pthread_attr_getstacksize(&attr, &size_org_stack);
TRACE("系统默认线程堆栈大小为%d bytes", size_org_stack);
if (size_org_stack < size_stack)
{
pthread_attr_setstacksize(&attr, size_stack);
cout << "，调整为" << size_stack << " bytes";
}
cout << endl;
if (pthread_mutex_init(&g_rq_mutex, pthread_mutexattr_default))
{
perror("Init g_rq_mutex error");
return -1;
}
if (pthread_mutex_init(&avg_i_mutex, pthread_mutexattr_default))
{
perror("Init avg_i_mutex error");
return -1;
}
if (pthread_mutex_init(&mutex_array_fault, pthread_mutexattr_default))
{
perror("Init mutex_array_fault error");
return -1;
}
if (pthread_mutex_init(&task_list_mutex, pthread_mutexattr_default))
{
perror("Init task_list_mutex error");
return -1;
}
if (pthread_mutex_init(&oci_mutex, pthread_mutexattr_default))
{
perror("Init oci_mutex error");
return -1;
}
if (pthread_mutex_init(&simu_sync_mutex, pthread_mutexattr_default))
{
perror("Init simu_mutex error");
return -1;
}
g_fdir_r = new FDIR_R2(g_bob);
g_fdir_r->Init();
//g_fdir_r->count_ld();
for(int iFault = 0; iFault < MAX_FAULT; iFault++)
{
array_fdir_r[iFault] = new FDIR_R2(g_bob);
map_idle_fdir_r[iFault] = false;
}
// g_fdir_r->Do(114560315538017527, true);
// g_fdir_r->ExecFdir("CSCSEC18", "sec");
// fill_fdir_db("1111111111111111111111", "CSCSEC18", 0);
//#define _NO_RTE_
#ifdef _NO_RTE_
///////////////////故障定位测试代码
cout<<"start loop"<<endl;
// FDIR_R *fdir_r1=NULL;
// while(true)
// {
// fdir_r1 = new FDIR_R(g_bob);
// delete fdir_r1;
//
// usleep(50);
// }
//
// fdir_r1 = new FDIR_R(g_bob);
// delete fdir_r1;
//
// fdir_r1 = new FDIR_R(g_bob);
// delete fdir_r1;
// fdir_r1 = new FDIR_R(g_bob);
// delete fdir_r1;
FDIR_POINT_TRIG data;
data.bjxcb = false;
data.id.evt.point_name=114560315538017527;// "CSCCBA7";
g_lstTrig.push_back(data);
// data.bjxcb = false;
// strcpy(data.id.evt.point_name, "CSCRLYA8BCGL");
// g_lstTrig.push_back(data);
// data.bjxcb = false;
// strcpy(data.id.evt.point_name, "22222_Rs");
// g_lstTrig.push_back(data);
// data.bjxcb = false;
// strcpy(data.id.evt.point_name, "18731_Pos");
// g_lstTrig.push_back(data);
g_fdir_r->data_start.type = TASK_FAULT_LD;
g_fdir_r->data_start.source.ld_id=114560315538017527;// "CSCCBA7");
// g_map_trig_fi["GuZhangCeShi1"].push_back("GZ1TFS1");
// g_map_trig_fi["GuZhangCeShi1"].push_back("GZ1TFS2");
// g_map_trig_fi["GuZhangCeShi1"].push_back("GZ1TFS3");
// g_map_trig_fi["GuZhangCeShi3"].push_back("GZ3TFS129");
// g_map_trig_fi["GuZhangCeShi3"].push_back("GZ3TFS131");
// g_map_trig_fi["GuZhangCeShi3"].push_back("GZ3TFS88");
// g_lstSecTrig.push_back("GZCTFS6");
// g_lstSecTrig.push_back("CSC4");
g_fdir_r->ExecFdir();
// cout << "**************模拟开关CSCCBA2拒动******************" << endl;
//
// delete fdir_r1;
//
// fdir_r1 = new FDIR_R(g_bob);
//// FDIR_POINT_TRIG data;
//
// data.bjxcb = false;
// strcpy(data.id.evt.point_name, "YSCCBA1");
// g_lstTrig.push_back(data);
//
// data.bjxcb = false;
// strcpy(data.id.evt.point_name, "YSCCBB1");
// g_lstTrig.push_back(data);
//
// data.bjxcb = false;
// strcpy(data.id.evt.point_name, "YSCCBS1");
// g_lstTrig.push_back(data);
//
//
// fdir_r1->data_start.type = TASK_FAULT_JXCB;
// strcpy(fdir_r1->data_start.source.ld_id, "YSCCBS1");
//
// fdir_r1->ExecFdir();
//
// delete fdir_r1;
//生成故障描述文本文件
// map<string, string> keys;
// FAULT_ITEM fault_head;
// list<FAULT_ITEM> fault_tails;
// time_t now; ///////
//
// char str[4096] = { 0 };
// char str_tmp[1024] = { 0 };
//
// sprintf(str, "<?xml version = \"1.0\" encoding = \"ISO-8859-1\" ?>\r\n<Message>\r\n");
// sprintf(str_tmp, "<fault fault_id = \"%s\"/>\r\n", "");
// strcat(str, str_tmp);
// strcat(str, "<Body>\r\n");
// g_fdir_r->get_fault_area(fault_head, fault_tails);
// PSBOB::FAULTINFO faultinfo = { 0 };
// //写入故障区段首端结点
// if (fault_head.table == "FI")
// {
// if (oodbread_rk(&faultinfo, const_cast<char*>(fault_head.id.c_str()), const_cast<TB_DESCR*>(g_db_psbob->GetTB("faultinfo")), sizeof(PSBOB::FAULTINFO)) == OO_FAIL)
// {
// printf("读取faultinfo表关键字为:%s的记录失败，errno:%d,line:%d\r\n", fault_head.id.c_str(), _oodb_errno, __LINE__);
// return 0;
// }
// sprintf(str_tmp, "<Record id = \"%s\" type = \"%s\" pole = \"%s\" sec = \"%s\"/>\r\n", fault_head.id.c_str(), fault_head.table.c_str(), faultinfo.poleid,
// faultinfo.secid);
// }
// else
// {
// sprintf(str_tmp, "<Record id = \"%s\" type = \"%s\" pole = \"\" sec = \"\"/>\r\n", fault_head.id.c_str(), fault_head.table.c_str());
// }
//
// strcat(str, str_tmp);
//
// for (list<FAULT_ITEM>::iterator it_tail = fault_tails.begin(); it_tail != fault_tails.end(); it_tail++)
// {
// if (it_tail->table == "FI")
// {
// if (oodbread_rk(&faultinfo, const_cast<char*>(it_tail->id.c_str()), const_cast<TB_DESCR*>(g_db_psbob->GetTB("faultinfo")), sizeof(PSBOB::FAULTINFO)) == OO_FAIL)
// {
// printf("读取faultinfo表关键字为:%s的记录失败，errno:%d,line:%d\r\n", it_tail->id.c_str(), _oodb_errno, __LINE__);
// break;
// }
// sprintf(str_tmp, "<Record id = \"%s\" type = \"%s\" pole = \"%s\" sec = \"%s\"/>\r\n", it_tail->id.c_str(), it_tail->table.c_str(), faultinfo.poleid, faultinfo.secid);
// }
// else
// {
// sprintf(str_tmp, "<Record id = \"%s\" type = \"%s\" pole = \"\" sec = \"\"/>\r\n", it_tail->id.c_str(), it_tail->table.c_str());
// }
//
// strcat(str, str_tmp);
// }
// strcat(str, "</Body>\r\n</Message>");
// cout << "str=" << str << endl;
//
// FILE *fp = fopen(FAULT_DESC_FILE, "w+");
//
// if (fp != NULL)
// {
// fwrite(str, 1, strlen(str), fp);
// fclose(fp);
// }
return 0;
///////////////////故障定位测试代码
#endif
if (pthread_mutex_init(&trig_list_mutex, pthread_mutexattr_default))
{
perror("Init trig_list_mutex error");
return -1;
}
#ifndef _FAST_DEBUG
pthread_t pt_process;
if (pthread_create(&pt_process, &attr, (pthread_startroutine_t) thread_process, 0) < 0)
{
cout << "创建故障处理线程失败！" << endl;
}
pthread_detach(pt_process);
pthread_t pt_alarm_process;
if (pthread_create(&pt_alarm_process, &attr, (pthread_startroutine_t) thread_alarm_process, 0) < 0)
{
cout << "创建故障信号扫描线程失败！" << endl;
}
pthread_detach(pt_alarm_process);
pthread_t pt_iv;
if (pthread_create(&pt_iv, &attr, (pthread_startroutine_t) thread_get_ivalue, 0) < 0)
{
cout<<"创建开关电流平均值读取线程失败！"<<endl;
}
pthread_detach(pt_iv);
if (version == VERSION_REALTIME)
{
// 创建扫描母线故障线程
pthread_t pt_scan_bus_process;
if (pthread_create(&pt_scan_bus_process, pthread_attr_default, (pthread_startroutine_t) thread_scan_bus, 0) < 0)
{
cout << "创建母线故障扫描线程失败！" << endl;
}
pthread_detach(&pt_scan_bus_process);
//连接RTE
//D5000连接RTE
bob_inv = new message_invocation;
proc_inv = new proc_invocation;
rte_connect(_argc, _argv);
pthread_t pt_recv_rte;
if (pthread_create(&pt_recv_rte, &attr, (pthread_startroutine_t) thread_recv_rte, 0) < 0)
{
cout << "创建RTE事件接收线程失败！" << endl;
}
pthread_detach(pt_recv_rte);
}
else if (version == VERSION_STUDY)
{
proc_inv = new proc_invocation;
int Process = proc_inv->proc_init("study", "dscada_dms", "dmshan_study");
if (Process >= 0)
{
TRACE("进程管理初始化成功，本进程号为:%d\r\n", Process);
}
else
{
TRACE("进程管理初始化失败！\r\n");
return OO_FAIL;
}
}
#endif
tcptools = new TCPClass;
int ret = tcptools->Srv_Init(version == VERSION_REALTIME ? SERVER_PORT : SERVER_PORT_STUDY);
if (ret < 0)
{
cout << " tcp Srv_init failed ... " << endl;
return -1;
}
listenfd = tcptools->GetListenfd();
//
// Accept client connect request
//
int newsockfd = 0;
numthread = 0;
for (int i = 0; i < MAX_THREAD; i++)
{
pthread_id[i].fdinThread = -1;
}
while (GDI_TRUE)
{
if (numthread > MAX_THREAD)
{
numthread = 0;
}
if ((newsockfd = tcptools->Srv_Accept()) < 0)
{
}
numthread = newsockfd;
//yangyong 20150623
if (pthread_id[numthread].fdinThread == -1)
{
pthread_id[numthread].fdinThread = newsockfd;
pthread_id[numthread + 1].fdinThread = newsockfd;
}
if (newsockfd == -1 && numthread == -1)
{
break;
}
int ret;
if ((ret = pthread_create(&pthread_id[numthread].thread_id, &attr, (pthread_startroutine_t) HandlerMessage, (pthread_addr_t) &newsockfd)) < 0)
{
#ifdef _DEBUG_
printf("Create Failed!!!\n");
#endif
}
else if((ret = pthread_create(&pthread_id[numthread + 1].thread_id, &attr, (pthread_startroutine_t) thread_simu_return, (pthread_addr_t) &newsockfd)) < 0)
{
#ifdef _DEBUG_
TRACE("Create Failed!!!\n");
#endif
}
pthread_detach(pthread_id[numthread].thread_id);
pthread_detach(pthread_id[numthread + 1].thread_id);
}
return 0;
}
void HandlerMessage(void *para)
{
//
// Recv and Send client xml message init
//
int ret;
int newsockfd;
TiXmlDocument *pXmlDoc = new TiXmlDocument();
struct timeval tpstart, tpend;
long iTimeInterval;
newsockfd = *((int*)para);
cout << " ******** New Thread (" << newsockfd << ")********" << endl;
char recv_buf[MAX_BUFLEN];
bzero(recv_buf, MAX_BUFLEN);
//
// Transact client xml message
//
int msgType = 0;
timeval stimer = {0};
time_t now = 0;
//char recv_xml[40960] = {0};
FILE *pfile = NULL;
char filename[256];
sprintf(filename, "dms_socket_%d.xml", newsockfd);
while (GDI_TRUE)
{
RE_RECV:
if ((ret = tcptools->ReadLine(newsockfd, recv_buf, MAX_BUFLEN)) <= 0)
{
if (ret == 0)
{
}
break;
}
//接收到新的XML格式请求信息，创建新的临时文件储存接下来收到的XML文件数据
if(strncasecmp(recv_buf, "<?xml", 5) == 0)
{
cout << ">>>>>>>>"<<ctime(&(now = time(NULL)))<<"new request!" << endl;
gettimeofday(&stimer, NULL);
pfile = fopen(filename, "w+");
// fwrite(test_misoperation, 1, strlen(test_misoperation), pfile);
if (pfile == NULL)
{
cout << "创建临时XML文件失败，" << strerror(errno) << endl;
break;
}
}
cout << recv_buf << endl;
//将收到的数据写入临时文件
if (pfile > 0)
fputs(recv_buf, pfile);
else
cout << "错误的请求报文数据：" << recv_buf << endl;
//XML传送结束
if (strstr(recv_buf, "</Message>") != NULL)
{
try
{
fclose(pfile);
} catch (...)
{
}
pfile = NULL;
MAP_SO_PATH paths;
ORDER order = {0};
char ret_buf[1024] = { 0 };
paths.clear();
cout << "下行报文结束！" << endl;
int cmd = 0;
//XML解析器载入临时XML文档并解析
if (pXmlDoc->LoadFile(filename))
{
try
{
unlink(filename); //删除临时文件
} catch (...)
{
}
TiXmlNode *pnode = pXmlDoc->FirstChild(); //xml版本
while ((pnode = pnode->NextSibling()) != NULL)
{
TiXmlElement *element = pnode->ToElement();
if (element != NULL && strcasecmp(element->Value(), "Message") == 0) //Message节点
{
TiXmlNode *pmsgnode = pnode->FirstChild();
char Header[100] = {0};//请求类型
while (pmsgnode != NULL)
{
TiXmlElement *msgelement = pmsgnode->ToElement();
if (strcasecmp(msgelement->Value(), "Header") == 0) //Header节点
{
// if (strcasecmp(msgelement->Attribute("type"), "Equipment_Color") != 0) //判断是否着色请求,如果不是,将不响应本次请求
// goto RE_RECV;
strncpy(Header, msgelement->Attribute("type"), 100);
}
else if (strcasecmp(msgelement->Value(), "Body") == 0) //Body节点
{
TiXmlNode *pbodynode = pmsgnode->FirstChild();
while (pbodynode != NULL)
{
TiXmlElement *bodyelement = pbodynode->ToElement();
//设备着色
if (strcasecmp(Header, "Equipment_Color") == 0)
{
if (strcasecmp(bodyelement->Value(), "Order") == 0)
{
//将请求上下文信息储存起来以便返回响应包里使用
strcpy(order.contextname, bodyelement->Attribute("contextname"));
strcpy(order.bobname, bodyelement->Attribute("bobname"));
strcpy(order.equipment_type, bodyelement->Attribute("equipment_type"));
strcpy(order.picturename, bodyelement->Attribute("pictureName"));
strcpy(order.st, bodyelement->Attribute("st"));
cmd = atoi(bodyelement->Attribute("equipment_type"));
//加多请求线程互斥锁
pthread_mutex_lock(&g_rq_mutex);
//更新开关状态,并根据母线的遥测信息添加SO
if (nmd->update_cb_state() && nmd->add_so()/* && nmd->DoValidate() && g_bob2->WriteReDB(NULL, NULL, NULL)*/)
{
TiXmlNode *pordernode = pbodynode->FirstChild();
//循环查找Record项,并处理
while (pordernode != NULL)
{
TiXmlElement *porderelement = pordernode->ToElement();
if (strcasecmp(porderelement->Value(), "Record") == 0)
{
switch (cmd)
{
case 1: //电源跟踪
{
nmd->find_so(atol(porderelement->Attribute("id")), porderelement->Attribute("tablename"), paths, FIND_TYPE_SO);
break;
}
case 2: //供电范围
{
nmd->find_so(atol(porderelement->Attribute("id")), porderelement->Attribute("tablename"), paths, FIND_TYPE_SO_AREA);
break;
}
case 100: //检查设备连接状态
{
nmd->find_so(atol(porderelement->Attribute("id")), porderelement->Attribute("tablename"), paths, FIND_TYPE_CONNECT);
break;
}
default:
break;
}
}
else
{
}
pordernode = pordernode->NextSibling();
}
}
pthread_mutex_unlock(&g_rq_mutex);
}
else
{
}
//发送请求响应数据
//发送XML响应头
cout << head_xml << endl;
ret = tcptools->Send(newsockfd, head_xml, strlen(head_xml));
if (ret <= 0)
{
cout << "发送数据失败，" << strerror(errno) << endl;
goto RE_RECV;
}
//发送响应请求上下文信息
sprintf(ret_buf, "<Order pictureName = \"%s\" contextname = \"%s\" bobname = \"%s\" st = \"%s\" equipment_type = \"%s\" >\r\n", order.picturename,
order.contextname, order.bobname, order.st, order.equipment_type);
cout << ret_buf << endl;
ret = tcptools->Send(newsockfd, ret_buf, strlen(ret_buf));
if (ret <= 0)
{
cout << "发送数据失败，" << strerror(errno) << endl;
goto RE_RECV;
}
//逐项发送设备列表里的设备信息
for (MAP_SO_PATH::iterator it = paths.begin(); it != paths.end(); it++)
{
while (it->second.path.size() > 0)
{
sprintf(ret_buf, "<Record id = \"%ld\" tablename = \"%s\" />\r\n", it->second.path.top().id, it->second.path.top().table.c_str());
if(it->second.path.top().table == "busbarsection" || it->second.path.top().table == "energyconsumer")
{
int field_no[2] = { 0, 0 };
int ret = 0;
int field_num = 2;
ret = GetFieldNoByName(const_cast<TB_DESCR*>(g_db_psbob->GetTB(it->second.path.top().table.c_str())), "nd,name", field_no, &field_num);
if (ret >= 0)
{
struct
{
long nd;
char name[64];
} value;
ret = GetFieldsByID(const_cast<TB_DESCR*>(g_db_psbob->GetTB(it->second.path.top().table.c_str())), (char*) &it->second.path.top().id, field_no,
field_num, sizeof(value), (char*) &value);
if (ret == 0)
{
TRACE("nd:%ld,name:%s\r\n", value.nd, value.name);
}
}
}
else
{
int field_no[3] = { 0, 0, 0 };
int ret = 0;
int field_num = 3;
ret = GetFieldNoByName(const_cast<TB_DESCR*>(g_db_psbob->GetTB(it->second.path.top().table.c_str())), "ind,jnd,name", field_no, &field_num);
if (ret >= 0)
{
struct
{
long ind;
long jnd;
char name[64];
} value;
ret = GetFieldsByID(const_cast<TB_DESCR*>(g_db_psbob->GetTB(it->second.path.top().table.c_str())), (char*) &it->second.path.top().id, field_no,
field_num, sizeof(value), (char*) &value);
if (ret == 0)
{
TRACE("ind:%ld,jnd:%ld,name:%s\r\n", value.ind, value.jnd, value.name);
}
}
}
cout << ret_buf << endl;
ret = tcptools->Send(newsockfd, ret_buf, strlen(ret_buf));
if (ret <= 0)
{
cout << "发送数据失败，" << strerror(errno) << endl;
goto RE_RECV;
}
//杨勇 20160614 添加对环网柜母线的着色
DEV curDev = it->second.path.top();
map<long, list<long> >::iterator itRMUbus = g_map_nd_bus.find(curDev.nd);
if (itRMUbus != g_map_nd_bus.end() && strcasecmp(curDev.table.c_str(), "BUS") != 0
&& strcasecmp(curDev.table.c_str(), "busbarsection") != 0)
{
for (list<long>::iterator itRMU = itRMUbus->second.begin(); itRMU != itRMUbus->second.end(); itRMU++)
{
sprintf(ret_buf, "<Record id = \"%ld\" tablename = \"%s\" />\r\n", *itRMU, "busbarsection");
cout << ret_buf << endl;
ret = tcptools->Send(newsockfd, ret_buf, strlen(ret_buf));
if (ret <= 0)
{
cout << "发送数据失败，" << strerror(errno) << endl;
goto RE_RECV;
}
}
}
it->second.path.pop();
}
}
//发送XML响应尾
cout << tail_xml << endl;
ret = tcptools->Send(newsockfd, tail_xml, strlen(tail_xml));
if (ret <= 0)
{
cout << "发送数据失败，" << strerror(errno) << endl;
goto RE_RECV;
}
}
else if(strcasecmp(Header,"fdir_step") == 0)
{
char fault_id[100] = {0};
char fault_machine[100] = { 0 };
if (strcasecmp(bodyelement->Value(), "Order") == 0)
{
//将请求上下文信息储存起来以便返回响应包里使用
strcpy(order.contextname, bodyelement->Attribute("contextname"));
strcpy(order.bobname, bodyelement->Attribute("bobname"));
strcpy(order.picturename, bodyelement->Attribute("pictureName"));
strcpy(order.st, bodyelement->Attribute("st"));
strcpy(fault_machine, bodyelement->Attribute("machine"));
strcpy(fault_id, bodyelement->Attribute("fault_id"));
int ret = FDIR_R_FAIL;
//加多请求线程互斥锁
pthread_mutex_lock(&g_rq_mutex);
sprintf(sql, "DELETE FROM FDIR_STEP WHERE ID =\'%s\' and status=0", fault_id);
ExecSQL(sql);
TiXmlNode *pordernode = pbodynode->FirstChild();
//循环查找Record项,并处理
while (pordernode != NULL)
{
TiXmlElement *porderelement = pordernode->ToElement();
if (strcasecmp(porderelement->Value(), "Record") == 0)
{
sprintf(sql, "Insert into FDIR_STEP (ID, CB_ID, OPERATION, STEP, STATUS, CONTROL, STAGE) Values(\'%s\', \'%s\', %s, %s, 0, %s, %s)"
,fault_id, porderelement->Attribute("cbId"), porderelement->Attribute("operation")
,porderelement->Attribute("step"), porderelement->Attribute("control"), porderelement->Attribute("stage"));
ExecSQL(sql);
}
else
{
}
pordernode = pordernode->NextSibling();
}
pthread_mutex_unlock(&g_rq_mutex);
}
else
{
}
UpdateExtStatus(fault_id);
//发送请求响应数据
//发送XML响应头
cout << head_xml5 << endl;
ret = tcptools->Send(newsockfd, head_xml5, strlen(head_xml5));
if (ret <= 0)
{
cout << "发送数据失败，" << strerror(errno) << endl;
goto RE_RECV;
}
//发送响应请求上下文信息
sprintf(ret_buf, "<Order pictureName = \"%s\" contextname = \"%s\" bobname = \"%s\" st = \"%s\" machine=\"%s\">\r\n", order.picturename,
order.contextname, order.bobname, order.st, fault_machine);
cout << ret_buf << endl;
ret = tcptools->Send(newsockfd, ret_buf, strlen(ret_buf));
if (ret <= 0)
{
cout << "发送数据失败，" << strerror(errno) << endl;
goto RE_RECV;
}
//逐项发送设备列表里的设备信息
sprintf(ret_buf, "<Record id = \"%s\" result = \"0\" error=\"\"/>\r\n", fault_id);
cout << ret_buf << endl;
ret = tcptools->Send(newsockfd, ret_buf, strlen(ret_buf));
if (ret <= 0)
{
cout << "发送数据失败，" << strerror(errno) << endl;
goto RE_RECV;
}
//发送XML响应尾
cout << tail_xml << endl;
ret = tcptools->Send(newsockfd, tail_xml, strlen(tail_xml));
if (ret <= 0)
{
cout << "发送数据失败，" << strerror(errno) << endl;
goto RE_RECV;
}
}
else if (strcasecmp(Header, "study_fdir") == 0)
{
map<string, string> map_fault_group;
list<string> lst_group;
list<string> lst_remove_group;//故障模拟完成后需要从内存中删除的故障id
char fault_id[100] = {0};
long fault_sec;
char fault_table[50] = { 0 };
char fault_machine[100] = { 0 };
if (strcasecmp(bodyelement->Value(), "Order") == 0)
{
//将请求上下文信息储存起来以便返回响应包里使用
strcpy(order.contextname, bodyelement->Attribute("contextname"));
strcpy(order.bobname, bodyelement->Attribute("bobname"));
strcpy(order.picturename, bodyelement->Attribute("pictureName"));
strcpy(order.st, bodyelement->Attribute("st"));
strcpy(fault_machine, bodyelement->Attribute("machine"));
int ret = FDIR_R_FAIL;
//加多请求线程互斥锁
pthread_mutex_lock(&g_rq_mutex);
pthread_mutex_lock(&task_list_mutex);
TiXmlNode *pordernode = pbodynode->FirstChild();
//循环查找Record项,并处理
while (pordernode != NULL)
{
TiXmlElement *porderelement = pordernode->ToElement();
if (strcasecmp(porderelement->Value(), "Record") == 0)
{
fault_sec = atol(porderelement->Attribute("id"));
strcpy(fault_table, porderelement->Attribute("tablename"));
FDIR_TASK data_task;
PSBOB::DV dv = { 0 };
PSBOB::CB breaker = { 0 };
PSBOB::FI faultinfo = { 0 };
PSBOB::LD energyconsumer = { 0 };
PSBOB::BUS busbarsection = { 0 };
// 将可能是遥信ID转换成设备ID
KEY_STRU ks = { 0 };
CCommon::long_to_keyid(fault_sec, &ks);
ks.field_id = 0;
long dev_id = 0;
CCommon::keyid_to_long(&ks, &dev_id);
if (strcasecmp(fault_table, "faultinfo") == 0) //模拟故障的设备是故障指示器
{
if (oodbread_rk(&faultinfo, &fault_sec, const_cast<TB_DESCR*>(g_db_psbob->GetTB("faultinfo")), sizeof(PSBOB::FI)) < 0)
{
TRACE("oodbread_rk(%ld) failed!\r\n", fault_sec);
}
else
{
data_task.task_data.fault.st = faultinfo.st_id;
GetDv(faultinfo.aclnseg_id, "sec", dv);
}
}
else if (strcasecmp(fault_table, "breaker") == 0) //模拟故障的设备是开关设备
{
if (oodbread_rk(&breaker, &fault_sec, const_cast<TB_DESCR*>(g_db_psbob->GetTB("breaker")), sizeof(PSBOB::CB)) < 0)
{
TRACE("oodbread_rk(%ld) failed\r\n", fault_sec);
}
else
{
data_task.task_data.fault.st = breaker.st_id;
if (HasMask(g_db_psbob->GetTB("breaker"), "brk_type", breaker.brk_type, MENU_BRK_TYPE_JX))
{
GetJxcbDv(breaker.id, dv);
}
else
{
GetDv(breaker.id, "cb", dv);
}
}
}
else if (strcasecmp(fault_table, "energyconsumer") == 0) //模拟故障的设备是负荷设备
{
if (oodbread_rk(&energyconsumer, &fault_sec, const_cast<TB_DESCR*>(g_db_psbob->GetTB("energyconsumer")), sizeof(PSBOB::LD)) < 0)
{
TRACE("oodbread_rk(%ld) failed\r\n", fault_sec);
}
else
{
data_task.task_data.fault.st = energyconsumer.st_id;
GetDv(fault_sec, "ld", dv);
}
}
else if (strcasecmp(fault_table, "busbarsection") == 0) //模拟故障的设备是母线
{
if (oodbread_rk(&busbarsection, &fault_sec, const_cast<TB_DESCR*>(g_db_psbob->GetTB("busbarsection")), sizeof(PSBOB::BUS)) < 0)
{
TRACE("oodbread_rk(%ld) failed\r\n", fault_sec);
}
else
{
data_task.task_data.fault.st = busbarsection.st_id;
GetDv(fault_sec, "bus", dv);
}
}
if (dv.id != 0)
{
int fdir_damode = GetDvDamode(dv.id);
if (fdir_damode == -1)
{
cout << "获取馈线的故障处理模式失败" << dv.id << endl;
pordernode = pordernode->NextSibling();
continue;
}
//禁止处理故障
if (fdir_damode == FDIR_MODE_FORBID)
{
pordernode = pordernode->NextSibling();
continue;
}
GetFdirConfig(g_FdirConfig);
data_task.rq_type = TASK_TYPE_FAULT;
gettimeofday(&data_task.tv_creat, NULL);
data_task.task_data.fault.next_step = TASK_FAULT_STATUS_CALC_ISO;
if (g_FdirConfig.AUTO_DEAL_HIS)
{
data_task.task_data.fault.bAuto = 2;
}
else
{
data_task.task_data.fault.bAuto = fdir_damode == FDIR_MODE_AUTO ? 1 : 0;
}
data_task.task_data.fault.dv = dv.id;
data_task.task_data.fault.type = TASK_FAULT_STUDY;
data_task.task_data.fault.head.type = 0;
data_task.task_data.fault.head.size = sizeof(FDIR_TASK_DATA_FAULT);
data_task.task_data.fault.point_name = atol(porderelement->Attribute("id"));
tm *ptm = localtime(&data_task.tv_creat.tv_sec);
sprintf(data_task.task_data.fault.head.fault_id, "%04d/%02d/%02d %02d:%02d:%02d.%06ld", 1900 + ptm->tm_year, ptm->tm_mon + 1, ptm->tm_mday,
ptm->tm_hour, ptm->tm_min, ptm->tm_sec, data_task.tv_creat.tv_usec);
strcpy(fault_id, data_task.task_data.fault.head.fault_id);
cout << "新故障,故障ID:" << data_task.task_data.fault.head.fault_id << endl;
gettimeofday(&data_task.tv_start, NULL);
if (!AddTask(&data_task))
{
cout << "添加新故障任务失败" << endl;
}
else
{
if (g_lstTask.back().task_data.fault.fdir_r->ExecFdir(dev_id, fault_table) == FDIR_R_SUCCEED)
{
map_fault_group[fault_id] = "";
cout << "模拟故障成功" << endl;
}
else
{
sprintf(sql,
"Insert into FDIR_FDIRECT (ID, GROUPID, TYPE, FD, FD_DESCR, STATUS,STUDY_EQ,STUDY_MACHINE) Values (\'%s\', \'%s\', 1, \'%ld\', \'%s\', %d, \'%ld\',\'%s\')",
fault_id, fault_id, dv.id, dv.name, STATUS_FDIRECT_DIRECT_FAIL, fault_sec, fault_machine);
ExecSQL(sql);
RemoveTask(fault_id);
}
}
}
else
{
cout << "获取馈线信息失败" << porderelement->Attribute("id") << endl;
}
}
else
{
}
pordernode = pordernode->NextSibling();
}
pthread_mutex_unlock(&task_list_mutex);
pthread_mutex_unlock(&g_rq_mutex);
}
else
{
}
map<string, string>::iterator it_map_fault_group;
while (true)
{
pthread_mutex_lock(&task_list_mutex);
for (list<FDIR_TASK>::iterator it = g_lstTask.begin(); it != g_lstTask.end(); it++)
{
if (it->rq_type != TASK_TYPE_FAULT)
continue;
if (it->task_data.fault.next_step != TASK_FAULT_STATUS_ISO)
continue;
it_map_fault_group = map_fault_group.find(it->task_data.fault.head.fault_id);
if (it_map_fault_group != map_fault_group.end())
{
it_map_fault_group->second = it->task_data.fault.head.group_id;
if (it->task_data.fault.bAuto == 0)
{
//计算完成后把故障从任务列表的内存中删除，在执行的时候再把内存数据恢复
lst_remove_group.push_back(it->task_data.fault.head.fault_id);
}
}
}
pthread_mutex_unlock(&task_list_mutex);
for (it_map_fault_group = map_fault_group.begin(); it_map_fault_group != map_fault_group.end(); it_map_fault_group++)
{
if(it_map_fault_group->second.size() < 10) break;
else
{
lst_group.push_back(it_map_fault_group->second);
}
}
if (it_map_fault_group == map_fault_group.end())
{
break;
}
sleep(1);
}
lst_group.sort();
lst_group.unique();
string str_group;
for(list<string>::iterator it_lst_group = lst_group.begin(); it_lst_group != lst_group.end(); it_lst_group++)
{
str_group += *it_lst_group;
str_group += ";";
sprintf(sql, "UPDATE FDIR_FDIRECT SET TYPE=1,STUDY_MACHINE=\'%s\' WHERE GROUPID=\'%s\'", fault_machine, it_lst_group->c_str());
ExecSQL(sql);
}
pthread_mutex_lock(&task_list_mutex);
for (list<string>::iterator it_lst = lst_remove_group.begin(); it_lst != lst_remove_group.end(); it_lst++)
{
RemoveTask(it_lst->c_str());
}
pthread_mutex_unlock(&task_list_mutex);
//发送请求响应数据
//发送XML响应头
cout << head_xml4 << endl;
ret = tcptools->Send(newsockfd, head_xml4, strlen(head_xml4));
if (ret <= 0)
{
cout << "发送数据失败，" << strerror(errno) << endl;
goto RE_RECV;
}
//发送响应请求上下文信息
sprintf(ret_buf, "<Order pictureName = \"%s\" contextname = \"%s\" bobname = \"%s\" st = \"%s\" machine=\"%s\">\r\n", order.picturename,
order.contextname, order.bobname, order.st, fault_machine);
cout << ret_buf << endl;
ret = tcptools->Send(newsockfd, ret_buf, strlen(ret_buf));
if (ret <= 0)
{
cout << "发送数据失败，" << strerror(errno) << endl;
goto RE_RECV;
}
sprintf(ret_buf, "<Record fault_id=\"%s\" restult = \"0\" error=\"0\"/>\r\n", str_group.c_str());
cout << ret_buf << endl;
ret = tcptools->Send(newsockfd, ret_buf, strlen(ret_buf));
if (ret <= 0)
{
cout << "发送数据失败，" << strerror(errno) << endl;
goto RE_RECV;
}
//发送XML响应尾
cout << tail_xml << endl;
ret = tcptools->Send(newsockfd, tail_xml, strlen(tail_xml));
if (ret <= 0)
{
cout << "发送数据失败，" << strerror(errno) << endl;
goto RE_RECV;
}
}
else if (strcasecmp(Header, "fault_simu_save") == 0)
{
if(strcasecmp(bodyelement->Value(), "Simu_Plan") == 0)
{
//接收报文
SIMU_PLAN simu = {0};
strcpy(simu.plan_id, bodyelement->Attribute("id"));
strcpy(simu.machine_name, bodyelement->Attribute("machine"));
strcpy(simu.usr_id, bodyelement->Attribute("user"));
strcpy(simu.plan_name, bodyelement->Attribute("name"));
simu.type = atoi(bodyelement->Attribute("type"));
TiXmlNode* simu_node = pbodynode->FirstChild();
SIMU_SIG_LIST lst_sig;
while (simu_node != NULL)
{
TiXmlElement* simu_element = simu_node->ToElement();
if (strcasecmp(simu_element->Value(), "Record") == 0)
{
SIMU_SIGNAL simu_signal = {0};
strcpy(simu_signal.plan_id, simu.plan_id);
simu_signal.sig_id = atol(simu_element->Attribute("id"));
simu_signal.status = atoi(simu_element->Attribute("status"));
simu_signal.type = atoi(simu_element->Attribute("type"));
simu_signal.sig_delay = atoi(simu_element->Attribute("delay"));
strcpy(simu_signal.sig_name, simu_element->Attribute("name"));
if (strlen(simu_element->Attribute("comment")) > 0)
{
strcpy(simu_signal.comment, simu_element->Attribute("comment"));
}
else
{
strcpy(simu_signal.comment, "");
}
lst_sig.push_back(simu_signal);
}
simu_node = simu_node->NextSibling();
}
sprintf(sql, "INSERT INTO PMS_PARAM.FDIR_SIG_SUMMARY(ID, TYPE, NAME, MACHINE, USERID, RUN_TIME, FAULT_INDEX) VALUES(\'%s\', %d, \'%s\', \'%s\', \'%s\', 1, -1)",
simu.plan_id, simu.type, simu.plan_name, simu.machine_name, simu.usr_id);
ExecSQL(sql);
std::list<SIMU_SIGNAL>::iterator it_sig;
for(it_sig = lst_sig.begin(); it_sig != lst_sig.end(); it_sig++)
{
sprintf(sql, "INSERT INTO PMS_PARAM.FDIR_SIG_SIGNAL (ID, SIG_ID, SIG_NAME, TYPE, DELAY, STATUS, COMMENT) VALUES (\'%s\', %ld, \'%s\', %d, %d, %d, \'%s\')",
it_sig->plan_id, it_sig->sig_id, it_sig->sig_name, it_sig->type, it_sig->sig_delay, it_sig->status, it_sig->comment);
ExecSQL(sql);
}
//临时方案不校验
bool bresult = true;
if (simu.type == SIMU_PLAN_PERMANENT)
{
//分析拓扑，参考典型运行方式的代码
it_sig = lst_sig.begin();
SIMU_SIGNAL start_sig = {0};
memcpy(&start_sig, &(*it_sig), sizeof(SIMU_SIGNAL));
bresult = save_simu_cb_info(start_sig.sig_id, simu.plan_id);
}
//发送请求响应数据
//发送XML响应头
cout << head_xml_simu_save << endl;
ret = tcptools->Send(newsockfd, head_xml_simu_save, strlen(head_xml_simu_save));
if (ret <= 0)
{
cout << "发送数据失败，" << strerror(errno) << endl;
goto RE_RECV;
}
//发送响应请求上下文信息
sprintf(ret_buf, "<Simu_Plan id = \"%s\" type=\"%d\" name=\'%s\' machine=\"%s\" user=\'%s\'>\r\n",
simu.plan_id, simu.type, simu.plan_name, simu.machine_name, simu.usr_id);
cout << ret_buf << endl;
ret = tcptools->Send(newsockfd, ret_buf, strlen(ret_buf));
if (ret <= 0)
{
cout << "发送数据失败，" << strerror(errno) << endl;
goto RE_RECV;
}
sprintf(ret_buf, "<Record result = \"%d\" error=\"0\"/>\r\n", bresult?0:-1);
cout << ret_buf << endl;
ret = tcptools->Send(newsockfd, ret_buf, strlen(ret_buf));
if (ret <= 0)
{
cout << "发送数据失败，" << strerror(errno) << endl;
goto RE_RECV;
}
//发送XML响应尾
cout << tail_xml_simu << endl;
ret = tcptools->Send(newsockfd, tail_xml_simu, strlen(tail_xml_simu));
if (ret <= 0)
{
cout << "发送数据失败，" << strerror(errno) << endl;
goto RE_RECV;
}
}
}
else if (strcasecmp(Header, "fault_imitation_check") == 0) //故障模拟校验
{
if (strcasecmp(bodyelement->Value(), "Simu_Plan") == 0)
{
//接收报文
SIMU_PLAN simu = {0};
strcpy(simu.plan_id, bodyelement->Attribute("id"));
strcpy(simu.machine_name, bodyelement->Attribute("machine"));
strcpy(simu.usr_id, bodyelement->Attribute("user"));
simu.type = atoi(bodyelement->Attribute("type"));
TiXmlNode* simu_node = pbodynode->FirstChild();
CHECK_LIST check_cbs;
//循环查找Record项,并处理
while (simu_node != NULL)
{
TiXmlElement* simu_element = simu_node->ToElement();
if (strcasecmp(simu_element->Value(), "Record") == 0)
{
long record_id = atol(simu_element->Attribute("id"));
KEY_STRU ks = {0};
CCommon::long_to_keyid(record_id, &ks);
ks.field_id = 0;
CCommon::keyid_to_long(&ks, &record_id);
pthread_mutex_lock(&task_list_mutex);
if (ks.table_no == g_db_psbob->GetTB("breaker")->table_id)
{
CHECK_DATA data_check = {0};
data_check.cb_id = record_id;
data_check.status = atoi(simu_element->Attribute("status"));
data_check.Ia = atof(simu_element->Attribute("ia"));
data_check.Ib = atof(simu_element->Attribute("ib"));
data_check.Ic = atof(simu_element->Attribute("ic"));
data_check.p = atof(simu_element->Attribute("p"));
data_check.q = atof(simu_element->Attribute("q"));
check_cbs.push_back(data_check);
}
else
{
TRACE("无法校验的设备ID：%ld\r\n", record_id);
simu_node = simu_node->NextSibling();
continue;
}
pthread_mutex_unlock(&task_list_mutex);
}
simu_node = simu_node->NextSibling();
}
//向人机返回校验结果
if (Check_Simu_Data(check_cbs))
{
//发送请求响应数据
//发送XML响应头
cout << head_xml4 << endl;
ret = tcptools->Send(newsockfd, head_xml4, strlen(head_xml4));
if (ret <= 0)
{
cout << "发送数据失败，" << strerror(errno) << endl;
goto RE_RECV;
}
//发送响应请求上下文信息
sprintf(ret_buf, "<Simu_Plan id = \"%s\" type = \"%d\" name=\"%s\" machine=\"%s\" user=\"%s\">\r\n",
simu.plan_id, simu.type, simu.plan_name, simu.machine_name, simu.usr_id);
cout << ret_buf << endl;
ret = tcptools->Send(newsockfd, ret_buf, strlen(ret_buf));
if (ret <= 0)
{
cout << "发送数据失败，" << strerror(errno) << endl;
goto RE_RECV;
}
//返回开关记录信息
for (std::list<CHECK_DATA>::iterator it_chk = check_cbs.begin(); it_chk != check_cbs.end();it_chk++)
{
sprintf(ret_buf, "<Record id=\"%ld\" status=\"%d\" ia=\"%.2f\" ib=\"%.2f\" ic=\"%.2f\" p=\"%.2f\" q=\"%.2f\"/>\r\n",
it_chk->cb_id, it_chk->status, it_chk->Ia, it_chk->Ib, it_chk->Ic, it_chk->p, it_chk->q);
cout << ret_buf << endl;
ret = tcptools->Send(newsockfd, ret_buf, strlen(ret_buf));
if (ret <= 0)
{
cout << "发送数据失败，" << strerror(errno) << endl;
goto RE_RECV;
}
}
//发送XML响应尾
cout << tail_xml_simu << endl;
ret = tcptools->Send(newsockfd, tail_xml_simu, strlen(tail_xml_simu));
if (ret <= 0)
{
cout << "发送数据失败，" << strerror(errno) << endl;
goto RE_RECV;
}
}
}
}
else if (strcasecmp(Header, "fault_imitation_preexec") == 0)
{
SIMU_PLAN simu = {0};
strcpy(simu.plan_id, bodyelement->Attribute("id"));
strcpy(simu.machine_name, bodyelement->Attribute("machine"));
strcpy(simu.usr_id, bodyelement->Attribute("user"));
simu.type = atoi(bodyelement->Attribute("type"));
//不想保存的临时方案，先保存，返回报文之后再删除
if (strstr(simu.plan_id, "1970/01/01") != NULL)
{
//临时建立的方案
sprintf(sql, "INSERT INTO PMS_PARAM.FDIR_SIG_SUMMARY(ID, TYPE, NAME, MACHINE, USERID, RUN_TIME, FAULT_INDEX) VALUES(\'%s\', %d, \'%s\', \'%s\', \'%s\', 1, -1)",
simu.plan_id, 1, simu.plan_name, simu.machine_name, simu.usr_id);
ExecSQL(sql);
}
//清空历史故障模拟信号
simu_mac_trig.clear();
TiXmlNode* simu_node = pbodynode->FirstChild();
//循环查找Record项,并处理
while (simu_node != NULL)
{
TiXmlElement* simu_element = simu_node->ToElement();
if (strcasecmp(simu_element->Value(), "Record") == 0)
{
long sig_id = atol(simu_element->Attribute("id"));
int type = atoi(simu_element->Attribute("type"));
int status = atoi(simu_element->Attribute("status"));
if (type == 1 && status == 1)
{
//保护信号动作
PSBOB::PROTECT relay = {0};
if (oodbread_rk(&relay, &sig_id, const_cast<TB_DESCR*>(g_db_psbob->GetTB("relaysig")), sizeof(PSBOB::PROTECT)) > 0)
{
FDIR_POINT_TRIG data_trig = {0};
data_trig.trig_type = TRIG_TYPE_SIMU;
PSBOB::DV psbob_dv = {0};
if (GetDv(relay.st_id, "st", psbob_dv) == OO_FAIL)
{
TRACE("获取厂站%ld的馈线信息失败！\r\n", data_trig.alarm.st_id);
continue;
}
data_trig.dv_id = psbob_dv.id;
data_trig.alarm.key_id = sig_id;
data_trig.damode = GetDvDamode(psbob_dv.id);
if (data_trig.damode <= FDIR_MODE_FORBID)
{
TRACE("馈线%ld(%s)为禁止DA处理(%d)\r\n", psbob_dv.id, psbob_dv.name, psbob_dv.damode);
continue;
}
unsigned long id = 0;
KEY_STRU ks = {0};
CCommon::long_to_keyid(relay.oo_dev, &ks);
ks.field_id = 0;
CCommon::keyid_to_long(&ks, &id);
if (oodbread_rk(&data_trig.psbob_data.point, &id, const_cast<TB_DESCR*>(g_db_psbob->GetTB("breaker")), sizeof(data_trig.psbob_data.point)) < 0)
{
TRACE("读取开关表关键字为%ld的记录失败！\r\n", id);
continue;
}
TB_DESCR* tb_descr = const_cast<TB_DESCR*>(g_db_psbob->GetTB("relaysig"));
if (!(HasMask(tb_descr, "pnt_type", relay.pnt_type , MENU_TYPE_RELAY_SGZ) || HasMask(tb_descr, "pnt_type", relay.pnt_type , MENU_TYPE_RELAY_ACT)))
{
continue;
}
gettimeofday(&data_trig.tm_add, NULL);
data_trig.alarm.dev = ALARM_SGZ;
data_trig.alarm.name = relay.name;
data_trig.simu_plan_id = simu.plan_id;
std::string machine = simu.machine_name;
simu_mac_trig[machine].push_back(data_trig);
TRACE("模拟故障信号%ld已加入待处理故障信号列表！\r\n", data_trig.alarm.key_id);
}
else
{
TRACE("读取保护信号表关键字为%ld的记录失败！\r\n", sig_id);
}
}
else if (type == 0 && status == 0)
{
//开关分闸
PSBOB::CB cb = {0};
if (oodbread_rk(&cb, &sig_id, const_cast<TB_DESCR*>(g_db_psbob->GetTB("breaker")), sizeof(PSBOB::CB)) > 0)
{
FDIR_POINT_TRIG data_trig = {0};
data_trig.trig_type = TRIG_TYPE_SIMU;
PSBOB::DV psbob_dv = {0};
if (GetDv(cb.st_id, "st", psbob_dv) == OO_FAIL)
{
TRACE("获取厂站%ld的馈线信息失败！\r\n", data_trig.alarm.st_id);
continue;
}
data_trig.dv_id = psbob_dv.id;
data_trig.alarm.key_id = sig_id;
data_trig.damode = GetDvDamode(psbob_dv.id);
if (data_trig.damode <= FDIR_MODE_FORBID)
{
TRACE("馈线%ld(%s)为禁止DA处理(%d)\r\n", psbob_dv.id, psbob_dv.name, psbob_dv.damode);
continue;
}
gettimeofday(&data_trig.tm_add, NULL);
KEY_STRU ks = { 0 };
CCommon::long_to_keyid(data_trig.alarm.key_id, &ks);
ks.field_id = 0;
CCommon::keyid_to_long(&ks, &data_trig.alarm.key_id);
if (oodbread_rk(&data_trig.psbob_data.point, &data_trig.alarm.key_id, const_cast<TB_DESCR*>(g_db_psbob->GetTB("breaker")), sizeof(data_trig.psbob_data.point)) == OO_FAIL)
{
TRACE("读取开关表关键字为%ld的记录失败！\r\n", data_trig.alarm.key_id);
continue;
}
data_trig.alarm.dev = ALARM_BREAKER;
data_trig.alarm.name = data_trig.psbob_data.point.name;
data_trig.simu_plan_id = simu.plan_id;
std::string machine = simu.machine_name;
simu_mac_trig[machine].push_back(data_trig);
TRACE("模拟故障信号%ld已加入待处理故障信号列表！\r\n", data_trig.alarm.key_id);
}
else
{
TRACE("读取断路器表关键字为%ld的记录失败！\r\n", sig_id);
}
}
else
{
TRACE("信号%ld,status:%d, type:%d被过滤！\r\n", sig_id, status, type);
}
}
simu_node = simu_node->NextSibling();
}
}
else if (strcasecmp(Header, "fault_imitation_exec") == 0)
{
if (strcasecmp(bodyelement->Value(), "Simu_Plan") == 0)
{
SIMU_PLAN simu = {0};
strcpy(simu.plan_id, bodyelement->Attribute("id"));
strcpy(simu.machine_name, bodyelement->Attribute("machine"));
strcpy(simu.usr_id, bodyelement->Attribute("user"));
simu.type = atoi(bodyelement->Attribute("type"));
TiXmlNode* simu_node = pbodynode->FirstChild();
//循环查找Record项,并处理
while (simu_node != NULL)
{
TiXmlElement* simu_element = simu_node->ToElement();
if (strcasecmp(simu_element->Value(), "Record") == 0)
{
long sig_id = atol(simu_element->Attribute("id"));
int type = atoi(simu_element->Attribute("type"));
int status = atoi(simu_element->Attribute("status"));
//实时态转发为告警，研究态接收报文
if (version == VERSION_REALTIME)
{
Message message = { 0 };
RealDataPkg pkg={0};
KEY_STRU ks = {0};
CCommon::long_to_keyid(sig_id, &ks);
if (ks.table_no == 407)
{
ks.field_id = 40;
}
else if(ks.table_no == 434)
{
ks.field_id = 20;
}
CCommon::keyid_to_long(&ks, &sig_id);
ChangeYx yx = { sig_id, status, true, 222, -1 };
memcpy(pkg.mes, &yx, sizeof(ChangeYx));
pkg.package_head.data_num=1;
pkg.package_head.package_type = MT_YC_CHANGE;
pkg.package_head.second = time(NULL);
pkg.package_head.msecond = 0;
memcpy(message.Msg_buf, &pkg, sizeof(pkg));
message.header.event = MT_YX_CHANGE;
message.header.serv = D_CH_UP_REAL_DATA;
cout << "bob_inv->messageSend,return:" << bob_inv->messageSend(&message, sizeof(message.header) +sizeof(yx), NULL) << endl;
}
else if(version == VERSION_STUDY)
{
if (type == 1 && status == 1)
{
//保护信号动作
PSBOB::PROTECT relay = {0};
if (oodbread_rk(&relay, &sig_id, const_cast<TB_DESCR*>(g_db_psbob->GetTB("relaysig")), sizeof(PSBOB::PROTECT)) > 0)
{
FDIR_POINT_TRIG data_trig = {0};
data_trig.trig_type = TRIG_TYPE_SIMU;
PSBOB::DV psbob_dv = {0};
if (GetDv(relay.st_id, "st", psbob_dv) == OO_FAIL)
{
TRACE("获取厂站%ld的馈线信息失败！\r\n", data_trig.alarm.st_id);
continue;
}
data_trig.dv_id = psbob_dv.id;
data_trig.alarm.key_id = sig_id;
data_trig.damode = GetDvDamode(psbob_dv.id);
if (data_trig.damode <= FDIR_MODE_FORBID)
{
TRACE("馈线%ld(%s)为禁止DA处理(%d)\r\n", psbob_dv.id, psbob_dv.name, psbob_dv.damode);
continue;
}
unsigned long id = 0;
KEY_STRU ks = {0};
CCommon::long_to_keyid(relay.oo_dev, &ks);
ks.field_id = 0;
CCommon::keyid_to_long(&ks, &id);
if (oodbread_rk(&data_trig.psbob_data.point, &id, const_cast<TB_DESCR*>(g_db_psbob->GetTB("breaker")), sizeof(data_trig.psbob_data.point)) < 0)
{
TRACE("读取开关表关键字为%ld的记录失败！\r\n", id);
continue;
}
TB_DESCR* tb_descr = const_cast<TB_DESCR*>(g_db_psbob->GetTB("relaysig"));
if (!(HasMask(tb_descr, "pnt_type", relay.pnt_type , MENU_TYPE_RELAY_SGZ) || HasMask(tb_descr, "pnt_type", relay.pnt_type , MENU_TYPE_RELAY_ACT)))
{
continue;
}
gettimeofday(&data_trig.tm_add, NULL);
data_trig.alarm.dev = ALARM_SGZ;
data_trig.alarm.name = relay.name;
data_trig.simu_plan_id = simu.plan_id;
//将该信号加入过流信号列表
pthread_mutex_lock(&trig_list_mutex);
g_lstTrig.push_back(data_trig);
pthread_mutex_unlock(&trig_list_mutex);
TRACE("模拟故障信号%ld已加入过流信号列表！\r\n", data_trig.alarm.key_id);
}
else
{
TRACE("读取保护信号表关键字为%ld的记录失败！\r\n", sig_id);
}
}
else if (type == 0 && status == 0)
{
//开关分闸
PSBOB::CB cb = {0};
if (oodbread_rk(&cb, &sig_id, const_cast<TB_DESCR*>(g_db_psbob->GetTB("breaker")), sizeof(PSBOB::CB)) > 0)
{
FDIR_POINT_TRIG data_trig = {0};
data_trig.trig_type = TRIG_TYPE_SIMU;
PSBOB::DV psbob_dv = {0};
if (GetDv(cb.st_id, "st", psbob_dv) == OO_FAIL)
{
TRACE("获取厂站%ld的馈线信息失败！\r\n", data_trig.alarm.st_id);
continue;
}
data_trig.dv_id = psbob_dv.id;
data_trig.alarm.key_id = sig_id;
data_trig.damode = GetDvDamode(psbob_dv.id);
if (data_trig.damode <= FDIR_MODE_FORBID)
{
TRACE("馈线%ld(%s)为禁止DA处理(%d)\r\n", psbob_dv.id, psbob_dv.name, psbob_dv.damode);
continue;
}
gettimeofday(&data_trig.tm_add, NULL);
KEY_STRU ks = { 0 };
CCommon::long_to_keyid(data_trig.alarm.key_id, &ks);
ks.field_id = 0;
CCommon::keyid_to_long(&ks, &data_trig.alarm.key_id);
if (oodbread_rk(&data_trig.psbob_data.point, &data_trig.alarm.key_id, const_cast<TB_DESCR*>(g_db_psbob->GetTB("breaker")), sizeof(data_trig.psbob_data.point)) == OO_FAIL)
{
TRACE("读取开关表关键字为%ld的记录失败！\r\n", data_trig.alarm.key_id);
continue;
}
data_trig.alarm.dev = ALARM_BREAKER;
data_trig.alarm.name = data_trig.psbob_data.point.name;
data_trig.simu_plan_id = simu.plan_id;
//将该开关加入过流开关列表
pthread_mutex_lock(&trig_list_mutex);
g_lstTrig.push_back(data_trig);
pthread_mutex_unlock(&trig_list_mutex);
TRACE("模拟故障信号%ld已加入过流信号列表！\r\n", data_trig.alarm.key_id);
}
else
{
TRACE("读取断路器表关键字为%ld的记录失败！\r\n", sig_id);
}
}
else
{
TRACE("信号%ld,status:%d, type:%d被过滤！\r\n", sig_id, status, type);
}
}
else
{
}
}
simu_node = simu_node->NextSibling();
}
}
}
else if (strcasecmp(Header, "pntcontrol") == 0) //故障隔离恢复遥控
{
if (strcasecmp(bodyelement->Value(), "operation") == 0)
{
TiXmlNode *pordernode = pbodynode->FirstChild();
//循环查找order项,并处理
while (pordernode != NULL)
{
TiXmlElement *porderelement = pordernode->ToElement();
if (strcasecmp(porderelement->Value(), "order") == 0)
{
if (strcmp(porderelement->Attribute("op_type"), "finish") == 0) //故障处理完成
{
ClearFdirDB(porderelement->Attribute("fault_id"));
}
else if (strcmp(porderelement->Attribute("op_type"), "auto") == 0)//手工转自动
{
// if (!g_FdirConfig.USER2AUTO)
// {
// cout << "当前配置为禁止手工转自动" << endl;
// continue;
// }
cout << "**********手动转自动执行" << endl;
//
pthread_mutex_lock(&task_list_mutex);
list<FDIR_TASK>::iterator it;
for (it = g_lstTask.begin(); it != g_lstTask.end(); it++)
{
if (it->rq_type == TASK_TYPE_FAULT)
{
if (strcmp(it->task_data.fault.head.group_id, porderelement->Attribute("fault_id")) == 0)
{
it->task_data.fault.bAuto = 1;
break;
}
}
}
//如果不在任务列表，把故障重新加载到内存中，然后再把故障详细加载进去
if (it == g_lstTask.end())
{
RecoMemTask(porderelement->Attribute("fault_id"));
RecoTaskStep(porderelement->Attribute("fault_id"));
for (it = g_lstTask.begin(); it != g_lstTask.end(); it++)
{
if (it->rq_type == TASK_TYPE_FAULT)
{
if (strcmp(it->task_data.fault.head.group_id, porderelement->Attribute("fault_id")) == 0)
{
it->task_data.fault.bAuto = 1;
}
}
}
}
list<CB_CONTROL> lstcb;
GetLeftStep(porderelement->Attribute("fault_id"), lstcb);
//还有步骤执行
if (lstcb.size() > 0)
{
AddControlItem(porderelement->Attribute("fault_id"), lstcb.begin()->point_id, lstcb.begin()->bOpen, lstcb.begin()->stage);
}
//
else
{
}
pthread_mutex_unlock(&task_list_mutex);
}
else if(strcmp(porderelement->Attribute("op_type"), "stop") == 0) //人工停止故障处理
{
ClearFdirDB(porderelement->Attribute("fault_id"));
//更新故障状态为人工停止故障处理,首先判断故障信息是否已经转入his表里
sprintf(sql, "UPDATE FDIR_FDIRECT_HIS SET STATUS=%d WHERE GROUPID=\'%s\'", STATUS_FDIRECT_STOP, porderelement->Attribute("fault_id"));
if (ExecSQL(sql) != OCI_ERROR)
{
sprintf(sql, "UPDATE FDIR_FDIRECT SET STATUS=%d WHERE GROUPID=\'%s\'", STATUS_FDIRECT_STOP, porderelement->Attribute("fault_id"));
ExecSQL(sql);
}
//从任务列表中删除所有与该故障关联的项目
pthread_mutex_lock(&task_list_mutex);
#if 0
for (FDIR_TASK_LIST::iterator it_task = g_lstTask.begin(); it_task != g_lstTask.end(); it_task++)
{
if (it_task->rq_type == TASK_TYPE_FAULT)
{
if (strcmp(it_task->task_data.fault.head.group_id, porderelement->Attribute("fault_id")) == 0)
{
g_lstTask.erase(it_task);
it_task = g_lstTask.begin();
}
}
else if (it_task->rq_type == TASK_TYPE_CB_CTRL)
{
if (strcmp(it_task->task_data.control.head.group_id, porderelement->Attribute("fault_id")) == 0)
{
g_lstTask.erase(it_task);
it_task = g_lstTask.begin();
}
}
else
{
}
}
#else
RemoveTasks(porderelement->Attribute("fault_id"));
#endif
pthread_mutex_unlock(&task_list_mutex);
}
else if(strcmp(porderelement->Attribute("op_type"), "manposer") == 0) //人工处理故障完成
{
ClearFdirDB(porderelement->Attribute("fault_id"));
sprintf(sql, "UPDATE FDIR_FDIRECT_HIS SET STATUS=%d, USERID=\'%s\', MACHINE=\'%s\' WHERE GROUPID=\'%s\'", STATUS_FDIRECT_MANPOSER,
porderelement->Attribute("userName"), porderelement->Attribute("machine"), porderelement->Attribute("fault_id"));
if (ExecSQL(sql) != OCI_ERROR)
{
sprintf(sql, "UPDATE FDIR_FDIRECT SET STATUS=%d, USERID=\'%s\', MACHINE=\'%s\' WHERE GROUPID=\'%s\'", STATUS_FDIRECT_MANPOSER,
porderelement->Attribute("userName"), porderelement->Attribute("machine"), porderelement->Attribute("fault_id"));
ExecSQL(sql);
//更新故障步骤状态为未知-1
sprintf(sql, "UPDATE FDIR_STEP SET STATUS=%d WHERE ID=\'%s\'", STATUS_FDIRECT_UNKOWN, porderelement->Attribute("fault_id"));
ExecSQL(sql);
//更新故障步骤状态为未知-1
sprintf(sql, "UPDATE FDIR_STEP_HIS SET STATUS=%d WHERE ID=\'%s\'", STATUS_FDIRECT_UNKOWN, porderelement->Attribute("fault_id"));
ExecSQL(sql);
}
//从任务列表中删除所有与该故障关联的项目
pthread_mutex_lock(&task_list_mutex);
RemoveTasks(porderelement->Attribute("fault_id"));
pthread_mutex_unlock(&task_list_mutex);
}
else if (strcasecmp(porderelement->Attribute("op_type"), "yes_Fault") == 0) //误报、可能故障确认为真实故障
{
sprintf(sql, "UPDATE FDIR_FDIRECT SET STATUS=%d, USERID=\'%s\', MACHINE=\'%s\' WHERE GROUPID=\'%s\'", STATUS_FDIRECT_DIRECT_OK,
porderelement->Attribute("userName"), porderelement->Attribute("machine"), porderelement->Attribute("fault_id"));
ExecSQL(sql);
}
else if (strcasecmp(porderelement->Attribute("op_type"), "no_Fault") == 0) //误报、可能故障确认为非故障
{
ClearFdirDB(porderelement->Attribute("fault_id"));
sprintf(sql, "UPDATE FDIR_FDIRECT_HIS SET USERID=\'%s\', MACHINE=\'%s\' WHERE GROUPID=\'%s\'", porderelement->Attribute("userName"),
porderelement->Attribute("machine"), porderelement->Attribute("fault_id"));
if (ExecSQL(sql) != OCI_ERROR)
{
SetFdirectStatus(porderelement->Attribute("fault_id"));
}
//从任务列表中删除所有与该故障关联的项目
pthread_mutex_lock(&task_list_mutex);
RemoveTasks(porderelement->Attribute("fault_id"));
pthread_mutex_unlock(&task_list_mutex);
}
else if (strcasecmp(porderelement->Attribute("op_type"), "invalid") == 0) //故障执行步骤失效
{
sprintf(sql, "UPDATE FDIR_STEP SET STATUS=%d, STARTTIME=SYSDATE, ENDTIME=SYSDATE WHERE ID=\'%s\' AND STAGE=\'%s\' AND CB_ID=\'%s\'",
STATUS_FDIR_STEP_INVALID, porderelement->Attribute("fault_id"), porderelement->Attribute("stage"), porderelement->Attribute("cb"));
ExecSQL(sql);
ClearFdirDB(porderelement->Attribute("fault_id"));
sprintf(sql, "UPDATE FDIR_FDIRECT_HIS SET STATUS=%d WHERE GROUPID=\'%s\'", STATUS_FDIRECT_INVALID, porderelement->Attribute("fault_id"));
if (ExecSQL(sql) != OCI_ERROR)
{
sprintf(sql, "UPDATE FDIR_FDIRECT SET STATUS=%d WHERE GROUPID=\'%s\'", STATUS_FDIRECT_INVALID, porderelement->Attribute("fault_id"));
ExecSQL(sql);
}
//从任务列表中删除所有与该故障关联的项目
pthread_mutex_lock(&task_list_mutex);
RemoveTasks(porderelement->Attribute("fault_id"));
pthread_mutex_unlock(&task_list_mutex);
}
else if (strcasecmp(porderelement->Attribute("op_type"), "pass") == 0) //跳过指定遥控步骤
{
SetPassControl(porderelement->Attribute("fault_id"), atol(porderelement->Attribute("cb")), STATUS_FDIR_STEP_PASS,
atoi(porderelement->Attribute("stage")));
UpdateExtStatus(porderelement->Attribute("fault_id"));
//置处理完成标志
list<CB_CONTROL> lstCB;
if (GetLeftStep(porderelement->Attribute("fault_id"), lstCB) == 0)
{
ClearFdirDB(porderelement->Attribute("fault_id"));
sprintf(sql, "UPDATE FDIR_FDIRECT_HIS SET STATUS=%d WHERE groupid=\'%s\'", STATUS_FDIRECT_FINISH, porderelement->Attribute("fault_id"));
if (ExecSQL(sql) != OCI_ERROR)
{
sprintf(sql, "UPDATE FDIR_FDIRECT SET STATUS=%d WHERE groupid=\'%s\'", STATUS_FDIRECT_FINISH, porderelement->Attribute("fault_id"));
ExecSQL(sql);
}
RemoveTasks(porderelement->Attribute("fault_id"));
printf("故障组%s处理完成！！！！\r\n", porderelement->Attribute("fault_id"));
}
}
else
{
list<FDIR_TASK>::iterator it;
for (it = g_lstTask.begin(); it != g_lstTask.end(); it++)
{
if (it->rq_type == TASK_TYPE_FAULT)
{
if (strcmp(it->task_data.fault.head.group_id, porderelement->Attribute("fault_id")) == 0)
{
break;
}
}
}
//如果不在任务列表，把故障重新加载到内存中，然后再把故障详细加载进去
if (it == g_lstTask.end())
{
RecoMemTask(porderelement->Attribute("fault_id"));
RecoTaskStep(porderelement->Attribute("fault_id"));
}
if (strcasecmp("realtime", bodyelement->Attribute("contextname")) == 0)
{
pthread_mutex_lock(&task_list_mutex);
AddReturnControl(porderelement->Attribute("fault_id"), atol(porderelement->Attribute("cb")), atoi(porderelement->Attribute("op_type")) - 1,
atoi(porderelement->Attribute("stage")));
pthread_mutex_unlock(&task_list_mutex);
}
else
{
pthread_mutex_lock(&task_list_mutex);
AddControlItem(porderelement->Attribute("fault_id"), atol(porderelement->Attribute("cb")), atoi(porderelement->Attribute("op_type")) - 1,
atoi(porderelement->Attribute("stage")));
pthread_mutex_unlock(&task_list_mutex);
}
}
}
pordernode = pordernode->NextSibling();
}
}
}
//防误闭锁判断
else if (strcasecmp(Header, "misoperation") == 0)
{
if (strcasecmp(bodyelement->Value(), "operation") == 0)
{
//将请求上下文信息储存起来以便返回响应包里使用
strcpy(order.contextname, bodyelement->Attribute("contextname"));
strcpy(order.bobname, bodyelement->Attribute("bobname"));
strcpy(order.picturename, bodyelement->Attribute("pictureName"));
//加多请求线程互斥锁
pthread_mutex_lock(&g_rq_mutex);
//更新开关状态,并根据母线的遥测信息添加SO
if (nmd->update_cb_state() && nmd->add_so()/* && nmd->DoValidate() && g_bob2->WriteReDB(NULL, NULL, NULL)*/)
{
TiXmlNode *pordernode = pbodynode->FirstChild();
//循环查找Record项,并处理
while (pordernode != NULL)
{
TiXmlElement *porderelement = pordernode->ToElement();
if (strcasecmp(porderelement->Value(), "order") == 0)
{
DATA_MISOPERATION data_mis;
int op_type = atoi(porderelement->Attribute("op_type"));
nmd->find_so(atol(porderelement->Attribute("cb")), "breaker", paths, FIND_TYPE_MISOPERAT, &data_mis);
cout << "*******DV1******" << endl;
{
for (list<PSBOB::DV>::iterator it = data_mis.dv1.begin(); it != data_mis.dv1.end(); it++)
{
cout << it->id << "," << it->name << endl;
}
}
cout << "*******LD1******" << endl;
{
for (list<CLS_LD>::iterator it = data_mis.lst_ld1.begin(); it != data_mis.lst_ld1.end(); it++)
{
cout << it->id << "," << it->descr << endl;
}
}
cout << "*******DV2******" << endl;
{
for (list<PSBOB::DV>::iterator it = data_mis.dv2.begin(); it != data_mis.dv2.end(); it++)
{
cout << it->id << "," << it->name << endl;
}
}
cout << "*******LD2******" << endl;
{
for (list<CLS_LD>::iterator it = data_mis.lst_ld2.begin(); it != data_mis.lst_ld2.end(); it++)
{
cout << it->id << "," << it->descr << endl;
}
}
int Result = -1;
bool bhasdv[2] = {false, false};
list<CLS_LD> lst_ld; //充电或失电的LD
bhasdv[0] = data_mis.dv1.size() > 0 ? true : false;
bhasdv[1] = data_mis.dv2.size() > 0 ? true : false;
if (op_type == 1) //合闸操作
{
if (bhasdv[0]) //一端有电源
{
if (bhasdv[1]) Result = 1; //另一端也有电源，合环了
else
{
Result = 3; //另一端无电源，充电
lst_ld = data_mis.lst_ld2;
}
}
else //一端无电源
{
if (bhasdv[1])
{
Result = 3; //另一端有电源， 充电了
lst_ld = data_mis.lst_ld1;
}
else ; //另一端也无电源，啥都不是
}
}
else if (op_type == 2) //分闸操作
{
if (bhasdv[0]) //一端有电源
{
if (bhasdv[1]) Result = 2; //另一端也有电源，解环了
else
{
Result = 4; //另一端无电源，失电
lst_ld = data_mis.lst_ld2;
}
}
else //一端无电源
{
if (bhasdv[1])
{
Result = 4; //另一端有电源， 失电了
lst_ld = data_mis.lst_ld1;
}
else
; //另一端也无电源，啥都不是
}
}
else //其它操作无效
{
cout << "无效操作！" << endl;
nmd->m_Errors.push_back("无效操作！");
}
//发送请求响应数据
//发送XML响应头
cout << head_xml2 << endl;
ret = tcptools->Send(newsockfd, head_xml2, strlen(head_xml2));
if (ret <= 0)
{
cout << "发送数据失败，" << strerror(errno) << endl;
goto RE_RECV;
}
//发送响应请求上下文信息
sprintf(ret_buf, "<operation pictureName=\"%s\" contextname=\"%s\" bobname=\"%s\">\r\n<order cb=\"%s\" op_type=\"%d\" />\r\n</operation>\r\n",
order.picturename, order.contextname, order.bobname, porderelement->Attribute("cb"), op_type);
cout << ret_buf << endl;
ret = tcptools->Send(newsockfd, ret_buf, strlen(ret_buf));
if (ret <= 0)
{
cout << "发送数据失败，" << strerror(errno) << endl;
goto RE_RECV;
}
//发送错误信息
string strError = "<ErrorMsg>\r\n";
//逐条处理错误信息
{
for (list<string>::iterator it = nmd->m_Errors.begin(); it != nmd->m_Errors.end(); it++)
{
strError += "<error msg=\"";//" />
strError += *it;
strError += "\" />";
strError += "\r\n";
}
}
strError += "</ErrorMsg>\r\n";
cout << strError.c_str() << endl;
ret = tcptools->Send(newsockfd, strError.c_str(), strError.size());
if (ret <= 0)
{
cout << "发送数据失败，" << strerror(errno) << endl;
goto RE_RECV;
}
//有合解环数据
if (Result != -1)
{
//发送合解环结果
sprintf(ret_buf, "<Result type=\"%d\" level=\"1\">\r\n", Result);
cout << ret_buf << endl;
ret = tcptools->Send(newsockfd, ret_buf, strlen(ret_buf));
if (ret <= 0)
{
cout << "发送数据失败，" << strerror(errno) << endl;
goto RE_RECV;
}
//发送设备信息
switch (Result)
{
//合、解环
case 1:
case 2:
{
list<PSBOB::DV>::iterator it;
for (it = data_mis.dv1.begin(); it != data_mis.dv1.end(); it++)
{
sprintf(ret_buf, "<Record id=\"%ld\" descr=\"%s\" tablename=\"subcontrolarea\" />\r\n", it->id, it->name);
cout << ret_buf << endl;
ret = tcptools->Send(newsockfd, ret_buf, strlen(ret_buf));
if (ret <= 0)
{
cout << "发送数据失败，" << strerror(errno) << endl;
goto RE_RECV;
}
}
for (it = data_mis.dv2.begin(); it != data_mis.dv2.end(); it++)
{
sprintf(ret_buf, "<Record id=\"%ld\" descr=\"%s\" tablename=\"subcontrolarea\" />\r\n", it->id, it->name);
cout << ret_buf << endl;
ret = tcptools->Send(newsockfd, ret_buf, strlen(ret_buf));
if (ret <= 0)
{
cout << "发送数据失败，" << strerror(errno) << endl;
goto RE_RECV;
}
}
break;
}
//充、失电
case 3:
case 4:
{
for (list<CLS_LD>::iterator it = lst_ld.begin(); it != lst_ld.end(); it++)
{
sprintf(ret_buf, "<Record id=\"%ld\" descr=\"%s\" tablename=\"energyconsumer\" />\r\n", it->id, it->descr);
cout << ret_buf << endl;
ret = tcptools->Send(newsockfd, ret_buf, strlen(ret_buf));
if (ret <= 0)
{
cout << "发送数据失败，" << strerror(errno) << endl;
goto RE_RECV;
}
}
break;
}
default:
break;
}
strcpy(ret_buf, "</Result>\r\n");
cout << ret_buf << endl;
ret = tcptools->Send(newsockfd, ret_buf, strlen(ret_buf));
if (ret <= 0)
{
cout << "发送数据失败，" << strerror(errno) << endl;
goto RE_RECV;
}
}
//发送XML响应尾
cout << tail_xml2 << endl;
ret = tcptools->Send(newsockfd, tail_xml2, strlen(tail_xml2));
if (ret <= 0)
{
cout << "发送数据失败，" << strerror(errno) << endl;
goto RE_RECV;
}
}
pordernode = pordernode->NextSibling();
}
}
pthread_mutex_unlock(&g_rq_mutex);
}
}
else if (strcasecmp(Header, "fhzg") == 0)
{
char cb_id[MAX_CB_ID_LEN] = { 0 };
char fhzg_id[50] = { 0 };
char error[500] = { 0 };
int ret_err = -1;
if (strcasecmp(bodyelement->Value(), "Order") == 0)
{
//将请求上下文信息储存起来以便返回响应包里使用
strcpy(order.contextname, bodyelement->Attribute("contextname"));
strcpy(order.bobname, bodyelement->Attribute("bobname"));
strcpy(order.picturename, bodyelement->Attribute("pictureName"));
strcpy(order.st, bodyelement->Attribute("st"));
TiXmlNode *pordernode = pbodynode->FirstChild();
//循环查找Record项,并处理
while (pordernode != NULL)
{
TiXmlElement *porderelement = pordernode->ToElement();
if (strcasecmp(porderelement->Value(), "Record") == 0)
{
timeval tval = { 0 };
strcpy(cb_id, porderelement->Attribute("id"));
gettimeofday(&tval, NULL);
tm *ptm = localtime(&tval.tv_sec);
sprintf(fhzg_id, "%04d/%02d/%02d %02d:%02d:%02d.%06ld", 1900 + ptm->tm_year, ptm->tm_mon + 1, ptm->tm_mday, ptm->tm_hour, ptm->tm_min, ptm->tm_sec,
tval.tv_usec);
if (strcasecmp("busbarsection", porderelement->Attribute("tablename")) == 0)
{
list<list<MAP_SO_NODE> > fdir_steps;
FDIR_R2 *fdir_r2 = new FDIR_R2(g_bob);
list<long> lstIsolate;
if (fdir_r2->FHZG_Bus(atol(porderelement->Attribute("id")), fdir_steps, lstIsolate) == FDIR_R_FAIL)
{
strcpy(error, "没有联络电源，转供失败！");
ret_err = -1;
}
else
{
list<FAULT_ITEM> lst;
write_fhzg_step(fhzg_id, "", fdir_steps, fdir_r2, lst, lstIsolate,true);
ret_err = 0;
}
delete fdir_r2;
}
else if (strcasecmp("breaker", porderelement->Attribute("tablename")) == 0)
{
FHZG *fhzg = new FHZG(g_bob);
int fhzg_ret = fhzg->Do(atol(porderelement->Attribute("id")));
switch (fhzg_ret)
{
case 0: //转供成功
{
//写负荷转供关系库表
fill_fhzg_db(atol(cb_id), fhzg_id, fhzg, true);
sprintf(error, "%f", fhzg->fhzg_capacity);
ret_err = 0;
break;
}
case FHZG_FAIL_NO_SO:
{
strcpy(error, "没有可供转供的电源，转供失败！");
ret_err = -1 ;
break;
}
case FHZG_FAIL_SO_FULL:
{
strcpy(error, "所有可转供的电源剩余容量不足，转供失败！");
ret_err = -1;
break;
}
case FHZG_FAIL_NO_IVALUE:
{
strcpy(error, "没有获取到要转供开关的电流值，转供失败！");
ret_err = -1;
break;
}
}
delete fhzg;
}
else
{
TRACE("不支持的设备类型%s\r\n", porderelement->Attribute("tablename"));
}
}
pordernode = pordernode->NextSibling();
}
}
else
{
}
//发送请求响应数据
//发送XML响应头
cout << head_xml3 << endl;
ret = tcptools->Send(newsockfd, head_xml3, strlen(head_xml3));
if (ret <= 0)
{
cout << "发送数据失败，" << strerror(errno) << endl;
goto RE_RECV;
}
//发送响应请求上下文信息
sprintf(ret_buf, "<Order pictureName = \"%s\" contextname = \"%s\" bobname = \"%s\" st = \"%s\" >\r\n", order.picturename, order.contextname, order.bobname,
order.st);
cout << ret_buf << endl;
ret = tcptools->Send(newsockfd, ret_buf, strlen(ret_buf));
if (ret <= 0)
{
cout << "发送数据失败，" << strerror(errno) << endl;
goto RE_RECV;
}
sprintf(ret_buf, "<Record id = \"%s\" tablename = \"cb\" fhzg_id=\"%s\" result=\"%d\" error=\"%s\"/>\r\n", cb_id, fhzg_id, ret_err, error);
//发送故障转供标识符
cout << ret_buf << endl;
ret = tcptools->Send(newsockfd, ret_buf, strlen(ret_buf));
if (ret <= 0)
{
cout << "发送数据失败，" << strerror(errno) << endl;
goto RE_RECV;
}
//发送XML响应尾
cout << tail_xml << endl;
ret = tcptools->Send(newsockfd, tail_xml, strlen(tail_xml));
if (ret <= 0)
{
cout << "发送数据失败，" << strerror(errno) << endl;
goto RE_RECV;
}
}
else if(strcasecmp(Header, "typical") == 0)
{
//D5000 典型运行方式暂未移植
char userid[100] = { 0 };
char machine[100] = { 0 };
char id[50] = { 0 };
char str_time[50] = { 0 };
char ch_time[40] = { 0 };
time_t res_time;
string dv_id;
int result = -1;
if (strcasecmp(bodyelement->Value(), "Order") == 0)
{
//将请求上下文信息储存起来以便返回响应包里使用
strcpy(order.contextname, bodyelement->Attribute("contextname"));
strcpy(order.bobname, bodyelement->Attribute("bobname"));
strcpy(order.picturename, bodyelement->Attribute("pictureName"));
strcpy(machine, bodyelement->Attribute("machine"));
strcpy(userid, bodyelement->Attribute("userid"));
int ret = FDIR_R_FAIL;
//加多请求线程互斥锁
pthread_mutex_lock(&g_rq_mutex);
TiXmlNode *pordernode = pbodynode->FirstChild();
//循环查找Record项,并处理
while (pordernode != NULL)
{
TiXmlElement *porderelement = pordernode->ToElement();
if (strcasecmp(porderelement->Value(), "Record") == 0)
{
cmd = atoi(porderelement->Attribute("operate_type"));
switch (cmd)
{
case 0: //保存典型方式
{
timeval tval = { 0 };
gettimeofday(&tval, NULL);
tm *ptm = localtime(&tval.tv_sec);
sprintf(id, "%04d/%02d/%02d %02d:%02d:%02d.%06ld", 1900 + ptm->tm_year, ptm->tm_mon + 1, ptm->tm_mday, ptm->tm_hour, ptm->tm_min, ptm->tm_sec,
tval.tv_usec);
typical *typi = new typical(g_fdir_r, id);
if(typi->typical_save(atol(porderelement->Attribute("cb_id")), machine, userid))
{
result = 0;
}
break;
}
case 1: //恢复典型方式
{
typical *typi = new typical(g_fdir_r, id);
if(typi->typical_restore(atol(porderelement->Attribute("cb_id")), machine, userid, dv_id, res_time))
{
result = 0;
}
struct tm tmtime;
localtime_r(&res_time,&tmtime);
sprintf(ch_time,"%04d/%02d/%02d %02d:%02d:%02d",(tmtime.tm_year + 1900),(tmtime.tm_mon + 1), tmtime.tm_mday, tmtime.tm_hour, tmtime.tm_min, tmtime.tm_sec);
strcpy(id, dv_id.c_str());
break;
}
default:
break;
}
}
else
{
}
pordernode = pordernode->NextSibling();
}
pthread_mutex_unlock(&g_rq_mutex);
}
else
{
}
//发送请求响应数据
//发送XML响应头
cout << head_xml6 << endl;
ret = tcptools->Send(newsockfd, head_xml6, strlen(head_xml6));
if (ret <= 0)
{
cout << "发送数据失败，" << strerror(errno) << endl;
goto RE_RECV;
}
//发送响应请求上下文信息
sprintf(ret_buf, "<Order pictureName = \"%s\" contextname = \"%s\" bobname = \"%s\" userid = \"%s\" machine=\"%s\">\r\n", order.picturename,
order.contextname, order.bobname, userid, machine);
cout << ret_buf << endl;
ret = tcptools->Send(newsockfd, ret_buf, strlen(ret_buf));
if (ret <= 0)
{
cout << "发送数据失败，" << strerror(errno) << endl;
goto RE_RECV;
}
//逐项发送设备列表里的设备信息
sprintf(ret_buf, "<Record id = \"%s\" time = \"%s\" result = \"%d\" error=\"\"/>\r\n", id, ch_time, result);
cout << ret_buf << endl;
ret = tcptools->Send(newsockfd, ret_buf, strlen(ret_buf));
if (ret <= 0)
{
cout << "发送数据失败，" << strerror(errno) << endl;
goto RE_RECV;
}
//发送XML响应尾
cout << tail_xml << endl;
ret = tcptools->Send(newsockfd, tail_xml, strlen(tail_xml));
if (ret <= 0)
{
cout << "发送数据失败，" << strerror(errno) << endl;
goto RE_RECV;
}
}
else if (strcasecmp(Header, "check_data") == 0)
{
char userid[100] = { 0 };
char machine[100] = { 0 };
char groupid[100] = { 0 };
const char *errmsg[] = { "校验通过，数据一致", "实时库版本号变化", "故障相关开关状态发生变化", "读取保存开关状态的数据库失败", "解析报文中groupid失败" };
if (strcasecmp(bodyelement->Value(), "Order") == 0)
{
//将请求上下文信息储存起来以便返回响应包里使用
strcpy(order.contextname, bodyelement->Attribute("contextname"));
strcpy(order.bobname, bodyelement->Attribute("bobname"));
strcpy(order.picturename, bodyelement->Attribute("pictureName"));
strcpy(machine, bodyelement->Attribute("machine"));
strcpy(userid, bodyelement->Attribute("userid"));
int ret = FDIR_R_FAIL;
//加多请求线程互斥锁
pthread_mutex_lock (&g_rq_mutex);
TiXmlNode *pordernode = pbodynode->FirstChild();
//循环查找Record项,并处理
while (pordernode != NULL)
{
TiXmlElement *porderelement = pordernode->ToElement();
if (strcasecmp(porderelement->Value(), "Record") == 0)
{
strcpy(groupid, porderelement->Attribute("fault_id"));
}
else
{
}
pordernode = pordernode->NextSibling();
}
pthread_mutex_unlock(&g_rq_mutex);
}
else
{
}
int result = CHECK_DATA_ID_ERR;
if (strlen(groupid) != 0)
{
//校验数据是否跟故障时一致，如果一致返回0，实时库版本号变化返回1，如果相关数据发生变化返回2，读库失败返回3
result = data_verify(groupid);
if (result == CHECK_DATA_CB_ERR)
{
//方案已经失效，设置故障标识为失效状态
sprintf(sql, "UPDATE FDIR_FDIRECT SET EXT_STATUS=%d WHERE GROUPID=\'%s\'", STATUS_FDIRECT_INVALID, groupid);
ExecSQL(sql);
}
else if (result == CHECK_DATA_PSBOB_ERR)
{
//实时库版本号变化设置故障标识为版本号变化
sprintf(sql, "UPDATE FDIR_FDIRECT SET EXT_STATUS=%d WHERE GROUPID=\'%s\'", STATUS_FDIRECT_VERSION_ERR, groupid);
ExecSQL(sql);
}
}
//发送请求响应数据
//发送XML响应头
cout << head_xml7 << endl;
ret = tcptools->Send(newsockfd, head_xml7, strlen(head_xml7));
if (ret <= 0)
{
cout << "发送数据失败，" << strerror(errno) << endl;
goto RE_RECV;
}
//发送响应请求上下文信息
sprintf(ret_buf, "<Order pictureName = \"%s\" contextname = \"%s\" bobname = \"%s\" userid = \"%s\" machine=\"%s\">\r\n", order.picturename,
order.contextname, order.bobname, userid, machine);
cout << ret_buf << endl;
ret = tcptools->Send(newsockfd, ret_buf, strlen(ret_buf));
if (ret <= 0)
{
cout << "发送数据失败，" << strerror(errno) << endl;
goto RE_RECV;
}
//逐项发送设备列表里的设备信息
sprintf(ret_buf, "<Record id = \"%s\" result = \"%d\" error=\"%s\"/>\r\n", groupid, result, errmsg[result]);
cout << ret_buf << endl;
ret = tcptools->Send(newsockfd, ret_buf, strlen(ret_buf));
if (ret <= 0)
{
cout << "发送数据失败，" << strerror(errno) << endl;
goto RE_RECV;
}
//发送XML响应尾
cout << tail_xml << endl;
ret = tcptools->Send(newsockfd, tail_xml, strlen(tail_xml));
if (ret <= 0)
{
cout << "发送数据失败，" << strerror(errno) << endl;
goto RE_RECV;
}
}
else if (strcasecmp(Header, "recalc") == 0)
{
//方案失效，重新计算隔离和恢复方案
char userid[100] = { 0 };
char machine[100] = { 0 };
char groupid[100] = { 0 };
if (strcasecmp(bodyelement->Value(), "Order") == 0)
{
//将请求上下文信息储存起来以便返回响应包里使用
strcpy(order.contextname, bodyelement->Attribute("contextname"));
strcpy(order.bobname, bodyelement->Attribute("bobname"));
strcpy(order.picturename, bodyelement->Attribute("pictureName"));
strcpy(machine, bodyelement->Attribute("machine"));
strcpy(userid, bodyelement->Attribute("userid"));
int ret = FDIR_R_FAIL;
//加多请求线程互斥锁
pthread_mutex_lock (&g_rq_mutex);
TiXmlNode *pordernode = pbodynode->FirstChild();
//循环查找Record项,并处理
while (pordernode != NULL)
{
TiXmlElement *porderelement = pordernode->ToElement();
if (strcasecmp(porderelement->Value(), "Record") == 0)
{
strcpy(groupid, porderelement->Attribute("fault_id"));
}
else
{
}
pordernode = pordernode->NextSibling();
}
pthread_mutex_unlock(&g_rq_mutex);
}
else
{
}
int result = -1;
char errmsg[50] = { 0 };
if (strlen(groupid) != 0)
{
pthread_mutex_lock(&task_list_mutex);
list<FDIR_TASK>::iterator it;
for (it = g_lstTask.begin(); it != g_lstTask.end(); it++)
{
if (it->rq_type == TASK_TYPE_FAULT)
{
if (strcmp(it->task_data.fault.head.group_id, groupid) == 0)
{
break;
}
}
}
//如果不在任务列表，把故障重新加载到内存中，然后再把故障详细加载进去
if (it == g_lstTask.end())
{
RecoMemTask(groupid);
RecoTaskStep(groupid);
}
pthread_mutex_unlock(&task_list_mutex);
if (invalid_recalc(groupid))
{
result = 0;
}
}
else
{
sprintf(errmsg, "报文中解析groupid有问题！");
}
//发送请求响应数据
//发送XML响应头
cout << head_xml8 << endl;
ret = tcptools->Send(newsockfd, head_xml8, strlen(head_xml8));
if (ret <= 0)
{
cout << "发送数据失败，" << strerror(errno) << endl;
goto RE_RECV;
}
//发送响应请求上下文信息
sprintf(ret_buf, "<Order pictureName = \"%s\" contextname = \"%s\" bobname = \"%s\" userid = \"%s\" machine=\"%s\">\r\n", order.picturename,
order.contextname, order.bobname, userid, machine);
cout << ret_buf << endl;
ret = tcptools->Send(newsockfd, ret_buf, strlen(ret_buf));
if (ret <= 0)
{
cout << "发送数据失败，" << strerror(errno) << endl;
goto RE_RECV;
}
//逐项发送设备列表里的设备信息
sprintf(ret_buf, "<Record id = \"%s\" result = \"%d\" error=\"%s\"/>\r\n", groupid, result, errmsg);
cout << ret_buf << endl;
ret = tcptools->Send(newsockfd, ret_buf, strlen(ret_buf));
if (ret <= 0)
{
cout << "发送数据失败，" << strerror(errno) << endl;
goto RE_RECV;
}
//发送XML响应尾
cout << tail_xml << endl;
ret = tcptools->Send(newsockfd, tail_xml, strlen(tail_xml));
if (ret <= 0)
{
cout << "发送数据失败，" << strerror(errno) << endl;
goto RE_RECV;
}
}
else
{
TRACE("不识别的类型[%s]\r\n", Header);
}
pbodynode = pbodynode->NextSibling();
}
}
else
{
}
pmsgnode = pmsgnode->NextSibling();
}
}
else
{
}
}
}
else
{
cout << "请求报文XML语法错误！" << endl;
}
timeval etimer = {0};
gettimeofday(&etimer, NULL);
float cost = etimer.tv_sec * 1000 * 1000 + etimer.tv_usec - (stimer.tv_sec * 1000 * 1000 + stimer.tv_usec);
printf(">>>>>>>>%sprocessed, total cost:%.2fs\r\n", ctime(&(now = time(NULL))), cost / 1000 / 1000);
}
} //while(GDI_TRUE)
printf("********** Exit Thread (%d) **********\n", newsockfd);
close(newsockfd);
delete pXmlDoc;
int exitThread = -1;
for (int i = 0; i < MAX_THREAD; i++)
{
if (pthread_id[i].fdinThread == newsockfd)
{
exitThread = i;
pthread_id[i].fdinThread = -1;
break;
}
}
pthread_exit(0);
}
void fill_fhzg_db(const long cb_id, const char *fhzg_id, FHZG *fhzg, bool bhas_fhzg_cb)
{
assert(fhzg != NULL);
int fhzg_type = fhzg->GetType();
if (fhzg_type > 0)
{
//写消减负荷表
const LIST_TREENODE *lst_cut_zn = fhzg->GetLdCut();
int istep = 0; //开关操作步骤序号
const list<long> *cut_step = fhzg->GetLdCutOperations();
map<int, list<CLS_LD> >::iterator it_map_zn_ld;
char buf[50];
for (LIST_TREENODE::const_iterator it_cut_zn = lst_cut_zn->begin(); it_cut_zn != lst_cut_zn->end(); it_cut_zn++)
{
char zone_cb_id[500] = { 0 };
list<long> lst_zone_cb;
for (it_map_zn_ld = (*it_cut_zn)->data.node_zn.map_zn_ld.begin(); it_map_zn_ld != (*it_cut_zn)->data.node_zn.map_zn_ld.end(); it_map_zn_ld++)
{
// zone_cb_id[0] = 0;
//
// fhzg->GetZoneCB(it_map_zn_ld->first, lst_zone_cb);
//
// for (list<long>::iterator it_zone_cb = lst_zone_cb.begin(); it_zone_cb != lst_zone_cb.end(); it_zone_cb++)
// {
// if (zone_cb_id[0] != 0)
// strcat(zone_cb_id, ";");
//
// sprintf(buf, "%ld", *it_zone_cb);
// strcat(zone_cb_id, buf);
// }
//
// sprintf(sql, "Insert into FHZG_CUT_ZONE (ID, IZONE, CB_ID) Values (\'%s\', %ld, \'%s\')", fhzg_id, it_map_zn_ld->first, zone_cb_id);
// ExecSQL(sql);
list<FAULT_ITEM> lst_dev;
fhzg->get_zone_devs(it_map_zn_ld->first, lst_dev);
for (list<FAULT_ITEM>::iterator it_devs = lst_dev.begin(); it_devs != lst_dev.end(); it_devs++)
{
sprintf(sql, "Insert into FHZG_CUT_ZONE (ID, IZONE, DEV_ID, DEV_TABLE) Values (\'%s\', %d, \'%ld\', \'%s\')", fhzg_id, it_map_zn_ld->first, it_devs->eq_id, it_devs->table.c_str());
ExecSQL(sql);
}
list<CLS_LD>::const_iterator it_ld;
for (it_ld = it_map_zn_ld->second.begin(); it_ld != it_map_zn_ld->second.end(); it_ld++)
{
sprintf(sql, "Insert into FHZG_LOAD (ID, LD_ID, LD_DESCR, LD_PRIOR, LD_AMOUNT, IZONE) Values (\'%s\', \'%ld\', \'%s\', %d, %f, %d)", fhzg_id, it_ld->pid, it_ld->descr, (*it_cut_zn)->data.node_zn.prio, it_ld->w, it_map_zn_ld->first);
ExecSQL(sql);
}
}
}
switch (fhzg_type)
{
case FHZG_TYPE_ALL: //独立转供
{
cout << "独立转供……" << endl;
//写可提供独立转供的电源表
const LIST_TREENODE *lst_so = fhzg->GetSO();
LIST_TREENODE::const_iterator it;
for (it = lst_so->begin(); it != lst_so->end(); it++)
{
long so_name = (*it)->data.node_so.so_name;
long cb_to_so = (*it)->data.node_so.cb_id;
id_to_pid(so_name);
id_to_pid(cb_to_so);
sprintf(sql, "Insert into FHZG_SO (ID, SO_ID, SO_DESCR, TYPE, FULL_CAPACITY, LEFT_CAPACITY, CB_ID, ORG_WLOSS, NEW_WLOSS,ZG_CAPACITY) Values (\'%s\', \'%ld\', \'%s\', %d, %f, %f, \'%ld\', %f, %f, %f)", fhzg_id, so_name, (*it)->data.node_so.so_descr, 1/*独立转供*/,
(*it)->data.node_so.full_capacity, (*it)->data.node_so.left_capacity, cb_to_so, (*it)->data.node_so.org_wloss, (*it)->data.node_so.new_wloss,fhzg->fhzg_capacity);
ExecSQL(sql);
istep = 0;
for (list<long>::const_iterator it_cut_step = cut_step->begin(); it_cut_step != cut_step->end(); it_cut_step++)
{
long id = *it_cut_step;
id_to_pid(id);
sprintf(sql, "Insert into FHZG_STEP (ID, CB_ID, OPERATION, STEP, STATUS, SO_ID, CONTROL) Values ('%s', '%ld', %d, %d, 0, '%ld', 1)", fhzg_id, *it_cut_step, 1, istep, so_name);
ExecSQL(sql);
istep++;
}
//只有oracle数据库支持这种插入库的sql语句，其他数据库还是一条一条的记录插入tianyq
#ifdef _ORACLE_
sprintf(sql, "Insert into FHZG_SO_ZONE (ID, IZONE, SO_ID, DEV_ID, DEV_TABLE, CB_TO_SO) ");
memset(sqltemp, 0, sizeof(sqltemp));
for (list<int>::iterator it_lst_so_zones = (*it)->data.node_so.lst_zones.begin(); it_lst_so_zones != (*it)->data.node_so.lst_zones.end(); it_lst_so_zones++)
{
list<FAULT_ITEM> lst_dev;
fhzg->get_zone_devs(*it_lst_so_zones, lst_dev);
for (list<FAULT_ITEM>::iterator it_devs = lst_dev.begin(); it_devs != lst_dev.end(); it_devs++)
{
strcat(sql, sqltemp);
sprintf(sqltemp, " select \'%s\', %d, \'%s\', \'%s\', \'%s\', \'%s\' from dual union all ", fhzg_id, *it_lst_so_zones, so_name, it_devs->id.c_str(), it_devs->table.c_str(), cb_to_so);
}
}
strncat(sql, sqltemp, (strlen(sqltemp)-10));
ExecSQL(sql);
#else
for (list<long>::iterator it_lst_so_zones = (*it)->data.node_so.lst_zones.begin(); it_lst_so_zones != (*it)->data.node_so.lst_zones.end(); it_lst_so_zones++)
{
list<FAULT_ITEM> lst_dev;
fhzg->get_zone_devs(*it_lst_so_zones, lst_dev);
for (list<FAULT_ITEM>::iterator it_devs = lst_dev.begin(); it_devs != lst_dev.end(); it_devs++)
{
sprintf(sql, "Insert into FHZG_SO_ZONE (ID, IZONE, SO_ID, DEV_ID, DEV_TABLE) Values (\'%s\', %ld, \'%ld\', \'%ld\', \'%s\')", fhzg_id, *it_lst_so_zones, so_name, it_devs->eq_id, it_devs->table.c_str());
ExecSQL(sql);
}
}
#endif
//设置边界开关
sprintf(sql, "update fhzg_so_zone set edge = 1 where id = \'%s\' and so_id = \'%ld\' and dev_id in (select dev_id from (select dev_id,count(dev_id) as num from FHZG_SO_ZONE where id = \'%s\' and dev_table='CB' and so_id = \'%ld\' group by dev_id) where num =1)", fhzg_id,
so_name, fhzg_id, so_name);
ExecSQL(sql);
if (bhas_fhzg_cb)
{
sprintf(sql, "Insert into FHZG_STEP (ID, CB_ID, OPERATION, STEP, STATUS, SO_ID, CONTROL) Values (\'%s\', \'%ld\', %d, %d, 0, \'%ld\', 1)", fhzg_id, cb_id, 1, istep, so_name);
ExecSQL(sql);
}
sprintf(sql, "Insert into FHZG_STEP (ID, CB_ID, OPERATION, STEP, STATUS, SO_ID, CONTROL) Values (\'%s\', \'%ld\', %d, %d, 0, \'%ld\', 1)", fhzg_id, cb_to_so, 2, istep + 1, so_name);
ExecSQL(sql);
}
const LIST_TREENODE *lst_down_zone = fhzg->GetDownZones();
for (it = lst_down_zone->begin(); it != lst_down_zone->end(); it++)
{
list<FAULT_ITEM> lst_dev;
for (it_map_zn_ld = (*it)->data.node_zn.map_zn_ld.begin(); it_map_zn_ld != (*it)->data.node_zn.map_zn_ld.end(); it_map_zn_ld++)
{
fhzg->get_zone_devs(it_map_zn_ld->first, lst_dev);
//只有oracle数据库支持这种插入库的sql语句，其他数据库还是一条一条的记录插入tianyq
#ifdef _ORACLE_
sprintf(sql, "Insert into FHZG_ZONE (ID, IZONE, SO_ID, DEV_ID, DEV_TABLE) ");
memset(sqltemp, 0, sizeof(sqltemp));
for (list<FAULT_ITEM>::iterator it_devs = lst_dev.begin(); it_devs != lst_dev.end(); it_devs++)
{
strcat(sql, sqltemp);
sprintf(sqltemp, " select \'%s\', %d, \'%s\', \'%s\', \'%s\' from dual union all ", fhzg_id, it_map_zn_ld->first, "", it_devs->id.c_str(), it_devs->table.c_str());
}
strncat(sql, sqltemp, (strlen(sqltemp)-10));
ExecSQL(sql);
#else
for (list<FAULT_ITEM>::iterator it_devs = lst_dev.begin(); it_devs != lst_dev.end(); it_devs++)
{
sprintf(sql, "Insert into FHZG_ZONE (ID, IZONE, DEV_ID, DEV_TABLE) Values (\'%s\', %d, \'%ld\', \'%s\')", fhzg_id, it_map_zn_ld->first, it_devs->eq_id, it_devs->table.c_str());
ExecSQL(sql);
}
#endif
list<CLS_LD>::const_iterator it_ld;
//只有oracle数据库支持这种插入库的sql语句，其他数据库还是一条一条的记录插入tianyq
#ifdef _ORACLE_
if(it_map_zn_ld->second.size() > 0)
{
sprintf(sql, "Insert into FHZG_LOAD (ID, LD_ID, LD_DESCR, LD_PRIOR, LD_AMOUNT, IZONE) ");
memset(sqltemp, 0, sizeof(sqltemp));
for (it_ld = it_map_zn_ld->second.begin(); it_ld != it_map_zn_ld->second.end(); it_ld++)
{
strcat(sql, sqltemp);
sprintf(sqltemp, " select \'%s\', \'%s\', \'%s\', %d, %f, %d from dual union all ", fhzg_id, it_ld->id,
it_ld->descr, (*it)->data.node_zn.prio, it_ld->w, it_map_zn_ld->first);
}
strncat(sql, sqltemp, (strlen(sqltemp)-10));
ExecSQL(sql);
}
#else
for (it_ld = it_map_zn_ld->second.begin(); it_ld != it_map_zn_ld->second.end(); it_ld++)
{
sprintf(sql, "Insert into FHZG_LOAD (ID, LD_ID, LD_DESCR, LD_PRIOR, LD_AMOUNT, IZONE) Values (\'%s\', \'%ld\', \'%s\', %d, %f, %d)", fhzg_id, it_ld->pid, it_ld->descr, (*it)->data.node_zn.prio, it_ld->w, it_map_zn_ld->first);
ExecSQL(sql);
}
#endif
}
}
sprintf(sql, "update fhzg_zone set edge = 1 where id = \'%s\' and dev_id in (select dev_id from (select dev_id,count(dev_id) as num from FHZG_ZONE where id = \'%s\' and dev_table='CB' group by dev_id) where num =1)", fhzg_id, fhzg_id);
ExecSQL(sql);
break;
}
case FHZG_TYPE_SHARE:
{
cout << "分摊转供……" << endl;
//写可提供分摊转供的电源表
// const LIST_TREENODE *lst_so = fhzg->GetSO();
//
// LIST_TREENODE::const_iterator it;
const map<TreeNode<DataType>*, LIST_TREENODE> *m_so_zone = fhzg->GetSoFhzgZone();
map<TreeNode<DataType>*, LIST_TREENODE>::const_iterator it_m_so_zone;
//写操作步骤表
const list<_OPERATION_STEP> *opera_step = fhzg->GetOperation();
list<_OPERATION_STEP>::const_iterator it_step;
for (list<long>::const_iterator it_cut_step = cut_step->begin(); it_cut_step != cut_step->end(); it_cut_step++)
{
long id = *it_cut_step;
id_to_pid(id);
sprintf(sql, "Insert into FHZG_STEP (ID, CB_ID, OPERATION, STEP, STATUS, SO_ID, CONTROL) Values ('%s', '%ld', %d, %d, 0, 0, 1)", fhzg_id, id, 1, istep);
ExecSQL(sql);
istep++;
}
map<long, long> m_tmp_close_steps;
map<long, long>::iterator it_m_close;
for (it_step = opera_step->begin(); it_step != opera_step->end(); it_step++, istep++)
{
long id = it_step->open_cb;
id_to_pid(id);
sprintf(sql, "Insert into FHZG_STEP (ID, CB_ID, OPERATION, STEP, STATUS, SO_ID, CONTROL) Values ('%s', '%ld', %d, %d, 0, '%ld', 1)", fhzg_id, id, 1, istep, it_step->so_id);
ExecSQL(sql);
istep++;
m_tmp_close_steps[it_step->close_cb] = it_step->so_id;
}
for (it_m_close = m_tmp_close_steps.begin(); it_m_close != m_tmp_close_steps.end(); it_m_close++)
{
long id = it_m_close->first;
id_to_pid(id);
sprintf(sql, "Insert into FHZG_STEP (ID, CB_ID, OPERATION, STEP, STATUS, SO_ID, CONTROL) Values ('%s', '%ld', %d, %d, 0, '%ld', 1)", fhzg_id, id, 2, istep, it_m_close->second);
ExecSQL(sql);
istep++;
}
for (it_m_so_zone = m_so_zone->begin(); it_m_so_zone != m_so_zone->end(); it_m_so_zone++)
{
long so_name = it_m_so_zone->first->data.node_so.so_name;
long cb_to_so = cb_to_so;
float zg_capacity = 0.0;
id_to_pid(so_name);
id_to_pid(cb_to_so);
list<TreeNode<DataType>*> ::const_iterator it_m_so_zone_data;
for(it_m_so_zone_data = it_m_so_zone->second.begin();it_m_so_zone_data != it_m_so_zone->second.end();it_m_so_zone_data++)
{
zg_capacity += (*it_m_so_zone_data)->data.node_zn.ldamount;
}
sprintf(sql, "Insert into FHZG_SO (ID, SO_ID, SO_DESCR, TYPE, FULL_CAPACITY, LEFT_CAPACITY, CB_ID,ZG_CAPACITY) Values (\'%s\', \'%ld\', \'%s\', %d, %f, %f, \'%ld\',%f)", fhzg_id, so_name, it_m_so_zone->first->data.node_so.so_descr, 2/*分摊转供*/,
it_m_so_zone->first->data.node_so.full_capacity, it_m_so_zone->first->data.node_so.left_capacity, cb_to_so,zg_capacity);
ExecSQL(sql);
//只有oracle数据库支持这种插入库的sql语句，其他数据库还是一条一条的记录插入tianyq
#ifdef _ORACLE_
sprintf(sql, "Insert into FHZG_SO_ZONE (ID, IZONE, SO_ID, DEV_ID, DEV_TABLE, CB_TO_SO) ");
memset(sqltemp, 0, sizeof(sqltemp));
for (list<int>::iterator it_lst_so_zones = it_m_so_zone->first->data.node_so.lst_zones.begin(); it_lst_so_zones != it_m_so_zone->first->data.node_so.lst_zones.end(); it_lst_so_zones++)
{
list<FAULT_ITEM> lst_dev;
fhzg->get_zone_devs(*it_lst_so_zones, lst_dev);
for (list<FAULT_ITEM>::iterator it_devs = lst_dev.begin(); it_devs != lst_dev.end(); it_devs++)
{
strcat(sql, sqltemp);
sprintf(sqltemp, " select \'%s\', %d, \'%s\', \'%s\', \'%s\', \'%s\' from dual union all ", fhzg_id, *it_lst_so_zones, so_name, it_devs->id.c_str(), it_devs->table.c_str(), cb_to_so);
}
}
strncat(sql, sqltemp, (strlen(sqltemp)-10));
ExecSQL(sql);
#else
for (list<long>::iterator it_lst_so_zones = it_m_so_zone->first->data.node_so.lst_zones.begin(); it_lst_so_zones != it_m_so_zone->first->data.node_so.lst_zones.end(); it_lst_so_zones++)
{
list<FAULT_ITEM> lst_dev;
fhzg->get_zone_devs(*it_lst_so_zones, lst_dev);
for (list<FAULT_ITEM>::iterator it_devs = lst_dev.begin(); it_devs != lst_dev.end(); it_devs++)
{
sprintf(sql, "Insert into FHZG_SO_ZONE (ID, IZONE, SO_ID, DEV_ID, DEV_TABLE) Values (\'%s\', %ld, \'%ld\', \'%ld\', \'%s\')", fhzg_id, *it_lst_so_zones, so_name, it_devs->eq_id, it_devs->table.c_str());
ExecSQL(sql);
}
}
#endif
//设置边界开关
sprintf(sql, "update fhzg_so_zone set edge = 1 where id = \'%s\' and so_id = \'%ld\' and dev_id in (select dev_id from (select dev_id,count(dev_id) as num from FHZG_SO_ZONE where id = \'%s\' and dev_table='CB' and so_id = \'%ld\' group by dev_id) where num =1)", fhzg_id,
so_name, fhzg_id, so_name);
ExecSQL(sql);
// const LIST_TREENODE *lst_so_zone = fhzg->GetZoneBySO((*it)->data.node_so.dv_id);
//
// if (lst_so_zone == NULL)
// continue;
LIST_TREENODE::const_iterator it_zone;
for (it_zone = it_m_so_zone->second.begin(); it_zone != it_m_so_zone->second.end(); it_zone++)
{
list<FAULT_ITEM> lst_dev;
for (it_map_zn_ld = (*it_zone)->data.node_zn.map_zn_ld.begin(); it_map_zn_ld != (*it_zone)->data.node_zn.map_zn_ld.end(); it_map_zn_ld++)
{
fhzg->get_zone_devs(it_map_zn_ld->first, lst_dev);
//只有oracle数据库支持这种插入库的sql语句，其他数据库还是一条一条的记录插入tianyq
#ifdef _ORACLE_
sprintf(sql, "Insert into FHZG_ZONE (ID, IZONE, SO_ID, DEV_ID, DEV_TABLE) ");
memset(sqltemp, 0, sizeof(sqltemp));
for (list<FAULT_ITEM>::iterator it_devs = lst_dev.begin(); it_devs != lst_dev.end(); it_devs++)
{
strcat(sql, sqltemp);
sprintf(sqltemp, " select \'%s\', %d, \'%s\', \'%s\', \'%s\' from dual union all ", fhzg_id, it_map_zn_ld->first, so_name, it_devs->id.c_str(), it_devs->table.c_str());
}
strncat(sql, sqltemp, (strlen(sqltemp)-10));
ExecSQL(sql);
#else
for (list<FAULT_ITEM>::iterator it_devs = lst_dev.begin(); it_devs != lst_dev.end(); it_devs++)
{
sprintf(sql, "Insert into FHZG_ZONE (ID, IZONE, SO_ID, DEV_ID, DEV_TABLE) Values (\'%s\', %d, \'%ld\', \'%ld\', \'%s\')", fhzg_id, it_map_zn_ld->first, so_name, it_devs->eq_id, it_devs->table.c_str());
ExecSQL(sql);
}
#endif
list<CLS_LD>::const_iterator it_ld;
//只有oracle数据库支持这种插入库的sql语句，其他数据库还是一条一条的记录插入tianyq
#ifdef _ORACLE_
if(it_map_zn_ld->second.size() > 0)
{
sprintf(sql, "Insert into FHZG_LOAD (ID, LD_ID, LD_DESCR, LD_PRIOR, LD_AMOUNT, IZONE) ");
memset(sqltemp, 0, sizeof(sqltemp));
for (it_ld = it_map_zn_ld->second.begin(); it_ld != it_map_zn_ld->second.end(); it_ld++)
{
strcat(sql, sqltemp);
sprintf(sqltemp, " select \'%s\', \'%s\', \'%s\', %d, %f, %d from dual union all ", fhzg_id, it_ld->id,
it_ld->descr, (*it_zone)->data.node_zn.prio, it_ld->w, it_map_zn_ld->first);
}
strncat(sql, sqltemp, (strlen(sqltemp)-10));
ExecSQL(sql);
}
#else
for (it_ld = it_map_zn_ld->second.begin(); it_ld != it_map_zn_ld->second.end(); it_ld++)
{
sprintf(sql, "Insert into FHZG_LOAD (ID, LD_ID, LD_DESCR, LD_PRIOR, LD_AMOUNT, IZONE) Values (\'%s\', \'%ld\', \'%s\', %d, %f, %d)", fhzg_id, it_ld->pid, it_ld->descr, (*it_zone)->data.node_zn.prio, it_ld->w, it_map_zn_ld->first);
ExecSQL(sql);
}
#endif
}
}
sprintf(sql, "update fhzg_zone set edge = 1 where id = \'%s\' and so_id = \'%ld\' and dev_id in (select dev_id from (select dev_id,count(dev_id) as num from FHZG_ZONE where id = \'%s\' and dev_table='CB' and so_id = \'%ld\' group by dev_id) where num =1)", fhzg_id,
so_name, fhzg_id, so_name);
ExecSQL(sql);
}
break;
}
}
}
}
int GetFHZGLeftStep(const char *FHZG_id, list<CB_CONTROL> &lstcb)
{
assert(FHZG_id != NULL);
char *buf1 = NULL, *buf2 = NULL, *buf3 = NULL;
int rec_num1, rec_num2, rec_num3, attr_num;
struct ORA_ATTR *attrs1 = NULL, *attrs2 = NULL, *attrs3 = NULL;
CB_CONTROL control = { 0 };
//获取消减负荷的操作步骤
sprintf(sql, "select CB_ID from FHZG_STEP where id=\'%s\' and status=0 and so_id=\'none\'", FHZG_id);
cout << sql << endl;
pthread_mutex_lock(&oci_mutex);
int ret = g_oci->ReadWithBind(sql, &buf1, &rec_num1, &attr_num, &attrs1);
pthread_mutex_unlock(&oci_mutex);
if (ret != OCI_ERROR)
{
for (int i = 0; i < rec_num1; i++)
{
char point_id[50];
bzero(point_id, sizeof(point_id));
memcpy(point_id, buf1 + (i * attrs1[0].col_width), attrs1[0].col_width);
control.bOpen = true;
control.point_id = *(long*)point_id;
lstcb.push_back(control);
cout << control.point_id << "分" << endl;
}
g_oci->Readdata_Free();
}
else
{
return -1;
}
//获取转供类型
sprintf(sql, "select so_id, type from FHZG_SO where id = \'%s\' order by LEFT_CAPACITY DESC", FHZG_id);
cout << sql << endl;
pthread_mutex_lock(&oci_mutex);
ret = g_oci->ReadWithBind(sql, &buf1, &rec_num1, &attr_num, &attrs1);
pthread_mutex_unlock(&oci_mutex);
if (ret != OCI_ERROR)
{
if(rec_num1 <= 0) return 0;
char type[25];
bzero(type, sizeof(type));
memcpy(type, buf1 + attrs1[0].col_width, attrs1[1].col_width);
switch (*(int*)type)
{
case 1: //独立转供
{
int cur_sel;
char so_id[21] = {0};
int i = 0;
//判断是否有方案已经执行成功
for (i = 0; i < rec_num1; i++)
{
bzero(so_id, sizeof(so_id));
memcpy(so_id, buf1 + i * (attrs1[0].col_width + attrs1[1].col_width), attrs1[0].col_width);
sprintf(sql, "select so_id from FHZG_STEP where ID=\'%s\' AND STATUS=3 AND SO_ID=\'%s\'", FHZG_id, so_id);
cout << sql << endl;
pthread_mutex_lock(&oci_mutex);
ret = g_oci->ReadWithBind(sql, &buf2, &rec_num2, &attr_num, &attrs2);
pthread_mutex_unlock(&oci_mutex);
if (ret != OCI_ERROR)
{
g_oci->Readdata_Free();
if (rec_num2 > 0)
{
return 0;
}
}
else
{
g_oci->Readdata_Free();
return -1;
}
}
//找一个正在执行中的独立转供方案
for(i = 0; i < rec_num1; i++)
{
bzero(so_id, sizeof(so_id));
memcpy(so_id, buf1 + i * (attrs1[0].col_width + attrs1[1].col_width), attrs1[0].col_width);
sprintf(sql, "select so_id from FHZG_STEP where ID=\'%s\' AND STATUS=1 AND SO_ID=\'%s\'", FHZG_id, so_id);
cout << sql << endl;
pthread_mutex_lock(&oci_mutex);
ret = g_oci->ReadWithBind(sql, &buf2, &rec_num2, &attr_num, &attrs2);
pthread_mutex_unlock(&oci_mutex);
if(ret != OCI_ERROR)
{
g_oci->Readdata_Free();
if(rec_num2 > 0)
{
break;
}
}
else
{
g_oci->Readdata_Free();
return -1;
}
}
if(rec_num2 > 0)
{
cur_sel = i;
}
//没有执行中的方案，则找一个还没有开始执行的方案
else
{
for (i = 0; i < rec_num1; i++)
{
bzero(so_id, sizeof(so_id));
memcpy(so_id, buf1 + i * (attrs1[0].col_width + attrs1[1].col_width), attrs1[0].col_width);
sprintf(sql, "select so_id from FHZG_STEP where ID=\'%s\' AND STATUS=0 AND SO_ID=\'%s\'", FHZG_id, so_id);
cout << sql << endl;
pthread_mutex_lock(&oci_mutex);
ret = g_oci->ReadWithBind(sql, &buf2, &rec_num2, &attr_num, &attrs2);
pthread_mutex_unlock(&oci_mutex);
if (ret != OCI_ERROR)
{
g_oci->Readdata_Free();
if (rec_num2 > 0)
{
break;
}
}
else
{
g_oci->Readdata_Free();
return -1;
}
}
if(rec_num2 > 0)
{
cur_sel = i;
}
//已经没有方案可选了（可能已经全部执行完成或执行失败）
else
return 0;
}
// //如果有正在执行中的方案则选中执行中的方案，如果没有则选中第一套方案（目前是剩余容量最多的方案）
// int cur_sel = (rec_num2 == 0) ? 0 : i;
bzero(type, sizeof(type));
memcpy(type, buf1 + cur_sel * (attrs1[0].col_width + attrs1[1].col_width), attrs1[0].col_width);
printf("第%d套方案被选中，该方案对应的电源名为%s\r\n", cur_sel, type);
sprintf(sql, "select CB_ID,OPERATION from FHZG_STEP where ID=\'%s\' and SO_ID=\'%s\' and status=0 order by step asc", FHZG_id, type);
cout << sql << endl;
pthread_mutex_lock(&oci_mutex);
ret = g_oci->ReadWithBind(sql, &buf2, &rec_num2, &attr_num, &attrs2);
pthread_mutex_unlock(&oci_mutex);
if(ret != OCI_ERROR)
{
for(i = 0; i < rec_num2; i++)
{
bzero(&control , sizeof(control));
bzero(type, sizeof(type));
char point_id[50];
bzero(point_id, sizeof(point_id));
memcpy(point_id, buf2 + i * (attrs2[0].col_width + attrs2[1].col_width), attrs2[0].col_width);
memcpy(type, buf2 + i * (attrs2[0].col_width + attrs2[1].col_width) + attrs2[0].col_width, attrs2[1].col_width);
control.bOpen = *(int*)type == 1 ? true : false;
control.point_id = *(long*)point_id;
lstcb.push_back(control);
cout << control.point_id << (control.bOpen ? "分" : "合") << endl;
}
g_oci->Readdata_Free();
}
else
{
g_oci->Readdata_Free();
return -1;
}
break;
}
case 2: //分摊转供
{
int i = 0;
sprintf(sql, "select CB_ID,OPERATION from FHZG_STEP where FHZG_ID=\'%s\' and status=0 order by step asc", FHZG_id);
cout << sql << endl;
pthread_mutex_lock(&oci_mutex);
ret = g_oci->ReadWithBind(sql, &buf2, &rec_num2, &attr_num, &attrs2);
pthread_mutex_unlock(&oci_mutex);
if (ret != OCI_ERROR)
{
for (i = 0; i < rec_num2; i++)
{
char point_id[50];
bzero(point_id, sizeof(point_id));
bzero(&control, sizeof(control));
bzero(type, sizeof(type));
memcpy(point_id, buf2 + i * (attrs2[0].col_width + attrs2[1].col_width), attrs2[0].col_width);
memcpy(type, buf2 + i * (attrs2[0].col_width + attrs2[1].col_width) + attrs2[0].col_width, attrs2[1].col_width);
control.bOpen = *(int*)type == 1 ? true : false;
control.point_id = *(long*)point_id;
lstcb.push_back(control);
cout << control.point_id << (control.bOpen ? "分" : "合") << endl;
}
g_oci->Readdata_Free();
}
else
{
g_oci->Readdata_Free();
return -1;
}
break;
}
default:
{
break;
}
}
g_oci->Readdata_Free();
}
else
{
return -1;
}
return lstcb.size();
}
int GetJxcbDv(long cbid, PSBOB::DV &dv)
{
int pnd = -1;
long id = cbid;
pid_to_id(id);
CLS_CB *cb = g_bob->cb_tb->Find(CLS_CB(id));
CLS_ND *pnd_nd = g_bob->nd_tb->GetDataByPos(cb->ind);
CLS_ND *pnd_znd = g_bob->nd_tb->GetDataByPos(cb->iznd);
list<CLS_ND *> lst_nd;
lst_nd.push_back(pnd_nd);
lst_nd.push_back(pnd_znd);
for (list<CLS_ND *>::iterator it_lst = lst_nd.begin(); it_lst != lst_nd.end(); it_lst++)
{
//查找连接的负荷设备
map<long, list<CLS_LD> >::iterator it = g_bob->m_map_nd_ld.find((*it_lst)->id);
if (it != g_bob->m_map_nd_ld.end())
{
for (list<CLS_LD>::iterator it_ld = it->second.begin(); it_ld != it->second.end(); it_ld++)
{
if (GetDv(it_ld->id, "ld", dv) >= 0)
{
printf("结点：%ld连接的负荷是：%ld\r\n", (*it_lst)->id, it_ld->id);
if (HasMask(g_db_psbob->GetTB("subcontrolarea"), "dtype", dv.dtype , MENU_DV_TYPE_FD))
{
return OO_SUCCEED;
}
else
{
bzero(&dv, sizeof(dv));
break;
}
}
}
}
//结点连接的线段
if ((*it_lst)->r_sec != -1)
{
ChildPtr *sec_ptr = g_bob->r_nd_sec_tb->FindChildPtr((*it_lst)->id);
ChildPtr *tmp_sec_ptr = sec_ptr;
CLS_SEC* sec = NULL;
while (tmp_sec_ptr != NULL)
{
sec = g_bob->sec_tb->GetDataByPos(tmp_sec_ptr->Ptr);
printf("结点：%ld连接的线段是：%ld\r\n", (*it_lst)->id, sec->id);
if (GetDv(sec->id, "sec", dv) >= 0)
{
if (HasMask(g_db_psbob->GetTB("subcontrolarea"), "dtype", dv.dtype, MENU_DV_TYPE_FD))
{
return OO_SUCCEED;
}
else
{
bzero(&dv, sizeof(dv));
break;
}
}
tmp_sec_ptr = tmp_sec_ptr->Next;
}
FreeChildPtr(sec_ptr);
}
//结点连接的开关查找dv
if ((*it_lst)->r_cb != -1)
{
ChildPtr *cb_ptr = g_bob->r_nd_cb_tb->FindChildPtr((*it_lst)->id);
ChildPtr *tmp_cb_ptr = cb_ptr;
while (tmp_cb_ptr != NULL)
{
cb = g_bob->cb_tb->GetDataByPos(tmp_cb_ptr->Ptr);
if (cb->pid == cbid)
{
if (!(cb->q & CB_FDHCB) && !(cb->q & CB_LWCB))
{
printf("结点：%ld连接的开关是：%ld\r\n", (*it_lst)->id, cb->id);
if (GetDv(cb->id, "cb", dv) >= 0)
{
if (HasMask(g_db_psbob->GetTB("subcontrolarea"), "dtype", dv.dtype, MENU_DV_TYPE_FD))
{
return OO_SUCCEED;
}
else
{
bzero(&dv, sizeof(dv));
break;
}
}
}
}
tmp_cb_ptr = tmp_cb_ptr->Next;
}
FreeChildPtr(cb_ptr);
}
}
return OO_FAIL;
}
int GetDv(long devid, const char *devtb, PSBOB::DV &dv)
{
id_to_pid(devid);
//D5000获取DV
PSBOB::ST psbob_st = { 0 };
if (strcasecmp(devtb, "ld") == 0)
{
PSBOB::LD psbob_ld = { 0 };
if (oodbread_rk(&psbob_ld, &devid, const_cast<TB_DESCR*>(g_db_psbob->GetTB("energyconsumer")), sizeof(psbob_ld)) > 0)
{
if (oodbread_rk(&psbob_st, &psbob_ld.st_id, const_cast<TB_DESCR*>(g_db_psbob->GetTB("substation")), sizeof(psbob_st)) > 0)
{
return oodbread_rk(&dv, &psbob_st.subarea_id, const_cast<TB_DESCR*>(g_db_psbob->GetTB("subcontrolarea")), sizeof(dv));
}
else
{
printf("%s(%d):读取substation表关键字为%ld的记录失败，错误号:%d\r\n", __FUNCTION__, __LINE__, psbob_ld.st_id, _oodb_errno);
}
}
else
{
printf("%s(%d):读取energyconsumer表关键字为%ld的记录失败，错误号:%d\r\n", __FUNCTION__, __LINE__, devid, _oodb_errno);
}
}
else if (strcasecmp(devtb, "bus") == 0)
{
PSBOB::BUS psbob_bus = { 0 };
if (oodbread_rk(&psbob_bus, &devid, const_cast<TB_DESCR*>(g_db_psbob->GetTB("busbarsection")), sizeof(psbob_bus)) > 0)
{
if (oodbread_rk(&psbob_st, &psbob_bus.st_id, const_cast<TB_DESCR*>(g_db_psbob->GetTB("substation")), sizeof(psbob_st)) > 0)
{
return oodbread_rk(&dv, &psbob_st.subarea_id, const_cast<TB_DESCR*>(g_db_psbob->GetTB("subcontrolarea")), sizeof(dv));
}
else
{
printf("%s(%d):读取substation表关键字为%ld的记录失败，错误号:%d\r\n", __FUNCTION__, __LINE__, psbob_bus.st_id, _oodb_errno);
}
}
else
{
printf("%s(%d):读取busbarsection表关键字为%ld的记录失败，错误号:%d\r\n", __FUNCTION__, __LINE__, devid, _oodb_errno);
}
}
else if (strcasecmp(devtb, "sec") == 0)
{
PSBOB::SEC psbob_sec = { 0 };
if (oodbread_rk(&psbob_sec, &devid, const_cast<TB_DESCR*>(g_db_psbob->GetTB("aclinesegment")), sizeof(psbob_sec)) > 0)
{
if (oodbread_rk(&psbob_st, &psbob_sec.ist_id, const_cast<TB_DESCR*>(g_db_psbob->GetTB("substation")), sizeof(psbob_st)) > 0)
{
return oodbread_rk(&dv, &psbob_st.subarea_id, const_cast<TB_DESCR*>(g_db_psbob->GetTB("subcontrolarea")), sizeof(dv));
}
else
{
printf("%s(%d):读取substation表关键字为%ld的记录失败，错误号:%d\r\n", __FUNCTION__, __LINE__, psbob_sec.ist_id, _oodb_errno);
}
}
else
{
printf("%s(%d):读取aclinesegment表关键字为%ld的记录失败，错误号:%d\r\n", __FUNCTION__, __LINE__, devid, _oodb_errno);
}
}
else if (strcasecmp(devtb, "cb") == 0)
{
PSBOB::CB psbob_cb = { 0 };
if (oodbread_rk(&psbob_cb, &devid, const_cast<TB_DESCR*>(g_db_psbob->GetTB("breaker")), sizeof(psbob_cb)) > 0)
{
if (oodbread_rk(&psbob_st, &psbob_cb.st_id, const_cast<TB_DESCR*>(g_db_psbob->GetTB("substation")), sizeof(psbob_st)) > 0)
{
return oodbread_rk(&dv, &psbob_st.subarea_id, const_cast<TB_DESCR*>(g_db_psbob->GetTB("subcontrolarea")), sizeof(dv));
}
else
{
printf("%s(%d):读取substation表关键字为%ld的记录失败，错误号:%d\r\n", __FUNCTION__, __LINE__, psbob_cb.st_id, _oodb_errno);
}
}
else
{
printf("%s(%d):读取breaker表关键字为%ld的记录失败，错误号:%d\r\n", __FUNCTION__, __LINE__, devid, _oodb_errno);
}
}
else if(strcasecmp(devtb, "st") == 0)
{
if (oodbread_rk(&psbob_st, &devid, const_cast<TB_DESCR*>(g_db_psbob->GetTB("substation")), sizeof(psbob_st)) > 0)
{
return oodbread_rk(&dv, &psbob_st.subarea_id, const_cast<TB_DESCR*>(g_db_psbob->GetTB("subcontrolarea")), sizeof(dv));
}
else
{
printf("%s(%d):读取substation表关键字为%ld的记录失败，错误号:%d\r\n", __FUNCTION__, __LINE__, devid, _oodb_errno);
}
}
return OO_FAIL;
}
int GetStbyDv(long dvid, PSBOB::ST &st)
{
//D5000获取DV
_oodb_errno = OO_SUCCEED;
PSBOB::ST psbob_st[20] = { 0 };
//读取st
int re_size = oodbread_ra(psbob_st, "subarea_id", &dvid, const_cast<TB_DESCR*>(g_db_psbob->GetTB("substation")), sizeof(psbob_st));
if (re_size < 0)
{
TRACE("读取substation表subarea_id属性为:%ld的记录失败，errno:%d\r\n", dvid, _oodb_errno);
return OO_FAIL;
}
else
{
int st_num = 0;
st_num = re_size / sizeof(PSBOB::OO_R_DV_ST);
for (int j = 0; j < st_num; j++)
{
if (HasMask(g_db_psbob->GetTB("substation"), "st_type", psbob_st[j].st_type, MENU_FAC_TYPE_FEEDVIR)
|| HasMask(g_db_psbob->GetTB("substation"), "st_type", psbob_st[j].st_type, MENU_FAC_TYPE_SUBSTN))
{
memcpy(&st, &psbob_st[j], sizeof(PSBOB::ST));
printf("the st id is %ld\n", st.id);
return OO_SUCCEED;
}
}
return OO_FAIL;
}
}
//校验数据是否跟故障定位时一致，如果一致返回0，如果相关数据发生变化返回2，实时库版本号变化返回1，读库失败返回3
int data_verify(const char* groupid)
{
assert(groupid != NULL);
char *buf = NULL;
int rec_num, attr_num;
struct ORA_ATTR *attrs = NULL;
bool dbnochange = true;
int old_version = 0;
//首先判断psbob实时库版本号是否一致，如果不一致返回false
//D5000暂时不知道从哪获取实时库的版本号
/*sprintf(sql, "select db_version from fdir_fdirect where id=\'%s\'", groupid);
cout << sql << endl;
pthread_mutex_lock(&oci_mutex);
int ret = g_oci->ReadWithBind(sql, &buf, &rec_num, &attr_num, &attrs);
pthread_mutex_unlock(&oci_mutex);
if (ret != OCI_ERROR)
{
if (rec_num <= 0)
{
g_oci->Readdata_Free();
return CHECK_DATA_READ_ERR;
}
else
{
old_version = *(int*)(buf);
}
}
else
{
g_oci->Readdata_Free();
return CHECK_DATA_READ_ERR;
}
g_oci->Readdata_Free();
PSBOB::GLOBAL global = { 0 };
if (oodbread_rp(&global, 0, const_cast<TB_DESCR*>(g_db_psbob->GetTB("secinfo")), 1, sizeof(global)) <= 0)
{
printf("读取global记录失败，errno:%d,line:%d\r\n", _oodb_errno, __LINE__);
return CHECK_DATA_READ_ERR;
}
if (!(global.sec_no == old_version))
{
TRACE("实时库的版本号不一致，old是：%d,now是:%d\r\n", old_version, global.sec_no);
return CHECK_DATA_PSBOB_ERR;
}*/
//判断开关状态是否改变，如果改变返回false
sprintf(sql, "select pt_id,status,isjxcb,topflags from fdir_cb_status where id=\'%s\'", groupid);
cout << sql << endl;
long point_id;
int status = CHECK_DATA_OK;
int old_status = 0;
int isjxcb = 0;
int bus_status = 0;
pthread_mutex_lock(&oci_mutex);
int ret = g_oci->ReadWithBind(sql, &buf, &rec_num, &attr_num, &attrs);
pthread_mutex_unlock(&oci_mutex);
if (ret != OCI_ERROR)
{
for (int i = 0; i < rec_num; i++)
{
int len_row = attrs[0].col_width + attrs[1].col_width + attrs[2].col_width + attrs[3].col_width;
point_id = *(long*) (buf + i * len_row);
old_status = *(int*) (buf + i * len_row + attrs[0].col_width);
isjxcb = *(int*) (buf + i * len_row + attrs[0].col_width + attrs[1].col_width);
bus_status = *(int*) (buf + i * len_row + attrs[0].col_width + attrs[1].col_width + attrs[2].col_width);
TRACE("pt_id=%ld, status=%d, isjxcb=%d, topflags=%d\r\n", point_id, old_status, isjxcb, bus_status);
PSBOB::CB point = { 0 };
if (oodbread_rk(&point, &point_id, const_cast<TB_DESCR*>(g_db_psbob->GetTB("breaker")), sizeof(point)) == OO_FAIL)
{
TRACE("读取breaker表关键字为:%ld的记录失败\r\n", point_id);
status = CHECK_DATA_READ_ERR;
}
else
{
if (point.point > 0)
{
status = CHECK_DATA_PSBOB_ERR;
}
else
{
status = CHECK_DATA_OK;
}
if (isjxcb == 1)
{
TRACE("进线开关point id：%ld , topflags is :%d\r\n", point.id, point.tpcolor);
if ((point.tpcolor <= 0 && (bus_status == 0)) || (point.tpcolor > 0 && (bus_status == 1)))
{
sprintf(sql, "update fdir_cb_status set change=1 where id=\'%s\' and pt_id=\'%ld\'", groupid, point_id);
ExecSQL(sql);
dbnochange = false;
}
}
}
if (status != old_status)
{
sprintf(sql, "update fdir_cb_status set change=1 where id=\'%s\' and pt_id=\'%ld\'", groupid, point_id);
ExecSQL(sql);
dbnochange = false;
}
}
}
else
{
g_oci->Readdata_Free();
return CHECK_DATA_READ_ERR;
}
g_oci->Readdata_Free();
if (dbnochange == false)
{
return CHECK_DATA_CB_ERR;
}
return CHECK_DATA_OK;
}
//故障恢复方案
void write_fhzg_step(const char* groupid, const char* table_name, list<list<MAP_SO_NODE> > lst_step, FDIR_R2* fdir_r, list<FAULT_ITEM> &lst_ld, list<long> lstIsolate, bool bStation)
{
int fhzg_index = 0;
char fhzg_id[100] = { 0 };
for (list<list<MAP_SO_NODE> >::iterator it_lst_steps = lst_step.begin(); it_lst_steps != lst_step.end(); it_lst_steps++)
{
sprintf(fhzg_id, "%s%c%d", groupid, bStation ? '_' : '#', fhzg_index);
int istep = 0;
map<long, _DATA_NODE_SO> map_so_data;
map<long, long> map_so_zone;
TRACE("list<MAP_SO_NODE>->size() = %d\r\n", it_lst_steps->size());
for(list<long>::const_iterator it_Isolate = lstIsolate.begin(); it_Isolate != lstIsolate.end(); it_Isolate++)
{
CLS_CB *tmp_open_cb = g_bob->cb_tb->Find(CLS_CB(*it_Isolate));
sprintf(sql,
"Insert into PMS_PARAM.FHZG_STEP%s (ID, CB_ID, OPERATION, STEP, STATUS, SO_ID, CONTROL) Values ('%s', %ld, %d, %d, 0, %d, 1)",
table_name, fhzg_id, tmp_open_cb->pid, 1, istep, 0);
ExecSQL(sql);
istep++;
}
for (list<MAP_SO_NODE>::iterator it_data = it_lst_steps->begin(); it_data != it_lst_steps->end(); it_data++)
{
map<long, _DATA_NODE_SO> m_tmp_close_steps;
map<long, _DATA_NODE_SO>::iterator it_m_close;
for(MAP_SO_NODE::iterator it_so_node = it_data->begin(); it_so_node != it_data->end(); it_so_node++)
{
//////////////////////////////////////
//将后面步骤的电源联络开关替换成初次用该电源时的联络开关
map<long, _DATA_NODE_SO>::iterator it_map_so_data = map_so_data.find(it_so_node->second.data_so.so_name);
if(it_map_so_data != map_so_data.end())
{
it_so_node->second.data_so.cb_id = it_map_so_data->second.cb_id;
it_so_node->second.data_so.lst_zones.splice(it_so_node->second.data_so.lst_zones.end(),it_map_so_data->second.lst_zones);
it_so_node->second.data_so.lst_zones.sort();
it_so_node->second.data_so.lst_zones.unique();
//it_data->data_so.lst_zones = it_map_so_data->second.lst_zones;
}
//将后面步骤的电源联络开关替换成初次用该电源时的联络开关
//////////////////////////////////////
map_so_data[it_so_node->second.data_so.so_name] = it_so_node->second.data_so;
for (list<FDIR_STEP>::iterator it_step = it_so_node->second.lst_steps.begin(); it_step != it_so_node->second.lst_steps.end(); it_step++)
{
if(it_step->bOpen)
{
long pid = it_step->cb;
id_to_pid(pid);
sprintf(sql, "Insert into PMS_PARAM.FHZG_STEP%s (ID, CB_ID, OPERATION, STEP, STATUS, SO_ID, CONTROL) Values ('%s', '%ld', %d, %d, 0, '%ld', 1)", table_name, fhzg_id, pid,
it_step->bOpen ? 1 : 2, istep, it_step->stage == CUT_LD ? 0 : it_so_node->second.data_so.so_name);
ExecSQL(sql);
istep++;
}
else
{
m_tmp_close_steps[it_step->cb] = it_so_node->second.data_so;
}
}
for (list<_DATA_NODE_ZN>::iterator it_zones = it_so_node->second.lst_zones.begin(); it_zones != it_so_node->second.lst_zones.end(); it_zones++)
{
list<FAULT_ITEM> lst_dev;
for (map<int, list<CLS_LD> >::iterator it_map_zn_ld = it_zones->map_zn_ld.begin(); it_map_zn_ld != it_zones->map_zn_ld.end(); it_map_zn_ld++)
{
fdir_r->get_zone_devs(it_map_zn_ld->first, lst_dev);
//只有oracle数据库支持这种插入库的sql语句，其他数据库还是一条一条的记录插入tianyq
#ifdef _ORACLE_
sprintf(sql, "Insert into FHZG_ZONE%s (ID, IZONE, SO_ID, DEV_ID, DEV_TABLE) ", table_name);
memset(sqltemp, 0, sizeof(sqltemp));
for (list<FAULT_ITEM>::iterator it_devs = lst_dev.begin(); it_devs != lst_dev.end(); it_devs++)
{
strcat(sql, sqltemp);
sprintf(sqltemp, " select \'%s\', %d, \'%s\', \'%s\', \'%s\' from dual union all ", fhzg_id, it_map_zn_ld->first, it_so_node->second.data_so.so_name, it_devs->eq_id.c_str(), it_devs->table.c_str());
}
strncat(sql, sqltemp, (strlen(sqltemp)-10));
strcat(sql,"\0");
ExecSQL(sql);
#else
for (list<FAULT_ITEM>::iterator it_devs = lst_dev.begin(); it_devs != lst_dev.end(); it_devs++)
{
sprintf(sql, "Insert into PMS_PARAM.FHZG_ZONE%s (ID, IZONE, SO_ID, DEV_ID, DEV_TABLE) Values (\'%s\', %d, \'%ld\', \'%ld\', \'%s\')", table_name, fhzg_id, it_map_zn_ld->first, it_so_node->second.data_so.so_name, it_devs->eq_id, it_devs->table.c_str());
strcat(sql,"\0");
ExecSQL(sql);
}
#endif
list<CLS_LD>::const_iterator it_ld;
//只有oracle数据库支持这种插入库的sql语句，其他数据库还是一条一条的记录插入tianyq
#ifdef _ORACLE_
if(it_map_zn_ld->second.size() > 0)
{
sprintf(sql, "Insert into FHZG_LOAD%s (ID, LD_ID, LD_DESCR, LD_PRIOR, LD_AMOUNT, IZONE) ", table_name);
memset(sqltemp, 0, sizeof(sqltemp));
for (it_ld = it_map_zn_ld->second.begin(); it_ld != it_map_zn_ld->second.end(); it_ld++)
{
strcat(sql, sqltemp);
sprintf(sqltemp, " select \'%s\', \'%s\', \'%s\', %d, %f, %d from dual union all ", fhzg_id, it_ld->id,
it_ld->descr, it_zones->prio, it_ld->w, it_map_zn_ld->first);
if (fhzg_index == 0)
lst_ld.push_back(FAULT_ITEM(NULL, it_ld->id, "ld", it_ld->descr));
}
strncat(sql, sqltemp, (strlen(sqltemp)-10));
strcat(sql,"\0");
ExecSQL(sql);
}
#else
for (it_ld = it_map_zn_ld->second.begin(); it_ld != it_map_zn_ld->second.end(); it_ld++)
{
sprintf(sql, "Insert into PMS_PARAM.FHZG_LOAD%s (ID, LD_ID, LD_DESCR, LD_PRIOR, LD_AMOUNT, IZONE) Values (\'%s\', \'%ld\', \'%s\', %d, %f, %d)", table_name, fhzg_id, it_ld->pid, it_ld->descr, it_zones->prio, it_ld->w, it_map_zn_ld->first);
strcat(sql,"\0");
ExecSQL(sql);
if (fhzg_index == 0)
lst_ld.push_back(FAULT_ITEM(0, it_ld->pid, "ld", it_ld->descr));
}
#endif
}
}
sprintf(sql, "update PMS_PARAM.fhzg_zone%s set edge = 1 where id = \'%s\' and so_id = \'%ld\' and dev_id in (select dev_id from (select dev_id,count(dev_id) as num from FHZG_ZONE where id = \'%s\' and so_id = \'%ld\' and dev_table='CB' and so_id = \'%ld\' group by dev_id) where num =1)", table_name, fhzg_id, it_so_node->second.data_so.so_name, fhzg_id, it_so_node->second.data_so.so_name, it_so_node->second.data_so.so_name);
ExecSQL(sql);
}
for (list<_DATA_NODE_ZN>::iterator it_zones = it_data->begin()->second.lst_cut_zones.begin(); it_zones != it_data->begin()->second.lst_cut_zones.end(); it_zones++)
{
list<FAULT_ITEM> lst_dev;
for (map<int, list<CLS_LD> >::iterator it_map_zn_ld = it_zones->map_zn_ld.begin(); it_map_zn_ld != it_zones->map_zn_ld.end(); it_map_zn_ld++)
{
fdir_r->get_zone_devs(it_map_zn_ld->first, lst_dev);
//只有oracle数据库支持这种插入库的sql语句，其他数据库还是一条一条的记录插入tianyq
#ifdef _ORACLE_
sprintf(sql, "Insert into FHZG_CUT_ZONE%s (ID, IZONE, DEV_ID, DEV_TABLE) ", table_name);
memset(sqltemp, 0, sizeof(sqltemp));
for (list<FAULT_ITEM>::iterator it_devs = lst_dev.begin(); it_devs != lst_dev.end(); it_devs++)
{
strcat(sql, sqltemp);
sprintf(sqltemp, " select \'%s\', %d, \'%s\', \'%s\' from dual union all ", fhzg_id, it_map_zn_ld->first, it_devs->id.c_str(), it_devs->table.c_str());
}
strncat(sql, sqltemp, (strlen(sqltemp)-10));
ExecSQL(sql);
#else
for (list<FAULT_ITEM>::iterator it_devs = lst_dev.begin(); it_devs != lst_dev.end(); it_devs++)
{
sprintf(sql, "Insert into PMS_PARAM.FHZG_CUT_ZONE%s (ID, IZONE, DEV_ID, DEV_TABLE) Values (\'%s\', %d, \'%ld\', \'%s\')", table_name, fhzg_id, it_map_zn_ld->first, it_devs->eq_id, it_devs->table.c_str());
ExecSQL(sql);
}
#endif
}
}
//分摊转供时会有非隔离开关的断开，断开步骤先执行，闭合步骤最后写入库
for(it_m_close = m_tmp_close_steps.begin(); it_m_close != m_tmp_close_steps.end(); it_m_close++)
{
long pid = it_m_close->first;
id_to_pid(pid);
sprintf(sql, "Insert into PMS_PARAM.FHZG_STEP%s (ID, CB_ID, OPERATION, STEP, STATUS, SO_ID, CONTROL) Values ('%s', '%ld', %d, %d, 0, '%ld', 1)", table_name, fhzg_id, pid, 2, istep, it_m_close->second.so_name);
ExecSQL(sql);
istep++;
}
}
TRACE("map_so_data.size()=%d\r\n", map_so_data.size());
for (map<long, _DATA_NODE_SO>::iterator it_map_so_data = map_so_data.begin(); it_map_so_data != map_so_data.end(); it_map_so_data++)
{
long id = it_map_so_data->second.cb_id;
id_to_pid(id);
sprintf(sql, "Insert into PMS_PARAM.FHZG_SO%s (ID, SO_ID, SO_DESCR, TYPE, FULL_CAPACITY, LEFT_CAPACITY, CB_ID, ORG_WLOSS, NEW_WLOSS) Values (\'%s\', \'%ld\', \'%s\', %d, %f, %f, \'%ld\', %f, %f)",
table_name, fhzg_id, it_map_so_data->second.so_name, it_map_so_data->second.so_descr, map_so_data.size() > 1 ? 2 : 1/*有两个以上电源时是分摊转供，少于两个电源是独立转供*/,
it_map_so_data->second.full_capacity, it_map_so_data->second.left_capacity, id, it_map_so_data->second.org_wloss, it_map_so_data->second.new_wloss);
strcat(sql,"\0");
ExecSQL(sql);
//分摊转供时方案中电源树可能会重复，下面通过map_so_zone避免重复写库
map<long, long>::iterator it_so_zone;
it_so_zone = map_so_zone.find(it_map_so_data->second.so_name);
if (it_so_zone == map_so_zone.end())
{
//针对每个电源生成电源树，把电源树上的开关信息写入表中，为数据校验用
list<long>::iterator it_so = it_map_so_data->second.lst_zones.begin();
if (it_so != it_map_so_data->second.lst_zones.end())
{
list<CLS_CB> lst_info_cbs;
fdir_r->getfhzglstcb(*it_so, lst_info_cbs);
for (list<CLS_CB>::iterator it_lst_info_cbs = lst_info_cbs.begin(); it_lst_info_cbs != lst_info_cbs.end(); it_lst_info_cbs++)
{
//开关的状态，1表示闭合，0表示断开，3表示状态未知
int cb_status = 1;
int isjxcb = 0;
int bus_status = 0;
sprintf(sql, "select count(pt_id) from fdir_cb_status where id=\'%s\' and pt_id=\'%ld\'", groupid, it_lst_info_cbs->pid);
cout<<sql<<endl;
char *buf = NULL;
int rec_num, attr_num;
struct ORA_ATTR *attrs = NULL;
int num = 0;
pthread_mutex_lock(&oci_mutex);
int ret = g_oci->ReadWithBind(sql, &buf, &rec_num, &attr_num, &attrs);
pthread_mutex_unlock(&oci_mutex);
if (ret != OCI_ERROR)
{
num = *(int*)(buf);
}
g_oci->Readdata_Free();
if (num > 0)
{
if (it_lst_info_cbs->q & CB_LWCB)
{
continue;
}
else
{
break;
}
}
if (it_lst_info_cbs->q & CB_OPEN)
{
cb_status = 0;
}
if (it_lst_info_cbs->q & CB_UNKNOWN)
{
cb_status = 3;
}
if (it_lst_info_cbs->q & CB_FDHCB)
{
isjxcb = 1;
if (it_lst_info_cbs->topflags & CB_DEAD)
{
bus_status = 1;
}
}
sprintf(sql, "INSERT into PMS_PARAM.FDIR_CB_STATUS (ID,PT_ID,CB_DESCR,STATUS,ISJXCB,TOPFLAGS) VALUES (\'%s\',\'%ld\',\'%s\',%d,%d,%d)",
groupid, it_lst_info_cbs->pid, it_lst_info_cbs->descr, cb_status, isjxcb, bus_status);
strcat(sql,"\0");
ExecSQL(sql);
}
}
map_so_zone[it_map_so_data->second.so_name] = it_map_so_data->second.so_name;
}
//只有oracle数据库支持这种插入库的sql语句，其他数据库还是一条一条的记录插入tianyq
#ifdef _ORACLE_
sprintf(sql, "Insert into FHZG_SO_ZONE%s (ID, IZONE, SO_ID, DEV_ID, DEV_TABLE) ", table_name);
memset(sqltemp, 0, sizeof(sqltemp));
for (list<int>::iterator it_lst_so_zones = it_map_so_data->second.lst_zones.begin(); it_lst_so_zones != it_map_so_data->second.lst_zones.end(); it_lst_so_zones++)
{
list<FAULT_ITEM> lst_dev;
map_fdir_task.begin()->first->get_zone_devs(*it_lst_so_zones, lst_dev);
for (list<FAULT_ITEM>::iterator it_devs = lst_dev.begin(); it_devs != lst_dev.end(); it_devs++)
{
strcat(sql, sqltemp);
sprintf(sqltemp, " select \'%s\', %d, \'%s\', \'%s\', \'%s\' from dual union all ", fhzg_id, *it_lst_so_zones, it_map_so_data->second.so_name, it_devs->eq_id.c_str(), it_devs->table.c_str());
}
}
strncat(sql, sqltemp, (strlen(sqltemp)-10));
strcat(sql,"\0");
ExecSQL(sql);
#else
for (list<long>::iterator it_lst_so_zones = it_map_so_data->second.lst_zones.begin(); it_lst_so_zones != it_map_so_data->second.lst_zones.end(); it_lst_so_zones++)
{
list<FAULT_ITEM> lst_dev;
fdir_r->get_zone_devs(*it_lst_so_zones, lst_dev);
for (list<FAULT_ITEM>::iterator it_devs = lst_dev.begin(); it_devs != lst_dev.end(); it_devs++)
{
sprintf(sql, "Insert into PMS_PARAM.FHZG_SO_ZONE%s (ID, IZONE, SO_ID, DEV_ID, DEV_TABLE) Values (\'%s\', %ld, \'%ld\', \'%ld\', \'%s\')", table_name, fhzg_id, *it_lst_so_zones, it_map_so_data->second.so_name, it_devs->eq_id, it_devs->table.c_str());
strcat(sql,"\0");
ExecSQL(sql);
}
}
#endif
//设置边界开关
sprintf(sql, "update PMS_PARAM.fhzg_so_zone%s set edge = 1 where id = \'%s\' and so_id = \'%ld\' and dev_id in (select dev_id from (select dev_id,count(dev_id) as num from FHZG_SO_ZONE where id = \'%s\' and dev_table='CB' and so_id = \'%ld\' group by dev_id) where num =1)", table_name, fhzg_id, it_map_so_data->second.so_name, fhzg_id, it_map_so_data->second.so_name);
strcat(sql,"\0");
ExecSQL(sql);
}
fhzg_index++;
}
}
void write_fault_dev(const char *fault_id, char *table_name, FDIR_R2* fdir_r)
{
std::map<long, int> map_st_type; //故障区域开关的厂站与其厂站类型的映射
list<FAULT_ITEM> lst_fault_devs, lst_up_devs, lst_down_devs;
fdir_r->get_fault_devs(lst_up_devs, lst_fault_devs, lst_down_devs);
//故障上游设备
for (list<FAULT_ITEM>::iterator it_devs = lst_up_devs.begin(); it_devs != lst_up_devs.end(); it_devs++)
{
if (strcmp(it_devs->table.c_str(), "CB") == 0)
{
sprintf(sql, "INSERT INTO FDIR_FAULT_DEV%s (ID, DEV_ID, DEV_TABLE, EDGE, WHOLE,DEV_DESCR, REL_DEV_ID, FLAG, AREA_TYPE) VALUES (\'%s\', \'%ld\', \'%s\', %d, %d, \'%s\', \'%ld\', %d, 0)",
table_name, fault_id, it_devs->eq_id, it_devs->table.c_str(), it_devs->border, it_devs->whole, it_devs->eq_descr.c_str(), it_devs->eq_id, it_devs->flag);
ExecSQL(sql);
}
else
{
sprintf(sql, "INSERT INTO FDIR_FAULT_DEV%s (ID, DEV_ID, DEV_TABLE, EDGE, WHOLE,DEV_DESCR, REL_DEV_ID, FLAG, AREA_TYPE) VALUES (\'%s\', \'%ld\', \'%s\', %d, %d, \'%s\', \'%ld\',%d, 0)",
table_name, fault_id, it_devs->id > 0 ? it_devs->id : it_devs->eq_id, it_devs->table.c_str(), it_devs->border, it_devs->whole, it_devs->eq_descr.c_str(), it_devs->eq_id, it_devs->flag);
ExecSQL(sql);
}
}
//故障设备
for (list<FAULT_ITEM>::iterator it_devs = lst_fault_devs.begin(); it_devs != lst_fault_devs.end(); it_devs++)
{
if (strcmp(it_devs->table.c_str(), "CB") == 0)
{
sprintf(sql, "INSERT INTO FDIR_FAULT_DEV%s (ID, DEV_ID, DEV_TABLE, EDGE, WHOLE,DEV_DESCR, REL_DEV_ID, FLAG, AREA_TYPE) VALUES (\'%s\', \'%ld\', \'%s\', %d, %d, \'%s\', \'%ld\', %d, 1)",
table_name, fault_id, it_devs->eq_id, it_devs->table.c_str(), it_devs->border, it_devs->whole, it_devs->eq_descr.c_str(), it_devs->eq_id, it_devs->flag);
ExecSQL(sql);
}
else
{
sprintf(sql, "INSERT INTO FDIR_FAULT_DEV%s (ID, DEV_ID, DEV_TABLE, EDGE, WHOLE,DEV_DESCR, REL_DEV_ID, FLAG, AREA_TYPE) VALUES (\'%s\', \'%ld\', \'%s\', %d, %d, \'%s\', \'%ld\',%d, 1)",
table_name, fault_id, it_devs->id > 0 ? it_devs->id : it_devs->eq_id, it_devs->table.c_str(), it_devs->border, it_devs->whole, it_devs->eq_descr.c_str(), it_devs->eq_id, it_devs->flag);
ExecSQL(sql);
}
}
// 添加故障区域所属厂站ID，用于解决进线开关故障不能推到馈线图和无法推环网图的问题
for (list<FAULT_ITEM>::iterator itFaultDevs = lst_fault_devs.begin(); itFaultDevs != lst_fault_devs.end(); itFaultDevs++)
{
if (strcmp(itFaultDevs->table.c_str(), "CB") == 0)
{
PSBOB::CB faultCB = {0};
int iRet = oodbread_rk(&faultCB, &(itFaultDevs->eq_id), const_cast<TB_DESCR*>(g_db_psbob->GetTB("breaker")), sizeof(PSBOB::CB));
if (iRet <= 0)
{
TRACE("在断路器表中查找关键字为%ld的记录失败啦！\r\n", itFaultDevs->eq_id);
continue;
}
else
{
PSBOB::ST faultST = {0};
iRet = oodbread_rk(&faultST, &(faultCB.st_id), const_cast<TB_DESCR*>(g_db_psbob->GetTB("substation")), sizeof(PSBOB::ST));
if (iRet <= 0)
{
TRACE("在厂站表中查找关键字为%ld的记录失败啦！\r\n", faultCB.st_id);
continue;
}
else
{
map_st_type.insert(std::make_pair(faultST.id, faultST.st_type));
}
}
}
}
//从map中取出厂站ID，如果有类型为馈线类型为虚拟馈线厂站的ID，将其赋到lFaultStId中，否则如果有类型为环网柜的ID，赋到lFaultStId中，否则填0
std::map<long, int>::iterator it_st = map_st_type.begin();
for (; it_st != map_st_type.end(); it_st++)
{
if (it_st->second == MENU_FAC_TYPE_FEEDVIR)
{
fdir_r->lFaultStId = it_st->first;
break;
}
}
if (it_st == map_st_type.end())
{
for (it_st = map_st_type.begin(); it_st != map_st_type.end(); it_st++)
{
if (it_st->second == MENU_FAC_TYPE_RINGMAINUNIT)
{
fdir_r->lFaultStId = it_st->first;
break;
}
}
}
if (it_st == map_st_type.end())
{
fdir_r->lFaultStId = 0;
}
//故障下游设备
for (list<FAULT_ITEM>::iterator it_devs = lst_down_devs.begin(); it_devs != lst_down_devs.end(); it_devs++)
{
if (strcmp(it_devs->table.c_str(), "CB") == 0)
{
sprintf(sql, "INSERT INTO FDIR_FAULT_DEV%s (ID, DEV_ID, DEV_TABLE, EDGE, WHOLE,DEV_DESCR, REL_DEV_ID, FLAG, AREA_TYPE) VALUES (\'%s\', \'%ld\', \'%s\', %d, %d, \'%s\', \'%ld\', %d, 2)",
table_name, fault_id, it_devs->eq_id, it_devs->table.c_str(), it_devs->border, it_devs->whole, it_devs->eq_descr.c_str(), it_devs->eq_id, it_devs->flag);
ExecSQL(sql);
}
else
{
sprintf(sql, "INSERT INTO FDIR_FAULT_DEV%s (ID, DEV_ID, DEV_TABLE, EDGE, WHOLE,DEV_DESCR, REL_DEV_ID, FLAG, AREA_TYPE) VALUES (\'%s\', \'%ld\', \'%s\', %d, %d, \'%s\', \'%ld\',%d, 2)",
table_name, fault_id, it_devs->id > 0 ? it_devs->id : it_devs->eq_id, it_devs->table.c_str(), it_devs->border, it_devs->whole, it_devs->eq_descr.c_str(), it_devs->eq_id, it_devs->flag);
ExecSQL(sql);
}
}
fdir_r->set_faultcb_edge(fault_id);
}
void write_fault_tree(const char* groupid, FDIR_R2* fdir_r)
{
list<CLS_CB> fault_cbs;
fdir_r->Get_Fdir_Cbs(fault_cbs);
for (list<CLS_CB>::iterator it_fault_cb = fault_cbs.begin(); it_fault_cb != fault_cbs.end(); it_fault_cb++)
{
//开关的状态，1表示闭合，0表示断开，3表示状态未知
int cb_status = 1;
if (it_fault_cb->q & CB_OPEN)
{
cb_status = 0;
}
if (it_fault_cb->q & CB_UNKNOWN)
{
cb_status = 3;
}
int up_pos = 0;
if (it_fault_cb->q & CB_FAULT)
{
up_pos = 1;
}
sprintf(sql, "INSERT into PMS_PARAM.FDIR_CB_STATUS (ID, PT_ID,CB_DESCR,STATUS,ISFAULTUP,ISFAULTDV) VALUES (\'%s\',\'%ld\',\'%s\',%d,%d,1)",
groupid, it_fault_cb->pid, it_fault_cb->descr, cb_status, up_pos);
ExecSQL(sql);
}
}
void write_fault_up_dev(const char* fault_id, char *table_name, FDIR_R2* fdir_r, bool upiso_fail, list<FAULT_ITEM> &lst_ld)
{
map<long, string> faultzone_cb;
list<FAULT_ITEM> lst_dev;
int isozone;
char uptempsql[1024] = { 0 };
char upsql[1024] = { 0 };
//写上游恢复区段表
//获取上游要恢复的区段号
isozone = fdir_r->getisozone();
int upzone = fdir_r->getfaultautoopenzone();
printf("上游分闸的区段是 %d, the 隔离区段是 %d\n", upzone, isozone);
//如果上游要恢复的区段和故障区段一样说明没有要恢复的上游区段
if(upzone != isozone && isozone != -1 && upzone != -1)
{
list<int> uplstzone;
fdir_r->getlstupzone(upzone, isozone, uplstzone);
faultzone_cb.clear();
//只有oracle数据库支持这种插入库的sql语句，其他数据库还是一条一条的记录插入tianyq
#ifdef _ORACLE_
sprintf(sql, "INSERT INTO FDIR_UP_ZONE%s (ID, IZONE, DEV_ID, DEV_TABLE, EDGE) ", table_name);
memset(sqltemp, 0, sizeof(sqltemp));
memset(uptempsql, 0, sizeof(uptempsql));
int upcount = 0;
sprintf(upsql, "update FDIR_UP_ZONE%s set edge = 0 where ", table_name);
for(list<int>::iterator it_up = uplstzone.begin(); it_up != uplstzone.end(); it_up++)
{
lst_dev.clear();
fdir_r->get_zone_devs(*it_up, lst_dev);
for (list<FAULT_ITEM>::iterator it_devs = lst_dev.begin(); it_devs != lst_dev.end(); it_devs++)
{
if(strcmp(it_devs->table.c_str(), "CB") == 0)
{
if(faultzone_cb.find(it_devs->eq_id) != faultzone_cb.end())
{
//设置边界开关
upcount++;
strcat(upsql, uptempsql);
sprintf(uptempsql, "(id = \'%s\' and dev_id = \'%s\') or ", fault_id, it_devs->eq_id.c_str());
}
else
{
faultzone_cb[it_devs->eq_id] = "CB";
strcat(sql, sqltemp);
sprintf(sqltemp, " select \'%s\', %d, \'%s\', \'%s\', %d from dual union all ", fault_id, *it_up, it_devs->eq_id.c_str(), it_devs->table.c_str(), 1);
}
}
else
{
strcat(sql, sqltemp);
sprintf(sqltemp, " select \'%s\', %d, \'%s\', \'%s\', %d from dual union all ", fault_id, *it_up, it_devs->eq_id.c_str(), it_devs->table.c_str(), 0);
if (strcasecmp(it_devs->table.c_str(), "ld") == 0)
{
lst_ld.push_back(*it_devs);
}
}
}
}
strncat(sql, sqltemp, (strlen(sqltemp)-10));
ExecSQL(sql);
if(upcount > 0)
{
strncat(upsql, uptempsql, (strlen(uptempsql)-3));
ExecSQL(upsql);
}
#else
for(list<int>::iterator it_up = uplstzone.begin(); it_up != uplstzone.end(); it_up++)
{
lst_dev.clear();
fdir_r->get_zone_devs(*it_up, lst_dev);
for (list<FAULT_ITEM>::iterator it_devs = lst_dev.begin(); it_devs != lst_dev.end(); it_devs++)
{
if(strcmp(it_devs->table.c_str(), "CB") == 0)
{
if(faultzone_cb.find(it_devs->eq_id) != faultzone_cb.end())
{
//设置边界开关
sprintf(sql, "update FDIR_UP_ZONE%s set edge = 0 where id = \'%s\' and dev_id = \'%ld\'",
table_name, fault_id, it_devs->eq_id);
ExecSQL(sql);
}
else
{
faultzone_cb[it_devs->eq_id] = "CB";
sprintf(sql, "INSERT INTO FDIR_UP_ZONE%s (ID, IZONE, DEV_ID, DEV_TABLE, EDGE) VALUES (\'%s\', %d, \'%ld\', \'%s\', %d)", table_name, fault_id, *it_up, it_devs->eq_id, it_devs->table.c_str(), 1);
ExecSQL(sql);
}
}
else
{
sprintf(sql, "INSERT INTO FDIR_UP_ZONE%s (ID, IZONE, DEV_ID, DEV_TABLE, EDGE) VALUES (\'%s\', %d, \'%ld\', \'%s\', %d)", table_name, fault_id, *it_up, it_devs->eq_id, it_devs->table.c_str(), 0);
ExecSQL(sql);
if (strcasecmp(it_devs->table.c_str(), "ld") == 0)
{
lst_ld.push_back(*it_devs);
}
}
}
}
#endif
}
}
bool invalid_recalc(const char *group_id)
{
cout << __FUNCTION__ << endl;
assert(group_id != NULL);
int i;
//查询出该组故障的故障跳闸开关，获取开关的最新状态，并将跳闸开关设置为合闸
char *buf = NULL;
int rec_num, attr_num;
struct ORA_ATTR *attrs = NULL;
list<long> lst_point; //该组故障中跳闸的开关
list<long> lst_up_cb; //故障上游的主干开关
list<FAULT_ITEM> lst_cb_item;
sprintf(sql, "SELECT RECV_POINT FROM FDIR_FDIRECT WHERE GROUPID=\'%s\'", group_id);
pthread_mutex_lock(&oci_mutex);
int ret = g_oci->ReadWithBind(sql, &buf, &rec_num, &attr_num, &attrs);
pthread_mutex_unlock(&oci_mutex);
cout << sql << endl;
if (ret != OCI_ERROR)
{
if (rec_num > 0)
{
for (i = 0; i < rec_num; i++)
{
char recv_point[1000];
bzero(recv_point, sizeof(recv_point));
memcpy(recv_point, buf + i * attrs[0].col_width, attrs[0].col_width);
cout << recv_point << endl;
char *pbuf1, *pbuf2; // = recv_point;
pbuf1 = pbuf2 = recv_point;
while ((pbuf2 = strchr(pbuf1, ';')) != NULL)
{
char cb[MAX_CB_ID_LEN + 5] = { 0 };
bzero(cb, sizeof(cb));
memcpy(cb, pbuf1, pbuf2 - pbuf1);
char *pTemp = strstr(cb, "[CB]");
if (pTemp != NULL)
{
*pTemp = 0;
lst_point.push_back(*(long*)cb);
cout << "读取到跳闸开关：" << cb << endl;
}
pbuf1 = pbuf2 + 1;
}
}
}
g_oci->Readdata_Free();
}
else
{
return false;
}
//如果故障所在馈线的上游主干开关变化，合主干变化的开关
sprintf(sql, "SELECT PT_ID FROM FDIR_CB_STATUS WHERE ID=\'%s\' AND ISFAULTUP=1 AND ((STATUS=1 AND CHANGE=1)OR(STATUS=0 AND CHANGE=0))", group_id);
pthread_mutex_lock(&oci_mutex);
ret = g_oci->ReadWithBind(sql, &buf, &rec_num, &attr_num, &attrs);
pthread_mutex_unlock(&oci_mutex);
cout << sql << endl;
if (ret != OCI_ERROR)
{
if (rec_num > 0)
{
for (i = 0; i < rec_num; i++)
{
char cb[MAX_CB_ID_LEN + 5] = { 0 };
bzero(cb, sizeof(cb));
memcpy(cb, buf + i * attrs[0].col_width, attrs[0].col_width);
cout << cb << endl;
lst_up_cb.push_back(*(long*)cb);
}
}
g_oci->Readdata_Free();
}
else
{
return false;
}
int lv_cb = g_bob->cb_tb->GetCount();
CLS_CB *cb = g_bob->cb_tb->GetTable();
for (i = 0; i < lv_cb; i++)
{
// add by spf 20140507
if (cb->q & CB_VIRTUAL)
{
if (get_virtual_path(cb->nd).size() > 0)
{
cb->q &= ~CB_OPEN;
}
else
{
cb->q |= CB_OPEN;
}
}
else
{
PSBOB::CB psbob_cb = { 0 };
long pid = (cb + i)->id;
id_to_pid(pid);
//读取开关对应的遥信信息 oodbread_ap为逻辑读属性 idigital为开关测点号
if (oodbread_rk(&psbob_cb, &pid, const_cast<TB_DESCR*>(g_db_psbob->GetTB("breaker")), sizeof(psbob_cb)) == OO_FAIL)
{
TRACE("读取%ld的开关记录失败！\r\n", pid);
return false;
}
(cb + i)->q &= ~CB_OPEN;
if (psbob_cb.point <= 0)
(cb + i)->q |= CB_OPEN;
}
//g_bob->digital_tb->Data[(cb + i)->idigital].value = value; //更新DIGITAL表信息
for (list<long>::iterator it = lst_point.begin(); it != lst_point.end(); it++)
{
if ((cb + i)->pid == *it)
{
//断开的开关才需要合闸，如果是闭合的开关不需要加入lst_point中
if ((cb + i)->q & CB_OPEN)
{
TRACE("合跳闸开关，cb:%ld, pointid:%s, point_name:%ld\r\n", (cb + i)->id, (cb + i)->descr, *it);
(cb + i)->q &= ~CB_OPEN;
lst_cb_item.push_back(FAULT_ITEM(0, (cb + i)->pid, "CB", g_bob->cb_tb->Data[i].descr));
break;
}
}
}
for (list<long>::iterator it_cb = lst_up_cb.begin(); it_cb != lst_up_cb.end(); it_cb++)
{
if ((cb + i)->pid == *it_cb)
{
TRACE("合故障上游的主干开关，cb:%ld, pointid:%s, point_name:%ld\r\n", (cb + i)->id, (cb + i)->descr, *it_cb);
(cb + i)->q &= ~CB_OPEN;
break;
}
}
}
sprintf(sql, "UPDATE FDIR_CB_STATUS SET STATUS=0,CHANGE=0 WHERE ID=\'%s\' AND CHANGE=1 AND STATUS=1", group_id);
ExecSQL(sql);
sprintf(sql, "UPDATE FDIR_CB_STATUS SET STATUS=1,CHANGE=0 WHERE ID=\'%s\' AND CHANGE=1 AND STATUS=0", group_id);
ExecSQL(sql);
//把计算失败的故障树重新建立
RecoTaskItem(group_id);
//设置方案失效的故障为待重新计算方案状态
for (FDIR_TASK_LIST::iterator it = g_lstTask.begin(); it != g_lstTask.end(); it++)
{
if (it->rq_type == TASK_TYPE_FAULT)
{
if (strcmp(it->task_data.fault.head.group_id, group_id) == 0)
{
it->task_data.fault.fdir_r->lst_point = lst_cb_item;
it->task_data.fault.next_step = TASK_FAULT_STATUS_INVALID_RECALC;
//更新FDIR_R对象fdir_cb里开关的状态
CLS_FDIR_CB *fdir_cb = it->task_data.fault.fdir_r->fdir_cb_tb->GetTable();
for (i = 0; i < lv_cb; i++)
{
if ((cb + i)->q & CB_OPEN)
{
(fdir_cb + i)->topflags |= FDIR_CB_OPEN0;
(fdir_cb + i)->topflags |= FDIR_CB_OPEN;
}
else
{
(fdir_cb + i)->topflags &= ~FDIR_CB_OPEN0;
(fdir_cb + i)->topflags &= ~FDIR_CB_OPEN;
}
}
}
}
}
//写状态到库
sprintf(sql, "update FDIR_FDIRECT set status=%d,status_isolate=%d,status_fhzg=%d where groupid=\'%s\'", STATUS_FDIRECT_RE_CALC, EXT_STATUS_FDIRECT_WAIT,EXT_STATUS_FDIRECT_WAIT, group_id);
ExecSQL(sql);
return true;
}
void EraseSameInfo(list<FAULT_ITEM> &lst_cont, list<FAULT_ITEM> lst_remove)
{
if (lst_cont.size() <= 0 || lst_remove.size() <= 0)
{
return;
}
map<long, FAULT_ITEM> m_cont;
map<long, FAULT_ITEM>::iterator it_mc;
list<FAULT_ITEM>::iterator it_lst;
for (it_lst = lst_cont.begin(); it_lst != lst_cont.end(); it_lst++)
{
m_cont[it_lst->eq_id] = *it_lst;
}
for (it_lst = lst_remove.begin(); it_lst != lst_remove.end(); it_lst++)
{
it_mc = m_cont.find(it_lst->eq_id);
if (it_mc != m_cont.end())
{
m_cont.erase(it_mc);
}
}
lst_cont.clear();
for (it_mc = m_cont.begin(); it_mc != m_cont.end(); it_mc++)
{
lst_cont.push_back(it_mc->second);
}
}
void write_res_and_disableres_ld(const char *groupid, list<FAULT_ITEM> lst_lose, list<FAULT_ITEM> lst_res)
{
if (groupid == NULL)
{
TRACE("传入的组号为空\r\n");
return;
}
list<FAULT_ITEM>::iterator it_lst;
for (it_lst = lst_lose.begin(); it_lst != lst_lose.end(); it_lst++)
{
sprintf(sql, "INSERT into PMS_PARAM.FDIR_DISABLE_RES (ID,DEV_ID,DEV_TYPE,DEV_DESCR) VALUES (\'%s\',\'%ld\',\'%s\',\'%s\')",groupid, it_lst->eq_id, it_lst->table.c_str(), it_lst->eq_descr.c_str());
ExecSQL(sql);
}
for (it_lst = lst_res.begin(); it_lst != lst_res.end(); it_lst++)
{
sprintf(sql, "INSERT into PMS_PARAM.FDIR_ENABLE_RES (ID,DEV_ID,DEV_TYPE,DEV_DESCR) VALUES (\'%s\',\'%ld\',\'%s\',\'%s\')",groupid, it_lst->eq_id, it_lst->table.c_str(), it_lst->eq_descr.c_str());
ExecSQL(sql);
}
}
void form_fdir_txt(const FDIR_TASK fault)
{
//D5000形成故障文本
}
long IDTransfor(long &id)
{
map<int, int> map_table;
map_table[g_db_psbob->GetTB("breaker")->table_id] = g_db_dms->GetTB("DMS_CB")->table_id;
map_table[g_db_psbob->GetTB("aclinesegment")->table_id] = g_db_dms->GetTB("DMS_SEC")->table_id;
map_table[g_db_psbob->GetTB("energyconsumer")->table_id] = g_db_dms->GetTB("DMS_LD")->table_id;
map_table[g_db_psbob->GetTB("busbarsection")->table_id] = g_db_dms->GetTB("DMS_BUS")->table_id;
map_table[g_db_psbob->GetTB("company")->table_id] = g_db_dms->GetTB("DMS_ST")->table_id;
map_table[g_db_psbob->GetTB("substation")->table_id] = g_db_dms->GetTB("DMS_FI")->table_id;
map<int, int>::const_iterator it;
for (it = map_table.begin(); it != map_table.end(); it++)
{
map_table[it->second] = it->first;
}
KEY_STRU ks = { 0 };
CCommon::long_to_keyid(id, &ks);
it = map_table.find(ks.table_no);
if (it != map_table.end())
{
ks.table_no = it->second;
CCommon::keyid_to_long(&ks, (unsigned long*)&id);
return id;
}
return 0;
}
bool pid_to_id(long &id)
{
map<string, TB_DESCR*> map_table;
map_table["breaker"] = const_cast<TB_DESCR*>(g_db_dms->GetTB("DMS_CB"));
map_table["aclinesegment"] = const_cast<TB_DESCR*>(g_db_dms->GetTB("DMS_SEC"));
map_table["energyconsumer"] = const_cast<TB_DESCR*>(g_db_dms->GetTB("DMS_LD"));
map_table["busbarsection"] = const_cast<TB_DESCR*>(g_db_dms->GetTB("DMS_BUS"));
map_table["company"] = const_cast<TB_DESCR*>(g_db_dms->GetTB("DMS_CO"));
map_table["substation"] = const_cast<TB_DESCR*>(g_db_dms->GetTB("DMS_ST"));
map_table["faultinfo"] = const_cast<TB_DESCR*>(g_db_dms->GetTB("DMS_FI"));
KEY_STRU ks = { 0 };
CCommon::long_to_keyid(id, &ks);
TB_DESCR* tb_descr = const_cast<TB_DESCR*>(g_db_psbob->GetTB(ks.table_no));
if (tb_descr == NULL)
{
return false;
}
map<string, TB_DESCR*>::iterator it = map_table.find(tb_descr->table_name);
if (it == map_table.end())
return false;
long value;
if (oodbread_aa(&value, "pid", &id, "id", it->second, sizeof(long)) <= 0)
{
return false;
}
id = value;
return true;
}
bool id_to_pid(long &id)
{
KEY_STRU ks = { 0 };
CCommon::long_to_keyid(id, &ks);
TB_DESCR* tb_descr = const_cast<TB_DESCR*>(g_db_dms->GetTB(ks.table_no));
if (tb_descr == NULL)
{
return false;
}
long value;
if (oodbread_ak(&value, &id, "pid", tb_descr, sizeof(long)) != OO_SUCCEED)
{
return false;
}
id = value;
return true;
}
//根据记录ID获取记录的英文标识
bool GetCode(const long id, string &code)
{
if (id <= 0) return false;
KEY_STRU ks = {0};
long key = 0;
CCommon::long_to_keyid(id, &ks);
if(ks.table_no <= 0) return false;
TB_DESCR *tb_descr = const_cast<TB_DESCR*>(g_db_dms->GetTB(ks.table_no));
if(tb_descr == NULL)
{
tb_descr = const_cast<TB_DESCR*>(g_db_psbob->GetTB(ks.table_no));
if(tb_descr == NULL) return false;
key = id;
}
else
{
if(oodbread_ak(&key, const_cast<long *>(&id), "pid", tb_descr, sizeof(long)) != OO_SUCCEED)
{
return false;
}
}
if(key <= 0) return false;
char buf[32];
CCommon::long_to_keyid(key, &ks);
if (oodbread_ak(buf, &key, "code", const_cast<TB_DESCR*>(g_db_psbob->GetTB(ks.table_no)), sizeof(char) * 32) != OO_SUCCEED)
{
return false;
}
code = buf;
return true;
}
//返回故障模拟方案执行后向人机返回的报文
void thread_simu_return(void* param)
{
int newsockfd = *((int*)param);
while (true)
{
pthread_mutex_lock(&simu_sync_mutex);
if (g_is_write_to_lib)
{
int rec_num, attr_num;
char* buf = NULL;
struct ORA_ATTR *attrs = NULL;
int his_count = 0;
sprintf(sql, "SELECT ID FROM PMS_PARAM.FDIR_FDIRECT ORDER BY ID DESC");
pthread_mutex_lock(&oci_mutex);
int ret = g_oci->ReadWithBind(sql, &buf, &rec_num, &attr_num, &attrs);
pthread_mutex_unlock(&oci_mutex);
std::string cur_fault_id;
int query_count = 0;
if (ret != OCI_ERROR && rec_num > 0)
{
cur_fault_id = buf;
}
//通过故障ID查找故障信号，若其对应的故障信号包含了机器名发出的所有故障信号，视为故障处理方案计算完成，向人机返回报文
buf = NULL;
attrs = NULL;
char return_str[1024] = {0};
char simu_sql[1024] = {0};
sprintf(simu_sql, "SELECT TM_ADD, KEY_ID FROM PMS_PARAM.FDIR_ALARM WHERE ID=\'%s\'", cur_fault_id.c_str());
FDIR_POINT_TRIG_LIST pt_trig;
pthread_mutex_lock(&oci_mutex);
ret = g_oci->ReadWithBind(simu_sql, &buf, &rec_num, &attr_num, &attrs);
pthread_mutex_unlock(&oci_mutex);
if (ret >= 0 && rec_num > 0)
{
for (int i = 0; i < rec_num; i++)
{
FDIR_POINT_TRIG his_trig = {0};
his_trig.tm_add.tv_sec = *(long*)(buf + i * (attrs[0].col_width + attrs[1].col_width));
his_trig.alarm.key_id = *(long*)(buf + i * (attrs[0].col_width + attrs[1].col_width) + attrs[0].col_width);
pt_trig.push_back(his_trig);
}
}
if (simu_mac_trig.size() > 0 && pt_trig.size() > 0)
{
std::map<std::string, FDIR_POINT_TRIG_LIST>::iterator it_map = simu_mac_trig.begin();
std::list<FDIR_POINT_TRIG>::iterator it_trig = pt_trig.begin();
for (;it_map != simu_mac_trig.end(); it_map++)
{
std::list<FDIR_POINT_TRIG>::iterator it_map_trig = it_map->second.begin();
for (; it_trig != pt_trig.end(); it_trig++)
{
for (; it_map_trig != it_map->second.end();)
{
if (it_trig->tm_add.tv_sec == it_map_trig->tm_add.tv_sec && it_trig->alarm.key_id == it_map_trig->alarm.key_id)
{
it_map->second.erase(it_map_trig++);
}
else
{
it_map_trig++;
continue;
}
}
if (it_trig != pt_trig.end() && it_map->second.size() > 0)
{
it_map_trig = it_map->second.begin();
continue;
}
string cur_machine = it_map->first;
if (it_map->second.size() == 0)
{
//获取模拟方案信息
buf = NULL;
attrs = NULL;
sprintf(simu_sql, "SELECT T1.ID, T1.TYPE, T1.NAME, T1.USERID FROM PMS_PARAM.FDIR_SIG_SUMMARY T1, PMS_PARAM.FDIR_SIG_FAULT T2 WHERE T2.FAULT_ID=\'%s\' AND T1.ID=T2.ID",
cur_fault_id.c_str());
pthread_mutex_lock(&oci_mutex);
ret = g_oci->ReadWithBind(simu_sql, &buf, &rec_num, &attr_num, &attrs);
pthread_mutex_unlock(&oci_mutex);
if (ret >= 0 && rec_num > 0)
{
char cur_plan_id[50] = {0};
memcpy(cur_plan_id, buf, attrs[0].col_width);
int plan_type = *(int*)(buf + attrs[0].col_width);
char plan_name[100] = {0};
char cur_usr[50] = {0};
memcpy(plan_name, buf + attrs[0].col_width + attrs[1].col_width, attrs[2].col_width);
memcpy(cur_usr, buf + attrs[0].col_width + attrs[1].col_width + attrs[2].col_width, attrs[3].col_width);
//发送XML响应头
cout << head_xml_simu_exec << endl;
ret = tcptools->Send(newsockfd, head_xml_simu_exec, strlen(head_xml_simu_exec));
if (ret <= 0)
{
cout << "发送数据失败，" << strerror(errno) << endl;
}
//查找group_id
sprintf(simu_sql, "SELECT GROUPID FROM PMS_PARAM.FDIR_FDIRECT WHERE ID=\'%s\'", cur_fault_id.c_str());
buf = NULL;
attrs = NULL;
pthread_mutex_lock(&oci_mutex);
int ret = g_oci->ReadWithBind(simu_sql, &buf, &rec_num, &attr_num, &attrs);
pthread_mutex_unlock(&oci_mutex);
std::string cur_group_id;
if (ret != OCI_ERROR && rec_num > 0)
{
cur_group_id = buf;
}
//发送响应请求上下文信息
sprintf(return_str, "<Simu_Plan id=\"%s\" group_id=\"%s\" type=\"%d\" name=\"%s\" machine=\"%s\" user=\"%s\">\r\n",
cur_plan_id, cur_group_id.c_str(), plan_type, plan_name, cur_machine.c_str(), cur_usr);
cout << return_str << endl;
ret = tcptools->Send(newsockfd, return_str, strlen(return_str));
if (ret <= 0)
{
cout << "发送数据失败，" << strerror(errno) << endl;
}
//发送XML响应尾
cout << tail_xml_simu << endl;
ret = tcptools->Send(newsockfd, tail_xml_simu, strlen(tail_xml_simu));
if (ret <= 0)
{
cout << "发送数据失败，" << strerror(errno) << endl;
}
g_is_write_to_lib = false;
//删除临时创建但不保存的方案
if (strstr(cur_plan_id, "1970/01/01") != NULL)
{
sprintf(simu_sql, "DELETE FROM PMS_PARAM.FDIR_SIG_SUMMARY WHERE ID=\'%s\'", cur_plan_id);
ExecSQL(simu_sql);
}
pthread_mutex_unlock(&simu_sync_mutex);
pthread_exit(0);
}
else
{
TRACE("故障模拟失败！\r\n");
}
}
}
}
}
}
pthread_mutex_unlock(&simu_sync_mutex);
usleep(1000);
}
}
//创建开关电流值读取线程，用于计算恢复策略时读取开关电流平均值,
//具体方法是每10秒读取一次开关电流瞬时值，该值为开关三相电流值的最大值，随后取这6个值的平均值
void thread_get_ivalue(void *param)
{
TRACE("计算平均电流值线程启动…\r\n");
TB_DESCR *tb_breaker = const_cast<TB_DESCR*>(g_db_psbob->GetTB("breaker"));
TB_DESCR * tb_dms_breaker = const_cast<TB_DESCR*>(g_db_dms->GetTB("DMS_CB"));
int size_cb = sizeof(PSBOB::CB);
int size_dms_cb = sizeof(DMS::CB);
if (tb_breaker == NULL || tb_dms_breaker == NULL)
{
TRACE("获取表指针失败！\r\n");
return;
}
g_mapTempIValue.clear();
list<long> lst_cb;
char *buf = NULL;
int index = 0;
//先将pwrflow里的cb表所有开关保存起来，方便后面计算平均值时过滤掉一些多余的开关
int ret = GetTableRecs(tb_dms_breaker, 1, &buf);
if (ret < 0)
{
TRACE("读取表DMS_CB记录失败！\r\n");
return;
}
int cnt_record = ret / size_dms_cb;
DMS::CB *ptr = reinterpret_cast<DMS::CB *>(buf);
for (index = 0; index < cnt_record; index++)
{
lst_cb.push_back(ptr->pid);
ptr++;
}
BufFree(buf);
buf = NULL;
while (true)
{
ret = GetTableRecs(tb_breaker, 1, &buf);
if (ret < 0)
{
TRACE("读取表breaker记录失败！\r\n");
continue;
}
cnt_record = ret / size_cb;
PSBOB::CB *ptr2 = reinterpret_cast<PSBOB::CB *>(buf);
for (index = 0; index < cnt_record; index++)
{
//开关在pwrflow库的CB表里不存在
if (::find(lst_cb.begin(), lst_cb.end(), ptr2->id) == lst_cb.end())
{
ptr2++;
continue;
}
g_mapTempIValue[ptr2->id].push_back(ptr2->i);
//最多只计算6个点的平均值，多余的点从列表删除
if (g_mapTempIValue[ptr2->id].size() > 6)
{
g_mapTempIValue[ptr2->id].pop_front();
}
ptr2++;
}
BufFree(buf);
buf = NULL;
//求取电流平均值
for (map<long, list<float> >::const_iterator it = g_mapTempIValue.begin(); it != g_mapTempIValue.end(); it++)
{
float fIVSum = 0;
for (list<float>::const_iterator it_value = it->second.begin(); it_value != it->second.end(); it_value++)
{
fIVSum += fabs(*it_value);
}
pthread_mutex_lock(&avg_i_mutex);
g_mapIValue[it->first] = fIVSum / it->second.size();
pthread_mutex_unlock(&avg_i_mutex);
}
//10秒钟查询一次
sleep(10);
}
}
| [
"swjasonyang@163.com"
] | swjasonyang@163.com |
9836e4359572fb265f86821cfc5be38dbe4f55b9 | c1720c81612dbd512dce413618d3cd246faa0a74 | /DEM/Src/L3/AI/Perceptors/PerceptorSmartObj.h | ae4e3d9ceb578d05aaf06b97f24e93610f7f2bab | [
"MIT"
] | permissive | moltenguy1/deusexmachina | 307ba62a863034437cd77a6599c191ffe8ae953c | 134f4ca4087fff791ec30562cb250ccd50b69ee1 | refs/heads/master | 2021-01-23T21:35:42.122378 | 2012-10-03T23:33:16 | 2012-10-03T23:33:16 | 35,931,317 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 444 | h | #pragma once
#ifndef __DEM_L3_AI_PERCEPTOR_SMART_OBJ_H__
#define __DEM_L3_AI_PERCEPTOR_SMART_OBJ_H__
#include <AI/Perception/Perceptor.h>
// Detects smart objects.
namespace AI
{
class CPerceptorIAO: public CPerceptor
{
DeclareRTTI;
DeclareFactory(CPerceptorIAO);
public:
virtual void ProcessStimulus(CActor* pActor, CStimulus* pStimulus, float Confidence = 1.f);
};
RegisterFactory(CPerceptorIAO);
}
#endif | [
"niello11@gmail.com@01a7efd1-0ae0-fa29-c58a-2c4763e9e309"
] | niello11@gmail.com@01a7efd1-0ae0-fa29-c58a-2c4763e9e309 |
7f2862096aeb54ba099c440a0a147ec29ab8544f | 8e78f5da3c1b3467560ab39054a71e69f280b703 | /archieve/Luogu5406/Luogu5406.cpp | 45c3beec18fc3a0884b9e1b9912f0cae85ab9827 | [] | no_license | ycsgg/oi_code | aed9922a3bd53ef5ee88450d80af9fbb79a48479 | 1f98dca6fb0b69da2f566276cce89817fe828edd | refs/heads/main | 2023-09-03T04:55:49.611275 | 2021-11-19T08:31:31 | 2021-11-19T08:31:31 | 342,456,005 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,194 | cpp | #include <array>
#include <assert.h>
#include <iostream>
#include <vector>
using namespace std;
namespace Matrix {
using ll = long long;
constexpr ll mod = 1e9 + 7;
template <typename T>
struct Matrix {
int row, col;
// vector<vector<T>> arr;
T arr[75][75];
void init(int row, int col, int typ = 1) {
this->row = row;
this->col = col;
// arr = vector<vector<T>>(row, vector<T>(col, T()));
}
auto &operator[](int x) {
return arr[x];
}
const auto &operator[](int x) const {
return arr[x];
}
Matrix(int row, int col) : row(row), col(col) {
init(row, col, 0);
}
Matrix(int n = 2) {
col = row = n;
init(n, n, 0);
}
Matrix(const Matrix &m) {
init(m.row, m.col);
for (int i = 0; i < row; i++) {
for (int j = 0; j < col; j++) {
arr[i][j] = m[i][j];
}
}
}
Matrix operator*(const Matrix &m) const {
// cout << "MUL" << endl;
Matrix res(row, m.col);
for (int k = 0; k < col; k++) {
for (int i = 0; i < row; i++) {
for (int j = 0; j < m.col; j++) {
res[i][j] += 1ll * (arr[i][k] * m[k][j]) % mod;
res[i][j] %= mod;
}
}
}
return res;
}
};
template <typename T>
ostream &operator<<(ostream &in, const Matrix<T> &A) {
for (int i = 0; i < A.col; i++) {
cout << "{";
for (int j = 0; j < A.row; j++) {
if (j != A.row - 1) {
cout << A[i][j] << ",";
} else {
cout << A[i][j];
}
}
cout << "},";
cout << endl;
}
return in;
}
ll qpow(ll a, ll b) {
ll res = 1;
while (b) {
if (b & 1) {
res = res * a % mod;
}
a = a * a % mod;
b /= 2;
}
return res;
}
template <typename T>
T det(Matrix<T> M, const ll p = mod) {
assert(M.col == M.row);
int n = M.col;
ll ans = 1;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++)
if ((M[i][i]) && M[j][i]) {
ans = p - ans;
swap(M[i], M[j]);
break;
}
if (!M[i][i])
return 0;
ll t = qpow(M[i][i], p - 2);
for (int j = i + 1; j < n; j++) {
ll t2 = t * M[j][i] % p;
for (int k = i; k < n; k++) {
M[j][k] = (M[j][k] - t2 * M[i][k] % p + p) % p;
}
}
}
for (int i = 1; i < n; i++) {
ans *= M[i][i];
ans %= p;
}
return ans;
}
} // namespace Matrix
namespace Transform {
using Poly = vector<int>;
const int mod = 1e9 + 7;
const int inv2 = 500000004;
int getLen(int x) {
int L = 1;
while (L < x) {
L *= 2;
}
return L;
}
void unit_OR(Poly &f, int lim, int mid, int typ) {
for (int i = 0; i < lim; i += mid * 2) {
for (int j = 0; j < mid; j++) {
auto x = f[i + j], y = f[i + j + mid];
if (typ == 1) {
f[i + j + mid] = (1ll * y + x) % mod;
} else {
f[i + j + mid] = (1ll * y - x + mod) % mod;
}
}
}
}
void unit_AND(Poly &f, int lim, int mid, int typ) {
for (int i = 0; i < lim; i += mid * 2) {
for (int j = 0; j < mid; j++) {
auto x = f[i + j], y = f[i + j + mid];
if (typ == 1) {
f[i + j] = (1ll * x + y) % mod;
} else {
f[i + j] = (1ll * x - y + mod) % mod;
}
}
}
}
void unit_XOR(Poly &f, int lim, int mid, int typ) {
for (int i = 0; i < lim; i += mid * 2) {
for (int j = 0; j < mid; j++) {
auto x = f[i + j], y = f[i + j + mid];
f[i + j] = (x + y) % mod;
f[i + j + mid] = (x - y + mod) % mod;
if (typ == -1) {
f[i + j] = 1ll * f[i + j] * inv2 % mod;
f[i + j + mid] = 1ll * f[i + j + mid] * inv2 % mod;
}
}
}
}
void exFWT(Poly &f, int typ, const string &oper) {
int lim = getLen(f.size());
f.resize(lim);
for (int mid = 1, cur = 0; mid < lim; mid *= 2, cur++) {
if (oper[cur] == '|') {
unit_OR(f, lim, mid, typ);
} else if (oper[cur] == '&') {
unit_AND(f, lim, mid, typ);
} else {
unit_XOR(f, lim, mid, typ);
}
}
}
} // namespace Transform
using namespace Transform;
int n, m;
string s;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
cin >> s;
int w = s.length();
Matrix::Matrix<Poly> M(n);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
M[i][j].resize(1 << w);
}
}
for (int i = 1; i <= m; i++) {
int u, v, w;
cin >> u >> v >> w;
--u, --v;
M[u][v][w]--;
M[v][u][w]--;
M[u][u][w]++;
M[v][v][w]++;
}
n--;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
for (int k = 0; k < (1 << w); k++) {
if (M[i][j][k] < 0) {
M[i][j][k] += mod;
}
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
for (int k = 0; k < (1 << w); k++) {
if (M[i][j][k] < 0) {
M[i][j][k] += mod;
}
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
exFWT(M[i][j], 1, s);
}
}
vector<int> c(1 << w);
for (int t = 0; t < (1 << w); t++) {
Matrix::Matrix<int> tmp(n);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
tmp[i][j] = M[i][j][t];
}
}
c[t] = Matrix::det(tmp);
}
exFWT(c, -1, s);
for (int i = (1 << w) - 1; ~i; i--) {
if (c[i]) {
cout << i << endl;
return 0;
}
}
cout << -1 << endl;
cout.flush();
return 0;
}
// Asusetic eru quionours | [
"ycs2495472711@outlook.com"
] | ycs2495472711@outlook.com |
648bf32fa8c19962ff00ff4a9aa8e476e73f2d01 | 792e697ba0f9c11ef10b7de81edb1161a5580cfb | /tools/clang/test/SemaCXX/return-stack-addr.cpp | 2f3b5b5d6c66000ff9c4a424e36ab48d42c04ba7 | [
"Apache-2.0",
"LLVM-exception",
"NCSA"
] | permissive | opencor/llvmclang | 9eb76cb6529b6a3aab2e6cd266ef9751b644f753 | 63b45a7928f2a8ff823db51648102ea4822b74a6 | refs/heads/master | 2023-08-26T04:52:56.472505 | 2022-11-02T04:35:46 | 2022-11-03T03:55:06 | 115,094,625 | 0 | 1 | Apache-2.0 | 2021-08-12T22:29:21 | 2017-12-22T08:29:14 | LLVM | UTF-8 | C++ | false | false | 6,612 | cpp | // RUN: %clang_cc1 -std=c++2b -fsyntax-only -verify=expected,cxx2b %s
// RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify=expected,cxx11_20 %s
// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify=expected,cxx11_20,cxx11 %s
int* ret_local() {
int x = 1;
return &x; // expected-warning {{address of stack memory}}
}
int* ret_local_array() {
int x[10];
return x; // expected-warning {{address of stack memory}}
}
int* ret_local_array_element(int i) {
int x[10];
return &x[i]; // expected-warning {{address of stack memory}}
}
int *ret_local_array_element_reversed(int i) {
int x[10];
return &i[x]; // expected-warning {{address of stack memory}}
}
int* ret_local_array_element_const_index() {
int x[10];
return &x[2]; // expected-warning {{address of stack memory}}
}
int& ret_local_ref() {
int x = 1;
return x; // cxx11_20-warning {{reference to stack memory}}
// cxx2b-error@-1 {{non-const lvalue reference to type 'int' cannot bind to a temporary of type 'int'}}
}
int* ret_local_addrOf() {
int x = 1;
return &*&x; // expected-warning {{address of stack memory}}
}
int* ret_local_addrOf_paren() {
int x = 1;
return (&(*(&x))); // expected-warning {{address of stack memory}}
}
int* ret_local_addrOf_ptr_arith() {
int x = 1;
return &*(&x+1); // expected-warning {{address of stack memory}}
}
int* ret_local_addrOf_ptr_arith2() {
int x = 1;
return &*(&x+1); // expected-warning {{address of stack memory}}
}
int* ret_local_field() {
struct { int x; } a;
return &a.x; // expected-warning {{address of stack memory}}
}
int& ret_local_field_ref() {
struct { int x; } a;
return a.x; // expected-warning {{reference to stack memory}}
}
int* ret_conditional(bool cond) {
int x = 1;
int y = 2;
return cond ? &x // expected-warning {{address of stack memory associated with local variable 'x' returned}}
: &y; // expected-warning {{address of stack memory associated with local variable 'y' returned}}
}
int* ret_conditional_rhs(int *x, bool cond) {
int y = 1;
return cond ? x : &y; // expected-warning {{address of stack memory}}
}
void* ret_c_cast() {
int x = 1;
return (void*) &x; // expected-warning {{address of stack memory}}
}
int* ret_static_var() {
static int x = 1;
return &x; // no warning.
}
int z = 1;
int* ret_global() {
return &z; // no warning.
}
int* ret_parameter(int x) {
return &x; // expected-warning {{address of stack memory}}
}
void* ret_cpp_static_cast(short x) {
return static_cast<void*>(&x); // expected-warning {{address of stack memory}}
}
int* ret_cpp_reinterpret_cast(double x) {
return reinterpret_cast<int*>(&x); // expected-warning {{address of stack me}}
}
int* ret_cpp_reinterpret_cast_no_warning(long x) {
return reinterpret_cast<int*>(x); // no-warning
}
int* ret_cpp_const_cast(const int x) {
return const_cast<int*>(&x); // expected-warning {{address of stack memory}}
}
struct A { virtual ~A(); }; struct B : A {};
A* ret_cpp_dynamic_cast(B b) {
return dynamic_cast<A*>(&b); // expected-warning {{address of stack memory}}
}
// PR 7999 - handle the case where a field is itself a reference.
template <typename T> struct PR7999 {
PR7999(T& t) : value(t) {}
T& value;
};
struct PR7999_X {};
PR7999_X& PR7999_f(PR7999<PR7999_X> s) { return s.value; } // no-warning
void test_PR7999(PR7999_X& x) { (void)PR7999_f(x); } // no-warning
// PR 8774: Don't try to evaluate parameters with default arguments like
// variables with an initializer, especially in templates where the default
// argument may not be an expression (yet).
namespace PR8774 {
template <typename U> struct B { };
template <typename V> V f(typename B<V>::type const &v = B<V>::value()) {
return v;
}
template <> struct B<const char *> {
typedef const char *type;
static const char *value();
};
void g() {
const char *t;
f<const char*>(t);
}
}
// Don't warn about returning a local variable from a surrounding function if
// we're within a lambda-expression.
void ret_from_lambda() {
int a;
int &b = a;
(void) [&]() -> int& { return a; };
(void) [&]() -> int& { return b; };
(void) [=]() mutable -> int& { return a; };
(void) [=]() mutable -> int& { return b; };
(void) [&]() -> int& { int a; return a; }; // cxx11_20-warning {{reference to stack}}
// cxx2b-error@-1 {{non-const lvalue reference to type 'int' cannot bind to a temporary of type 'int'}}
(void) [=]() -> int& { int a; return a; }; // cxx11_20-warning {{reference to stack}}
// cxx2b-error@-1 {{non-const lvalue reference to type 'int' cannot bind to a temporary of type 'int'}}
(void) [&]() -> int& { int &a = b; return a; };
(void) [=]() mutable -> int& { int &a = b; return a; };
(void) [] {
int a;
return [&] { // expected-warning {{address of stack memory associated with local variable 'a' returned}}
return a; // expected-note {{implicitly captured by reference due to use here}}
};
};
(void) [] {
int a;
return [&a] {}; // expected-warning {{address of stack memory associated with local variable 'a' returned}} expected-note {{captured by reference here}}
};
(void) [] {
int a;
return [=] {
return a;
};
};
(void) [] {
int a;
return [a] {};
};
(void) [] {
int a;
// cxx11-warning@+1 {{C++14}}
return [&b = a] {}; // expected-warning {{address of stack memory associated with local variable 'a' returned}} expected-note {{captured by reference via initialization of lambda capture 'b'}}
};
(void) [] {
int a;
// cxx11-warning@+1 {{C++14}}
return [b = &a] {}; // expected-warning {{address of stack memory associated with local variable 'a' returned}} expected-note {{captured via initialization of lambda capture 'b'}}
};
}
struct HoldsPointer { int *p; };
HoldsPointer ret_via_member_1() {
int n;
return {&n}; // expected-warning {{address of stack memory associated with local variable 'n' returned}}
}
HoldsPointer ret_via_member_2() {
int n;
return HoldsPointer(HoldsPointer{&n}); // cxx11-warning {{address of stack memory associated with local variable 'n' returned}}
}
// FIXME: We could diagnose this too.
HoldsPointer ret_via_member_3() {
int n;
const HoldsPointer hp = HoldsPointer{&n};
return hp;
}
namespace mem_ptr {
struct X {};
int X::*f();
int &r(X *p) { return p->*f(); }
}
namespace PR47861 {
struct A {
A(int i);
A &operator+=(int i);
};
A const &b = A(5) += 5; // expected-warning {{temporary bound to local reference 'b' will be destroyed at the end of the full-expression}}
}
| [
"agarny@hellix.com"
] | agarny@hellix.com |
21f797ebd77b8e16cc7de52c8cbe17b619e7162b | 0de9688de651ee81660dee187291bd97e5da1ee2 | /tool/code/trunk/cxx/Segmentation/MFA/include/ccipdMFADrivingFeaturePreparer.h | 34b385ede4fcabf2c64a3564b18fe741f87b0a8a | [] | no_license | zengruizhao/Radiomics | 2845cd7f17a46fae95be5d68b135ceda76ed4e44 | 34c1f1bff12fb994c904eaab0691f33819067003 | refs/heads/master | 2022-04-26T11:56:59.338297 | 2020-05-01T08:15:12 | 2020-05-01T08:15:12 | 257,222,358 | 3 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,650 | h | #ifndef __ccipdMFADrivingFeaturePreparer_h
#define __ccipdMFADrivingFeaturePreparer_h
//////////////////////////////////////////////////////////////////////////////////////////
// ccipd includes
#include "ccipdSIMFeaturePreparerInterface.h"
#include "ccipdMFATypes.h"
#include "ccipdMacros.h"
#include "ccipdFactory.h"
// serialization includes
#include "ccipdSegmentationOptions.h"
#ifdef Boost_SERIALIZATION_FOUND
ccipdSerializationForwardDeclarationMacro
#include <boost/serialization/version.hpp>
#include <boost/serialization/tracking.hpp>
#endif // Boost_SERIALIZATION_FOUND
//////////////////////////////////////////////////////////////////////////////////////////
namespace ccipd
{
/**
* This class provides
* the features to drive
* the MFA segmentation.
*
* \ingroup MFA
* \author Rob Toth
* \date 2013-01-22
*/
class MFADrivingFeaturePreparer :
public MFAFeaturePreparerInterface,
public Factory< MFADrivingFeaturePreparer >
{
//////////////////////////////////////////////////////////////////////////////////////////
ccipdConstructorDeclarationMacro( MFADrivingFeaturePreparer )
ccipdFactorySuperclassTypedefsMacro
//////////////////////////////////////////////////////////////////////////////////////////
public:
//////////////////////////////////////////////////////////////////////////////////////////
typedef MFAFeaturePreparerInterface Superclass;
/// Return all the feature ID's
virtual FeatureIDConstCollection GetWhichFeatures() const;
/// Extract all features for a given study
virtual FeatureCollectionPointer GetFeatures(
const StudyConstPointer & study ) const;
//////////////////////////////////////////////////////////////////////////////////////////
public: // set/get
//////////////////////////////////////////////////////////////////////////////////////////
/**
* \brief Set the trained MFA model.
*
* The feature extractors from the
* trained model will be used to prune
* the features.
*/
ccipdSetByrefDeclareMacro( MFAModel, MFAModelConstPointer )
/// Get the trained MFA model you have previously input.
ccipdGetConstDeclareMacro( MFAModel, MFAModelConstPointer )
/**
* \brief Set the levelset features.
*
* This will be parsed through the levelset
* extractor from the trained model, and only
* levelset objects in the trained levelset extractor
* will be used as a driving feature.
*
* This prevents you from trying to set a levelset
* which wasn't trained.
*/
ccipdSetByrefDeclareMacro( InputLevelsetFeatures, FeatureIDConstCollection )
/// Get the pruned, valid levelset features which will drive the segmentation.
ccipdGetConstDeclareMacro( InputLevelsetFeatures, FeatureIDConstCollection )
/**
* \brief Set the texture features.
*
* This will be parsed through the texture
* extractor from the trained model, and only
* levelset objects in the trained texture extractor
* will be used as a driving feature.
*
* This prevents you from trying to set a texture
* which wasn't trained.
*/
ccipdSetByrefDeclareMacro( InputTextureFeatures, FeatureIDConstCollection )
/// Get the pruned, valid texture features which will drive the segmentation.
ccipdGetConstDeclareMacro( InputTextureFeatures, FeatureIDConstCollection )
/**
* If you set this to non-zero (default is 0),
* then after optionally transforming
* and cropping the feature, it will be
* extrapolated by this many mm.
*/
ccipdSetByvalDeclareMacro( ExtrapolateInMM, float )
ccipdGetConstDeclareMacro( ExtrapolateInMM, float )
//////////////////////////////////////////////////////////////////////////////////////////
private:
//////////////////////////////////////////////////////////////////////////////////////////
/** Serialization */
#ifdef Boost_SERIALIZATION_FOUND
/** We are serializable */
ccipdSerializationDeclarationMacro
#endif // Boost_SERIALIZATION_FOUND
//////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
ccipdPIMPLMacro
//////////////////////////////////////////////////////////////////////////////////////////
}; // class MFADrivingFeaturePreparer
} // namespace ccipd
#ifdef Boost_SERIALIZATION_FOUND
/**
* 2013-03-14
* Version 2: Add in extrapolation value.
*/
BOOST_CLASS_VERSION( ccipd::MFADrivingFeaturePreparer, 2 )
BOOST_CLASS_TRACKING(ccipd::MFADrivingFeaturePreparer,
boost::serialization::track_always )
#endif
#endif // __ccipdMFADrivingFeaturePreparer_h
| [
"zzr_nuist@163.com"
] | zzr_nuist@163.com |
465075bdbf744681dc0c8eb8cc4ab011e25faa18 | 41a2f2dfd4c84979af975d2c0d3e69b802cf4c4a | /Property.h | 86adc8914e594e439d8a7f2e8eca8ada5a8e2ecb | [] | no_license | heikkiaho/TemplateTest | 25c964753ac808d51fae82762fcb6aff84b277ae | 77399430faca311a0498e6dcfd195940ee2e6d00 | refs/heads/master | 2020-12-30T09:57:52.570408 | 2014-01-24T10:51:35 | 2014-01-24T10:51:35 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 470 | h | /*
* Property.h
*
* Created on: 22.1.2014
* Author: Heikki
*/
#ifndef PROPERTY_H_
#define PROPERTY_H_
#include <string>
using namespace std;
class Property {
private:
std::string id;
public:
Property( const std::string id);
virtual ~Property();
string value;
template<class TYPE>
string& operator[](const TYPE & val) {
return value;
}
template<typename TYPE>
void SetValue(const TYPE & val) {
value = val;
}
};
#endif /* PROPERTY_H_ */
| [
"heikki.aho@sarokal.net"
] | heikki.aho@sarokal.net |
a7a2150382a4d7eaa97d28d8d61689de134bd52b | 0cbdd9cd7c395cff651d4f895fa327d9e464ab38 | /Src/KhaosIrrBake_VP.cpp | ca7589be8ba8c12e23ebbd7bb0acad04187d8276 | [] | no_license | zengqh/khaos | 128c332a7bf443761e03847da69c6eb9aa9c3b4e | 929e60a8b72bf8e513200b9ce5837ec3e388bba4 | refs/heads/master | 2020-12-02T16:14:58.873539 | 2017-07-07T09:34:06 | 2017-07-07T09:34:06 | 96,522,956 | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 13,659 | cpp | #include "KhaosPreHeaders.h"
#include "KhaosIrrBake.h"
#include "KhaosMesh.h"
#include "KhaosMeshNode.h"
#include "KhaosMaterialManager.h"
#include "KhaosTextureManager.h"
#include "KhaosTexCfgParser.h"
#include "KhaosMaterialFile.h"
#include "KhaosRayQuery.h"
#include "KhaosTimer.h"
#include "KhaosLightNode.h"
#include "KhaosVolumeProbeNode.h"
#include "KhaosSceneGraph.h"
#include "KhaosInstObjSharedData.h"
#include "KhaosNameDef.h"
namespace Khaos
{
const float e_dot = 0.00873f; // 89.5度
//////////////////////////////////////////////////////////////////////////
// bake probe
void IrrBake::onPrepareVolumeProbe( SceneNode* node )
{
// 创建资源
VolumeProbeNode* volProbeNode = static_cast<VolumeProbeNode*>( node );
VolumeProbe* volProbe = volProbeNode->getProbe();
volProbe->unload(); // free exist first
volProbe->setVolID( -1 );
VolumeMapSet* lms = _getVolMapSet( node );
lms->createMaps( volProbe->getResolutionX(), volProbe->getResolutionY(), volProbe->getResolutionZ() );
lms->setOutMaps( m_resBaseVolName, m_volmapNextID );
if ( m_prebuildVolDataPath.size() )
{
char preName[1024] = {};
sprintf( preName, m_prebuildVolDataPath.c_str(), m_volmapNextID );
lms->preFileName = preName;
}
++m_volmapNextID;
}
void IrrBake::_finishVolMapDone()
{
KHAOS_FOR_EACH( VolumeMapSetMap, m_volMapSet, it )
{
_saveVolResult( it->first, it->second );
}
}
void IrrBake::_saveVolResult( SceneNode* node, VolumeMapSet* vms )
{
static const char* strChannel[3] = { "r", "g", "b" };
for ( int i = 0; i < 3; ++i )
{
SimpleVolumeMap* svm = vms->indIrrVolMaps[i];
#if 0
{
for ( int z = 0; z < svm->getDepth(); ++z )
{
for ( int y = 0; y < svm->getHeight(); ++y )
{
for ( int x = 0; x < svm->getWidth(); ++x )
{
Color clr = Color::BLACK;
clr[i] = x / (float)(svm->getWidth() - 1);
clr.a = 1;
svm->setColor( x, y, z, clr );
}
}
}
}
#endif
// save volume map
char file[4096] = {};
sprintf( file, vms->outFileNameFmt.c_str(), vms->mapID, strChannel[i] );
String resFullFileName = g_fileSystem->getFullFileName(file);
svm->saveFile( PIXFMT_A32B32G32R32F, resFullFileName.c_str() );
TexCfgSaver::saveSimple( file, TEXTYPE_VOLUME, PIXFMT_A32B32G32R32F,
TEXADDR_CLAMP, TEXF_LINEAR, TEXF_NONE, false, 1 );
}
_outputDebugStr( "IrrBake: volume save[%s] <= %d\n", node->getName().c_str(), vms->mapID );
}
void IrrBake::_initProbeSampleInfos()
{
m_sphVolMapper.setRandsDistribution( &m_randFull, SphereSampleMapper::EntireSphereUniform );
m_sphVolMapper.setCommConfig( true, true );
m_sphVolMapper.general();
m_probeSampleInfos.resize( m_sphVolMapper.getNumSamples() );
for ( int i = 0; i < m_sphVolMapper.getNumSamples(); ++i )
{
// 计算当前方向的半球潜在可见采样集合
HemiInfoList& info = m_probeSampleInfos[i];
info.resize( m_sphVolMapper.getNumSamples() );
const Vector3& currNormDir = m_sphVolMapper.getSample(i).dir;
for ( int j = 0; j < m_sphVolMapper.getNumSamples(); ++j )
{
const Vector3& inComingDir = m_sphVolMapper.getSample(j).dir;
float NdotL = currNormDir.dotProduct( inComingDir );
if ( NdotL > e_dot ) // 这里只考虑半球可见，场景可见需要后续自行计算
{
info[j] = HemiInfo(j, NdotL, true);
}
else
{
info[j] = HemiInfo(j, 0, false);
}
}
}
}
void IrrBake::_buildAllVolumeProbes()
{
const BakeSystem::SceneNodeList& litNodes = this->m_bakeSys.getVolumeProbeNodeList();
KHAOS_FOR_EACH_CONST( BakeSystem::SceneNodeList, litNodes, it )
{
m_currVolProbNode = static_cast<VolumeProbeNode*>(*it);
_buildOneVolumeProbe();
}
}
void IrrBake::_buildOneVolumeProbe()
{
_outputDebugStr( "IrrBake: bake volume probe - %s\n", m_currVolProbNode->getName().c_str() );
VolumeMapSet* vms = this->_getVolMapSet( m_currVolProbNode );
VolumeProbe* probe = m_currVolProbNode->getProbe();
// 预处理文件设置
khaosAssert( !m_preVolHeadFile );
_createPreBuildFiles( m_preVolHeadFile, m_preVolFile, vms->preFileName,
probe->getResolutionX(), probe->getResolutionY(), probe->getResolutionZ(),
m_bakeSys.getThreadsCount(), m_randFull.getNumSamples(), m_onlyUseVol );
// 执行每个体素的bake
int voxelCnt = probe->getResolutionX() * probe->getResolutionY() * probe->getResolutionZ();
BatchTasks tasks;
tasks.setTask( _bakeVolProbeSatic );
tasks.setUserData( this );
tasks.planTask( voxelCnt, m_bakeSys.getThreadsCount() );
// 关闭预处理文件
int count = m_bakeSys.getThreadsCount();
for ( int i = 0; i < count; ++i )
{
KHAOS_DELETE m_preVolFile[i];
m_preVolFile[i] = 0;
}
KHAOS_DELETE m_preVolHeadFile;
m_preVolHeadFile = 0;
}
void IrrBake::_bakeVolProbeSatic( int threadID, void* para, int voxelID )
{
IrrBake* baker = (IrrBake*)para;
if ( baker->m_status == IBS_PREBUILD )
{
baker->_bakeVolProbePre( threadID, voxelID );
}
else
{
khaosAssert( baker->m_status == IBS_VOLPROB );
baker->_bakeVolProbe( threadID, voxelID );
}
}
void IrrBake::_voxelIDToXYZ( VolumeProbe* probe, int voxelID, int& x, int& y, int& z ) const
{
// 从id转换到x,y,z
const int planeSize = probe->getResolutionX() * probe->getResolutionY();
int xy = voxelID % planeSize;
z = voxelID / planeSize;
x = xy % probe->getResolutionX();
y = xy / probe->getResolutionX();
}
void IrrBake::_bakeVolProbePre( int threadID, int voxelID )
{
// 当前光探
VolumeProbe* probe = m_currVolProbNode->getProbe();
// 当前线程预处理文件
LightMapPreBuildFile& preFile = *(m_preVolFile[threadID]);
// voxelID得到坐标
int x, y, z;
_voxelIDToXYZ( probe, voxelID, x, y, z );
// 光探世界位置
Vector3 centerPos = probe->getCenterWorldPos( x, y, z );
// 信息对象
LightMapPreBuildHeadFile::ItemHeadInfo* headInfo = m_preVolHeadFile->getItemInfo( x, y, z );
LightMapPreBuildFile::TexelItem* texelItem = preFile.setCurrTexelItem( x, y, z );
headInfo->subIdxInMesh = voxelID;
headInfo->faceIdxInMesh = -1;
// 收集此光探的射线信息
for ( int i = 0; i < m_sphVolMapper.getNumSamples(); ++i )
{
const SphereSampleMapper::Sample& smpl = m_sphVolMapper.getSample( i );
Ray ray( centerPos, smpl.dir );
SceneBVH::Result result;
if ( !m_bakeSys.getSG()->getBVH()->intersect( ray, result ) )
continue; // 不相交
const SBVHFaceInfo* faceInfo = m_bakeSys.getSG()->getBVH()->getFaceInfo( result.faceID );
SceneNode* node = m_bakeSys.getSG()->getBVH()->getSceneNode( faceInfo->instanceID );
MeshNode* meshNode = static_cast<MeshNode*>(node);
SubMesh* subMesh = meshNode->getMesh()->getSubMesh(faceInfo->subIndex);
// 是否交在正面上
Vector3 normalOther = subMesh->getTriNormal( faceInfo->faceIdx, result.gravity );
normalOther = meshNode->getDerivedMatrix().transformAffineNormal( normalOther );
if ( normalOther.dotProduct(smpl.dir) < 0 ) // 应该法线相对
{
LightMapPreBuildFile::RayInfo* rayInfo = texelItem->addRayInfo( i );
rayInfo->globalFaceID = result.faceID; // 记录全局面id
rayInfo->flag = 0; // 正面
}
}
// 写入信息
preFile.writeCurrTexelItem();
}
float _reconstructSH4( float* b, const Vector3& s )
{
static const float c0 = 1.0f / (2.0f * Math::sqrt(Math::PI));
static const float c1 = Math::sqrt(3.0f) / (2.0f * Math::sqrt(Math::PI));
static const Vector4 y = Vector4(c0, -c1, c1, -c1);
Vector4 by = (*(Vector4*)b) * y;
float dd = Vector4(1, s.z, s.y, s.x).dotProduct( by );
return Math::maxVal( dd, 0.0f );
}
void IrrBake::_bakeVolProbe( int threadID, int voxelID )
{
_outputDebugStr( "IrrBake::_bakeVolProbe: vox-%d, tid-%d\n", voxelID, threadID );
// 当前光探
VolumeProbe* probe = m_currVolProbNode->getProbe();
// 当前线程预处理文件
LightMapPreBuildFile& preFile = *(m_preVolFile[threadID]);
// voxelID得到坐标
int x, y, z;
_voxelIDToXYZ( probe, voxelID, x, y, z );
// 光探世界位置
Vector3 centerPos = probe->getCenterWorldPos( x, y, z );
// 信息对象
LightMapPreBuildFile::TexelItem* texelItem = preFile.readNextTexelItem( x, y, z );
khaosAssert( texelItem );
// 计算这个光探的每个方向的irradiance
const float integScale = (4.0f * Math::PI) / m_sphVolMapper.getNumSamples();
vector<Vector3>::type irrs( m_sphVolMapper.getNumSamples() );
for ( int i = 0; i < m_sphVolMapper.getNumSamples(); ++i )
{
const HemiInfoList& hil = m_probeSampleInfos[i]; // 此方向的已经预计算的一些信息
Color totalVal(Color::BLACK);
// 遍历每个潜在样本
for ( int j = 0; j < m_sphVolMapper.getNumSamples(); ++j )
{
const HemiInfo& hi = hil[j];
if ( !hi.isFront ) // 获取一个该方向的正半球的样本
continue;
const LightMapPreBuildFile::RayInfo* rayInfo = texelItem->getRayInfo( j );
if ( !rayInfo ) // 与世界有交
continue;
Ray ray( centerPos, m_sphVolMapper.getSample(j).dir );
SceneBVH::Result result;
m_bakeSys.getSG()->getBVH()->intersectTriAlways( ray, rayInfo->globalFaceID, result ); // 必定和此三角形相交
const SBVHFaceInfo* faceInfo = m_bakeSys.getSG()->getBVH()->getFaceInfo( rayInfo->globalFaceID );
int subIdx = faceInfo->subIndex;
SceneNode* node = m_bakeSys.getSG()->getBVH()->getSceneNode( faceInfo->instanceID );
MeshNode* meshNode = static_cast<MeshNode*>(node);
SubMesh* subMesh = meshNode->getMesh()->getSubMesh(subIdx);
Material* mtrOther = meshNode->getSubEntity(subIdx)->getMaterial();
LitMapSet* lmsOther = _getLitMapSet(node); // 取它的图集
Vector2 uv1 = subMesh->getTriUV( faceInfo->faceIdx, result.gravity ); // 交点处的uv1
Vector2 uv2 = subMesh->getTriUV2( faceInfo->faceIdx, result.gravity ); // 交点处的uv2
// irr = (other emit + other diffuse) * NdotL
Color otherOutLight = lmsOther->initEmit->getColorByUV(uv2) + // other emit
lmsOther->indIrrNext->getColorByUV(uv2) * mtrOther->_readDiffuseColor( uv1 ); // other diffuse
totalVal += otherOutLight * hi.NdotL; // add this incoming light
}
totalVal *= integScale;
irrs[i].setValue( totalVal.ptr() );
}
// 投影到SH
float shClr[3][4];
SphereSamples theSS;
theSS.setSamples( &m_sphVolMapper );
theSS.projectSH( _projectProbeToSHStatic, &irrs, &shClr[0][0], 4, 3 );
VolumeMapSet* vms = _getVolMapSet( m_currVolProbNode );
vms->indIrrVolMapR->setColor( x, y, z, *(Color*)&shClr[0][0] );
vms->indIrrVolMapG->setColor( x, y, z, *(Color*)&shClr[1][0] );
vms->indIrrVolMapB->setColor( x, y, z, *(Color*)&shClr[2][0] );
// 测试
#if 0
for ( int i = 0; i < m_sphVolMapper.getNumSamples(); ++i )
{
const Vector3& oldVal = irrs[i];
const Vector3& norm = m_sphVolMapper.getSample(i).dir;
float newVal;
SHMath::reconstructFunction4( &shClr[0][0], 1, norm.x, norm.y, norm.z, &newVal );
if ( newVal < 0 ) newVal = 0;
float newVal2 = _reconstructSH4( &shClr[0][0], norm );
float pp = (newVal - oldVal.x) / oldVal.x * 100;
float pp2 = (newVal2 - oldVal.x) / oldVal.x * 100;
_outputDebugStr( "diff = (%f, %f)\n", pp, pp2 );
}
#endif
}
void IrrBake::_projectProbeToSHStatic( SphereSamples* theSS, const SphereSamples::Sample& smpl,
void* context, float* vals, int groupCnt )
{
vector<Vector3>::type& datas = *(vector<Vector3>::type*)context;
*(Vector3*)vals = datas[smpl.idx];
}
}
| [
"zengqh.mansion@gmail.com"
] | zengqh.mansion@gmail.com |
0d4c9f27884aaca1c9b913140dc13e36bb672522 | 69837f478d084143f698083ee80c8c1367f35eaf | /DelFEM/test_glut/scalar2d/main.cpp | 7f680ea86b5f565965cde4511d31a2b685e6642f | [] | no_license | jindili/GarmentStudio | e5a34c093f7ede00418a3510a7948a46ceab7e87 | 4f6bdcb8f96b82ff1e36d4d62b9491969231e80c | refs/heads/master | 2020-03-30T03:51:08.574106 | 2016-09-19T12:38:47 | 2016-09-19T12:38:47 | null | 0 | 0 | null | null | null | null | SHIFT_JIS | C++ | false | false | 16,409 | cpp |
#if defined(__VISUALC__)
#pragma warning( disable : 4786 )
#endif
#define for if(0);else for
#include <iostream>
#include <vector>
#include <string>
#include <assert.h>
#include <math.h>
#include <stdlib.h>
#include <cstdlib> //(exit)
#if defined(__APPLE__) && defined(__MACH__)
# include <GLUT/glut.h>
#else
# include <GL/glut.h>
#endif
#include "delfem/camera.h"
#include "delfem/drawer_gl_utility.h"
#include "delfem/glut_utility.h"
#include "delfem/cad_obj2d.h" // CCadObj2D
#include "delfem/mesher2d.h" // CMesher2D
#include "delfem/field.h" //
#include "delfem/field_world.h" //
#include "delfem/field_value_setter.h"
#include "delfem/drawer_field.h"
#include "delfem/drawer_field_face.h"
#include "delfem/drawer_field_edge.h"
#include "delfem/drawer_field_vector.h"
#include "delfem/eqnsys_scalar.h"
using namespace Fem::Field;
using namespace Fem::Ls;
Fem::Field::CFieldWorld world;
Fem::Eqn::CEqnSystem_Scalar2D eqn_scalar;
double dt = 0.001;
View::CDrawerArrayField drawer_ary;
std::vector<Fem::Field::CFieldValueSetter> field_value_setter_ary;
Com::View::CCamera camera;
double mov_begin_x, mov_begin_y;
unsigned int id_base;
bool SetNewProblem()
{
const unsigned int nprob = 20;
static unsigned int iprob = 0;
static int id_val_bc0=0, id_val_bc1=0, id_val_bc2=0;
if( iprob == 0 ) // ２次元問題の設定
{
world.Clear();
drawer_ary.Clear();
////////////////
Cad::CCadObj2D cad_2d;
{ // 形を作る
std::vector<Com::CVector2D> vec_ary;
vec_ary.push_back( Com::CVector2D(0.0,0.0) );
vec_ary.push_back( Com::CVector2D(1.0,0.0) );
vec_ary.push_back( Com::CVector2D(1.0,1.0) );
vec_ary.push_back( Com::CVector2D(0.0,1.0) );
const unsigned int id_l = cad_2d.AddPolygon( vec_ary ).id_l_add;
const unsigned int id_v1 = cad_2d.AddVertex(Cad::LOOP,id_l,Com::CVector2D(0.7,0.5)).id_v_add;
const unsigned int id_v2 = cad_2d.AddVertex(Cad::LOOP,id_l,Com::CVector2D(0.7,0.9)).id_v_add;
const unsigned int id_v3 = cad_2d.AddVertex(Cad::LOOP,id_l,Com::CVector2D(0.8,0.9)).id_v_add;
const unsigned int id_v4 = cad_2d.AddVertex(Cad::LOOP,id_l,Com::CVector2D(0.8,0.5)).id_v_add;
cad_2d.ConnectVertex_Line(id_v1,id_v2);
cad_2d.ConnectVertex_Line(id_v2,id_v3);
cad_2d.ConnectVertex_Line(id_v3,id_v4);
cad_2d.ConnectVertex_Line(id_v4,id_v1);
}
// メッシュを作る
id_base = world.AddMesh( Msh::CMesher2D(cad_2d,0.02) );
Fem::Field::CIDConvEAMshCad conv = world.GetIDConverter(id_base);
eqn_scalar.SetDomain_Field(id_base,world); // 方程式の設定
dt = 0.02;
eqn_scalar.SetTimeIntegrationParameter(dt);
eqn_scalar.SetSaveStiffMat(false);
eqn_scalar.SetStationary(false);
eqn_scalar.SetAxialSymmetry(false);
// 全体の方程式の係数設定
eqn_scalar.SetAlpha(1.0);
eqn_scalar.SetCapacity(30.0);
eqn_scalar.SetAdvection(0);
id_val_bc0 = eqn_scalar.AddFixElemAry(conv.GetIdEA_fromCad(2,Cad::LOOP),world);
id_val_bc1 = eqn_scalar.AddFixElemAry(conv.GetIdEA_fromCad(1,Cad::EDGE),world);
id_val_bc2 = eqn_scalar.AddFixElemAry(conv.GetIdEA_fromCad(3,Cad::EDGE),world);
field_value_setter_ary.clear();
{
Fem::Field::CFieldValueSetter fvs(id_val_bc0,world);
fvs.SetMathExp("floor(1+0.8*cos(2*PI*t+0.1))",0,Fem::Field::VALUE,world);
field_value_setter_ary.push_back(fvs);
}
Fem::Field::SetFieldValue_Constant(id_val_bc1,0,Fem::Field::VALUE,world,+1.0);
Fem::Field::SetFieldValue_Constant(id_val_bc2,0,Fem::Field::VALUE,world,-1.0);
// 描画オブジェクトの登録
const unsigned int id_field_val = eqn_scalar.GetIdField_Value();
drawer_ary.PushBack( new View::CDrawerFace(id_field_val,true,world,id_field_val,-1,1) );
// drawer_ary.PushBack( new View::CDrawerFaceContour(id_field_val,world) );
drawer_ary.PushBack( new View::CDrawerEdge(id_field_val,true,world) );
drawer_ary.InitTrans(camera); // 視線座標変換行列の初期化
}
else if( iprob == 1 ){
eqn_scalar.SetCapacity(10);
}
else if( iprob == 2 ){
eqn_scalar.SetCapacity(5);
}
else if( iprob == 3 ){
eqn_scalar.SetCapacity(1);
}
else if( iprob == 4 ){
eqn_scalar.SetStationary(true);
}
else if( iprob == 5 ){
eqn_scalar.SetSaveStiffMat(true);
}
else if( iprob == 6 ){
eqn_scalar.SetStationary(false);
eqn_scalar.SetCapacity(10);
dt = 0.02;
eqn_scalar.SetTimeIntegrationParameter(dt);
}
else if( iprob == 7 ){
const unsigned int id_field_velo = world.MakeField_FieldElemDim(id_base,2,Fem::Field::VECTOR2,VELOCITY);
std::cout << "Velo : " << id_field_velo << std::endl;
Fem::Field::SetFieldValue_MathExp(id_field_velo,0,Fem::Field::VELOCITY,world," (y-0.5)",0);
Fem::Field::SetFieldValue_MathExp(id_field_velo,1,Fem::Field::VELOCITY,world,"-(x-0.5)",0);
field_value_setter_ary.clear();
{ // 固定境界条件の設定
Fem::Field::CFieldValueSetter fvs(id_val_bc0,world);
fvs.SetMathExp("floor(1+0.8*cos(3*t))",0,Fem::Field::VALUE,world);
field_value_setter_ary.push_back(fvs);
}
{ // 周囲の固定境界条件の設定
const CIDConvEAMshCad conv = world.GetIDConverter(id_base);
std::vector<unsigned int> m_aIDEA;
m_aIDEA.push_back(conv.GetIdEA_fromCad(1,Cad::EDGE));
m_aIDEA.push_back(conv.GetIdEA_fromCad(2,Cad::EDGE));
m_aIDEA.push_back(conv.GetIdEA_fromCad(3,Cad::EDGE));
m_aIDEA.push_back(conv.GetIdEA_fromCad(4,Cad::EDGE));
id_val_bc1 = eqn_scalar.AddFixElemAry(m_aIDEA,world);
}
Fem::Field::SetFieldValue_Constant(id_val_bc1,0,Fem::Field::VALUE,world,-1.0);
eqn_scalar.SetSaveStiffMat(false);
eqn_scalar.SetStationary(false);
eqn_scalar.SetAxialSymmetry(false);
eqn_scalar.SetTimeIntegrationParameter(dt);
// 方程式の係数の設定
eqn_scalar.SetAlpha(0.00001);
eqn_scalar.SetCapacity(1.0);
eqn_scalar.SetAdvection(id_field_velo);
}
else if( iprob == 8 ){
eqn_scalar.SetSaveStiffMat(true);
}
else if( iprob == 9 ){
eqn_scalar.SetStationary(true);
}
else if( iprob == 10 ){
eqn_scalar.SetSaveStiffMat(false);
}
else if( iprob == 11 )
{
////////////////
Cad::CCadObj2D cad_2d;
{ // 形を作る
{
std::vector<Com::CVector2D> vec_ary;
vec_ary.push_back( Com::CVector2D(0.0,0.0) );
vec_ary.push_back( Com::CVector2D(1.0,0.0) );
vec_ary.push_back( Com::CVector2D(1.0,1.0) );
vec_ary.push_back( Com::CVector2D(0.0,1.0) );
cad_2d.AddPolygon( vec_ary );
}
const unsigned int id_v1 = cad_2d.AddVertex(Cad::EDGE,1,Com::CVector2D(0.5,0.0)).id_v_add;
const unsigned int id_v2 = cad_2d.AddVertex(Cad::EDGE,3,Com::CVector2D(0.5,1.0)).id_v_add;
cad_2d.ConnectVertex_Line(id_v1,id_v2);
}
// メッシュを作る
world.Clear();
id_base = world.AddMesh( Msh::CMesher2D(cad_2d,0.05) ); // メッシュで表される場のハンドルを得る
const CIDConvEAMshCad& conv = world.GetIDConverter(id_base);
eqn_scalar.SetDomain_FieldElemAry(id_base,conv.GetIdEA_fromCad(2,Cad::LOOP),world);
eqn_scalar.SetSaveStiffMat(false);
eqn_scalar.SetStationary(true);
eqn_scalar.SetTimeIntegrationParameter(dt);
// 方程式の設定
dt = 0.02;
eqn_scalar.SetTimeIntegrationParameter(dt);
eqn_scalar.SetAlpha(1.0);
eqn_scalar.SetCapacity(30.0);
eqn_scalar.SetAdvection(false);
// 境界条件の設定
id_val_bc0 = eqn_scalar.AddFixElemAry(conv.GetIdEA_fromCad(2,Cad::EDGE),world);
field_value_setter_ary.clear();
{
Fem::Field::CFieldValueSetter fvs(id_val_bc0,world);
fvs.SetMathExp("cos(2*PI*t+0.1)",0,Fem::Field::VALUE,world);
field_value_setter_ary.push_back(fvs);
}
id_val_bc1 = eqn_scalar.AddFixElemAry(conv.GetIdEA_fromCad(3,Cad::EDGE),world);
Fem::Field::SetFieldValue_Constant(id_val_bc1,0,Fem::Field::VALUE,world,+1.0);
// 描画オブジェクトの登録
drawer_ary.Clear();
const unsigned int id_field_val = eqn_scalar.GetIdField_Value();
drawer_ary.PushBack( new View::CDrawerFace(id_field_val,true,world,id_field_val,-1.0,1.0) );
drawer_ary.PushBack( new View::CDrawerEdge(id_base,true,world) );
drawer_ary.InitTrans(camera);
}
else if( iprob == 12 ){
eqn_scalar.SetSaveStiffMat(true);
}
else if( iprob == 13 ){
eqn_scalar.SetSaveStiffMat(false);
eqn_scalar.SetStationary(false);
}
else if( iprob == 14 ){
eqn_scalar.SetSaveStiffMat(true);
}
else if( iprob == 15 ){
Cad::CCadObj2D cad_2d;
{ // 正方形に矩形の穴
std::vector<Com::CVector2D> vec_ary;
vec_ary.push_back( Com::CVector2D(0.0,0.0) );
vec_ary.push_back( Com::CVector2D(1.0,0.0) );
vec_ary.push_back( Com::CVector2D(1.0,1.0) );
vec_ary.push_back( Com::CVector2D(0.0,1.0) );
const unsigned int id_l = cad_2d.AddPolygon( vec_ary ).id_l_add;
const unsigned int id_v1 = cad_2d.AddVertex(Cad::LOOP,id_l,Com::CVector2D(0.3,0.2)).id_v_add;
const unsigned int id_v2 = cad_2d.AddVertex(Cad::LOOP,id_l,Com::CVector2D(0.7,0.2)).id_v_add;
const unsigned int id_v3 = cad_2d.AddVertex(Cad::LOOP,id_l,Com::CVector2D(0.7,0.8)).id_v_add;
const unsigned int id_v4 = cad_2d.AddVertex(Cad::LOOP,id_l,Com::CVector2D(0.3,0.8)).id_v_add;
cad_2d.ConnectVertex_Line(id_v1,id_v2);
cad_2d.ConnectVertex_Line(id_v2,id_v3);
cad_2d.ConnectVertex_Line(id_v3,id_v4);
cad_2d.ConnectVertex_Line(id_v4,id_v1);
}
world.Clear();
id_base = world.AddMesh( Msh::CMesher2D(cad_2d,0.02) );
const CIDConvEAMshCad conv = world.GetIDConverter(id_base);
eqn_scalar.SetDomain_Field(id_base,world);
eqn_scalar.SetStationary(true);
eqn_scalar.SetTimeIntegrationParameter(dt);
// 方程式の設定
eqn_scalar.SetAlpha(1.0);
eqn_scalar.SetCapacity(30.0);
eqn_scalar.SetAdvection(false);
eqn_scalar.SetSaveStiffMat(false);
{
Fem::Eqn::CEqn_Scalar2D eqn1 = eqn_scalar.GetEquation(conv.GetIdEA_fromCad(2,Cad::LOOP));
eqn1.SetAlpha(10.0);
eqn_scalar.SetEquation(eqn1);
}
id_val_bc0 = eqn_scalar.AddFixElemAry(conv.GetIdEA_fromCad(3,Cad::EDGE),world);
field_value_setter_ary.clear();
{
Fem::Field::CFieldValueSetter fvs(id_val_bc0,world);
fvs.SetMathExp("cos(2*PI*t+0.1)",0,Fem::Field::VALUE,world);
field_value_setter_ary.push_back(fvs);
}
id_val_bc1 = eqn_scalar.AddFixElemAry(conv.GetIdEA_fromCad(6,Cad::EDGE),world);
Fem::Field::SetFieldValue_Constant(id_val_bc1,0,Fem::Field::VALUE,world,+1.0);
// 描画オブジェクトの登録
drawer_ary.Clear();
const unsigned int id_field_val = eqn_scalar.GetIdField_Value();
drawer_ary.PushBack( new View::CDrawerFace(id_field_val,true,world,id_field_val,-1.0,1.0) );
drawer_ary.PushBack( new View::CDrawerEdge(id_field_val,true,world) );
drawer_ary.InitTrans(camera);
}
else if( iprob == 16 ){
eqn_scalar.SetSaveStiffMat(true);
}
else if( iprob == 17 ){
eqn_scalar.SetSaveStiffMat(false);
eqn_scalar.SetStationary(false);
}
else if( iprob == 18 ){
eqn_scalar.SetSaveStiffMat(true);
}
else if( iprob == 19 ){
Cad::CCadObj2D cad_2d;
{
std::vector<Com::CVector2D> vec_ary;
vec_ary.push_back( Com::CVector2D(0.0,0.0) );
vec_ary.push_back( Com::CVector2D(1.0,0.0) );
vec_ary.push_back( Com::CVector2D(1.0,0.1) );
vec_ary.push_back( Com::CVector2D(0.0,0.1) );
cad_2d.AddPolygon(vec_ary);
}
world.Clear();
id_base = world.AddMesh( Msh::CMesher2D(cad_2d,0.05) );
const CIDConvEAMshCad& conv = world.GetIDConverter(id_base);
eqn_scalar.SetDomain_Field(id_base,world);
eqn_scalar.SetStationary(false);
eqn_scalar.SetSaveStiffMat(false);
dt = 1;
eqn_scalar.SetTimeIntegrationParameter(dt,0.5);
eqn_scalar.SetAxialSymmetry(true);
// 全体の方程式の係数設定
eqn_scalar.SetAlpha(48.0);
eqn_scalar.SetCapacity(480*7.86*1000);
eqn_scalar.SetAdvection(0);
eqn_scalar.SetSource(0);
const unsigned int id_field_val = eqn_scalar.GetIdField_Value();
Fem::Field::SetFieldValue_Constant(id_field_val,0,Fem::Field::VALUE,world,500.0);
id_val_bc1 = eqn_scalar.AddFixElemAry(conv.GetIdEA_fromCad(2,Cad::EDGE),world);
Fem::Field::SetFieldValue_Constant(id_val_bc1,0,Fem::Field::VALUE,world,+0.0);
// 描画オブジェクトの登録
drawer_ary.Clear();
drawer_ary.PushBack( new View::CDrawerFace(id_field_val,true,world,id_field_val,0,500) );
drawer_ary.PushBack( new View::CDrawerEdge(id_field_val,true,world) );
drawer_ary.InitTrans(camera); // 視線座標変換行列の初期化
}
iprob++;
if( iprob == nprob ) iprob=0;
return true;
}
////////////////////////////////////////////////////////////////
double cur_time = 0.0;
bool is_animation = true;
// リサイズ時のコールバック関数
void myGlutResize(int w, int h)
{
camera.SetWindowAspect((double)w/h);
::glViewport(0, 0, w, h);
::glMatrixMode(GL_PROJECTION);
::glLoadIdentity();
Com::View::SetProjectionTransform(camera);
::glutPostRedisplay();
}
// 描画時のコールバック関数
void myGlutDisplay(void)
{
// ::glClearColor(0.2, 0.7, 0.7 ,1.0);
::glClearColor(1.0, 1.0, 1.0 ,1.0);
::glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
::glEnable(GL_DEPTH_TEST);
::glEnable(GL_POLYGON_OFFSET_FILL );
::glPolygonOffset( 1.1f, 4.0f );
::glMatrixMode(GL_MODELVIEW);
::glLoadIdentity();
Com::View::SetModelViewTransform(camera);
if( is_animation ){
cur_time += dt;
for(unsigned int iset=0;iset<field_value_setter_ary.size();iset++){
field_value_setter_ary[iset].ExecuteValue(cur_time,world);
}
eqn_scalar.Solve(world);
if( eqn_scalar.GetAry_ItrNormRes().size() > 0 ){
std::cout << "Iter : " << eqn_scalar.GetAry_ItrNormRes()[0].first << " ";
std::cout << "Res : " << eqn_scalar.GetAry_ItrNormRes()[0].second << std::endl;
}
drawer_ary.Update(world);
}
ShowFPS();
drawer_ary.Draw();
glutSwapBuffers();
}
void myGlutMotion( int x, int y ){
GLint viewport[4];
::glGetIntegerv(GL_VIEWPORT,viewport);
const int win_w = viewport[2];
const int win_h = viewport[3];
const double mov_end_x = (2.0*x-win_w)/win_w;
const double mov_end_y = (win_h-2.0*y)/win_h;
camera.MouseRotation(mov_begin_x,mov_begin_y,mov_end_x,mov_end_y);
mov_begin_x = mov_end_x;
mov_begin_y = mov_end_y;
::glutPostRedisplay();
}
void myGlutMouse(int button, int state, int x, int y){
GLint viewport[4];
::glGetIntegerv(GL_VIEWPORT,viewport);
const int win_w = viewport[2];
const int win_h = viewport[3];
mov_begin_x = (2.0*x-win_w)/win_w;
mov_begin_y = (win_h-2.0*y)/win_h;
}
void myGlutKeyboard(unsigned char Key, int x, int y)
{
switch(Key)
{
case 'q':
case 'Q':
case '\033':
exit(0); /* '\033' ? ESC ? ASCII ??? */
case 'a':
if( is_animation ){ is_animation = false; }
else{ is_animation = true; }
break;
case ' ':
SetNewProblem();
break;
}
::glutPostRedisplay();
}
void myGlutSpecial(int Key, int x, int y)
{
switch(Key)
{
case GLUT_KEY_PAGE_UP:
if( ::glutGetModifiers() && GLUT_ACTIVE_SHIFT ){
if( camera.IsPers() ){
const double tmp_fov_y = camera.GetFovY() + 10.0;
camera.SetFovY( tmp_fov_y );
}
}
else{
const double tmp_scale = camera.GetScale() * 0.9;
camera.SetScale( tmp_scale );
}
break;
case GLUT_KEY_PAGE_DOWN:
if( ::glutGetModifiers() && GLUT_ACTIVE_SHIFT ){
if( camera.IsPers() ){
const double tmp_fov_y = camera.GetFovY() - 10.0;
camera.SetFovY( tmp_fov_y );
}
}
else{
const double tmp_scale = camera.GetScale() * 1.111;
camera.SetScale( tmp_scale );
}
break;
case GLUT_KEY_HOME :
camera.Fit();
break;
case GLUT_KEY_END :
if( camera.IsPers() ) camera.SetIsPers(false);
else{ camera.SetIsPers(true); }
break;
default:
break;
}
::glMatrixMode(GL_MODELVIEW);
::glLoadIdentity();
Com::View::SetProjectionTransform(camera);
::glutPostRedisplay();
}
void myGlutIdle(){
::glutPostRedisplay();
}
////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
int main(int argc,char* argv[])
{
// glutの初期設定
glutInitWindowPosition(200,200);
glutInitWindowSize(400, 300);
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGBA|GLUT_DEPTH);
glutCreateWindow("DelFEM demo");
// コールバック関数の設定
glutDisplayFunc(myGlutDisplay);
glutReshapeFunc(myGlutResize);
glutMotionFunc(myGlutMotion);
glutMouseFunc(myGlutMouse);
glutKeyboardFunc(myGlutKeyboard);
glutSpecialFunc(myGlutSpecial);
glutIdleFunc(myGlutIdle);
// 問題設定
SetNewProblem();
// メインループ
glutMainLoop();
return 0;
}
| [
"Jeffritz Kidd"
] | Jeffritz Kidd |
85479e4d6e9ff83ba114aeb960358341daf61542 | ede874b59555fd65ab2aa44f17a71a5a748eafa6 | /include/etl/checks.hpp | 8c412f39608d9b3a9c75cdb605ac81bd63629419 | [
"MIT",
"LicenseRef-scancode-unknown-license-reference"
] | permissive | bechirzf/etl-2 | aad392dc07f42dd772914931ed192829d2d64a74 | 32e8153b38e0029176ca4fe2395b7fa6babe3189 | refs/heads/master | 2020-06-11T10:52:16.362349 | 2018-05-07T08:41:17 | 2018-05-07T08:41:17 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 12,180 | hpp | //=======================================================================
// Copyright (c) 2014-2018 Baptiste Wicht
// Distributed under the terms of the MIT License.
// (See accompanying file LICENSE or copy at
// http://opensource.org/licenses/MIT)
//=======================================================================
/*!
* \file
* \brief Contains utility checks
*
* The functions are using assertions to validate their conditions. When
* possible, static assertions are used.
*/
#pragma once
namespace etl {
/*!
* \brief Make sure the two expressions have the same size
*
* This function uses assertion to validate the condition. If possible, the
* assertion is done at compile time.
*
* \param lhs The left hand side expression
* \param rhs The right hand side expression
*/
template <typename LE, typename RE, cpp_enable_iff(etl_traits<LE>::is_generator || etl_traits<RE>::is_generator)>
void validate_expression_impl(const LE& lhs, const RE& rhs) noexcept {
//Nothing to test, generators are of infinite size
cpp_unused(lhs);
cpp_unused(rhs);
}
/*!
* \brief Make sure the two expressions have the same size
*
* This function uses assertion to validate the condition. If possible, the
* assertion is done at compile time.
*
* \param lhs The left hand side expression
* \param rhs The right hand side expression
*/
template <typename LE,
typename RE,
cpp_enable_iff(!(etl_traits<LE>::is_generator || etl_traits<RE>::is_generator) && all_etl_expr<LE, RE> && !all_fast<LE, RE>)>
void validate_expression_impl(const LE& lhs, const RE& rhs) {
cpp_assert(etl::size(lhs) == etl::size(rhs), "Cannot perform element-wise operations on collections of different size");
cpp_unused(lhs);
cpp_unused(rhs);
}
/*!
* \brief Make sure the two expressions have the same size
*
* This function uses assertion to validate the condition. If possible, the
* assertion is done at compile time.
*
* \param lhs The left hand side expression
* \param rhs The right hand side expression
*/
template <typename LE, typename RE, cpp_enable_iff(!(etl_traits<LE>::is_generator || etl_traits<RE>::is_generator) && all_etl_expr<LE, RE> && all_fast<LE, RE>)>
void validate_expression_impl(const LE& lhs, const RE& rhs) {
static_assert(etl_traits<LE>::size() == etl_traits<RE>::size(), "Cannot perform element-wise operations on collections of different size");
cpp_unused(lhs);
cpp_unused(rhs);
}
#define validate_expression(lhs, rhs) \
static_assert(all_etl_expr<decltype(lhs), decltype(rhs)>, "ETL functions are only made for ETL expressions "); \
validate_expression_impl(lhs, rhs);
/*!
* \brief Make sure that rhs can assigned to lhs.
*
* This function uses assertion to validate the condition. If possible, the
* assertion is done at compile time.
*
* \param lhs The left hand side expression
* \param rhs The right hand side expression
*/
template <typename LE, typename RE, cpp_enable_iff(etl_traits<RE>::is_generator)>
void validate_assign(const LE& lhs, const RE& rhs) noexcept {
static_assert(is_etl_expr<LE>, "Assign can only work on ETL expressions");
//Nothing to test, generators are of infinite size
cpp_unused(lhs);
cpp_unused(rhs);
}
/*!
* \brief Make sure that rhs can assigned to lhs.
*
* This function uses assertion to validate the condition. If possible, the
* assertion is done at compile time.
*
* \param lhs The left hand side expression
* \param rhs The right hand side expression
*/
template <typename LE, typename RE, cpp_enable_iff(!etl_traits<RE>::is_generator && is_etl_expr<RE> && !all_fast<LE, RE> && !is_wrapper_expr<RE>)>
void validate_assign(const LE& lhs, const RE& rhs) {
static_assert(is_etl_expr<LE>, "Assign can only work on ETL expressions");
cpp_assert(etl::size(lhs) == etl::size(rhs), "Cannot perform element-wise operations on collections of different size");
cpp_unused(lhs);
cpp_unused(rhs);
}
/*!
* \brief Make sure that rhs can assigned to lhs.
*
* This function uses assertion to validate the condition. If possible, the
* assertion is done at compile time.
*
* \param lhs The left hand side expression
* \param rhs The right hand side expression
*/
template <typename LE, typename RE, cpp_enable_iff(!etl_traits<RE>::is_generator && is_etl_expr<RE> && all_fast<LE, RE> && !is_wrapper_expr<RE>)>
void validate_assign(const LE& lhs, const RE& rhs) {
static_assert(is_etl_expr<LE>, "Assign can only work on ETL expressions");
static_assert(etl_traits<LE>::size() == etl_traits<RE>::size(), "Cannot perform element-wise operations on collections of different size");
cpp_unused(lhs);
cpp_unused(rhs);
}
/*!
* \brief Make sure that rhs can assigned to lhs.
*
* This function uses assertion to validate the condition. If possible, the
* assertion is done at compile time.
*
* \param lhs The left hand side expression
* \param rhs The right hand side expression
*/
template <typename LE, typename RE, cpp_enable_iff(!is_etl_expr<RE> && !is_wrapper_expr<RE>)>
void validate_assign(const LE& lhs, const RE& rhs) {
static_assert(is_etl_expr<LE>, "Assign can only work on ETL expressions");
cpp_assert(etl::size(lhs) == rhs.size(), "Cannot perform element-wise operations on collections of different size");
cpp_unused(lhs);
cpp_unused(rhs);
}
/*!
* \brief Make sure that rhs can assigned to lhs.
*
* This function uses assertion to validate the condition. If possible, the
* assertion is done at compile time.
*
* \param lhs The left hand side expression
* \param rhs The right hand side expression
*/
template <typename LE, typename RE, cpp_enable_iff(is_wrapper_expr<RE>)>
void validate_assign(const LE& lhs, const RE& rhs) {
static_assert(is_etl_expr<LE>, "Assign can only work on ETL expressions");
cpp_assert(etl::size(lhs) == etl::size(rhs), "Cannot perform element-wise operations on collections of different size");
cpp_unused(lhs);
cpp_unused(rhs);
}
/*!
* \brief Make sure that the expression is square
*
* This function uses assertion to validate the condition. If possible, the
* assertion is done at compile time.
*
* \param expr The expression to assert
*/
template <typename E>
void assert_square([[maybe_unused]] E&& expr) {
static_assert(is_2d<E>, "Function undefined for non-square matrix");
if constexpr (is_fast<E>) {
static_assert(decay_traits<E>::template dim<0>() == decay_traits<E>::template dim<1>(), "Function undefined for non-square matrix");
} else {
cpp_assert(etl::dim<0>(expr) == etl::dim<1>(expr), "Function undefined for non-square matrix");
}
}
namespace detail {
/*!
* \brief Make sure that the pooling ratios are correct and that the expression can be pooled from.
*
* This function uses assertion to validate the condition. If possible, the
* assertion is done at compile time.
*
* \tparam C1 The pooling ratio of the first dimension
* \tparam C2 The pooling ratio of the second dimension
* \param e The expression to assert
*/
template <size_t C1, size_t C2, typename E, cpp_enable_iff(is_2d<E> && !etl_traits<E>::is_fast)>
void validate_pmax_pooling_impl(const E& e) {
cpp_assert(etl::template dim<0>(e) % C1 == 0 && etl::template dim<1>(e) % C2 == 0, "Dimensions not divisible by the pooling ratio");
cpp_unused(e);
}
/*!
* \copydoc validate_pmax_pooling_impl
*/
template <size_t C1, size_t C2, typename E, cpp_enable_iff(is_3d<E> && !etl_traits<E>::is_fast)>
void validate_pmax_pooling_impl(const E& e) {
cpp_assert(etl::template dim<1>(e) % C1 == 0 && etl::template dim<2>(e) % C2 == 0, "Dimensions not divisible by the pooling ratio");
cpp_unused(e);
}
/*!
* \copydoc validate_pmax_pooling_impl
*/
template <size_t C1, size_t C2, typename E, cpp_enable_iff(is_4d<E> && !etl_traits<E>::is_fast)>
void validate_pmax_pooling_impl(const E& e) {
cpp_assert(etl::template dim<2>(e) % C1 == 0 && etl::template dim<3>(e) % C2 == 0, "Dimensions not divisible by the pooling ratio");
cpp_unused(e);
}
/*!
* \copydoc validate_pmax_pooling_impl
*/
template <size_t C1, size_t C2, typename E, cpp_enable_iff(is_2d<E>&& etl_traits<E>::is_fast)>
void validate_pmax_pooling_impl(const E& /*unused*/) {
static_assert(etl_traits<E>::template dim<0>() % C1 == 0 && etl_traits<E>::template dim<1>() % C2 == 0, "Dimensions not divisible by the pooling ratio");
}
/*!
* \copydoc validate_pmax_pooling_impl
*/
template <size_t C1, size_t C2, typename E, cpp_enable_iff(is_3d<E>&& etl_traits<E>::is_fast)>
void validate_pmax_pooling_impl(const E& /*unused*/) {
static_assert(etl_traits<E>::template dim<1>() % C1 == 0 && etl_traits<E>::template dim<2>() % C2 == 0, "Dimensions not divisible by the pooling ratio");
}
/*!
* \copydoc validate_pmax_pooling_impl
*/
template <size_t C1, size_t C2, typename E, cpp_enable_iff(is_4d<E>&& etl_traits<E>::is_fast)>
void validate_pmax_pooling_impl(const E& /*unused*/) {
static_assert(etl_traits<E>::template dim<2>() % C1 == 0 && etl_traits<E>::template dim<3>() % C2 == 0, "Dimensions not divisible by the pooling ratio");
}
/*!
* \brief Make sure that the pooling ratios are correct and that the expression can be pooled from.
*
* This function uses assertion to validate the condition. If possible, the
* assertion is done at compile time.
*
* \param c1 The pooling ratio of the first dimension
* \param c2 The pooling ratio of the second dimension
* \param e The expression to assert
*/
template <typename E, cpp_enable_iff(is_2d<E>)>
void validate_pmax_pooling_impl(const E& e, size_t c1, size_t c2) {
cpp_assert(etl::template dim<0>(e) % c1 == 0 && etl::template dim<1>(e) % c2 == 0, "Dimensions not divisible by the pooling ratio");
cpp_unused(e);
cpp_unused(c1);
cpp_unused(c2);
}
/*!
* \copydoc validate_pmax_pooling_impl
*/
template <typename E, cpp_enable_iff(is_3d<E>)>
void validate_pmax_pooling_impl(const E& e, size_t c1, size_t c2) {
cpp_assert(etl::template dim<1>(e) % c1 == 0 && etl::template dim<2>(e) % c2 == 0, "Dimensions not divisible by the pooling ratio");
cpp_unused(e);
cpp_unused(c1);
cpp_unused(c2);
}
/*!
* \copydoc validate_pmax_pooling_impl
*/
template <typename E, cpp_enable_iff(is_4d<E>)>
void validate_pmax_pooling_impl(const E& e, size_t c1, size_t c2) {
cpp_assert(etl::template dim<2>(e) % c1 == 0 && etl::template dim<3>(e) % c2 == 0, "Dimensions not divisible by the pooling ratio");
cpp_unused(e);
cpp_unused(c1);
cpp_unused(c2);
}
} //end of namespace detail
/*!
* \brief Make sure that the pooling ratios are correct and that the expression can be pooled from.
*
* This function uses assertion to validate the condition. If possible, the
* assertion is done at compile time.
*
* \tparam C1 The pooling ratio of the first dimension
* \tparam C2 The pooling ratio of the second dimension
* \param expr The expression to assert
*/
template <size_t C1, size_t C2, typename E>
void validate_pmax_pooling(const E& expr) {
static_assert(is_etl_expr<E>, "Prob. Max Pooling only defined for ETL expressions");
static_assert(etl_traits<E>::dimensions() >= 2 && etl_traits<E>::dimensions() <= 4, "Prob. Max Pooling only defined for 2D and 3D");
detail::validate_pmax_pooling_impl<C1, C2>(expr);
}
/*!
* \brief Make sure that the pooling ratios are correct and that the expression can be pooled from.
*
* This function uses assertion to validate the condition. If possible, the
* assertion is done at compile time.
*
* \param c1 The pooling ratio of the first dimension
* \param c2 The pooling ratio of the second dimension
* \param expr The expression to assert
*/
template <typename E>
void validate_pmax_pooling(const E& expr, size_t c1, size_t c2) {
static_assert(is_etl_expr<E>, "Prob. Max Pooling only defined for ETL expressions");
static_assert(etl_traits<E>::dimensions() >= 2 && etl_traits<E>::dimensions() <= 4, "Prob. Max Pooling only defined for 2D and 3D");
detail::validate_pmax_pooling_impl(expr, c1, c2);
}
} //end of namespace etl
| [
"baptiste.wicht@gmail.com"
] | baptiste.wicht@gmail.com |
de152d3923a9ac2de828f60459da82da02210c7b | 5fd70e0c064d5aae9f8e7e69a1e6c1346ca68a10 | /aggregate_unorderedmap_mult/affinitizer.cpp | 6488fe4077656b9faf3e7f10ce6da21b03d68478 | [] | no_license | zubeyr94/CPU_Aggregation | 4d01f53e8439b5fc04b76eb3d43dcd5a0f21996f | 790ecc27a95c184b7fbac227b14e8ccd31559308 | refs/heads/master | 2021-06-25T17:24:34.670465 | 2021-04-21T17:55:23 | 2021-04-21T17:55:23 | 221,391,881 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,069 | cpp | /*
Copyright 2011, Spyros Blanas.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "affinitizer.h"
#include "exceptions.h"
#include <iostream>
using namespace std;
#ifdef __linux__
#include <sched.h>
#include <sys/syscall.h>
#include <unistd.h>
#elif solaris
#endif
/**
* Caller is affinitized to particular CPU.
*/
void Affinitizer::affinitize(int threadid)
{
// If oversubscribing, let OS figure it out.
//
if (totalthreads > totalcpus) {
return;
}
// The code below has been hard-coded to use one out of the two CPUs in
// our two-socket, six-core Intel X5650 system. Change the function that
// maps threadid to the cpu_set_t mask to reflect your system.
//
// throw AffinitizationException();
#ifdef __linux__
// It seams that for a N-core machine, 0..N cores are first, followed by
// N+1...2*N SMT cores. NUMA nodes seem to be interleaved, aka core 0 is on
// NUMA 0, core 1 is on NUMA 1, core 2 on NUMA 0, etc.
//
int offset;
const int numanodes = 2;
const int threadspernode = 20;
// Start on NUMA 0, then NUMA 1, then SMT on NUMA 0, then SMT NUMA 1.
//
offset = (threadid) % (numanodes * threadspernode);
// Affinitize this thread at CPU \a offset.
//
cpu_set_t mask;
CPU_ZERO(&mask);
CPU_SET(offset, &mask);
int tid = syscall(SYS_gettid);
if (sched_setaffinity(tid, sizeof(cpu_set_t), &mask) == -1) {
throw AffinitizationException();
}
#else
#warning Affinitization not implemented yet!
#endif
}
| [
"zubeyreryilmaz@gmail.com"
] | zubeyreryilmaz@gmail.com |
01a1becef7e620fa7f1a9c85605586b6a16b2373 | 54d3e4cce20d31b45f34becefb6f577d897bb01f | /tests/unit/verilog/ieee1364_2001/actions/module.cpp | 47a027a4e8dbf1a5fc25ad3fd52db25b4923d355 | [] | no_license | cloudcalvin/vcd_assert | 78f5bc2987e94cd91ab1e9432216865431fed8a8 | 435d9c6c4ea5957439ea1742f09369262bcc85fb | refs/heads/master | 2020-03-24T23:17:43.146201 | 2018-08-01T08:25:34 | 2018-08-01T08:25:34 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,392 | cpp | #include "../design.hpp"
#include "verilog/ieee1364_2001/grammar/commands.hpp"
#include "verilog/ieee1364_2001/grammar/grammar_hacked.hpp"
#include "verilog/ieee1364_2001/actions/commands.hpp"
#include "verilog/ieee1364_2001/actions/grammar.hpp"
#include "verilog/ieee1364_2001/actions/module.hpp"
#include "verilog/types/commands.hpp"
#include "verilog/util/parse_input.hpp"
#include "parse/actions/control.hpp"
#include "parse/actions/make_pegtl_template.hpp"
#include "parse/test/match.hpp"
#include "parse/test/parse.hpp"
#include "parse/util/static_string.hpp"
#include <tao/pegtl/file_input.hpp>
#include <tao/pegtl/memory_input.hpp>
#include <tao/pegtl/parse.hpp>
#include <catch2/catch.hpp>
#include <range/v3/view/zip.hpp>
#include <string>
#include <string_view>
using namespace Verilog;
using namespace Verilog::IEEE1364_2001;
using namespace Verilog::Test::Verilog::IEEE1364_2001;
namespace __Grammar = Verilog::IEEE1364_2001::Grammar;
TEST_CASE("Verilog.Actions.Module", "[Verilog][Events][Module]")
{
using Parse::Test::require_parse;
SECTION("sdf annotation action")
{
Command test_command{};
auto wanted = sdf_annotation_command;
require_parse<__Grammar::sdf_annotate_task, Actions::SDFAnnotateTaskAction>(
sdf_annotate_example, test_command);
auto test = std::get<SDFAnnotateCommand>(test_command);
REQUIRE(wanted.sdf_file == test.sdf_file);
REQUIRE(wanted.name_of_instance == test.name_of_instance);
}
SECTION("sdf annotation from initial_block action")
{
std::vector<Command> test_commands{};
auto wanted = sdf_annotation_command;
CAPTURE(initial_block_with_sdf_example_1);
require_parse<__Grammar::initial_block, Actions::CommandArrayAction>(
initial_block_with_sdf_example_1, test_commands);
REQUIRE(test_commands.size() == 1);
auto test = std::get<SDFAnnotateCommand>(test_commands[0]);
REQUIRE(wanted.sdf_file == test.sdf_file);
REQUIRE(wanted.name_of_instance == test.name_of_instance);
}
SECTION("sdf annotation from module declaration action")
{
using IEEE1364_2001::Actions::ModuleEvent;
ModuleEvent test{};
ModuleEvent wanted{"basic_dro", {}, {{sdf_annotation_command}}};
require_parse<__Grammar::_module_declaration_,
Actions::ModuleDeclarationAction>(
basic_annotation_example, test);
REQUIRE(wanted.module_identifier == test.module_identifier);
// REQUIRE(wanted.instances.size(),test.instances.size());
for(auto&& [pair1,pair2] : ranges::view::zip(wanted.instances,test.instances)){
auto &&[str1,str2] = pair1;
auto &&[str3,str4] = pair2;
REQUIRE(str1== str3);
REQUIRE(str2 == str4);
}
// REQUIRE(test_commands.size() == 1);
// auto test = std::get<SDFAnnotateCommand>(test_commands[0]);
// REQUIRE(wanted.sdf_file == test.sdf_file);
// REQUIRE(wanted.name_of_instance == test.name_of_instance);
}
SECTION("module instantiation from module declaration action")
{
using IEEE1364_2001::Actions::StringStringMapping;
StringStringMapping test{};
StringStringMapping wanted{"basic_dro", "DUT"};
require_parse<__Grammar::module_instantiation,
Actions::ModuleInstantiationAction>(
module_instantiation_example, test);
REQUIRE(wanted.type == test.type);
REQUIRE(wanted.name == test.name);
}
} | [
"calvinworkaccount@live.co.uk"
] | calvinworkaccount@live.co.uk |
5a1765b03b598fbd94ecf8a141e66d54ff9b72c2 | ef0378f718f10f37da0d1f6432c8be9e97011049 | /gb9/b.cpp | e7d191a476aca30607c93ef9e0ff74fb010c3852 | [] | no_license | snandasena/cf-contests | 13355fa211f90e2d77f352d1857385bdfa9a2a18 | 62df67dad8da6de7d0572d6ca3c04b54f8d1d151 | refs/heads/master | 2023-01-12T20:37:05.681906 | 2020-11-22T02:06:58 | 2020-11-22T02:06:58 | 280,200,591 | 2 | 0 | null | 2020-11-22T02:06:59 | 2020-07-16T16:15:52 | C++ | UTF-8 | C++ | false | false | 1,249 | cpp | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int t, n, m;
cin >> t;
while (t--) {
cin >> n >> m;
bool ok = true;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int limit = 0;
if (i > 0) limit++;
if (i < n - 1) limit++;
if (j > 0) limit++;
if (j < m - 1) limit++;
int x;
cin >> x;
if (x > limit) {
ok = false;
}
}
}
if (!ok) cout << "NO\n";
else {
cout << "YES\n";
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (j > 0) cout << " ";
int limit = 0;
if (i > 0) limit++;
if (i < n - 1) limit++;
if (j > 0) limit++;
if (j < m - 1) limit++;
cout << limit;
}
cout << "\n";
}
}
}
return 0;
}
| [
"sajith@digitalxlabs.com"
] | sajith@digitalxlabs.com |
573ac4ad274a73645ed68e3c9130566ca38f0191 | aed1a4a858bd75c5958bad1ce5c8cd0b6c5e1711 | /XRmonitorsHologram/_attic_/OpenXrGraphics.hpp | ebd9edb8872620880ea17b2f7091c9ae9e20d1f8 | [
"BSD-3-Clause"
] | permissive | forksbot/XRmonitors | f8cf5e05684fb3aee6482e107d212ac27030731f | 17dddf10d0518596b1549a7e05071633226d0e7d | refs/heads/master | 2022-10-02T10:42:13.157334 | 2020-04-26T01:38:13 | 2020-04-26T01:38:13 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,351 | hpp | // Copyright 2019 Augmented Perception Corporation
#include "stdafx.h"
#include "OpenXrProgram.hpp"
#include <list>
#include <wrl/client.h>
#include <DirectXColors.h>
#include <D3Dcompiler.h>
#include "XrUtility/XrMath.h"
#include "D3D11Tools.hpp"
namespace xrm {
using Microsoft::WRL::ComPtr;
using namespace DirectX;
//------------------------------------------------------------------------------
// Cube
struct Cube
{
XrSpace Space{ XR_NULL_HANDLE };
XrVector3f Scale{ 0.1f, 0.1f, 0.1f };
XrBool32 PoseValid{ false };
XrPosef Pose = xr::math::Pose::Identity();
ComPtr<ID3D11VertexShader> VertexShader;
ComPtr<ID3D11PixelShader> PixelShader;
ComPtr<ID3D11InputLayout> InputLayout;
ComPtr<ID3D11Buffer> MvpCBuffer;
ComPtr<ID3D11Buffer> VertexBuffer;
ComPtr<ID3D11Buffer> IndexBuffer;
void SetPosition(XrSpace space);
void InitializeD3D(D3D11DeviceContext& device_context);
};
//------------------------------------------------------------------------------
// OpenXrD3D11Graphics
class OpenXrD3D11Graphics : public IGraphicsPlugin
{
logger::Channel Logger;
public:
OpenXrD3D11Graphics()
: Logger("OpenXrD3D11Graphics")
{
}
void InitializeDevice(XrInstance instance, XrSystemId systemId) override;
void OnSessionInit(XrRenderState* state) override;
const XrGraphicsBindingD3D11KHR* GetGraphicsBinding() const override;
int64_t SelectColorSwapchainFormat(const std::vector<int64_t>& runtimeFormats) const override;
std::vector<XrSwapchainImageBaseHeader*> AllocateSwapchainImageStructs(uint32_t capacity, const XrSwapchainCreateInfo& /*swapchainCreateInfo*/) override;
void RenderLayers(XrTime predictedDisplayTime, std::vector<XrCompositionLayerBaseHeader*>& layers) override;
private:
D3D11DeviceContext DeviceContext;
XrGraphicsBindingD3D11KHR m_xrGraphicsBindingD3D11{XR_TYPE_GRAPHICS_BINDING_D3D11_KHR};
std::list<std::vector<XrSwapchainImageD3D11KHR>> m_swapchainImageBuffers;
XrRenderState* State = nullptr;
// Cube
Cube m_Cube;
// Map color buffer to associated depth buffer. This map is populated on demand.
std::map<ID3D11Texture2D*, ComPtr<ID3D11DepthStencilView>> m_colorToDepthMap;
#if 0
// Data passed to OpenXrProgram: Left and Right Camera Images
XrCompositionLayerProjection LeftCameraLayer{ XR_TYPE_COMPOSITION_LAYER_PROJECTION };
std::vector<XrCompositionLayerProjectionView> LeftCameraProjectionLayerViews;
XrCompositionLayerProjection RightCameraLayer{ XR_TYPE_COMPOSITION_LAYER_PROJECTION };
std::vector<XrCompositionLayerProjectionView> RightCameraProjectionLayerViews;
XrCompositionLayerCylinderKHR MonitorLayer{ XR_TYPE_COMPOSITION_LAYER_PROJECTION };
#endif
// The projection layer consists of projection layer views.
XrCompositionLayerProjection BaseLayer{ XR_TYPE_COMPOSITION_LAYER_PROJECTION };
std::vector<XrCompositionLayerProjectionView> ProjectionLayerViews;
ComPtr<ID3D11DepthStencilView> GetDepthStencilView(ID3D11Texture2D* colorTexture);
void RenderView(const XrCompositionLayerProjectionView& layerView,
const XrSwapchainImageBaseHeader* swapchainImage,
const XrEnvironmentBlendMode environmentBlendMode,
int64_t colorSwapchainFormat);
bool RenderLayer(XrTime predictedDisplayTime, XrCompositionLayerProjection& layer);
};
} // namespace xrm
| [
"mrcatid@gmail.com"
] | mrcatid@gmail.com |
e7c609b9aef713e726a8ad8d29db34b9c5f003f5 | de7e771699065ec21a340ada1060a3cf0bec3091 | /analysis/common/src/java/org/apache/lucene/analysis/fa/PersianNormalizationFilterFactory.cpp | 8f10beb30da95a12bd71848ef490f70935f3ebdb | [] | no_license | sraihan73/Lucene- | 0d7290bacba05c33b8d5762e0a2a30c1ec8cf110 | 1fe2b48428dcbd1feb3e10202ec991a5ca0d54f3 | refs/heads/master | 2020-03-31T07:23:46.505891 | 2018-12-08T14:57:54 | 2018-12-08T14:57:54 | 152,020,180 | 7 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,368 | cpp | using namespace std;
#include "PersianNormalizationFilterFactory.h"
#include "../../../../../../../../../core/src/java/org/apache/lucene/analysis/TokenStream.h"
#include "../util/AbstractAnalysisFactory.h"
#include "PersianNormalizationFilter.h"
namespace org::apache::lucene::analysis::fa
{
using PersianNormalizationFilter =
org::apache::lucene::analysis::fa::PersianNormalizationFilter;
using TokenStream = org::apache::lucene::analysis::TokenStream;
using AbstractAnalysisFactory =
org::apache::lucene::analysis::util::AbstractAnalysisFactory;
using MultiTermAwareComponent =
org::apache::lucene::analysis::util::MultiTermAwareComponent;
using TokenFilterFactory =
org::apache::lucene::analysis::util::TokenFilterFactory;
PersianNormalizationFilterFactory::PersianNormalizationFilterFactory(
unordered_map<wstring, wstring> &args)
: org::apache::lucene::analysis::util::TokenFilterFactory(args)
{
if (!args.empty()) {
throw invalid_argument(L"Unknown parameters: " + args);
}
}
shared_ptr<PersianNormalizationFilter>
PersianNormalizationFilterFactory::create(shared_ptr<TokenStream> input)
{
return make_shared<PersianNormalizationFilter>(input);
}
shared_ptr<AbstractAnalysisFactory>
PersianNormalizationFilterFactory::getMultiTermComponent()
{
return shared_from_this();
}
} // namespace org::apache::lucene::analysis::fa | [
"smamunr@fedora.localdomain"
] | smamunr@fedora.localdomain |
8a91fc9a3a817b39207f553fa767a4550693f2f1 | 7d7d67a1e06b3adc077625bfa7c38f47c68bdf96 | /2_structure.cpp | 6ad50217b9895d69334fdcb8ba7f3bce36da49cd | [] | no_license | neerajjaiswall/OOPs | c548f1977a5a14e3329022b4872a088c078a1cd2 | 0e881e84a3cabdde9b45622301a4fd322ef05a9c | refs/heads/master | 2023-06-21T08:19:59.946774 | 2021-07-20T17:11:59 | 2021-07-20T17:11:59 | 282,789,302 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 730 | cpp |
// structure is a collection of dissimilar element
// structure is a way to group elements
// structure is used to create data type
// declaring a structure dosen't consume any memory as it not yet used
// if structure is defined globally or ( locally inside a function )
// By default all the members in structure are public
#include<iostream>
#include<string>
#include<cstring>
using namespace std;
struct book {
int bookid;
char title[40];
float price;
};
int main () {
book b1 = { 24, "Iam Neeraj Jaiswal ", 82.8}; // initializing while declaring
book b2;
b2.bookid = 54;
strcpy( b2.title, "string assigning method");
b2.price=67.3;
book b3=b2; // we can directly copy also which is pretty good thing
} | [
"neerajjaiswal8952@gmail.com"
] | neerajjaiswal8952@gmail.com |
1c55285721fa1b2d88f457274d195ce5b3185bf3 | e94ecbd72592ed0af5dfde9b15b5cefd7e78ac16 | /v3/symbolTable.h | e8dc86b731cd2aee3a91fcc5e7ee3f2328633de4 | [] | no_license | Adward-R/tinyCompiler | 38367380a78e2885d2848a19fa409b2ff24c9d49 | 1bb6cf378ac028705d3ed28d7b00c922b70cd86e | refs/heads/master | 2021-01-13T00:45:13.877104 | 2017-05-11T07:25:06 | 2017-05-11T07:25:06 | 35,466,260 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,022 | h | #ifndef _eddie_SYMBOLTABLE_H_
#define _eddie_SYMBOLTABLE_H_
#include "declare.h"
#include <cassert>
#include <vector>
#include <map>
#include <set>
#include <string>
#include <cstdio>
#include <iostream>
//#define SYMBOLTABLE_DEBUG
namespace eddie {
struct scopeValue{
int parent;//-1 stands for root
int choice;//0=universal, only valid for the program name in pascal
union {
eddie::program *type1;
eddie::function_decl *type2;
eddie::procedure_decl *type3;
} type;
scopeValue(int p, eddie::program *t):parent(p),choice(1) { type.type1 = t; }
scopeValue(int p, eddie::function_decl *t):parent(p),choice(2) { type.type2 = t; }
scopeValue(int p, eddie::procedure_decl *t):parent(p),choice(3) { type.type3 = t; }
scopeValue(int p):parent(p),choice(0) { }
scopeValue(int p, const std::string &s): parent(p), choice(0) { }
void print() const {
printf("parent : %d, type : ", parent);
switch(choice) {
case 0: printf("universal"); break;
case 1: printf("program, name : %s", type.type1->child1->child1->name.c_str()); break;
case 2: printf("function, name : %s", type.type2->child1->child1->name.c_str()); break;
case 3: printf("procedure, name : %s", type.type3->child1->child1->name.c_str()); break;
case 4: printf("error choice"); break;
}
printf("\n");
}
};
class symbolTable {
private :
std::vector<scopeValue> scope;
std::map<std::string,std::vector<eddie::identifier *> > table;
std::set<int> label;
std::set<int> usedlabel;
std::set<identifier *> const_pool;
public :
void printScope();
void printIdentifier();
void printConst();
void addConst(eddie::identifier *id) { const_pool.insert(id); }
//identifier *getConst(identifier *i, int scopee);
std::set<eddie::identifier *> &getConstPoll() { return const_pool; }
/*
insert a new scope into the table
return value=scope_id for this scope, -1 means there already exists this scope
*/
int insertScope() {//for global scope only
#ifdef SYMBOLTABLE_DEBUG
printf("Inside insertScope().\n");
#endif
scope.push_back(scopeValue(-1, "global"));
#ifdef SYMBOLTABLE_DEBUG
printf("Out of insertScope().\n");
#endif
return scope.size()-1;
}
int insertScope(eddie::program *id, int parent_scope) {
#ifdef SYMBOLTABLE_DEBUG
printf("Inside insertScope(), id = %s, pscope = %d\n",
id->child1->child1->name.c_str(), parent_scope);
#endif
if(lookUpScope(id)!=-1) {
#ifdef SYMBOLTABLE_DEBUG
printf("Out of insertScope(), id = %s, pscope = %d\n",
id->child1->child1->name.c_str(), parent_scope);
#endif
return -1;
}
scope.push_back(scopeValue(parent_scope, id));
#ifdef SYMBOLTABLE_DEBUG
printf("Out of insertScope(), id = %s, pscope = %d\n",
id->child1->child1->name.c_str(), parent_scope);
#endif
return scope.size()-1;
}
int insertScope(eddie::function_decl *id, int parent_scope) {
#ifdef SYMBOLTABLE_DEBUG
printf("Inside insertScope(), id = %s, pscope = %d\n",
id->child1->child1->name.c_str(), parent_scope);
#endif
if(lookUpScope(id)!=-1) {
#ifdef SYMBOLTABLE_DEBUG
printf("Out of insertScope(), id = %s, pscope = %d\n",
id->child1->child1->name.c_str(), parent_scope);
#endif
return -1;
}
scope.push_back(scopeValue(parent_scope, id));
#ifdef SYMBOLTABLE_DEBUG
printf("Out of insertScope(), id = %s, pscope = %d\n",
id->child1->child1->name.c_str(), parent_scope);
#endif
return scope.size()-1;
}
int insertScope(eddie::procedure_decl *id, int parent_scope) {
#ifdef SYMBOLTABLE_DEBUG
printf("Inside insertScope(), id = %s, pscope = %d\n",
id->child1->child1->name.c_str(), parent_scope);
#endif
if(lookUpScope(id)!=-1) {
#ifdef SYMBOLTABLE_DEBUG
printf("Out of insertScope(), id = %s, pscope = %d\n",
id->child1->child1->name.c_str(), parent_scope);
#endif
return -1;
}
scope.push_back(scopeValue(parent_scope, id));
#ifdef SYMBOLTABLE_DEBUG
printf("Out of insertScope(), id = %s, pscope = %d\n",
id->child1->child1->name.c_str(), parent_scope);
#endif
return scope.size()-1;
}
/*
search for the specified scope
return value is the id for that scope
-1 means no such scope exists
*/
int lookUpScope(eddie::program *id);
int lookUpScope(eddie::function_decl *id);
int lookUpScope(eddie::procedure_decl *id);
/*
get the scopeValue of the specified scope
*/
scopeValue getScope(int s) const {
//for(int i=0; i<scope.size(); ++i)
// scope[i].print();
//std::cout << " in getScope : " << s << std::endl;
assert(s<scope.size());
return scope.at(s);
}
/*
insert a new identifier into the table
if there already exists this name in this scope, return false
*/
bool insertID(eddie::identifier *id, int scope);
/*
look for the identifier specified by name and scope
will return the identifier found in the most nested scope, iscope is set to be the scope of found identifier
if it does not exist, return value is NULL
*/
eddie::identifier *lookUp(const eddie::identifier * const id, int s, int &is) const ;
eddie::identifier *lookUp(const std::string &id, int s, int &is) const;
/*
similar to the one above except this only looks in the specified scope, not potential parent scopes
*/
eddie::identifier *lookUp(const eddie::identifier * const id, int s) const {
#ifdef SYMBOLTABLE_DEBUG
printf("Inside lookUp(), id = %s , scope = %d\n",
id->name.c_str(), s);
#endif
return lookUp(id, s, s);
}
eddie::identifier *lookUp(const std::string &id, int s) const {
int temp;
return lookUp(id, s, temp);
}
/*
delete and return the specified identifier in the table
if it does not exist, the return value is NULL
*/
//eddie::identifier *pop(const identifier * const id, int s);
bool addLabel(int l) {
label.insert(l);
return true;
}
bool addUsedLabel(int l) {
usedlabel.insert(l);
return true;
}
bool checkLabel();
};
extern symbolTable gtable;
}
#endif
| [
"adward_r@icloud.com"
] | adward_r@icloud.com |
11f35ea4d3f7a524bbb2258c86612135c08f314c | ea49c06eb1991765cf9f0e41dc431919e0bc71cc | /Poligono.cpp | a03143edbef493da680327c26f7c7798bf222a9e | [] | no_license | JeremyCT/Poligono | d0e3492dfb1d1bb623f21a13f41089dedc6b719a | 44c79d26f8898ad24b99811ff6be6c653495c25a | refs/heads/master | 2021-01-12T11:37:14.786063 | 2016-10-28T17:53:22 | 2016-10-28T17:53:22 | 72,229,588 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 263 | cpp | #include <iostream>
#include "Poligono.h"
using namespace std;
int Poligono::n=0;
Poligono::Poligono(const PointArray &pa):points(pa){
++numPoli;
}
Poligono::Poligono(const PointArray[], const int numPoints): points(pointArr, numPoints)
{
++numPoli;
}
| [
"noreply@github.com"
] | noreply@github.com |
85fa060a9614265c0b1b9f6784fe65fac401b1e6 | 10b6a247841430a1ec6d950785b1459d09d52f76 | /HashTable/Int.h | 4bd01edd1a7d955f88ad8c5a2a9ac46b04e60714 | [
"Unlicense"
] | permissive | randerson400/MyProjects | 08b0be94b5876a7d6408c26b925bcb2804940d3b | 588a7d0df404ed813610f47dbe5829942b209947 | refs/heads/master | 2021-07-03T10:44:43.658933 | 2021-06-29T19:31:39 | 2021-06-29T19:31:39 | 123,146,545 | 0 | 0 | null | 2018-03-04T16:07:26 | 2018-02-27T15:12:13 | C++ | UTF-8 | C++ | false | false | 659 | h | // Brett Weicht and Ryan Anderson
//Int.h
#ifndef INT_H
#define INT_H
#include <cstdlib>
#include <iostream>
#include <string>
#include <sstream>
#include <stdlib.h>
using namespace std;
class Int
{
public:
Int(int i): x(i) { }
int x;
int hash(int m) const {return abs(x) % m;} // simple hash function for testing
bool operator==(Int i);
string toString() const;
};
ostream& operator<<(ostream& stream, const Int& i);
bool Int::operator==(Int i)
{
return x == i.x;
}
string Int::toString() const
{
stringstream s;
s << x;
return s.str();
}
ostream& operator<<(ostream& stream, const Int& i)
{
return stream << i.toString();
}
#endif
| [
"anders_r1@denison.edu"
] | anders_r1@denison.edu |
4fa5e5c835d5aca66a1ce2ea6be86f86ee807f2a | cc799cb41ba0f736a9611eafd4ad06a0767fd102 | /CncControlerGui/Depricated/CncManuallyPathHandler.cpp | 272ddf4478a906e728276bd909ac53c5a36bd64c | [] | no_license | HackiWimmer/cnc | 8cbfe5f5b9b39d96c9ea32da4adcb89f96ec1008 | 329278bbed7b4a10407e6ddb1c135366f3ef8537 | refs/heads/master | 2023-01-08T01:39:54.521532 | 2023-01-01T15:48:06 | 2023-01-01T15:48:06 | 85,393,224 | 3 | 2 | null | 2017-03-27T18:06:19 | 2017-03-18T10:30:06 | C++ | UTF-8 | C++ | false | false | 962 | cpp | #include "CncManuallyPathHandlerCnc.h"
/////////////////////////////////////////////////////////////
ManuallyPathHandlerCnc::ManuallyPathHandlerCnc(CncControl* cnc)
: PathHandlerBase()
, cncControl(cnc)
/////////////////////////////////////////////////////////////
{
}
/////////////////////////////////////////////////////////////
ManuallyPathHandlerCnc::~ManuallyPathHandlerCnc() {
/////////////////////////////////////////////////////////////
}
//////////////////////////////////////////////////////////////////
void ManuallyPathHandlerCnc::logMeasurementStart() {
//////////////////////////////////////////////////////////////////
wxASSERT(cncControl);
cncControl->getSerial()->startMeasurement();
}
//////////////////////////////////////////////////////////////////
void ManuallyPathHandlerCnc::logMeasurementEnd() {
//////////////////////////////////////////////////////////////////
wxASSERT(cncControl);
cncControl->getSerial()->stopMeasurement();
} | [
"stefan.hoelzer@fplusp.de"
] | stefan.hoelzer@fplusp.de |
7edebf6dc08a61a063326df5a7f699daaac4245c | 95f3f19bc264dfc86fc70493b93fb3943b296d97 | /TagAndProbe_Identification/include/Event.h | 36ad42466ada5e94b18a9b3e66782b4790d9033e | [] | no_license | jbsauvan/L1Trigger-AnalysisHistoMaker | 214c59299ea53b6759afe4397dbc986d083c7e8a | 5146c8f8dbab4e001ff85999af259b635ad48a86 | refs/heads/master | 2021-01-18T21:29:21.987626 | 2015-06-09T13:03:34 | 2015-06-09T13:03:34 | 37,124,567 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 664 | h | /**
* @file Event.h
* @brief
*
*
* @author Jean-Baptiste Sauvan <sauvan@llr.in2p3.fr>
*
* @date 07/29/2014
*
* @internal
* Created : 07/29/2014
* Last update : 07/29/2014 09:41:33 PM
* by : JB Sauvan
*
* =====================================================================================
*/
#ifndef EVENT_H
#define EVENT_H
#include "EventEGamma.h"
namespace AnHiMa
{
class Event: public EventEGamma
{
public:
Event();
~Event();
bool passSelection(int selection=0);
void connectVariables(TChain* inputChain);
private:
};
}
#endif
| [
"jean-baptiste.sauvan@cern.ch"
] | jean-baptiste.sauvan@cern.ch |
9f8a3710fdb405dd5abfc3ab23283bde31552b12 | 92364848ba2683567c8cc37749e2d94d191261c4 | /SceneExtend.cpp | 8f69b48d051109650e2d85ab4f40bd5a790e917e | [] | no_license | 625673575/MultiPassPostProcess | f2b74452c27ddb4739b81d9048e2148753d9eb7e | 155e3e4579dd7f35a63f9cfd3c7d22244c6caf31 | refs/heads/master | 2020-04-23T02:22:43.044302 | 2019-04-01T10:53:56 | 2019-04-01T10:53:56 | 170,844,678 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 33,376 | cpp | #include "SceneExtend.h"
#include "rapidjson/stringbuffer.h"
#include "rapidjson/prettywriter.h"
#include "Framework.h"
#include <fstream>
#include "Utils/Platform/OS.h"
#include "Graphics/Scene/Editor/SceneEditor.h"
#include "rapidjson/error/en.h"
#include "TextureHelperExtend.h"
#define SCENE_EXPORTER
#define SCENE_IMPORTER
#include "Graphics/Scene/SceneExportImportCommon.h"
SceneExtend::SceneExtend(const std::string& filename) :Scene(filename)
{
}
template<typename T>
void addLiteral(rapidjson::Value& jval, rapidjson::Document::AllocatorType& jallocator, const std::string& key, const T& value)
{
rapidjson::Value jkey;
jkey.SetString(key.c_str(), (uint32_t)key.size(), jallocator);
jval.AddMember(jkey, value, jallocator);
}
void addJsonValue(rapidjson::Value& jval, rapidjson::Document::AllocatorType& jallocator, const std::string& key, rapidjson::Value& value)
{
rapidjson::Value jkey;
jkey.SetString(key.c_str(), (uint32_t)key.size(), jallocator);
jval.AddMember(jkey, value, jallocator);
}
void addString(rapidjson::Value& jval, rapidjson::Document::AllocatorType& jallocator, const std::string& key, const std::string& value)
{
rapidjson::Value jstring, jkey;
jstring.SetString(value.c_str(), (uint32_t)value.size(), jallocator);
jkey.SetString(key.c_str(), (uint32_t)key.size(), jallocator);
jval.AddMember(jkey, jstring, jallocator);
}
void addBool(rapidjson::Value& jval, rapidjson::Document::AllocatorType& jallocator, const std::string& key, bool isValue)
{
rapidjson::Value jbool, jkey;
jbool.SetBool(isValue);
jkey.SetString(key.c_str(), (uint32_t)key.size(), jallocator);
jval.AddMember(jkey, jbool, jallocator);
}
void addInt(rapidjson::Value& jval, rapidjson::Document::AllocatorType& jallocator, const std::string& key, INT64 intValue)
{
rapidjson::Value jint64, jkey;
jint64.SetInt64(intValue);
jkey.SetString(key.c_str(), (uint32_t)key.size(), jallocator);
jval.AddMember(jkey, jint64, jallocator);
}
void addFloat(rapidjson::Value& jval, rapidjson::Document::AllocatorType& jallocator, const std::string& key, float fValue)
{
rapidjson::Value jfloat, jkey;
jfloat.SetFloat(fValue);
jkey.SetString(key.c_str(), (uint32_t)key.size(), jallocator);
jval.AddMember(jkey, jfloat, jallocator);
}
template<typename T>
void addVector(rapidjson::Value& jval, rapidjson::Document::AllocatorType& jallocator, const std::string& key, const T& value)
{
rapidjson::Value jkey;
jkey.SetString(key.c_str(), (uint32_t)key.size(), jallocator);
rapidjson::Value jvec(rapidjson::kArrayType);
for (int32_t i = 0; i < value.length(); i++)
{
jvec.PushBack(value[i], jallocator);
}
jval.AddMember(jkey, jvec, jallocator);
}
template<uint32_t VecSize>
bool SceneExtend::getFloatVec(const rapidjson::Value& jsonVal, const std::string& desc, float vec[VecSize])
{
if (jsonVal.IsArray() == false)
{
error("Trying to load a vector for " + desc + ", but JValue is not an array");
return false;
}
if (jsonVal.Size() != VecSize)
{
return error("Trying to load a vector for " + desc + ", but vector size mismatches. Required size is " + std::to_string(VecSize) + ", array size is " + std::to_string(jsonVal.Size()));
}
for (uint32_t i = 0; i < jsonVal.Size(); i++)
{
if (jsonVal[i].IsNumber() == false)
{
return error("Trying to load a vector for " + desc + ", but one the elements is not a number.");
}
vec[i] = (float)(jsonVal[i].GetDouble());
}
return true;
}
template<uint32_t VecSize>
bool SceneExtend::getIntVec(const rapidjson::Value & jsonVal, const std::string & desc, int vec[VecSize])
{
if (jsonVal.IsArray() == false)
{
error("Trying to load a vector for " + desc + ", but JValue is not an array");
return false;
}
if (jsonVal.Size() != VecSize)
{
return error("Trying to load a vector for " + desc + ", but vector size mismatches. Required size is " + std::to_string(VecSize) + ", array size is " + std::to_string(jsonVal.Size()));
}
for (uint32_t i = 0; i < jsonVal.Size(); i++)
{
if (jsonVal[i].IsNumber() == false)
{
return error("Trying to load a vector for " + desc + ", but one the elements is not a number.");
}
vec[i] = (jsonVal[i].GetInt());
}
return true;
}
bool SceneExtend::getFloatVecAnySize(const rapidjson::Value & jsonVal, const std::string & desc, std::vector<float> & vec)
{
if (jsonVal.IsArray() == false)
{
return error("Trying to load a vector for " + desc + ", but JValue is not an array");
}
vec.resize(jsonVal.Size());
for (uint32_t i = 0; i < jsonVal.Size(); i++)
{
if (jsonVal[i].IsNumber() == false)
{
return error("Trying to load a vector for " + desc + ", but one the elements is not a number.");
}
vec[i] = (float)(jsonVal[i].GetDouble());
}
return true;
}
void SceneExtend::addModelResource(const ModelResource & pModel, const std::string & instanceName, const glm::vec3 & translation, const glm::vec3 & yawPitchRoll, const glm::vec3 & scaling)
{
std::string name = instanceName;
if (instanceName.empty()) {
name = pModel.mpModel->getName();
}
mModelRes.emplace_back(pModel);
addModelInstance(pModel.mpModel, name, translation, yawPitchRoll, scaling);
}
bool SceneExtend::save(const std::string & filename)
{
//mExportOptions = exportOptions;
mFilename = filename;
// create the file
mJDoc.SetObject();
// Write the version
rapidjson::Value& JVal = mJDoc;
auto& allocator = mJDoc.GetAllocator();
//addLiteral(JVal, allocator, SceneKeys::kVersion, kVersion);
//// Write everything else
//bool exportPaths = (exportOptions & ExportPaths) != 0;
//if (exportOptions & ExportGlobalSettings) writeGlobalSettings(exportPaths);
//if (exportOptions & ExportModels) writeModels();
//if (exportOptions & ExportLights) writeLights();
//if (exportOptions & ExportCameras) writeCameras();
//if (exportOptions & ExportUserDefined) writeUserDefinedSection();
//if (exportOptions & ExportPaths) writePaths();
writeModelsJson();
// Get the output string
rapidjson::StringBuffer buffer;
rapidjson::PrettyWriter<rapidjson::StringBuffer> writer(buffer);
writer.SetIndent(' ', 4);
mJDoc.Accept(writer);
std::string str(buffer.GetString(), buffer.GetSize());
// Output the file
std::ofstream outputStream(mFilename.c_str());
if (outputStream.fail())
{
logError("Can't open output scene file " + mFilename + ".\nExporting failed.");
return false;
}
outputStream << str;
outputStream.close();
return true;
}
bool SceneExtend::load(const std::string & filename)
{
std::string fullpath;
mFilename = filename;
if (findFileInDataDirectories(filename, fullpath))
{
// Load the file
std::string jsonData = readFile(fullpath);
rapidjson::StringStream JStream(jsonData.c_str());
// Get the file directory
auto last = fullpath.find_last_of("/\\");
mDirectory = fullpath.substr(0, last);
// create the DOM
mJDoc.ParseStream(JStream);
if (mJDoc.HasParseError())
{
size_t line;
line = std::count(jsonData.begin(), jsonData.begin() + mJDoc.GetErrorOffset(), '\n');
return error(std::string("JSON Parse error in line ") + std::to_string(line) + ". " + rapidjson::GetParseError_En(mJDoc.GetParseError()));
}
clearModels();
if (topLevelLoop() == false)
{
return false;
}
return true;
}
else
{
return error("File not found.");
}
return false;
}
const SceneExtend::FuncValue SceneExtend::kFunctionTable[] =
{
//// The order matters here.
//{SceneKeys::kVersion, &SceneExtend::parseVersion},
//{SceneKeys::kSceneUnit, &SceneExtend::parseSceneUnit},
//{SceneKeys::kEnvMap, &SceneExtend::parseEnvMap},
//{SceneKeys::kAmbientIntensity, &SceneExtend::parseAmbientIntensity},
//{SceneKeys::kLightingScale, &SceneExtend::parseLightingScale},
//{SceneKeys::kCameraSpeed, &SceneExtend::parseCameraSpeed},
{SceneKeys::kModels, &SceneExtend::parseModels},
//{SceneKeys::kLights, &SceneExtend::parseLights},
//{SceneKeys::kLightProbes, &SceneExtend::parseLightProbes},
//{SceneKeys::kCameras, &SceneExtend::parseCameras},
//{SceneKeys::kActiveCamera, &SceneExtend::parseActiveCamera}, // Should come after ParseCameras
//{SceneKeys::kUserDefined, &SceneExtend::parseUserDefinedSection},
//{SceneKeys::kPaths, &SceneExtend::parsePaths},
//{SceneKeys::kActivePath, &SceneExtend::parseActivePath}, // Should come after ParsePaths
//{SceneKeys::kInclude, &SceneExtend::parseIncludes}
};
bool SceneExtend::validateSceneFile()
{
// Make sure the top-level is valid
for (auto it = mJDoc.MemberBegin(); it != mJDoc.MemberEnd(); it++)
{
bool found = false;
const std::string name(it->name.GetString());
for (uint32_t i = 0; i < arraysize(kFunctionTable); i++)
{
// Check that we support this value
if (kFunctionTable[i].token == name)
{
found = true;
break;
}
}
if (found == false)
{
return error("Invalid key found in top-level object. Key == " + std::string(it->name.GetString()) + ".");
}
}
return true;
}
bool SceneExtend::parseModels(const rapidjson::Value & jsonVal)
{
if (jsonVal.IsArray() == false)
{
return error("models section should be an array of objects.");
}
// Loop over the array
for (uint32_t i = 0; i < jsonVal.Size(); i++)
{
if (createModel(jsonVal[i]) == false)
{
return false;
}
}
return true;
}
bool SceneExtend::createModel(const rapidjson::Value & jsonModel)
{
// Model must have at least a filename
if (jsonModel.HasMember(SceneKeys::kFilename) == false)
{
return error("Model must have a filename");
}
// Get Model name
const auto& modelFile = jsonModel[SceneKeys::kFilename];
if (modelFile.IsString() == false)
{
return error("Model filename must be a string");
}
std::string file = mDirectory + '/' + modelFile.GetString();
if (doesFileExist(file) == false)
{
file = modelFile.GetString();
}
// Parse additional properties that affect loading
Model::LoadFlags modelFlags = mModelLoadFlags;
if (jsonModel.HasMember(SceneKeys::kMaterial))
{
const auto& materialSettings = jsonModel[SceneKeys::kMaterial];
if (materialSettings.IsObject() == false)
{
return error("Material properties for \"" + file + "\" must be a JSON object");
}
for (auto m = materialSettings.MemberBegin(); m != materialSettings.MemberEnd(); m++)
{
if (m->name == SceneKeys::kShadingModel)
{
if (m->value == SceneKeys::kShadingSpecGloss)
{
modelFlags |= Model::LoadFlags::UseSpecGlossMaterials;
}
else
{
modelFlags |= Model::LoadFlags::UseMetalRoughMaterials;
}
}
}
}
else {
modelFlags |= Model::LoadFlags::UseSpecGlossMaterials;
}
// Load the model
auto pModel = Model::createFromFile(file.c_str(), modelFlags);
if (pModel == nullptr)
{
return error("Could not load model: " + file);
}
bool instanceAdded = false;
// Loop over the other members
for (auto jval = jsonModel.MemberBegin(); jval != jsonModel.MemberEnd(); jval++)
{
std::string keyName(jval->name.GetString());
if (keyName == SceneKeys::kFilename)
{
// Already handled
}
else if (keyName == SceneKeys::kName)
{
if (jval->value.IsString() == false)
{
return error("Model name should be a string value.");
}
pModel->setName(std::string(jval->value.GetString()));
}
else if (keyName == SceneKeys::kModelInstances)
{
if (createModelInstances(jval->value, pModel) == false)
{
return false;
}
instanceAdded = true;
}
else if (keyName == SceneKeys::kActiveAnimation)
{
if (jval->value.IsUint() == false)
{
return error("Model active animation should be an unsigned integer");
}
uint32_t activeAnimation = jval->value.GetUint();
if (activeAnimation >= pModel->getAnimationsCount())
{
std::string msg = "Warning when parsing scene file \"" + mFilename + "\".\nModel " + pModel->getName() + " was specified with active animation " + std::to_string(activeAnimation);
msg += ", but model only has " + std::to_string(pModel->getAnimationsCount()) + " animations. Ignoring field";
logWarning(msg);
}
else
{
pModel->setActiveAnimation(activeAnimation);
}
}
else if (keyName == SceneKeys::kMaterial)
{
// Existing parameters already handled
}
else
{
return error("Invalid key found in models array. Key == " + keyName + ".");
}
}
// If no instances for the model were loaded from the scene file
if (instanceAdded == false)
{
addModelInstance(pModel, "Instance 0");
}
return true;
}
bool SceneExtend::isNameDuplicate(const std::string & name, const ObjectMap & objectMap, const std::string & objectType) const
{
if (objectMap.find(name) != objectMap.end())
{
const std::string msg = "Multiple " + objectType + " found the same name: " + name + ".\nObjects may not attach to paths correctly.\n\nContinue anyway?";
// If user pressed ok, return false to ignore duplicate
return msgBox(msg, MsgBoxType::OkCancel) == MsgBoxButton::Ok ? false : true;
}
return false;
}
bool SceneExtend::createModelInstances(const rapidjson::Value & jsonVal, const Model::SharedPtr & pModel)
{
if (jsonVal.IsArray() == false)
{
return error("Model instances should be an array of objects");
}
ModelResource modelRes(pModel);
modelRes.init("Diffuse");
for (uint32_t i = 0; i < jsonVal.Size(); i++)
{
const auto& instance = jsonVal[i];
glm::vec3 scaling(1, 1, 1);
glm::vec3 translation(0, 0, 0);
glm::vec3 rotation(0, 0, 0);
std::string name = "Instance " + std::to_string(i);
auto shadingModel = ShadingModelMetalRough;
for (auto m = instance.MemberBegin(); m < instance.MemberEnd(); m++)
{
std::string key(m->name.GetString());
if (key == SceneKeys::kName)
{
if (m->value.IsString() == false)
{
return error("Model instance name should be a string value.");
}
name = std::string(m->value.GetString());
}
else if (key == SceneKeys::kTranslationVec)
{
if (getFloatVec<3>(m->value, "Model instance translation vector", &translation[0]) == false)
{
return false;
}
}
else if (key == SceneKeys::kScalingVec)
{
if (getFloatVec<3>(m->value, "Model instance scale vector", &scaling[0]) == false)
{
return false;
}
}
else if (key == SceneKeys::kRotationVec)
{
if (getFloatVec<3>(m->value, "Model instance rotation vector", &rotation[0]) == false)
{
return false;
}
rotation = glm::radians(rotation);
}
else if (key == SceneKeys::kShadingModel)
{
std::string sVal = m->value.GetString();
if (sVal == SceneKeys::kShadingSpecGloss)
{
shadingModel = ShadingModelSpecGloss;
}
rotation = glm::radians(rotation);
}
else if (key == SceneExtendKeys::kMaterials) {
auto& mats = m->value.GetArray();
for (auto mm = mats.Begin(); mm < mats.End(); mm++)
{
std::string MaterialName = (*mm)[SceneExtendKeys::kMaterialName].GetString();
DepthStencilStateBundle bundle;
for (auto mmx = mm->MemberBegin(); mmx < mm->MemberEnd(); mmx++) {
std::string mkey(mmx->name.GetString());
modelRes.sharedMaterials[MaterialName]->mpMaterial->setShadingModel(shadingModel);
if (mkey == SceneExtendKeys::kRenderQueue) {
uint32_t RenderQueue(mmx->value.GetInt());
modelRes.sharedMaterials[MaterialName]->setRenderQueue(RenderQueue);
}
if (mkey == SceneExtendKeys::kBlendMode) {
uint32_t BlendMode(mmx->value.GetInt());
modelRes.sharedMaterials[MaterialName]->set_blendMode(MaterialInstance::EBlendMode(BlendMode));
}
if (mkey == SceneExtendKeys::kRasterizeMode) {
uint32_t RasterizeMode(mmx->value.GetInt());
modelRes.sharedMaterials[MaterialName]->set_rasterizeMode(MaterialInstance::ERasterizeMode(RasterizeMode));
}
{
if (mkey == SceneExtendKeys::kDepthTest) {
bundle.bDepthTest = mmx->value.GetBool();
}
if (mkey == SceneExtendKeys::kWriteDepth) {
bundle.bWriteDepth = mmx->value.GetBool();
}
if (mkey == SceneExtendKeys::kDepthTestFunc) {
auto DepthTestFunc = mmx->value.GetInt();
bundle.eDepthTestFunc = Falcor::ComparisonFunc(DepthTestFunc);
}
}
if (mkey == SceneExtendKeys::kParameter) {
auto& jmp = mmx->value;
for (auto mmxp = jmp.MemberBegin(); mmxp < jmp.MemberEnd(); mmxp++) {
std::string pkey = mmxp->name.GetString();
std::string prefix(pkey.substr(0, 4));
std::string parameter(pkey.substr(4));
if (prefix == ParameterPrefix::kBool) {
auto val = mmxp->value.GetBool();
modelRes.sharedMaterials[MaterialName]->insert_bool(parameter, val);
}
if (prefix == ParameterPrefix::kFloat) {
auto val = mmxp->value.GetFloat();
modelRes.sharedMaterials[MaterialName]->insert_float(parameter, val);
}
if (prefix == ParameterPrefix::kFloat2) {
glm::vec2 val;
getFloatVec<2>(mmxp->value, ParameterPrefix::kFloat2, &val[0]);
modelRes.sharedMaterials[MaterialName]->insert_vec2(parameter, val);
}
if (prefix == ParameterPrefix::kFloat3) {
glm::vec3 val;
getFloatVec<3>(mmxp->value, ParameterPrefix::kFloat3, &val[0]);
modelRes.sharedMaterials[MaterialName]->insert_vec3(parameter, val);
}
if (prefix == ParameterPrefix::kFloat4) {
glm::vec4 val;
getFloatVec<4>(mmxp->value, ParameterPrefix::kFloat4, &val[0]);
modelRes.sharedMaterials[MaterialName]->insert_vec4(parameter, val);
}
if (prefix == ParameterPrefix::kInt) {
auto val = mmxp->value.GetInt();
modelRes.sharedMaterials[MaterialName]->insert_int(parameter, val);
}
if (prefix == ParameterPrefix::kInt2) {
glm::ivec2 val;
getIntVec<2>(mmxp->value, ParameterPrefix::kInt2, &val[0]);
modelRes.sharedMaterials[MaterialName]->insert_ivec2(parameter, val);
}
if (prefix == ParameterPrefix::kInt3) {
glm::ivec3 val;
getIntVec<3>(mmxp->value, ParameterPrefix::kInt3, &val[0]);
modelRes.sharedMaterials[MaterialName]->insert_ivec3(parameter, val);
}
if (prefix == ParameterPrefix::kInt4) {
glm::ivec4 val;
getIntVec<4>(mmxp->value, ParameterPrefix::kInt4, &val[0]);
modelRes.sharedMaterials[MaterialName]->insert_ivec4(parameter, val);
}
if (prefix == ParameterPrefix::kTexture2D) {
std::string texName = mmxp->value.GetString();
if (!texName.empty()) {
auto pTexture = createTextureFromFile(texName.c_str(), false, true);
if (pTexture) {
if (parameter == ParameterDefault::kBaseColor) {
modelRes.sharedMaterials[MaterialName]->mpMaterial->setBaseColorTexture(pTexture);
modelRes.sharedMaterials[MaterialName]->bUseMaterial = true;
}
else if (parameter == ParameterDefault::kSpecular) {
modelRes.sharedMaterials[MaterialName]->mpMaterial->setSpecularTexture(pTexture);
modelRes.sharedMaterials[MaterialName]->bUseMaterial = true;
}
else if (parameter == ParameterDefault::kNormalMap) {
modelRes.sharedMaterials[MaterialName]->mpMaterial->setNormalMap(pTexture);
modelRes.sharedMaterials[MaterialName]->bUseMaterial = true;
}
else if (parameter == ParameterDefault::kEmissive) {
modelRes.sharedMaterials[MaterialName]->mpMaterial->setEmissiveTexture(pTexture);
modelRes.sharedMaterials[MaterialName]->bUseMaterial = true;
}
else if (parameter == ParameterDefault::kOcclusionMap) {
modelRes.sharedMaterials[MaterialName]->mpMaterial->setOcclusionMap(pTexture);
modelRes.sharedMaterials[MaterialName]->bUseMaterial = true;
}
else {
modelRes.sharedMaterials[MaterialName]->set_texture2D(parameter, pTexture);
}
}
}
}
}
}
}
modelRes.sharedMaterials[MaterialName]->set_depthStencilTest(bundle);
}
}
else
{
return error("Unknown key \"" + key + "\" when parsing model instance");
}
modelRes.setTRS(translation, rotation, scaling);
}
if (isNameDuplicate(name, mInstanceMap, "model instances"))
{
return false;
}
else
{
//auto pInstance = Scene::ModelInstance::create(pModel, translation, rotation, scaling, name);
//mInstanceMap[pInstance->getName()] = pInstance;
//addModelInstance(pInstance);
addModelResource(modelRes, "", translation, rotation, scaling);
}
}
return true;
}
bool SceneExtend::topLevelLoop()
{
for (uint32_t i = 0; i < arraysize(kFunctionTable); i++)
{
const auto& jsonMember = mJDoc.FindMember(kFunctionTable[i].token.c_str());
if (jsonMember != mJDoc.MemberEnd())
{
auto a = kFunctionTable[i].func;
if ((this->*a)(jsonMember->value) == false)
{
return false;
}
}
}
return true;
}
bool SceneExtend::error(const std::string & msg)
{
std::string err = "Error when parsing scene file \"" + mFilename + "\".\n" + msg;
#if _LOG_ENABLED
logError(err);
#else
msgBox(err);
#endif
return false;
}
void SceneExtend::createModelValue(uint32_t modelID, rapidjson::Document::AllocatorType & allocator, rapidjson::Value & jmodel)
{
jmodel.SetObject();
auto& modelRes = mModelRes.at(modelID);
const Model* pModel = modelRes.mpModel.get();
// Export model properties
addString(jmodel, allocator, SceneKeys::kFilename, stripDataDirectories(pModel->getFilename()));
addString(jmodel, allocator, SceneKeys::kName, pModel->getName());
if (getModel(modelID)->hasAnimations())
{
addLiteral(jmodel, allocator, SceneKeys::kActiveAnimation, pModel->getActiveAnimation());
}
// Export model instances
rapidjson::Value jsonInstanceArray;
jsonInstanceArray.SetArray();
for (uint32_t i = 0; i < getModelInstanceCount(modelID); i++)
{
rapidjson::Value jsonInstance;
jsonInstance.SetObject();
auto& pInstance = getModelInstance(modelID, i);
addString(jsonInstance, allocator, SceneKeys::kName, pInstance->getName());
addVector(jsonInstance, allocator, SceneKeys::kTranslationVec, pInstance->getTranslation());
// Translate rotation to degrees
glm::vec3 rotation = glm::degrees(pInstance->getRotation());
addVector(jsonInstance, allocator, SceneKeys::kRotationVec, rotation);
addVector(jsonInstance, allocator, SceneKeys::kScalingVec, pInstance->getScaling());
// Export model material properties
switch (pModel->getMesh(0)->getMaterial()->getShadingModel())
{
case ShadingModelMetalRough:
addString(jsonInstance, allocator, SceneKeys::kShadingModel, SceneKeys::kShadingMetalRough);
break;
case ShadingModelSpecGloss:
addString(jsonInstance, allocator, SceneKeys::kShadingModel, SceneKeys::kShadingSpecGloss);
break;
default:
logWarning("SceneExporter: Unknown shading model found on model " + pModel->getName() + ", ignoring value");
}
rapidjson::Value jsonMaterialArray;
jsonMaterialArray.SetArray();
for (uint32_t meshID = 0; meshID < pInstance->getObject()->getMeshCount(); meshID++)
{
rapidjson::Value jsonMaterial;
jsonMaterial.SetObject();
auto& mat = modelRes.getMaterialInstance(meshID);
addString(jsonMaterial, allocator, SceneExtendKeys::kMaterialName, mat->mName);
addString(jsonMaterial, allocator, SceneExtendKeys::kShader, mat->mShaderName);
addInt(jsonMaterial, allocator, SceneExtendKeys::kRenderQueue, mat->renderQueue);
addInt(jsonMaterial, allocator, SceneExtendKeys::kBlendMode, UINT64(mat->blendMode));
addInt(jsonMaterial, allocator, SceneExtendKeys::kRasterizeMode, UINT64(mat->rasterizeMode));
addBool(jsonMaterial, allocator, SceneExtendKeys::kDepthTest, mat->depthStencilBundle.bDepthTest);
addBool(jsonMaterial, allocator, SceneExtendKeys::kWriteDepth, mat->depthStencilBundle.bWriteDepth);
addInt(jsonMaterial, allocator, SceneExtendKeys::kDepthTestFunc, UINT64(mat->depthStencilBundle.eDepthTestFunc));
rapidjson::Value jsonMaterialParams;
jsonMaterialParams.SetObject();
if (mat->bUseMaterial) {
auto& pMat = mat->mpMaterial;
const std::string sTex2d(ParameterPrefix::kTexture2D);
addString(jsonMaterialParams, allocator, sTex2d + ParameterDefault::kBaseColor, pMat->getBaseColorTexture()->getSourceFilename());
addString(jsonMaterialParams, allocator, sTex2d + ParameterDefault::kSpecular, pMat->getSpecularTexture()->getSourceFilename());
addString(jsonMaterialParams, allocator, sTex2d + ParameterDefault::kNormalMap, pMat->getNormalMap()->getSourceFilename());
addString(jsonMaterialParams, allocator, sTex2d + ParameterDefault::kEmissive, pMat->getEmissiveTexture()->getSourceFilename());
addString(jsonMaterialParams, allocator, sTex2d + ParameterDefault::kOcclusionMap, pMat->getOcclusionMap()->getSourceFilename());
}
for (auto& v : mat->param_bool) {
addFloat(jsonMaterialParams, allocator, ParameterPrefix::kBool + v.first, v.second);
}
for (auto& v : mat->param_float) {
addFloat(jsonMaterialParams, allocator, ParameterPrefix::kFloat + v.first, v.second);
}
for (auto& v : mat->param_vec2) {
addVector(jsonMaterialParams, allocator, ParameterPrefix::kFloat2 + v.first, v.second);
}
for (auto& v : mat->param_vec3) {
addVector(jsonMaterialParams, allocator, ParameterPrefix::kFloat3 + v.first, v.second);
}
for (auto& v : mat->param_vec4) {
addVector(jsonMaterialParams, allocator, ParameterPrefix::kFloat4 + v.first, v.second);
}
for (auto& v : mat->param_int) {
addInt(jsonMaterialParams, allocator, ParameterPrefix::kInt + v.first, v.second);
}
for (auto& v : mat->param_ivec2) {
addVector(jsonMaterialParams, allocator, ParameterPrefix::kInt2 + v.first, v.second);
}
for (auto& v : mat->param_ivec3) {
addVector(jsonMaterialParams, allocator, ParameterPrefix::kInt3 + v.first, v.second);
}
for (auto& v : mat->param_ivec4) {
addVector(jsonMaterialParams, allocator, ParameterPrefix::kInt4 + v.first, v.second);
}
for (auto& v : mat->param_texture2D) {
addString(jsonMaterialParams, allocator, ParameterPrefix::kTexture2D + v.first, v.second->getSourceFilename());
}
addJsonValue(jsonMaterial, allocator, SceneExtendKeys::kParameter, jsonMaterialParams);
//todo : mat 写入
jsonMaterialArray.PushBack(jsonMaterial, allocator);
//const auto& shaderName = ;
}
rapidjson::Value jkey;
std::string k(SceneExtendKeys::kMaterials);
jkey.SetString(k.c_str(), rapidjson::SizeType(k.size()), allocator);
jsonInstance.AddMember(jkey, jsonMaterialArray, allocator);
jsonInstanceArray.PushBack(jsonInstance, allocator);
}
addJsonValue(jmodel, allocator, SceneKeys::kModelInstances, jsonInstanceArray);
}
void SceneExtend::writeModelsJson()
{
if (getModelCount() == 0)
{
return;
}
rapidjson::Value jsonModelArray;
jsonModelArray.SetArray();
for (uint32_t i = 0; i < getModelCount(); i++)
{
rapidjson::Value jsonModel;
createModelValue(i, mJDoc.GetAllocator(), jsonModel);
jsonModelArray.PushBack(jsonModel, mJDoc.GetAllocator());
}
addJsonValue(mJDoc, mJDoc.GetAllocator(), SceneKeys::kModels, jsonModelArray);
}
SceneExtend::~SceneExtend()
{
}
| [
"625673575@qq.com"
] | 625673575@qq.com |
d2b2467461d0c0fedd80b0e5ad17ce999017b13d | 7dd9c92a5be3f6df54b64e8147a9e801fe964bcb | /seven-segment/SevenSegment/SevenSegment.ino | 051007b04ec240646cc9dbcc4c79c3ffa892b4c5 | [] | no_license | prp-e/iot-projects | 9e9b4ecd12dfe20088792842f9acb47c652eafcc | 1504f2b8ee1891b44b7fea7363b356d53aaa8c4a | refs/heads/master | 2020-05-18T13:10:55.421146 | 2017-03-17T11:06:37 | 2017-03-17T11:06:37 | 84,240,502 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,640 | ino | //IoT Seven Segment
#include <ESP8266WiFi.h>
const char* ssid = "Muhammadreza";
const char* passwd = "Muhammadreza@123456";
int a = 16;
int b = 5;
int c = 4;
int d = 2;
int e = 0;
int f = 14;
int g = 12;
int led = 13;
WiFiServer server(80);
void setup() {
// put your setup code here, to run once:
pinMode(led, OUTPUT);
pinMode(a, OUTPUT);
pinMode(b, OUTPUT);
pinMode(c, OUTPUT);
pinMode(d, OUTPUT);
pinMode(e, OUTPUT);
pinMode(f, OUTPUT);
pinMode(g, OUTPUT);
Serial.begin(115200);
delay(10);
digitalWrite(led, HIGH);
WiFi.begin(ssid, passwd);
while(WiFi.status() != WL_CONNECTED){
delay(500);
Serial.print(".");
}
Serial.println(" ");
Serial.println("WiFi Connected");
server.begin();
Serial.println("Server Started!");
Serial.println(WiFi.localIP());
digitalWrite(led, LOW);
digitalWrite(a, HIGH);
digitalWrite(b, HIGH);
digitalWrite(c, HIGH);
digitalWrite(d, HIGH);
digitalWrite(e, HIGH);
digitalWrite(f, HIGH);
digitalWrite(g, HIGH);
}
void loop() {
// put your main code here, to run repeatedly:
WiFiClient client = server.available();
if(!client){
return;
}
while(!client.available()){
delay(1);
}
String request = client.readStringUntil('\r');
Serial.println(request);
client.flush();
int value = LOW;
if(request.indexOf("/1") != -1){
digitalWrite(a, HIGH);
digitalWrite(b, LOW);
digitalWrite(c, LOW);
digitalWrite(d, HIGH);
digitalWrite(e, HIGH);
digitalWrite(f, HIGH);
digitalWrite(g, HIGH);
value = HIGH;
}
if(request.indexOf("/2") != -1){
digitalWrite(a, LOW);
digitalWrite(b, LOW);
digitalWrite(c, HIGH);
digitalWrite(d, LOW);
digitalWrite(e, LOW);
digitalWrite(f, HIGH);
digitalWrite(g, LOW);
value = HIGH;
}
if(request.indexOf("/3") != -1){
digitalWrite(a, LOW);
digitalWrite(b, LOW);
digitalWrite(c, LOW);
digitalWrite(d, LOW);
digitalWrite(e, HIGH);
digitalWrite(f, HIGH);
digitalWrite(g, LOW);
value = HIGH;
}
if(request.indexOf("/4") != -1){
digitalWrite(a, HIGH);
digitalWrite(b, LOW);
digitalWrite(c, LOW);
digitalWrite(d, HIGH);
digitalWrite(e, HIGH);
digitalWrite(f, LOW);
digitalWrite(g, LOW);
value = HIGH;
}
if(request.indexOf("/5") != -1){
digitalWrite(a, LOW);
digitalWrite(b, HIGH);
digitalWrite(c, LOW);
digitalWrite(d, LOW);
digitalWrite(e, HIGH);
digitalWrite(f, LOW);
digitalWrite(g, LOW);
value = HIGH;
}
if(request.indexOf("/6") != -1){
digitalWrite(a, LOW);
digitalWrite(b, HIGH);
digitalWrite(c, LOW);
digitalWrite(d, LOW);
digitalWrite(e, LOW);
digitalWrite(f, LOW);
digitalWrite(g, LOW);
value = HIGH;
}
if(request.indexOf("/7") != -1){
digitalWrite(a, LOW);
digitalWrite(b, LOW);
digitalWrite(c, LOW);
digitalWrite(d, HIGH);
digitalWrite(e, HIGH);
digitalWrite(f, HIGH);
digitalWrite(g, HIGH);
value = HIGH;
}
if(request.indexOf("/8") != -1){
digitalWrite(a, LOW);
digitalWrite(b, LOW);
digitalWrite(c, LOW);
digitalWrite(d, LOW);
digitalWrite(e, LOW);
digitalWrite(f, LOW);
digitalWrite(g, LOW);
value = HIGH;
}
if(request.indexOf("/9") != -1){
digitalWrite(a, LOW);
digitalWrite(b, LOW);
digitalWrite(c, LOW);
digitalWrite(d, LOW);
digitalWrite(e, HIGH);
digitalWrite(f, LOW);
digitalWrite(g, LOW);
value = HIGH;
}
if(request.indexOf("/0") != -1){
digitalWrite(a, LOW);
digitalWrite(b, LOW);
digitalWrite(c, LOW);
digitalWrite(d, LOW);
digitalWrite(e, LOW);
digitalWrite(f, LOW);
digitalWrite(g, HIGH);
value = HIGH;
}
if(request.indexOf("/off") != -1){
digitalWrite(a, HIGH);
digitalWrite(b, HIGH);
digitalWrite(c, HIGH);
digitalWrite(d, HIGH);
digitalWrite(e, HIGH);
digitalWrite(f, HIGH);
digitalWrite(g, HIGH);
value = LOW;
}
client.println("HTTP/1.1 200 OK");
client.println("Content-type: text/html");
client.println("");
client.println("<!DOCTYPE HTML>");
client.println("<html>");
client.println("<head>");
client.println("<title> IoT Seven Segment </title>");
client.println("</head>");
client.println("<body>");
client.println("<h1> IoT Seven Segment </h1>");
client.println("<p> Just send requests like this :");
client.println("<br/><pre>/0</pre><br/>");
client.println("to show the number you want! It works with digits from 0 to 9");
client.println("if you want to turn it off, just <a href='/off'> click here</a></p>");
client.println("</body>");
}
| [
"haghiri75@gmail.com"
] | haghiri75@gmail.com |
9a447065943633239df0577db8c3217c511ddaa9 | d0c44dd3da2ef8c0ff835982a437946cbf4d2940 | /cmake-build-debug/programs_tiling/function14424/function14424_schedule_8/function14424_schedule_8.cpp | 20098e056faac213ad92cf97564d905f26a41d9f | [] | no_license | IsraMekki/tiramisu_code_generator | 8b3f1d63cff62ba9f5242c019058d5a3119184a3 | 5a259d8e244af452e5301126683fa4320c2047a3 | refs/heads/master | 2020-04-29T17:27:57.987172 | 2019-04-23T16:50:32 | 2019-04-23T16:50:32 | 176,297,755 | 1 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 1,092 | cpp | #include <tiramisu/tiramisu.h>
using namespace tiramisu;
int main(int argc, char **argv){
tiramisu::init("function14424_schedule_8");
constant c0("c0", 32768), c1("c1", 2048);
var i0("i0", 0, c0), i1("i1", 0, c1), i01("i01"), i02("i02"), i03("i03"), i04("i04");
input input00("input00", {i1}, p_int32);
input input01("input01", {i0}, p_int32);
input input02("input02", {i1}, p_int32);
computation comp0("comp0", {i0, i1}, input00(i1) * input01(i0) - input02(i1));
comp0.tile(i0, i1, 128, 128, i01, i02, i03, i04);
comp0.parallelize(i01);
buffer buf00("buf00", {2048}, p_int32, a_input);
buffer buf01("buf01", {32768}, p_int32, a_input);
buffer buf02("buf02", {2048}, p_int32, a_input);
buffer buf0("buf0", {32768, 2048}, p_int32, a_output);
input00.store_in(&buf00);
input01.store_in(&buf01);
input02.store_in(&buf02);
comp0.store_in(&buf0);
tiramisu::codegen({&buf00, &buf01, &buf02, &buf0}, "../data/programs/function14424/function14424_schedule_8/function14424_schedule_8.o");
return 0;
} | [
"ei_mekki@esi.dz"
] | ei_mekki@esi.dz |
ad8082dc6c83cca9f21afa2ee6cac44a67b06dd3 | acf7398d661bb8c5ca64017fafe34af42ed0b8d7 | /NETWORKMODULE/network/NetServerAdv.cpp | e0be34930aa71b1c26ad93363d9e9c4b339add0f | [] | no_license | luw630/Serverframe | 884be88f9e83c0f0cbb3686b033868778db11afc | e8460cc9b5304fae3470b3eed0ea65fccb24c5b8 | refs/heads/master | 2021-01-10T07:39:08.308979 | 2016-01-12T03:39:24 | 2016-01-12T03:39:24 | 46,545,341 | 2 | 0 | null | null | null | null | GB18030 | C++ | false | false | 21,082 | cpp | //---------------------------------------------------------------------------
// Engine (c) 1999-2000 by Dreamwork
//
// File: CNetServerAdv.cpp
// Date: 2003.07.08
// Code: Dreamwork
// Desc: Simple double linked node class
//---------------------------------------------------------------------------
#include "NetServerAdv.h"
#define USE_CRC
#include "desdec.h"
#pragma comment (lib, "DirectNetServer.lib")
extern BOOL rfalse(char, char, LPCSTR, ...);
extern void TraceMemory(LPVOID pDumpEntry, int iOffset, unsigned int uiSize, LPCSTR szFilename);
//---------------------------------------------------------------------------
#define N_SOCKET_MIN_PORTNUM (7000)
#define N_SOCKET_MAX_PORTNUM (7999)
#define N_SOCKET_PORTRANGE (N_SOCKET_MAX_PORTNUM - N_SOCKET_MIN_PORTNUM)
#define TIMEOUTTIME (100000)
#define PINGMARGIN (15000)
cDirectNetDecryption _cryption2;
#define CHECKINFO "this is guard array in class CNetServerExAdv for check overflow"
extern void _set_server_ga_info(char _ga[64]);
// comput hash value, same as g_Hash(char *) in enginelib.lib
static DWORD ComputHashValue(LPCSTR szStr)
{
BYTE const * pStr = (BYTE const *)szStr;
unsigned long i = 0, j = 1;
while (*pStr != 0) i += (*pStr++) * j++;
return i % 256;
}
//---------------------------------------------------------------------------
// 函数: CNetServerAdv
// 功能: 构造
// 参数: void
// 返回: void
//---------------------------------------------------------------------------
CNetServerAdv::CNetServerAdv(BOOL bUseVerify) :
m_bUseVerify(bUseVerify)
{
InitializeCriticalSection(&m_ClientMapLock);
InitializeCriticalSection(&m_PacketQueueLock);
m_pDirectNetServer = iDirectNetServer::CreateInstance();
m_pDefaultContext = NULL;
m_dwPrevCheckTime = timeGetTime();
_set_server_ga_info(CHECKINFO);
m_dwInSize = 0;
m_dwOutSize = 0;
m_dwInNumber = 0;
m_dwOutNumber = 0;
}
//---------------------------------------------------------------------------
// 函数: ~CNetServerAdv
// 功能: 分构
// 参数: void
// 返回: void
//---------------------------------------------------------------------------
CNetServerAdv::~CNetServerAdv(void)
{
Close();
m_pDefaultContext = NULL;
m_pDirectNetServer->Release();
DeleteCriticalSection(&m_PacketQueueLock);
DeleteCriticalSection(&m_ClientMapLock);
}
//---------------------------------------------------------------------------
// 函数: Create
// 功能: 构造
// 参数: char*
// 返回: void
//---------------------------------------------------------------------------
BOOL CNetServerAdv::Create(const char *szPortName)
{
if (szPortName == NULL)
return FALSE;
// use 'this' as context for the message handler
DNRESULT dnr = m_pDirectNetServer->Initialize(&_cryption2, this, MAX_CLIENT_NUMBER);
if (DNR_FAILED(dnr))
return FALSE;
// this is needed for extracting the port number from a string
WORD wPort = static_cast<WORD>( ComputHashValue(szPortName) + N_SOCKET_MIN_PORTNUM );
dnr = m_pDirectNetServer->Host(wPort);
// ok, the DreamNetServer is now hosting ...
return !DNR_FAILED(dnr);
}
//---------------------------------------------------------------------------
// 函数: Close
// 功能:
// 参数: void
// 返回: void
//---------------------------------------------------------------------------
BOOL CNetServerAdv::Close(void)
{
DNRESULT dnr = m_pDirectNetServer->Close();
__try
{
EnterCriticalSection(&m_ClientMapLock);
m_ClientMap.clear();
}
__finally
{
LeaveCriticalSection(&m_ClientMapLock);
}
__try
{
EnterCriticalSection(&m_PacketQueueLock);
while (!m_PacketQueue.empty())
{
delete m_PacketQueue.front()->m_pvBuffer;
delete m_PacketQueue.front();
m_PacketQueue.pop();
}
}
__finally
{
LeaveCriticalSection(&m_PacketQueueLock);
}
return DNR_FAILED(dnr);
}
//---------------------------------------------------------------------------
// 函数: SendMessage
// 功能: 向某一客户端发数据包
// 参数: int nClientIndex
// 返回: int
//---------------------------------------------------------------------------
BOOL CNetServerAdv::SendMessage(DNID dnidClient, const void *pvBuf, WORD wSize)
{
if (dnidClient == 0 || pvBuf == NULL || wSize == 0)
return FALSE;
DNRESULT dnr = DNR_E_FAIL;
__try
{
dnr = m_pDirectNetServer->SendTo(dnidClient, const_cast<PVOID>(pvBuf), wSize);
// 更新统计数据
m_dwOutSize += wSize + 4; // 后面的4是封包头的数据
m_dwOutNumber ++;
}
__finally
{
}
return !DNR_FAILED(dnr);
}
BOOL CNetServerAdv::SendDirect(DNID dnidClient, LPVOID pPackage, WORD wSize)
{
if (dnidClient == 0 || pPackage == NULL || wSize == 0)
return FALSE;
DNRESULT dnr = DNR_E_FAIL;
DWORD optopen[2] = {2, 1};
if (SetOption(optopen))
{
dnr = m_pDirectNetServer->SendTo(dnidClient, pPackage, wSize);
DWORD optclose[2] = {2, 0};
SetOption(optclose);
}
else
{
// 旧的directnetserver不支持setoption，所以需要先解码，然后再一个个发送
// 暂时不允许！！！
MessageBox(0, "directnetserver.dll 版本太低！！！", 0, 0);
}
return !DNR_FAILED(dnr);
}
//---------------------------------------------------------------------------
// 函数: GetMessage
// 功能: 接收某一客户端的数据包
// 参数: int nClientIndex
// 返回: const PACKET &
// 说明:
//---------------------------------------------------------------------------
BOOL CNetServerAdv::GetMessage(SNetServerPacketAdv **ppPacket)
{
__try
{
EnterCriticalSection(&m_PacketQueueLock);
if (m_PacketQueue.size() == 0)
return FALSE;
*ppPacket = m_PacketQueue.front();
m_PacketQueue.pop();
}
__finally
{
LeaveCriticalSection(&m_PacketQueueLock);
}
return TRUE;
}
//---------------------------------------------------------------------------
// 函数: DelOneClient
// 功能: 断开一个客户端连接
// 参数: nClientIndex
// 返回: void
// 2004-1-25 添加互斥锁
//---------------------------------------------------------------------------
BOOL CNetServerAdv::DelOneClient(DNID dnidClient)
{
if (dnidClient == 0)
return FALSE;
__try
{
// the rest will be handled inside DN_MSGID_DELETE_PLAYER handler
// rfalse(2, 1, "因为某种原因删除角色:%x", dnidClient);
m_pDirectNetServer->DeletePlayer(dnidClient);
}
__finally
{
}
return TRUE;
}
//---------------------------------------------------------------------------
void CNetServerAdv::OnCreatePlayer(DNID dnidClient, PVOID *ppvPlayerContext)
{
if (dnidClient == 0 || ppvPlayerContext == NULL)
return;
__try
{
EnterCriticalSection(&m_ClientMapLock);
*ppvPlayerContext = NewLinkData(dnidClient);
}
__finally
{
LeaveCriticalSection(&m_ClientMapLock);
}
}
//---------------------------------------------------------------------------
void CNetServerAdv::OnReceivePacket(DNID dnidClient, PVOID pvPlayerContext, PVOID pvBuffer, DWORD dwLength, DWORD dwSequence)
{
if (dnidClient == 0 || pvPlayerContext == NULL || pvBuffer == NULL || dwLength == 0 || dwLength > 0xffff)
return;
WORD wLength = static_cast<WORD>(dwLength);
CLinkDataAdv *pLinkData = static_cast<CLinkDataAdv *>(pvPlayerContext);
LINKSTATUS enumStatus = LinkStatus_UnConnected;
LPVOID pContext = NULL;
if (m_bUseVerify)
{
if (wLength < 12)
{
// 无效的数据包长度，可能进行了封包修改，直接删除连接！
DelOneClient(dnidClient);
return;
}
DWORD qwHeader[2] = {0, 0};
memcpy(qwHeader, pvBuffer, 8);
_cryption2.DES_decrypt(qwHeader, 8);
DWORD Key32 = qwHeader[1];
DWORD Crc32 = qwHeader[0] ^ Key32;
// 这里操作了m_ClientMap的数据，所以需要加锁！
__try
{
EnterCriticalSection(&m_ClientMapLock);
// 更新统计数据
m_dwInSize += dwLength;
m_dwInNumber ++;
enumStatus = pLinkData->GetLinkStatus();
pContext = pLinkData->GetContext();
// 可能是第一次连接游戏服务器
if (dwSequence == 0)
{
// 记录异或值
pLinkData->SetXorCipher(Key32);
}
// 已经连接过服务器了，通过Key32校验数据
else if (_get_dval(pLinkData->GetXorCipher()) == Key32)
{
// 更新异或值
pLinkData->SetXorCipher(Key32);
}
else
{
// 校验失败，可能进行了封包修改，直接删除连接！
DelOneClient(dnidClient);
return;
}
}
__finally
{
LeaveCriticalSection(&m_ClientMapLock);
}
LPDWORD pXorPtr = static_cast<LPDWORD>(pvBuffer) + 2;
DWORD count = (wLength >> 2) - 2;
DWORD dwAccKey = Key32;
while (count > 0)
{
*pXorPtr ^= dwAccKey;
pXorPtr ++;
count --;
dwAccKey += 0xcdcd;
}
// 校验Crc32
if (Crc32 != _cryption2.CRC32_compute(static_cast<LPBYTE>(pvBuffer) + 8, wLength - 8))
{
// 无效的数据包Crc数据，可能进行了封包修改，直接删除连接！
DelOneClient(dnidClient);
return;
}
pvBuffer = static_cast<LPBYTE>(pvBuffer) + 8;
wLength -= 8;
}
else
{
__try
{
EnterCriticalSection(&m_ClientMapLock);
enumStatus = pLinkData->GetLinkStatus();
pContext = pLinkData->GetContext();
}
__finally
{
LeaveCriticalSection(&m_ClientMapLock);
}
}
if (wLength == 8)
{
// 及时响应ping消息
if (static_cast<const LPDWORD>(pvBuffer)[0] ==
static_cast<const LPDWORD>(static_cast<void *>("ping"))[0])
{
__try
{
EnterCriticalSection(&m_ClientMapLock);
pLinkData->SetTimeOutTime(timeGetTime());
}
__finally
{
LeaveCriticalSection(&m_ClientMapLock);
}
DWORD pong[2] = {
static_cast<const LPDWORD>(static_cast<void *>("pong"))[0],
static_cast<const LPDWORD>(pvBuffer)[1]
};
SendMessage(dnidClient, pong, 8);
return;
}
}
PushPacket(dnidClient, enumStatus, pvBuffer, wLength, pContext);
}
//---------------------------------------------------------------------------
void CNetServerAdv::OnDeletePlayer(DNID dnidClient, PVOID pvPlayerContext)
{
if (dnidClient == 0 || pvPlayerContext == NULL)
return;
CLinkDataAdv *pLinkData = static_cast<CLinkDataAdv *>(pvPlayerContext);
LINKSTATUS enumStatus = LinkStatus_UnConnected;
LPVOID pContext = NULL;
__try
{
EnterCriticalSection(&m_ClientMapLock);
enumStatus = pLinkData->GetLinkStatus();
pContext = pLinkData->GetContext();
m_ClientMap.erase(dnidClient);
if (enumStatus == LinkStatus_Connected)
enumStatus = LinkStatus_Disconnected;
else
enumStatus = LinkStatus_UnConnected;
}
__finally
{
LeaveCriticalSection(&m_ClientMapLock);
}
PushPacket(dnidClient, enumStatus, NULL, 0, pContext);
}
//---------------------------------------------------------------------------
BOOL CNetServerAdv::IsValidDnid(DNID dnidClient)
{
if (dnidClient == 0)
return FALSE;
__try
{
EnterCriticalSection(&m_ClientMapLock);
if (m_ClientMap.find(dnidClient) != m_ClientMap.end())
return TRUE;
}
__finally
{
LeaveCriticalSection(&m_ClientMapLock);
}
return FALSE;
}
BOOL CNetServerAdv::GetDnidAddr(DNID dnidClient, sockaddr_in *pAddr, size_t size)
{
if (size != sizeof(sockaddr_in))
return FALSE;
if (!IsValidDnid(dnidClient))
return FALSE;
iDirectNetServer::CONNECTIONINFO cinfo;
DNRESULT dnr = m_pDirectNetServer->GetPlayerConnectionInfo(dnidClient, &cinfo);
if (DNR_FAILED(dnr))
return FALSE;
pAddr->sin_port = cinfo.port;
pAddr->sin_addr.S_un.S_addr = cinfo.addr;
return TRUE;
}
LINKSTATUS CNetServerAdv::GetLinkStatus(DNID dnidClient)
{
if (dnidClient == 0)
return LinkStatus_UnConnected;
LINKSTATUS ret = LinkStatus_UnConnected;
__try
{
EnterCriticalSection(&m_ClientMapLock);
std::map<DNID, CLinkDataAdv>::iterator it = m_ClientMap.find(dnidClient);
if (it != m_ClientMap.end())
ret = it->second.GetLinkStatus();
}
__finally
{
LeaveCriticalSection(&m_ClientMapLock);
}
return ret;
}
BOOL CNetServerAdv::SetLinkStatus(DNID dnidClient, LINKSTATUS enumStatus)
{
if (dnidClient == 0)
return FALSE;
__try
{
EnterCriticalSection(&m_ClientMapLock);
std::map<DNID, CLinkDataAdv>::iterator it = m_ClientMap.find(dnidClient);
if (it != m_ClientMap.end())
{
it->second.SetLinkStatus(enumStatus);
return TRUE;
}
}
__finally
{
LeaveCriticalSection(&m_ClientMapLock);
}
return FALSE;
}
BOOL CNetServerAdv::SetLinkForceTimeOutTime(DNID dnidClient, DWORD dwTime)
{
__try
{
EnterCriticalSection(&m_ClientMapLock);
std::map<DNID, CLinkDataAdv>::iterator it = m_ClientMap.find(dnidClient);
if (it != m_ClientMap.end())
{
it->second.SetForceTimeOutTime(timeGetTime() + dwTime);
return TRUE;
}
}
__finally
{
LeaveCriticalSection(&m_ClientMapLock);
}
return FALSE;
}
BOOL CNetServerAdv::ClearLinkForceTimeOutTime(DNID dnidClient)
{
return SetLinkForceTimeOutTime(dnidClient, 0xffffffff);
}
LPVOID CNetServerAdv::GetDefaultContext()
{
return m_pDefaultContext;
}
BOOL CNetServerAdv::SetDefaultContext(LPVOID pContext)
{
m_pDefaultContext = pContext;
return TRUE;
}
LPVOID CNetServerAdv::GetLinkContext(DNID dnidClient)
{
if (dnidClient == 0)
return NULL;
LPVOID ret = NULL;
__try
{
EnterCriticalSection(&m_ClientMapLock);
std::map<DNID, CLinkDataAdv>::iterator it = m_ClientMap.find(dnidClient);
if (it != m_ClientMap.end())
ret = it->second.GetContext();
}
__finally
{
LeaveCriticalSection(&m_ClientMapLock);
}
return ret;
}
BOOL CNetServerAdv::SetLinkContext(DNID dnidClient, LPVOID pContext)
{
if (dnidClient == 0)
return NULL;
__try
{
EnterCriticalSection(&m_ClientMapLock);
std::map<DNID, CLinkDataAdv>::iterator it = m_ClientMap.find(dnidClient);
if (it != m_ClientMap.end())
it->second.SetContext(pContext);
}
__finally
{
LeaveCriticalSection(&m_ClientMapLock);
}
return TRUE;
}
DWORD CNetServerAdv::GetClientNum()
{
__try
{
EnterCriticalSection(&m_ClientMapLock);
return static_cast<DWORD>(m_ClientMap.size());
}
__finally
{
LeaveCriticalSection(&m_ClientMapLock);
}
}
BOOL CNetServerAdv::SetOption(LPDWORD pParam)
{
return m_pDirectNetServer->GetPlayerConnectionInfo(0xff00ff00ff00ff00,
(iDirectNetServer::CONNECTIONINFO *)pParam) == DNR_S_OK;
}
DWORD CNetServerAdv::GetClientNum_Dll()
{
iDirectNetServer::CONNECTIONINFO cinfo;
DNRESULT dnr = m_pDirectNetServer->GetPlayerConnectionInfo(-1, &cinfo);
if (DNR_FAILED(dnr))
return -1;
return cinfo.addr;
}
void CNetServerAdv::CheckAlive()
{
DWORD dwCurrentTime = timeGetTime();
if ((int)(dwCurrentTime - m_dwPrevCheckTime) < PINGMARGIN/10)
return;
// 以这个时间段作为Dump流量的采样单位
m_dwPrevCheckTime = dwCurrentTime;
__try
{
EnterCriticalSection(&m_ClientMapLock);
std::map<DNID, CLinkDataAdv>::iterator it = m_ClientMap.begin();
while (it != m_ClientMap.end())
{
CLinkDataAdv *pLinkData = &it->second;
it++;
if ((int)(dwCurrentTime - pLinkData->GetTimeOutTime()) > TIMEOUTTIME)
DelOneClient(pLinkData->GetDnidClient());
if (pLinkData->GetForceTimeOutTime() != 0)
if ((int)(dwCurrentTime - pLinkData->GetForceTimeOutTime()) > 0)
DelOneClient(pLinkData->GetDnidClient());
}
}
__finally
{
LeaveCriticalSection(&m_ClientMapLock);
}
}
DWORD CNetServerAdv::GetPacketNumber()
{
return (DWORD)m_PacketQueue.size();
}
BOOL CNetServerAdv::PushPacket(DNID dnidClient, LINKSTATUS enumStatus, LPVOID pvBuffer, WORD wLength, LPVOID pContext)
{
__try
{
if( wLength>60000 ) return FALSE;
EnterCriticalSection(&m_PacketQueueLock);
SNetServerPacketAdv *pPacket = new SNetServerPacketAdv;
if (wLength == 0)
{
pPacket->m_pvBuffer = NULL;
}
else
{
pPacket->m_pvBuffer = new char [((DWORD)wLength) + 512];
memcpy(pPacket->m_pvBuffer, pvBuffer, wLength);
}
pPacket->m_wLength = wLength;
pPacket->m_dnidClient = dnidClient;
pPacket->m_enumStatus = enumStatus;
pPacket->m_pContext = pContext;
static bool cc = false;
if (cc)
{
delete pPacket->m_pvBuffer;
delete pPacket;
return TRUE;
}
m_PacketQueue.push(pPacket);
extern DWORD sinsize;
sinsize += (((DWORD)wLength) + 512);
}
__finally
{
LeaveCriticalSection(&m_PacketQueueLock);
}
return TRUE;
}
CLinkDataAdv *CNetServerAdv::NewLinkData(DNID dnidClient)
{
m_ClientMap[dnidClient] = CLinkDataAdv(dnidClient, m_pDefaultContext);
#ifdef LOG_IP
sockaddr_in addr;
GetDnidAddr(dnidClient, &addr, sizeof(addr));
void SetIPConnect(DWORD IP);
SetIPConnect(addr.sin_addr.S_un.S_addr);
#endif
return &m_ClientMap[dnidClient];
}
DWORD CNetServerAdv::GetInSizeAndClear(void)
{
DWORD dwSize = m_dwInSize;
m_dwInSize = 0;
return dwSize;
}
DWORD CNetServerAdv::GetOutSizeAndClear(void)
{
DWORD dwSize = m_dwOutSize;
m_dwOutSize = 0;
return dwSize;
}
////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////
//
// class CLinkDataAdv
//
////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////
CLinkDataAdv::CLinkDataAdv() :
CLinkData()
{
m_pContext = NULL;
}
CLinkDataAdv::CLinkDataAdv(DNID dnidClient, LPVOID pContext) :
CLinkData(dnidClient)
{
m_pContext = pContext;
}
CLinkDataAdv::~CLinkDataAdv()
{
m_pContext = NULL;
}
LPVOID CLinkDataAdv::GetContext()
{
return m_pContext;
}
BOOL CLinkDataAdv::SetContext(LPVOID pContext)
{
m_pContext = pContext;
return TRUE;
}
////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////
//
// class CNetServerPacketAdv
//
////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////
/*
CNetServerPacketAdv::CNetServerPacketAdv() :
CNetServerPacket()
{
m_pContext = NULL;
}
CNetServerPacketAdv::CNetServerPacketAdv(const CNetServerPacketAdv &Packet) :
CNetServerPacket(Packet)
{
m_pContext = Packet.m_pContext;
const_cast<LPVOID>(Packet.m_pContext) = NULL;
}
CNetServerPacketAdv::CNetServerPacketAdv(DNID dnidClient,
LINKSTATUS enumStatus, LPVOID pvBuffer, WORD wLength, LPVOID pContext) :
CNetServerPacket(dnidClient, enumStatus, pvBuffer, wLength)
{
m_pContext = pContext;
}
CNetServerPacketAdv::~CNetServerPacketAdv()
{
m_pContext = NULL;
}
LPVOID CNetServerPacketAdv::GetContext()
{
return m_pContext;
}
void CNetServerPacketAdv::operator = (const CNetServerPacketAdv &Packet)
{
CNetServerPacket::operator = (Packet);
m_pContext = Packet.m_pContext;
const_cast<LPVOID>(Packet.m_pContext) = NULL;
}
*/ | [
"luw630@gmail.com"
] | luw630@gmail.com |
f6844d66cb664869f26f30518b549ed6f5f7d779 | df1695a0f18a68e0785d336eb2453bbd49ba2068 | /Lab4/2.cpp | 89677cf77cb5a2c42d0589bf8ea5ae0c07ce9ae2 | [] | no_license | IrisStream/PTTKGT | c63cc6ac6a39d6bf431f1e7aedd1a4c423ee9d65 | f4db5550714a4d8b8246b8ea7f8df1111d9ff26c | refs/heads/main | 2023-05-30T06:52:48.147924 | 2021-06-09T03:47:10 | 2021-06-09T03:47:10 | 356,627,736 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 621 | cpp | #include <algorithm>
#include <iostream>
#include <fstream>
#include <queue>
using namespace std;
int J(int n){
if(n == 1)
return 1;
if(n & 1)
return 2 * J(n >> 1) + 1;
else
return 2 * J(n >> 1) - 1;
}
int main(){
ifstream input("input_2.txt");
int n;
input >> n;
input.close();
queue<int> q;
for(int i = 0;i<n;i++)
q.push(i + 1);
while(q.size() > 1){
int killer = q.front(); q.pop();
int deadth = q.front(); q.pop();
q.push(killer);
cout << deadth << " ";
}
cout << endl << J(n) << endl;
return 0;
}
| [
"ngodaisonn@gmail.com"
] | ngodaisonn@gmail.com |
d50c474656e5fbd33def1c1cc6fb8cb8fdb463e0 | 0eff74b05b60098333ad66cf801bdd93becc9ea4 | /second/download/git/gumtree/git_repos_function_2312_git-2.0.5.cpp | a548bac329305e56ca12647806f427fdca078ae9 | [] | no_license | niuxu18/logTracker-old | 97543445ea7e414ed40bdc681239365d33418975 | f2b060f13a0295387fe02187543db124916eb446 | refs/heads/master | 2021-09-13T21:39:37.686481 | 2017-12-11T03:36:34 | 2017-12-11T03:36:34 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 705 | cpp | static void *zlib_deflate_raw(void *data, unsigned long size,
int compression_level,
unsigned long *compressed_size)
{
git_zstream stream;
unsigned long maxsize;
void *buffer;
int result;
memset(&stream, 0, sizeof(stream));
git_deflate_init_raw(&stream, compression_level);
maxsize = git_deflate_bound(&stream, size);
buffer = xmalloc(maxsize);
stream.next_in = data;
stream.avail_in = size;
stream.next_out = buffer;
stream.avail_out = maxsize;
do {
result = git_deflate(&stream, Z_FINISH);
} while (result == Z_OK);
if (result != Z_STREAM_END) {
free(buffer);
return NULL;
}
git_deflate_end(&stream);
*compressed_size = stream.total_out;
return buffer;
} | [
"993273596@qq.com"
] | 993273596@qq.com |
6e579dd5111b0657b3018e0f40985d65a5b8dfca | 3d85474e3ca2c9de7941477d0e06d7bdb867e6af | /412-fizz-buzz.cpp | 582bc3207cb0b625a495f80d1a8f4bb6587e3cea | [
"MIT"
] | permissive | nave7693/leetcode | 9dd7c14d27e8f3abc974a50028709c236bdc03ef | 8ff388cb17e87aa9053eaed3b84e7dc2be3e2e49 | refs/heads/master | 2020-05-22T08:02:27.292507 | 2017-08-28T18:20:46 | 2017-08-28T18:20:46 | 51,724,795 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 721 | cpp | // https://leetcode.com/problems/fizz-buzz/
class Solution {
public:
vector<string> fizzBuzz(int n) {
vector<string> result(0);
if (n >= 1) {
for (int i = 1; i <= n; i++) {
if (i % 3 != 0 && i % 5 != 0) {
result.push_back(std::to_string(i));
} else {
if (i % 15 == 0) {
result.push_back("FizzBuzz");
} else if (i % 3 == 0) {
result.push_back("Fizz");
} else {
result.push_back("Buzz");
}
}
}
}
return result;
}
}; | [
"nave7693@digitcastle.net"
] | nave7693@digitcastle.net |
7c4e5fc52f24dcf5c5d04989cada7648fb4a3021 | b196975bbdc3571a3907ad5d5ac7fe762cdf193d | /corrections/TriggerCorrector.h | 0dd0a94788225f49828fad616412fd279e48643f | [] | no_license | kpedro88/Analysis | 70393073cf0c6f47ab6fdb2ed2037db25587076a | 04d9c42e30292e35e50e103458225c435b459302 | refs/heads/SVJ2018 | 2023-09-01T13:39:23.766256 | 2023-08-22T19:30:08 | 2023-08-22T19:30:08 | 27,397,021 | 3 | 7 | null | 2021-01-08T20:40:10 | 2014-12-01T19:59:02 | Shell | UTF-8 | C++ | false | false | 1,103 | h | #ifndef TRIGGERCORRECTOR_H
#define TRIGGERCORRECTOR_H
#include "Helper.h"
#include <TFile.h>
#include <TEfficiency.h>
#include <string>
#include <vector>
#include <iostream>
#include <cmath>
class TriggerCorrector {
public:
//constructor
TriggerCorrector() : eff(NULL), debug(false) {}
//destructor
virtual ~TriggerCorrector() {}
//setup
void SetEff(std::string fname, std::string effname){
TFile* file = helper::Open(fname);
eff = helper::Get<TEfficiency>(file,effname);
eff->SetDirectory(0);
file->Close();
}
//function
double GetCorrection(double var, int unc=0){
int bin = eff->FindFixBin(var);
//underflow/overflow protection
bin = std::min(std::max(1,bin),eff->GetTotalHistogram()->GetNbinsX());
double val = eff->GetEfficiency(bin);
if(unc>0) val += eff->GetEfficiencyErrorUp(bin);
else if(unc<0) val -= eff->GetEfficiencyErrorLow(bin);
if(debug) std::cout << "corr = " << val << " (var = " << var << ", bin = " << bin << ", unc = " << unc << ")" << std::endl;
return val;
}
//members
TEfficiency *eff;
bool debug;
};
#endif
| [
"kpedro88@gmail.com"
] | kpedro88@gmail.com |
968ab7b768b10f2ac1c0d5599989756de8ec911b | d579be23744b02583d7ced1282f76ee2c9ed5df4 | /Exercise6-17.cpp | 1a60499d1d309b07c0d08922f1e8e11bded74606 | [] | no_license | jarye-bread/C-Primer-Examples | 10ee681e0b8c14f168448515904b4c698c67075a | 4c2d2aad90d5179901f45ec45898daf2c50cb49f | refs/heads/master | 2021-01-02T08:43:08.280438 | 2017-11-22T06:32:14 | 2017-11-22T06:32:14 | 99,051,232 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,198 | cpp | // Jarye Murphy
// exercise 6.17 from c++ primer
/*
Exercise 6.17: Write a function to determine whether a string contains any capital
letters. Write a function to change a string to all lowercase. Do the parameters you
used in these functions have the same type? If so, why? If not, why not?
*/
#include <iostream>
#include <string>
using std::string;
using std::cout;
using std::cin;
bool hasCapitalLetters(const string &s)
{
for (auto it = s.begin(); it != s.end(); ++it)
{
if (isupper(*it) == 1)
{
return true;
}
}
return false;
}
void allLowerCase(string &s)
{
for (auto it = s.begin(); it != s.end(); ++it)
{
if (isupper(*it) == 1)
{
*it = tolower(*it);
}
}
}
int main()
{
cout << "Enter a string and I will tell you if it has capital letters: " << std::endl;
string res;
getline(cin, res);
if (hasCapitalLetters(res) == true)
{
cout << "the string: " << res << " has capital letters in it" << std::endl;
}
else
{
cout << "the string: " << res << " doesnt have capital letters in it" << std::endl;
}
allLowerCase(res);
cout << "all lowercase now: " << res << std::endl;
system("Pause");
return 0;
} | [
"noreply@github.com"
] | noreply@github.com |
966b7dfbdfcad028092c8ee2b6c3e77dfb7902fe | e8160a316d2943cce7e2eb914cfc626e3e51cbfe | /2146 다리 만들기/2146 다리 만들기/main.cpp | 1b7266459abad0d4fc41519ad1a4b37bd4f34aae | [] | no_license | Erica1217/algorithm | c5a411289ae12672c3d7418672be574beab370a1 | a2e15aa72fbfbc149d5409a9a14a8379e929d949 | refs/heads/main | 2023-01-20T13:17:19.652577 | 2020-11-26T05:31:24 | 2020-11-26T05:31:24 | 316,132,323 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,327 | cpp | //
// main.cpp
// 2146 다리 만들기
//
// Created by 김유진 on 2020/07/24.
// Copyright © 2020 김유진. All rights reserved.
//
#include <cstdio>
int n;
int input[200][200]={0,};
int dx[5]={0,0,-1,1};
int dy[5]={1,-1,0,0};
int result= 1000000;
int data[110][110][11000]={0,};
void func(int num, int x, int y)
{
for(int i=0 ; i<4 ; i++)
{
int X = x+dx[i];
int Y = y+dy[i];
if(X>=0 && X<n && Y>=0 && y<n && input[X][Y]==1)
{
input[X][Y]=num;
func(num,X,Y);
}
}
}
void getMin(int start, int x, int y, int num)
{
for(int i=0 ; i<4 ; i++)
{
int X = x+dx[i];
int Y = y+dy[i];
if(X>=0 && X<n && Y>=0 && y<n)
{
if(input[X][Y]!=0 && input[X][Y]!=start)
{
data[X][Y][start]=num+1;
result = result<num+1 ? result:num+1;
}
else if(input[X][Y]==start && data[X][Y][start]==0)
{
data[X][Y][start]=num;
getMin(start,X,Y,num);
}
else if(data[X][Y][start]==0 || data[X][Y][start]>num+1)
{
printf("%d %d\n",data[X][Y][start], num+1);
printf("%d %d %d %d\n",start,x,y,num);
data[X][Y][start]=num+1;
getMin(start,X,Y,num+1);
}
}
}
}
int main()
{
freopen("input.txt","r",stdin);
scanf("%d",&n);
for(int i=0 ; i<n ; i++)
{
for(int j=0 ; j<n ; j++)
{
scanf("%d",&input[i][j]);
}
}
int num=2;
for(int i=0 ; i<n ; i++)
{
for(int j=0 ; j<n ;j++)
{
if(input[i][j]==1)
{
input[i][j]=num;
func(num,i,j);
num++;
}
}
}
num=2;
for(int i=0 ; i<n ; i++)
{
for(int j=0 ; j<n ; j++)
{
if(input[i][j]==num)
{
getMin(num,i,j,1);
}
}
}
// for(int i=0 ; i<n ; i++)
// {
// for(int j=0 ; j<n ; j++)
// {
//// printf("%d ",data[i][j][2]);
// printf("%d ",input[i][j]);
// }
// printf("\n");
// }
printf("%d\n",result-2);
}
| [
"yyjin1217@naver.com"
] | yyjin1217@naver.com |
6e065b741dcdb278877a0dd96574ab82c85cc38a | 23ace58d05876953cb78ff44f963b8e79070889c | /zoj/3936.cpp | 9901e42e2705c5696a93d2d508a8de859537904c | [] | no_license | InTheBloodHorse/ACM | ae9d2fccb33efee2d54b530eba0b0640aff5ae43 | 7a1a5c7d3b5e1ede7c62b484f91e89bcf012bd5d | refs/heads/master | 2020-03-28T09:01:59.552044 | 2019-04-30T13:37:58 | 2019-04-30T13:37:58 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 213 | cpp | #include<bits/stdc++.h>
using namespace std;
int main()
{
int t;
cin >> t;
while(t--){
int a,b,c,d;
cin >> a >> b >> c >> d;
cout << c << " " << (b+d) << endl;
cout << a << " " << (b+d) << endl;
}
}
| [
"2495088064@qq.com"
] | 2495088064@qq.com |
1c1e758a424103a1821ce1a7888721360fcbee94 | d1f0f07df2f44fab9c5d5ad097b9e813059fc2cc | /module03/ex01/FragTrap.hpp | 66206420643e298383615ba78d88935b98331203 | [] | no_license | jnannie21/cpp_modules | ed64d952fa90df70fdd94fb65bdf6abae1143b72 | 708c41eae5fefd1d3f2ea371b4fab6ee0da7db10 | refs/heads/master | 2023-02-06T07:12:07.768602 | 2020-12-30T11:24:32 | 2020-12-30T11:24:32 | 318,843,245 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,047 | hpp | //
// Created by Johnette Nannie on 12/17/20.
//
#ifndef FRAGTRAP_HPP
#define FRAGTRAP_HPP
#include <string>
class FragTrap {
public:
FragTrap(void);
FragTrap(std::string name);
FragTrap(const FragTrap &f);
FragTrap &operator=(const FragTrap &f);
~FragTrap(void);
void takeDamage(unsigned int amount);
void beRepaired(unsigned int amount);
void rangedAttack(std::string const & target) const;
void meleeAttack(std::string const & target) const;
void vaultHunterDotExe(std::string const & target);
private:
std::string _type;
unsigned int _hitPoints;
unsigned int _maxHitPoints;
unsigned int _energyPoints;
unsigned int _maxEnergyPoints;
unsigned int _level;
std::string _name;
unsigned int _meleeAttackDamage;
unsigned int _rangedAttackDamage;
unsigned int _armorDamageReduction;
static bool _isRandInitialized;
static const std::string _randomAttackPool[5];
static const unsigned int _randomAttackDamage[5];
static const unsigned int _randomAttackEnergyCost;
void _initializeRand(void);
};
#endif //FRAGTRAP_HPP
| [
"jnannie@student.21-school.ru"
] | jnannie@student.21-school.ru |
97a2cb51c9c843a1fd137707c8c74218257f8c47 | 0fb306192d1c715f50e7c20f55f0f0e4273ef32e | /FloorPlanGit/Original Code/cqsa/mcs/include/ManufacturingDefect.h | 158b42eda9d414cd4fd9b8eef100861fa4b8d154 | [] | no_license | archfp/floorplan | e168d3c96f10d3f63e802d908aeb0ac290b02b83 | b3646f1d523687f27a767b100f5ea89edef40b5b | refs/heads/master | 2021-01-22T08:28:33.950842 | 2014-02-10T02:28:20 | 2014-02-10T02:28:20 | 8,962,309 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,672 | h | /*
Copyright 2009 Carnegie Mellon University.
This software developed under GRC contract 2008-HJ-1795 funded by
the Semiconductor Research Corporation.
*/
#ifndef MANUFACTURINGDEFECT_H_
#define MANUFACTURINGDEFECT_H_
#include <gsl/gsl_rng.h>
#include <string>
#include "types.h"
#define DEFECTDENSITY 0.163 // number of defects per cm^2
//#define DEFECTDENSITY 1.63 // number of defects per cm^2
using namespace std;
class ManufacturingDefect
{
string name; // manufacturing defect name
Component *owner; // Component to which this defect model belongs
gsl_rng *rand_u; // uniform random number generator
// failure parameters
float yield; // component average yield based on defect density and area
bool defect; // true if there is a defect
// defect density parameters
float defectDensity; // defect density in cm^2
public:
ManufacturingDefect(string dname, Component *downer, gsl_rng *rng);
// get various parameters
string getName() { return name; }
Component *getOwner() { return owner; }
bool getDefect() { return defect; }
// set various parametrs
void setDefectDensity(float density) { defectDensity = density; }
void initialize(); // initialize expected yield
bool sample(); // generate a random defect sample
};
#endif /*MANUFACTURINGDEFECT_H_*/
| [
"charles.lu@mail.mcgill.ca"
] | charles.lu@mail.mcgill.ca |
6fac4fb765be28e5e659345ba02e6dde97ea80a4 | 0edbcda83b7a9542f15f706573a8e21da51f6020 | /private/shell/browseui/htmlbm.cpp | 6145f7a7dce2a9820837288e5630ff7fb72cc3f4 | [] | no_license | yair-k/Win2000SRC | fe9f6f62e60e9bece135af15359bb80d3b65dc6a | fd809a81098565b33f52d0f65925159de8f4c337 | refs/heads/main | 2023-04-12T08:28:31.485426 | 2021-05-08T22:47:00 | 2021-05-08T22:47:00 | 365,623,923 | 1 | 3 | null | null | null | null | UTF-8 | C++ | false | false | 13,898 | cpp |
#include "priv.h"
//#include "local.h"
#include "sccls.h"
#include "htmlbm.h"
//#include "deskstat.h"
//#include "dutil.h"
#include "isfband.h"
#include "runtask.h"
#include "dbgmem.h"
#ifndef POSTPOSTSPLIT
static const GUID TOID_Thumbnail = { 0xadec3450, 0xe907, 0x11d0, {0xa5, 0x7b, 0x00, 0xc0, 0x4f, 0xc2, 0xf7, 0x6a} };
HRESULT CDiskCacheTask_Create( CLogoBase * pView,
LPSHELLIMAGESTORE pImageStore,
LPCWSTR pszItem,
LPCWSTR pszGLocation,
DWORD dwItem,
LPRUNNABLETASK * ppTask );
class CDiskCacheTask : public CRunnableTask
{
public:
CDiskCacheTask();
~CDiskCacheTask();
STDMETHODIMP RunInitRT( void );
friend HRESULT CDiskCacheTask_Create( CLogoBase * pView,
LPSHELLIMAGESTORE pImageStore,
LPCWSTR pszItem,
LPCWSTR pszGLocation,
DWORD dwItem,
const SIZE * prgSize,
LPRUNNABLETASK * ppTask );
protected:
HRESULT PrepImage( HBITMAP * phBmp );
LPSHELLIMAGESTORE _pImageStore;
WCHAR _szItem[MAX_PATH];
WCHAR _szGLocation[MAX_PATH];
CLogoBase * _pView;
DWORD _dwItem;
SIZE m_rgSize;
};
// CreateInstance
HRESULT CThumbnail_CreateInstance(IUnknown *punkOuter, IUnknown **ppunk, LPCOBJECTINFO poi)
{
*ppunk = NULL;
CThumbnail *thumbnailInstance = new CThumbnail();
if (thumbnailInstance != NULL)
{
*ppunk = SAFECAST(thumbnailInstance, IThumbnail*);
return S_OK;
}
return E_OUTOFMEMORY;
}
// Constructor / Destructor
CThumbnail::CThumbnail(void):
m_cRef(1)
{
DllAddRef();
}
CThumbnail::~CThumbnail(void)
{
if (_pTaskScheduler)
{
_pTaskScheduler->RemoveTasks(TOID_Thumbnail, ITSAT_DEFAULT_LPARAM, FALSE);
_pTaskScheduler->Release();
_pTaskScheduler = NULL;
}
DllRelease();
}
// *** IUnknown ***
HRESULT CThumbnail::QueryInterface(REFIID riid, void **ppvObj)
{
if (IsEqualIID(riid, IID_IUnknown) || IsEqualIID(riid, IID_IThumbnail))
{
*ppvObj = SAFECAST(this, IThumbnail*);
}
else
{
*ppvObj = NULL;
return E_NOINTERFACE;
}
AddRef();
return S_OK;
}
ULONG CThumbnail::AddRef(void)
{
m_cRef++;
return m_cRef;
}
ULONG CThumbnail::Release(void)
{
ASSERT(m_cRef > 0);
m_cRef--;
if (m_cRef > 0)
{
return m_cRef;
}
delete this;
return 0;
}
// *** IThumbnail ***
HRESULT CThumbnail::Init(HWND hwnd, UINT uMsg)
{
_hwnd = hwnd;
_uMsg = uMsg;
_pTaskScheduler = NULL;
return S_OK;
} // Init
HRESULT CThumbnail::GetBitmap(LPCWSTR wszFile, DWORD dwItem, LONG lWidth, LONG lHeight)
{
HRESULT hr = E_FAIL;
//
// Make sure we have a task scheduler.
//
if (!_pTaskScheduler)
{
if (SUCCEEDED(CoCreateInstance(CLSID_ShellTaskScheduler, NULL, CLSCTX_INPROC_SERVER, IID_IShellTaskScheduler, (void **)&_pTaskScheduler)))
{
// make sure RemoveTasks() actually kills old tasks even if they're not done yet
_pTaskScheduler->Status(ITSSFLAG_KILL_ON_DESTROY, ITSS_THREAD_TIMEOUT_NO_CHANGE);
}
}
if (_pTaskScheduler)
{
//
// Kill any old tasks in the scheduler.
//
_pTaskScheduler->RemoveTasks(TOID_Thumbnail, ITSAT_DEFAULT_LPARAM, FALSE);
if (wszFile)
{
LPITEMIDLIST pidl = ILCreateFromPathW(wszFile);
if (pidl)
{
LPCITEMIDLIST pidlFile;
IShellFolder *psf;
if (SUCCEEDED(SHBindToIDListParent(pidl, IID_IShellFolder, (void **)&psf, &pidlFile)))
{
IExtractImage *pei;
if (SUCCEEDED(psf->GetUIObjectOf(NULL, 1, (LPCITEMIDLIST *)&pidlFile, IID_IExtractImage, NULL, (void **)&pei)))
{
DWORD dwPriority;
DWORD dwFlags = IEIFLAG_ASYNC | IEIFLAG_ASPECT | IEIFLAG_OFFLINE;
SIZEL rgSize;
rgSize.cx = lWidth;
rgSize.cy = lHeight;
WCHAR szBufferW[MAX_PATH];
HRESULT hr2 = pei->GetLocation(szBufferW, ARRAYSIZE(szBufferW), &dwPriority, &rgSize, SHGetCurColorRes(), &dwFlags);
if ( hr2 == E_PENDING)
{
// now get the date stamp and check the disk cache....
FILETIME ftImageTimeStamp;
BOOL fNoDateStamp = TRUE;
LPEXTRACTIMAGE2 pei2;
// try it in the background...
LPRUNNABLETASK prt;
// od they support date stamps....
if ( SUCCEEDED( pei->QueryInterface( IID_IExtractImage2, (void **) &pei2)))
{
if ( SUCCEEDED( pei2->GetDateStamp( & ftImageTimeStamp )))
{
// Houston, we have a date stamp..
fNoDateStamp = FALSE;
}
pei2->Release();
}
// if it is in the cache, and it is an uptodate image, then fetch from disk....
// if the timestamps are wrong, then the extract code further down will then try
// we only test the cache on NT5 because the templates are old on other platforms and
// thus the image will be the wrong size...
if ( IsOS( OS_NT5 ) && IsItInCache( wszFile, szBufferW, ( fNoDateStamp ? NULL : &ftImageTimeStamp )))
{
hr = CDiskCacheTask_Create( this, _pImageStore, wszFile, szBufferW,
dwItem, &rgSize, & prt );
if ( SUCCEEDED( hr ))
{
// let go of the image store, so the task has the only ref and the lock..
ATOMICRELEASE( _pImageStore );
}
}
else
{
// Cannot hold the prt which is returned in a member variable since that
// would be a circular reference
hr = CExtractImageTask_Create(this,
pei, L"", dwItem,
-1, EITF_SAVEBITMAP | EITF_ALWAYSCALL, &prt);
}
//
// Create our own task to perform the extraction.
//
if ( SUCCEEDED( hr ))
{
//
// Add the task to the scheduler.
//
if (SUCCEEDED(_pTaskScheduler->AddTask(prt, TOID_Thumbnail, ITSAT_DEFAULT_LPARAM, dwPriority)))
{
// now belongs to the scheduler thread
remove_from_memlist( prt );
hr = S_OK;
}
else
{
TraceMsg(TF_WARNING, "hb: Could not add task!");
}
prt->Release();
}
else
{
TraceMsg(TF_WARNING, "hb: Could not create task!");
}
}
else
{
TraceMsg(TF_WARNING, "hb: Could not get location on IExtractImage");
}
pei->Release();
}
psf->Release();
}
ILFree(pidl);
}
}
}
// make sure we are not still holding it...
ReleaseImageStore();
return hr;
} // GetBitmap
// private stuff
HRESULT CThumbnail::UpdateLogoCallback(DWORD dwItem, int iIcon, HBITMAP hImage, LPCWSTR pszCache, BOOL fCache)
{
if (!PostMessage(_hwnd, _uMsg, dwItem, (LPARAM)hImage))
{
DeleteObject(hImage);
}
return S_OK;
}
REFTASKOWNERID CThumbnail::GetTOID()
{
return TOID_Thumbnail;
}
BOOL CThumbnail::IsItInCache( LPCWSTR pszItemPath, LPCWSTR pszGLocation, const FILETIME * pftDateStamp )
{
LPPERSISTFILE pFile;
WCHAR szName[MAX_PATH];
BOOL fRes = FALSE;
DWORD dwStoreLock;
// use pszItemPath to find the cache.....
StrCpyNW( szName, pszItemPath, MAX_PATH );
PathRemoveFileSpecW( szName );
HRESULT hr = CoCreateInstance( CLSID_ShellThumbnailDiskCache, NULL, CLSCTX_INPROC, IID_IPersistFile, (void **) & pFile);
if (FAILED( hr ))
{
return FALSE;
}
hr = pFile->Load( szName, STGM_READ );
if ( SUCCEEDED( hr ))
{
hr = pFile->QueryInterface( IID_IShellImageStore, (void **) & _pImageStore );
}
if ( SUCCEEDED( hr ))
{
hr = _pImageStore->Open( STGM_READ, & dwStoreLock );
}
pFile->Release();
if ( FAILED( hr ))
{
return FALSE;
}
FILETIME ftCacheDateStamp;
hr = _pImageStore->IsEntryInStore( pszGLocation, &ftCacheDateStamp );
if (( hr == S_OK ) && (!pftDateStamp ||
(pftDateStamp->dwLowDateTime == ftCacheDateStamp.dwLowDateTime &&
pftDateStamp->dwHighDateTime == ftCacheDateStamp.dwHighDateTime)))
{
fRes = TRUE;
}
_pImageStore->Close( &dwStoreLock );
return fRes;
}
void CThumbnail::ReleaseImageStore()
{
ATOMICRELEASE( _pImageStore );
}
////////////////////////////////////////////////////////////////////////////////////
HRESULT CDiskCacheTask_Create( CLogoBase * pView,
LPSHELLIMAGESTORE pImageStore,
LPCWSTR pszItem,
LPCWSTR pszGLocation,
DWORD dwItem,
const SIZE * prgSize,
LPRUNNABLETASK * ppTask )
{
if ( !ppTask || !pView || !pszItem || !pszGLocation || !pImageStore || !prgSize )
{
return E_INVALIDARG;
}
CDiskCacheTask *pTask = new CDiskCacheTask;
if ( pTask == NULL )
{
return E_OUTOFMEMORY;
}
StrCpyW( pTask->_szItem, pszItem );
StrCpyW( pTask->_szGLocation, pszGLocation );
pTask->_pView = pView;
pTask->_pImageStore = pImageStore;
pImageStore->AddRef();
pTask->_dwItem = dwItem;
pTask->m_rgSize = * prgSize;
*ppTask = SAFECAST( pTask, IRunnableTask *);
return NOERROR;
}
STDMETHODIMP CDiskCacheTask::RunInitRT( )
{
// otherwise, run the task ....
HBITMAP hBmp = NULL;
DWORD dwLock;
HRESULT hr = _pImageStore->Open (STGM_READ, &dwLock );
if ( SUCCEEDED( hr ))
{
// at this point, we assume that it IS in the cache, and we already have a read lock on the cache...
hr = _pImageStore->GetEntry( _szGLocation, STGM_READ, &hBmp );
// release the lock, we don't need it...
_pImageStore->Close( &dwLock );
}
ATOMICRELEASE( _pImageStore );
PrepImage( &hBmp );
_pView->UpdateLogoCallback( _dwItem, 0, hBmp, _szItem, TRUE );
// ensure we don't return the "we've suspended" value...
if ( hr == E_PENDING )
hr = E_FAIL;
return hr;
}
CDiskCacheTask::CDiskCacheTask()
: CRunnableTask( RTF_DEFAULT )
{
}
CDiskCacheTask::~CDiskCacheTask()
{
ATOMICRELEASE( _pImageStore );
}
HRESULT CDiskCacheTask::PrepImage( HBITMAP * phBmp )
{
ASSERT( phBmp && *phBmp );
DIBSECTION rgDIB;
if ( !GetObject( *phBmp, sizeof( rgDIB ), &rgDIB ))
{
return E_FAIL;
}
// the disk cache only supports 32 Bpp DIBS now, so we can ignore the palette issue...
ASSERT( rgDIB.dsBm.bmBitsPixel == 32 );
HBITMAP hBmpNew = NULL;
HPALETTE hPal = NULL;
if ( SHGetCurColorRes() == 8 )
{
hPal = SHCreateShellPalette( NULL );
}
IScaleAndSharpenImage2 * pScale;
HRESULT hr = CoCreateInstance( CLSID_ThumbnailScaler,
NULL,
CLSCTX_INPROC_SERVER,
IID_IScaleAndSharpenImage2,
(void **) &pScale );
if ( SUCCEEDED( hr ))
{
hr = pScale->ScaleSharpen2((BITMAPINFO *) &rgDIB.dsBmih,
rgDIB.dsBm.bmBits,
&hBmpNew,
&m_rgSize,
SHGetCurColorRes(),
hPal,
0, FALSE );
pScale->Release();
}
DeletePalette( hPal );
if ( SUCCEEDED (hr ) && hBmpNew )
{
DeleteObject( *phBmp );
*phBmp = hBmpNew;
}
return NOERROR;
}
#endif // !POSTPOSTSPLIT
| [
"ykorokhov@pace.ca"
] | ykorokhov@pace.ca |
6b8eccda3b00560a49098d47f969ab61b8841be4 | f68c1a09ade5d969f3973246747466e4a540ff74 | /src/prod/src/LeaseAgent/LeaseAgent.h | 7219ab52436e334ba36bb507b26612ed89e3cf1e | [
"MIT"
] | permissive | GitTorre/service-fabric | ab38752d4cc7c8f2ee03553372c0f3e05911ff67 | 88da19dc5ea8edfe1c9abebe25a5c5079995db63 | refs/heads/master | 2021-04-09T10:57:45.678751 | 2018-08-20T19:17:28 | 2018-08-20T19:17:28 | 125,401,516 | 0 | 0 | MIT | 2018-03-15T17:13:53 | 2018-03-15T17:13:52 | null | UTF-8 | C++ | false | false | 11,598 | h | // ------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License (MIT). See License.txt in the repo root for license information.
// ------------------------------------------------------------
#pragma once
#include "Common/Common.h"
#include "Transport/Transport.h"
#include <schannel.h>
#include "LeaseAgentInstance.h"
#include "Lease/inc/public/leaselayerinc.h"
#define DISK_PROBING_FILE_NAME L"LeaseHeartbeat.tmp"
// TODO: LeaseAgent and LeasePartner Source Code will be moving to ~src\Lease\Api directory later.
namespace LeaseWrapper
{
class ILeasingApplication
{
public:
ILeasingApplication( bool supportArbitrate = false ):
supportArbitrate_ ( supportArbitrate )
{
}
virtual ~ILeasingApplication()
{
}
virtual void OnLeaseFailed() = 0;
virtual void OnRemoteLeasingApplicationFailed( std::wstring const & id ) = 0;
virtual void Arbitrate(
LeaseAgentInstance const & local,
Common::TimeSpan localTTL,
LeaseAgentInstance const & remote,
Common::TimeSpan remoteTTL,
USHORT remoteVersion,
LONGLONG monitorLeaseInstance,
LONGLONG subjectLeaseInstance,
LONG remoteArbitrationDurationUpperBound) = 0;
private:
bool supportArbitrate_;
};
struct LeaseAgentConfiguration
{
public:
LeaseAgentConfiguration();
LeaseAgentConfiguration(
std::wstring const & leasingApplicationId,
std::wstring const & localLeaseAddress,
bool enableArbitrate = false);
LeaseAgentConfiguration(LeaseAgentConfiguration const & rhs);
std::wstring leasingApplicationId_; // The ID of this Lease Agent that would be registered with the Lease Layer
std::wstring localLeaseAddress_; // The socket address at which the listener for the lease agent is listening.
Common::TimeSpan leaseSuspendTimeout_; // Short arbitration timeout
Common::TimeSpan arbitrationTimeout_; // Long arbitration timeout
int leaseRetryCount_; // Number of renew times in a lease duration
int LeaseRenewBeginRatio_; // Starting point of lease retry; calculated as (lease duration / #)
Common::TimeSpan leasingAppExpiryTimeout_; // remaining lease TTL defined in federation config
bool arbitrationEnabled_; // Arbitration is now optional; This flag indicates whether or not to support it;
Common::TimeSpan MaxIndirectLeaseTimeout_; // Upper limit that lease renewed by indirect lease
};
#ifndef PLATFORM_UNIX
struct LeaseCertHashStore
{
BYTE ShaHash[20];
WCHAR pwszStoreName[SCH_CRED_MAX_STORE_NAME_SIZE];
};
#endif
class LeasePartner;
typedef std::shared_ptr<LeasePartner> LeasePartnerSPtr;
class LeaseAgent: public Common::RootedObject, public Common::FabricComponent, public Common::TextTraceComponent<Common::TraceTaskCodes::LeaseAgent>
{
public:
LeaseAgent(Common::ComponentRoot const & root, ILeasingApplication & leasingApp, LeaseAgentConfiguration const & leaseAgentConfig, Transport::SecuritySettings const& securitySettings);
~LeaseAgent() { }
#if !defined(PLATFORM_UNIX)
static DWORD LoadRemoteCertificate(DWORD cbCertificate, PBYTE pbCertificate, PCCERT_CONTEXT *ppCertContext);
#endif
static void SetHealthReportCallback(std::function<void(int, wstring const &, wstring const &)> & callback);
#if !defined(PLATFORM_UNIX)
static void InvokeHealthReportCallback(int reportCode, LPCWSTR dynamicProperty, LPCWSTR extraDescription);
#endif
Common::ErrorCode OnOpen();
Common::ErrorCode OnClose();
void OnAbort();
Common::ErrorCode Restart(std::wstring const & newLeasingApplicationId);
__declspec (property(get=getInstanceId)) int64 InstanceId;
int64 getInstanceId() const { return instanceId_; }
Common::ErrorCode SetSecurity(Transport::SecuritySettings const & securitySettings);
_Success_(return)
static bool InitializeListenEndpoint(
_Inout_opt_ LeaseAgent* leaseAgent,
std::wstring const & localLeaseAddress,
_Out_ TRANSPORT_LISTEN_ENDPOINT & endPoint);
_Success_(return)
bool InitializeListenEndpoint(std::wstring const & localLeaseAddress, _Out_ TRANSPORT_LISTEN_ENDPOINT & endPoint);
void InitializeLeaseConfigDurations(LEASE_CONFIG_DURATIONS & durations);
//
// Operations
//
// Sync - Don't wait for Establish Reply
void Establish(
std::wstring const & remoteLeasingApplicationId,
std::wstring const & remoteFaultDomain,
std::wstring const & remoteLeaseAddress,
int64 remoteLeaseAgentInstanceId,
LEASE_DURATION_TYPE leaseTimeoutType);
// Async Op
Common::AsyncOperationSPtr BeginEstablish(
std::wstring const & remoteLeasingApplicationId,
std::wstring const & remoteFaultDomain,
std::wstring const & remoteLeaseAgentAddress,
int64 remoteLeaseAgentInstanceId,
LEASE_DURATION_TYPE leaseTimeoutType,
Common::TimeSpan timeout,
Common::AsyncCallback const & callback,
Common::AsyncOperationSPtr const & context);
static Common::ErrorCode EndEstablish(__in Common::AsyncOperationSPtr const & operation);
void Terminate(std::wstring const & remoteLeasingApplicationId);
BOOL GetLeasingApplicationExpirationTime(PLONG milliseconds, PLONGLONG kernelCurrentTime) const;
BOOL GetLeasingApplicationExpirationTimeFromIPC(PLONG milliseconds, PLONGLONG kernelCurrentTime) const;
static BOOL GetLeasingApplicationExpirationTime(HANDLE appHandle, PLONG milliseconds, PLONGLONG kernelCurrentTime);
BOOL SetGlobalLeaseExpirationTime(LONGLONG expireTime);
BOOL GetRemoteLeaseExpirationTime(std::wstring const & remoteLeasingApplicationId, Common::StopwatchTime & monitorExpireTime, Common::StopwatchTime & subjectExpireTime);
//
// Callbacks from the driver.
//
void OnLeaseFailed();
void OnRemoteLeasingApplicationFailed( std::wstring const & remoteLeasingApplicationId );
void OnLeaseEstablished( std::wstring remoteLeasingApplicationId, HANDLE leaseHandle);
void OnCompleteRemoteCertificateVerification(DWORD cbCertificate, PBYTE pbCertificate, PVOID RemoteCertVerifyCallbackOperation);
void Arbitrate(
HANDLE appHandle,
int64 localInstance,
long localTTL,
std::wstring const & remoteLeaseAddress,
int64 remoteInstance,
long remoteTTL,
USHORT remoteVersion,
int64 monitorLeaseInstance,
int64 subjectLeaseInstance,
LONG remoteArbitrationDurationUpperBound);
void RetryEstablish(LeasePartnerSPtr const & leaseParnter, LEASE_DURATION_TYPE leaseTimeoutType);
void CompleteArbitrationSuccessProcessing(LONGLONG localInstance, __in LPCWSTR remoteLeaseAddress, LONGLONG remoteInstance, Common::TimeSpan localTTL, Common::TimeSpan remoteTTL, BOOL isDelayed);
// Chl = caller holding lock
BOOL CompleteRemoteCertificateVerification(PVOID RemoteCertVerifyCallbackOperation, NTSTATUS verifyResult);
#if !defined(PLATFORM_UNIX)
BOOL UpdateLeaseGlobalConfig();
#endif
BOOL UpdateLeaseDuration();
__declspec (property(get=getIsLeaseExpired)) bool IsLeaseExpired;
bool getIsLeaseExpired();
__declspec(property(get=get_LeaseHandle)) HANDLE LeaseHandle;
HANDLE get_LeaseHandle() const { return appHandle_; }
bool IsDummyLeaseDriverEnabled() const
{
return dummyLeaseDriverEnabled_;
}
Common::TimeSpan LeaseDuration() const;
Common::TimeSpan LeaseSuspendTimeout() const
{
return leaseAgentConfig_.leaseSuspendTimeout_;
}
Common::TimeSpan ArbitrationTimeout() const
{
return leaseAgentConfig_.arbitrationTimeout_;
}
Common::ComponentRootSPtr const & GetOwner() { return pRoot_; }
void WriteTo(Common::TextWriter&, Common::FormatOptions const &) const;
private:
typedef std::map<std::wstring, LeasePartnerSPtr> LeasePartnerMap;
void Cleanup(bool isDelayed);
HANDLE InternalClose();
bool InitializeCertHashStore(Transport::SecuritySettings const & securitySettings);
Transport::TransportSecuritySPtr LeaseSecurity();
LeasePartner* GetLeasePartnerByAddress(std::wstring const & remoteLeaseAddress);
// Wrappers around lease functions to call dummy or real lease agents dependign upon config.
HANDLE RegisterLeasingApplication(Transport::SecuritySettings const & securitySettings);
void UnregisterLeasingApplication(HANDLE handle, std::wstring const & leasingApplicationId, BOOL isDelayed);
BOOL CompleteArbitrationSuccessProcessing(HANDLE appHandle, LONGLONG localInstance, __in LPCWSTR remoteLeaseAddress, LONGLONG remoteInstance, LONG localTTL, LONG remoteTTL, BOOL isDelayed);
// For security
BOOL UpdateCertificate();
BOOL SetSecurityDescriptor();
void TryStartHeartbeat();
// Corresponding to the Owner of this Lease Agent
LeaseAgentConfiguration leaseAgentConfig_;
ILeasingApplication & leasingApp_; // Owner; The Leasing Application to which this agent belongs.
Common::ComponentRootSPtr pRoot_; // Required for controling the life-time of Leasing Application
// Lease Agent functionality
HANDLE appHandle_; // The handle to the drivers datastructure for this site.
HANDLE leaseAgentHandle_; // The handle to the drivers lease agent for this site.
int64 instanceId_; // Instance of kernel lease agent.
mutable bool calledFromIPC_; // Ever called from IPC.
LONGLONG expiryTime_; // The expiry time for this lease agent and hence this site node.
Common::RwLock leaseAgentLock_; // Lock for ensuring serialization of data structure operations.
static Common::Global<Common::RwLock> healthReportGlobalLock_;
// Data-Structures
LeasePartnerMap leases_; // The state of the various leases held by this agent
bool dummyLeaseDriverEnabled_; // Dummy IOCTLs or Lease Driver IOCTLs
Transport::ResolveOptions::Enum addressResolveType_;
// Security
Transport::SecuritySettings initialSecuritySetting_;
Common::RwLock leaseSecurityLock_;
Transport::TransportSecuritySPtr leaseSecurity_;
#ifndef PLATFORM_UNIX
LeaseCertHashStore certHash_;
#endif
Common::HHandler leaseDurationChangeHandler_;
Common::HHandler leaseDurationAcrossFDChangeHandler_;
Common::HHandler unresponsiveDurationChangeHandler_;
#if !defined(PLATFORM_UNIX)
Common::HHandler maintenanceIntervalChangeHandler_;
Common::HHandler processAssertExitTimeoutChangeHandler_;
#endif
Common::TimerSPtr heartbeatTimer_; // Timer for disk probing
HANDLE diskProbingFileHandle_; // File handle for disk probing
Common::ByteBuffer diskProbingBuffer_; // Disk probing buffer
static std::function<void(int, wstring const &, wstring const &)> healthReportCallback_;
};
}
| [
"noreply-sfteam@microsoft.com"
] | noreply-sfteam@microsoft.com |
f790007ca87862433a26f800b3376310c0d683f3 | a45da086e4777f6bde0f1a35b2d81c2ad37679e2 | /1.Basics-Warm-Up/8.Multiple-of-3.cpp | f6111efdd783017c04e1e17b8a5ff210972e8f1d | [] | no_license | purplevarun/CodeChef-DSA | b41e7c42f0c7e6adb5dea638a0e0b70f7d3a99a3 | b0da886a1cdb1afa3779f235a5e302d122bcd2a0 | refs/heads/master | 2023-08-31T04:11:40.045394 | 2021-10-17T22:03:55 | 2021-10-17T22:03:55 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 641 | cpp | #include <bits/stdc++.h>
#define int int64_t
using namespace std;
void onigiri() {
int K, A, B;
cin >> K >> A >> B;
int Sum = A + B;
int Cycle = (2*Sum)%10 + (4*Sum)%10 + (8*Sum)%10 + (6*Sum)%10;
int numCycles = (K - 3) / 4;
int total = 0;
if (K == 2){
total = Sum;
}
else {
total = Sum + (Sum)%10 + Cycle * numCycles;
int left_overs = (K - 3) - (numCycles * 4);
int p = 2;
for (int i = 0;i < left_overs; ++i){
total += (p*Sum)%10;
p = (p*2)%10;
}
}
cout << (total%3==0?"YES":"NO") << "\n";
}
int32_t main () {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t = 1;
cin >> t;
while (t--){
onigiri ();
}
}
| [
"purplevarun@gmail.com"
] | purplevarun@gmail.com |
63c0be0741d3928cdabe7c1f3202da96f5a98a23 | ccc1c9ebe66e1497713ba374b11a0f816e5e63c0 | /include/Input.h | 25d9b54b0a753e05c2e526c21cbb4ca481b9c90e | [] | no_license | TanguyHardelin/Game_engine | 64129d3cd9e5731076012cdd05599ddf2d432a67 | 81ee7d2f30a682183829c4e74a99a2e520fdde3b | refs/heads/master | 2021-07-12T02:11:35.353545 | 2018-12-12T17:10:37 | 2018-12-12T17:10:37 | 147,126,604 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 647 | h | #ifndef INPUT_H
#define INPUT_H
#include <vector>
//Define a structure for keys:
typedef struct{
long name;
int x;
int y;
} INPUT_KEY;
//Defines:
#define MOUSE_OFFSET 5000
#define KEYBOARD_OFFSET 0
#define LEFT_CLICK MOUSE_OFFSET + 0
#define SCROOL_WHEEL_CLICK MOUSE_OFFSET + 1
#define RIGHT_CLICK MOUSE_OFFSET + 2
#define SCROOL_WHEEL_UP MOUSE_OFFSET + 3
#define SCROOL_WHEEL_DOWN MOUSE_OFFSET + 4
class Input{
public:
//Getter:
inline std::vector<INPUT_KEY> getBuffer(){return _buffer;}
//Setter:
void clearBuffer();
protected:
std::vector<INPUT_KEY> _buffer;
};
#endif | [
"t4hardel@enib.fr"
] | t4hardel@enib.fr |
08b9d50969741aae19aaa78862b575c9d5d217ed | ecf47b47279fcf3b12ef8b0550f9b4fe35155aa6 | /src/Corrade/TestSuite/Compare/FileToString.cpp | a385d0322f588994f99318eee36763540c93b167 | [
"MIT",
"Unlicense",
"LicenseRef-scancode-public-domain"
] | permissive | mgood7123/corrade | b4d9f6ff2cbf5c84ac3dfb8e02437fe977208826 | b048d6868f096d3ea5b162ed45d36aff9a9f5427 | refs/heads/master | 2023-05-13T21:04:53.651253 | 2021-06-11T13:21:29 | 2021-06-11T13:21:29 | 376,030,041 | 0 | 0 | NOASSERTION | 2021-06-11T13:13:00 | 2021-06-11T13:12:59 | null | UTF-8 | C++ | false | false | 3,508 | cpp | /*
This file is part of Corrade.
Copyright © 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016,
2017, 2018, 2019, 2020, 2021
Vladimír Vondruš <mosra@centrum.cz>
Permission is hereby granted, free of charge, to any person obtaining a
copy of this software and associated documentation files (the "Software"),
to deal in the Software without restriction, including without limitation
the rights to use, copy, modify, merge, publish, distribute, sublicense,
and/or sell copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
*/
#include "FileToString.h"
#include <cstddef>
#ifdef _MSC_VER
#include <algorithm> /* std::max() */
#endif
#include "Corrade/TestSuite/Comparator.h"
#include "Corrade/Utility/DebugStl.h"
#include "Corrade/Utility/Directory.h"
namespace Corrade { namespace TestSuite {
Comparator<Compare::FileToString>::Comparator(): _state(State::ReadError) {}
ComparisonStatusFlags Comparator<Compare::FileToString>::operator()(const std::string& filename, const std::string& expectedContents) {
_filename = filename;
if(!Utility::Directory::exists(filename))
return ComparisonStatusFlag::Failed;
_actualContents = Utility::Directory::readString(filename);
_expectedContents = expectedContents;
_state = State::Success;
return _actualContents == expectedContents ? ComparisonStatusFlags{} :
ComparisonStatusFlag::Failed;
}
void Comparator<Compare::FileToString>::printMessage(ComparisonStatusFlags, Utility::Debug& out, const char* actual, const char* expected) const {
if(_state != State::Success) {
out << "File" << actual << "(" + _filename + ")" << "cannot be read.";
return;
}
out << "Files" << actual << "and" << expected << "have different";
if(_actualContents.size() != _expectedContents.size())
out << "size, actual" << _actualContents.size() << "but" << _expectedContents.size() << "expected.";
else
out << "contents.";
for(std::size_t i = 0, end = std::max(_actualContents.size(), _expectedContents.size()); i != end; ++i) {
if(_actualContents.size() > i && _expectedContents.size() > i && _actualContents[i] == _expectedContents[i]) continue;
/** @todo do this without std::string */
if(_actualContents.size() <= i)
out << "Expected has character" << std::string() + _expectedContents[i];
else if(_expectedContents.size() <= i)
out << "Actual has character" << std::string() + _actualContents[i];
else
out << "Actual character" << std::string() + _actualContents[i] << "but" << std::string() + _expectedContents[i] << "expected";
out << "on position" << i << Utility::Debug::nospace << ".";
break;
}
}
}}
| [
"mosra@centrum.cz"
] | mosra@centrum.cz |
7ddc67d46c014c17c9939944ce7351e5ac6581e0 | bf580fc7c835fe3fa3ed132f767c45f3984f0379 | /runtime/string.hpp | d14d54875004d0691bd84e94d6b0a9857e9dc830 | [] | no_license | flavioc/meld | eb9ddb9a244498769511cc6c9f2e9f3541d1169a | 08511ad36d96386ff06ed9c695d05c3ac2761cb8 | refs/heads/master | 2016-09-16T00:18:00.744714 | 2013-12-05T19:00:23 | 2013-12-05T19:00:23 | 1,469,942 | 17 | 5 | null | null | null | null | UTF-8 | C++ | false | false | 1,386 | hpp |
#ifndef RUNTIME_STRING_HPP
#define RUNTIME_STRING_HPP
#include "conf.hpp"
#include <iostream>
#include <string>
#include <stack>
#ifdef COMPILE_MPI
#include <boost/mpi.hpp>
#endif
#include "utils/types.hpp"
#include "utils/atomic.hpp"
#include "mem/base.hpp"
#include "vm/defs.hpp"
namespace runtime
{
class rstring: public mem::base
{
public:
typedef rstring* rstring_ptr;
typedef rstring_ptr ptr;
MEM_METHODS(rstring)
private:
const std::string content;
utils::atomic<vm::ref_count> refs;
explicit rstring(const std::string& _content, const size_t _refs):
content(_content), refs(_refs)
{
}
public:
inline void inc_refs(void)
{
refs++;
}
inline void dec_refs(void)
{
assert(refs > 0);
refs--;
if(zero_refs())
destroy();
}
inline void destroy(void)
{
assert(zero_refs());
delete this;
}
inline bool zero_refs(void) const
{
return refs == 0;
}
inline bool has_refs(void) const
{
return refs > 0;
}
inline std::string get_content(void) const
{
return content;
}
inline rstring_ptr copy(void) const
{
return make_string(content);
}
// XXX implement MPI stuff
static rstring_ptr make_default_string(const std::string& str)
{
return new rstring(str, 1);
}
static rstring_ptr make_string(const std::string& str)
{
return new rstring(str, 0);
}
};
}
#endif
| [
"flaviocruz@gmail.com"
] | flaviocruz@gmail.com |
61deda6ed5bedfc97fc84f8359af9cac6d41a86f | 98bcf26a658834fe14d87caf980a575b6b1974fa | /allosphere.node/src/node_phasespace.cpp | 88f6e4f73f37393a16d386e5e9b196073f697dd1 | [
"MIT"
] | permissive | donghaoren/Allofw | eb65ce7af03308749bde53a10c52ab522709b438 | 4367327cda0605aad53469294ed8751f8befbdc3 | refs/heads/master | 2021-01-24T02:06:06.316183 | 2018-07-30T21:16:29 | 2018-07-30T21:16:29 | 35,452,775 | 3 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 1,420 | cpp | #include <phasespace.h>
#include <node.h>
#include <nan.h>
#include <vector>
using namespace std;
using namespace node;
using namespace v8;
allofw::Phasespace* phasespace = NULL;
NAN_METHOD(EXPORT_start) {
if(!phasespace) {
phasespace = allofw::Phasespace::Create();
phasespace->start();
}
}
NAN_METHOD(EXPORT_getMarkers) {
Nan::HandleScope scope;
if(!phasespace) return;
int start = info[0]->IntegerValue();
int count = info[1]->IntegerValue();
vector<allofw::Vector3> v(count);
vector<int> s(count);
phasespace->getMarkers(&v[0], &s[0], start, count);
Local<Array> array = Nan::New<Array>(count);
for(int i = 0; i < count; i++) {
Local<Object> obj = Nan::New<Array>(4);
obj->Set(0, Nan::New<Number>(v[i].x));
obj->Set(1, Nan::New<Number>(v[i].y));
obj->Set(2, Nan::New<Number>(v[i].z));
obj->Set(3, Nan::New<Integer>(s[i]));
array->Set(i, obj);
}
info.GetReturnValue().Set(array);
}
void NODE_init(Handle<Object> exports) {
Nan::Set(exports, Nan::New<String>("start").ToLocalChecked(), Nan::New<FunctionTemplate>(EXPORT_start)->GetFunction());
// getMarkers(start, count) -> [ [ x, y, z, last_seen ], ... ]
Nan::Set(exports, Nan::New<String>("getMarkers").ToLocalChecked(), Nan::New<FunctionTemplate>(EXPORT_getMarkers)->GetFunction());
}
NODE_MODULE(node_phasespace, NODE_init)
| [
"donghao.ren@gmail.com"
] | donghao.ren@gmail.com |
db5e4fcbcd5ae9b88f756a16b23d6075d83aa5ec | 870da5a53545073f36be3e481d34a2a97f12862a | /NewUserView.cc | 9a56875f3fe55fc373cd071a336d3e0252d566ff | [] | no_license | randypitcherii/IMProject | 88f10f86bb68bbfc03cc240e2097a26a7f44a750 | 2e31a0cc2c1859296cb0216f1c590ee1a757c748 | refs/heads/master | 2021-01-15T16:10:49.226602 | 2015-09-21T03:54:39 | 2015-09-21T03:54:39 | 42,842,642 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,519 | cc | #include "SetupView.h"
#include "Comm.h"
#include <stdio.h>
#include <gtk/gtk.h>
//text boxes and inputs declared here
GtkWidget * newUserViewhostText;
GtkWidget * newUserViewhostInputBox;
GtkWidget * newUserViewportText;
GtkWidget * newUserViewportInputBox;
GtkWidget * newUserViewuserText;
GtkWidget * newUserViewuserInputBox;
GtkWidget * newUserViewpasswordText;
GtkWidget * newUserViewpasswordInputBox;
GtkWidget * newUserViewWindow;
char * newUserViewtempHost;
char * newUserViewtempSport;
char * newUserViewtempUser;
char * newUserViewtempPassword;
char * newUserViewtempResponse;
//gets entry data in the event that login is clicked and sets the value pointed to by loginValid to true to indicate login was pressed;
static void newUserLoginButton_callback( GtkWidget * widget, gboolean * loginValid) {
newUserViewtempHost = (char *) malloc(sizeof(char) * (strlen(gtk_entry_get_text (GTK_ENTRY (newUserViewhostInputBox))) + 1));
strcpy(newUserViewtempHost, gtk_entry_get_text (GTK_ENTRY (newUserViewhostInputBox)));
newUserViewtempSport = (char *) malloc(sizeof(char) * (strlen(gtk_entry_get_text (GTK_ENTRY (newUserViewportInputBox))) + 1));
strcpy(newUserViewtempSport, gtk_entry_get_text (GTK_ENTRY (newUserViewportInputBox)));
newUserViewtempUser = (char *) malloc(sizeof(char) * (strlen(gtk_entry_get_text (GTK_ENTRY (newUserViewuserInputBox))) + 1));
strcpy(newUserViewtempUser, gtk_entry_get_text (GTK_ENTRY (newUserViewuserInputBox)));
newUserViewtempPassword = (char *) malloc(sizeof(char) * (strlen(gtk_entry_get_text (GTK_ENTRY (newUserViewpasswordInputBox))) + 1));
strcpy(newUserViewtempPassword, gtk_entry_get_text (GTK_ENTRY (newUserViewpasswordInputBox)));
loginValid[0] = true;
gtk_widget_destroy(newUserViewWindow);
char * noArg = (char *) malloc(sizeof(char)*2);
noArg[0] = ' ';
noArg[1] = '\0';
char * addUser = (char *) malloc(sizeof(char)*9);
strcpy(addUser, "ADD-USER");
Comm * comm = new Comm(newUserViewtempHost, newUserViewtempSport, newUserViewtempUser, newUserViewtempPassword);
newUserViewtempResponse = (*comm).sendCommand(addUser, noArg, noArg);
gtk_main_quit();
}
//returns 0 if NewUser is pressed and 1 if LogIn is pressed.
int startNewUserView(char ** host, char ** sport, char ** user, char ** password, char ** response) {
gboolean * loginValid = g_new(gboolean, 1);
loginValid[0] = false; //used to track if newUserLoginButton was pushed
//initializes gtk activity
gtk_init (NULL, NULL);
//The main window is instantiated and defined.
newUserViewWindow = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (newUserViewWindow), "Chat Client Add New User");
g_signal_connect (newUserViewWindow, "destroy", G_CALLBACK (gtk_main_quit), NULL);
gtk_container_set_border_width (GTK_CONTAINER (newUserViewWindow), 35);
gtk_widget_set_size_request (GTK_WIDGET (newUserViewWindow), 350, 300);
//text boxes and inputs declared here
newUserViewhostText = gtk_label_new ("Host: ");
newUserViewhostInputBox = gtk_entry_new ();
newUserViewportText = gtk_label_new ("Port: ");
newUserViewportInputBox = gtk_entry_new ();
newUserViewuserText = gtk_label_new ("Username: ");
newUserViewuserInputBox = gtk_entry_new ();
newUserViewpasswordText = gtk_label_new ("Password: ");
newUserViewpasswordInputBox = gtk_entry_new ();
gtk_entry_set_visibility(GTK_ENTRY(newUserViewpasswordInputBox), (gboolean) false);
//buttons declared here.
GtkWidget * newUserLoginButton = gtk_button_new_with_label ("Add New User");
//a table is created here for organizing the widgets.
GtkWidget * table = gtk_table_new(6, 4, false);
gtk_container_add(GTK_CONTAINER(newUserViewWindow), table);
gtk_table_set_row_spacings(GTK_TABLE (table), 5);
gtk_table_set_col_spacings(GTK_TABLE (table), 5);
gtk_widget_show (table);
//Widgets are now placed in the table
gtk_table_attach_defaults(GTK_TABLE(table), newUserViewhostText, 0,1, 0,1);
gtk_widget_show(newUserViewhostText);
gtk_table_attach_defaults(GTK_TABLE(table), newUserViewhostInputBox, 2,3, 0,1);
gtk_widget_show(newUserViewhostInputBox);
gtk_table_attach_defaults(GTK_TABLE(table), newUserViewportText, 0,1, 1,2);
gtk_widget_show(newUserViewportText);
gtk_table_attach_defaults(GTK_TABLE(table), newUserViewportInputBox, 2,3, 1,2);
gtk_widget_show(newUserViewportInputBox);
gtk_table_attach_defaults(GTK_TABLE(table), newUserViewuserText, 0,1, 2,3);
gtk_widget_show(newUserViewuserText);
gtk_table_attach_defaults(GTK_TABLE(table), newUserViewuserInputBox, 2,3, 2,3);
gtk_widget_show(newUserViewuserInputBox);
gtk_table_attach_defaults(GTK_TABLE(table), newUserViewpasswordText, 0,1, 3,4);
gtk_widget_show(newUserViewpasswordText);
gtk_table_attach_defaults(GTK_TABLE(table), newUserViewpasswordInputBox, 2,3, 3,4);
gtk_widget_show(newUserViewpasswordInputBox);
gtk_table_attach_defaults(GTK_TABLE(table), newUserLoginButton, 0,3, 4,5);
gtk_widget_show(newUserLoginButton);
//Wire up the bottons here
g_signal_connect(newUserLoginButton, "clicked", G_CALLBACK(newUserLoginButton_callback), loginValid);
//Everything works and is now ready to be shown
gtk_widget_show (newUserViewWindow);
gtk_main();
if (loginValid[0]) {
//login was pushed, the entry data is passed here
host[0] = newUserViewtempHost;
sport[0] = newUserViewtempSport;
user[0] = newUserViewtempUser;
password[0] = newUserViewtempPassword;
return 1;
} else {
//the user clicked exit instead of one of the buttons.
return -1;
}
}
| [
"rpitcher@purdue.edu"
] | rpitcher@purdue.edu |
b2ee210caf5aeafd0b164972b32ee2e6cf19d75c | 378295ab367dfc95eef032be507b156e792da966 | /LeetCode-237-Delete Node in a Linked List-Easy.cpp | bdb0e4093ae788b1d692ddd1df5aa495fd248b74 | [] | no_license | kimixuchen/leetcode | 6a9392883e6a5609b304931753d079a17ac242b1 | 90d88ed5933cdd4c3a44e034dbe4577479638369 | refs/heads/master | 2021-01-23T13:35:32.713751 | 2017-12-17T05:11:32 | 2017-12-17T05:11:32 | 47,063,714 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 719 | cpp | /**
LeetCode-237-Delete Node in a Linked List
12/10/16 10:32:17
xuchen
**/
#include <iostream>
#include <cfloat>
#include <cctype>
#include <unordered_set>
#include <unordered_map>
#include <cmath>
#include <vector>
#include <map>
#include <cmath>
#include <string>
#include <algorithm>
#include <cstring>
#include <queue>
#include <list>
#include <stack>
#include <bitset>
using namespace std;
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
void deleteNode(ListNode* node) {
ListNode *next = node->next;
*node = *next;
delete(next);
}
};
| [
"kimixuchen@163.com"
] | kimixuchen@163.com |
c082804aa58d96993b697981143df1579243b1d6 | a9221a302f28dc317b9fbcf7657d955bf6fda4da | /data structure_codes/rever_s.cpp | 1e11b019b56292a483ec5b13b284e80293dc1c88 | [] | no_license | aaksh01/codespractice | 6292af891fabc05eb67a1d626af794768b1a580c | 470a858e15a3c413f70621a08f63a0e8896d186e | refs/heads/master | 2023-06-21T20:30:06.410253 | 2021-07-19T12:57:59 | 2021-07-19T12:57:59 | 387,459,807 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 693 | cpp | #include<bits/stdc++.h>
#define endl "\n"
using namespace std;
void reverse(char a[])
{
int i=0,j=0;
while(a[j]!='\0')
{
j++;
}
cout<<j;
for( i=0;a[i]!='\0' && i<j;i++,j--)
{
char temp= a[i];
a[i]=a[j];
a[j]= temp;
}
for(int k=0;a[k]!='\0';k++)
{
cout<<a[k];
}
}
void palindrom(string s1)
{
int i=0,j=s1.length()-1;
for(i,j;i<j;i++,j--)
{
if(s1[i]!=s1[j])
{
cout<<"String is not palindrom"<<endl;
return;
}
else
{
continue;
}
}
cout<<"String is palindrom"<<endl;
return;
}
void com_string(string &s1,string &s2)
{
if(s1!=s2)
{
cout<<"NOT EQUAL!\n";
return;
}
cout<<"EQUAL!\n";
}
int main()
{
string s1;
cin>>s1;
palindrom(s1);
}
| [
"aksh01kumar01@gmail.com"
] | aksh01kumar01@gmail.com |
bceb9b8e46e7db695bfd5983b8e9f07c2b86f6a4 | 49f88ff91aa582e1a9d5ae5a7014f5c07eab7503 | /gen/third_party/blink/renderer/bindings/modules/v8/v8_webgl_vertex_array_object_oes.cc | cc1d62d3ca77ee4bb8b1a18f9cc1be987b33ef92 | [] | no_license | AoEiuV020/kiwibrowser-arm64 | b6c719b5f35d65906ae08503ec32f6775c9bb048 | ae7383776e0978b945e85e54242b4e3f7b930284 | refs/heads/main | 2023-06-01T21:09:33.928929 | 2021-06-22T15:56:53 | 2021-06-22T15:56:53 | 379,186,747 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 5,824 | cc | // 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.
// This file has been auto-generated from the Jinja2 template
// third_party/blink/renderer/bindings/templates/interface.cpp.tmpl
// by the script code_generator_v8.py.
// DO NOT MODIFY!
// clang-format off
#include "third_party/blink/renderer/bindings/modules/v8/v8_webgl_vertex_array_object_oes.h"
#include "base/memory/scoped_refptr.h"
#include "third_party/blink/renderer/bindings/core/v8/exception_state.h"
#include "third_party/blink/renderer/bindings/core/v8/v8_dom_configuration.h"
#include "third_party/blink/renderer/core/execution_context/execution_context.h"
#include "third_party/blink/renderer/platform/bindings/v8_object_constructor.h"
#include "third_party/blink/renderer/platform/wtf/get_ptr.h"
namespace blink {
// Suppress warning: global constructors, because struct WrapperTypeInfo is trivial
// and does not depend on another global objects.
#if defined(COMPONENT_BUILD) && defined(WIN32) && defined(__clang__)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wglobal-constructors"
#endif
const WrapperTypeInfo V8WebGLVertexArrayObjectOES::wrapperTypeInfo = {
gin::kEmbedderBlink,
V8WebGLVertexArrayObjectOES::domTemplate,
nullptr,
"WebGLVertexArrayObjectOES",
nullptr,
WrapperTypeInfo::kWrapperTypeObjectPrototype,
WrapperTypeInfo::kObjectClassId,
WrapperTypeInfo::kNotInheritFromActiveScriptWrappable,
};
#if defined(COMPONENT_BUILD) && defined(WIN32) && defined(__clang__)
#pragma clang diagnostic pop
#endif
// This static member must be declared by DEFINE_WRAPPERTYPEINFO in WebGLVertexArrayObjectOES.h.
// For details, see the comment of DEFINE_WRAPPERTYPEINFO in
// platform/bindings/ScriptWrappable.h.
const WrapperTypeInfo& WebGLVertexArrayObjectOES::wrapper_type_info_ = V8WebGLVertexArrayObjectOES::wrapperTypeInfo;
// not [ActiveScriptWrappable]
static_assert(
!std::is_base_of<ActiveScriptWrappableBase, WebGLVertexArrayObjectOES>::value,
"WebGLVertexArrayObjectOES inherits from ActiveScriptWrappable<>, but is not specifying "
"[ActiveScriptWrappable] extended attribute in the IDL file. "
"Be consistent.");
static_assert(
std::is_same<decltype(&WebGLVertexArrayObjectOES::HasPendingActivity),
decltype(&ScriptWrappable::HasPendingActivity)>::value,
"WebGLVertexArrayObjectOES is overriding hasPendingActivity(), but is not specifying "
"[ActiveScriptWrappable] extended attribute in the IDL file. "
"Be consistent.");
namespace WebGLVertexArrayObjectOESV8Internal {
} // namespace WebGLVertexArrayObjectOESV8Internal
static void installV8WebGLVertexArrayObjectOESTemplate(
v8::Isolate* isolate,
const DOMWrapperWorld& world,
v8::Local<v8::FunctionTemplate> interfaceTemplate) {
// Initialize the interface object's template.
V8DOMConfiguration::InitializeDOMInterfaceTemplate(isolate, interfaceTemplate, V8WebGLVertexArrayObjectOES::wrapperTypeInfo.interface_name, v8::Local<v8::FunctionTemplate>(), V8WebGLVertexArrayObjectOES::internalFieldCount);
v8::Local<v8::Signature> signature = v8::Signature::New(isolate, interfaceTemplate);
ALLOW_UNUSED_LOCAL(signature);
v8::Local<v8::ObjectTemplate> instanceTemplate = interfaceTemplate->InstanceTemplate();
ALLOW_UNUSED_LOCAL(instanceTemplate);
v8::Local<v8::ObjectTemplate> prototypeTemplate = interfaceTemplate->PrototypeTemplate();
ALLOW_UNUSED_LOCAL(prototypeTemplate);
// Register IDL constants, attributes and operations.
// Custom signature
V8WebGLVertexArrayObjectOES::InstallRuntimeEnabledFeaturesOnTemplate(
isolate, world, interfaceTemplate);
}
void V8WebGLVertexArrayObjectOES::InstallRuntimeEnabledFeaturesOnTemplate(
v8::Isolate* isolate,
const DOMWrapperWorld& world,
v8::Local<v8::FunctionTemplate> interface_template) {
v8::Local<v8::Signature> signature = v8::Signature::New(isolate, interface_template);
ALLOW_UNUSED_LOCAL(signature);
v8::Local<v8::ObjectTemplate> instance_template = interface_template->InstanceTemplate();
ALLOW_UNUSED_LOCAL(instance_template);
v8::Local<v8::ObjectTemplate> prototype_template = interface_template->PrototypeTemplate();
ALLOW_UNUSED_LOCAL(prototype_template);
// Register IDL constants, attributes and operations.
// Custom signature
}
v8::Local<v8::FunctionTemplate> V8WebGLVertexArrayObjectOES::domTemplate(v8::Isolate* isolate, const DOMWrapperWorld& world) {
return V8DOMConfiguration::DomClassTemplate(isolate, world, const_cast<WrapperTypeInfo*>(&wrapperTypeInfo), installV8WebGLVertexArrayObjectOESTemplate);
}
bool V8WebGLVertexArrayObjectOES::hasInstance(v8::Local<v8::Value> v8Value, v8::Isolate* isolate) {
return V8PerIsolateData::From(isolate)->HasInstance(&wrapperTypeInfo, v8Value);
}
v8::Local<v8::Object> V8WebGLVertexArrayObjectOES::findInstanceInPrototypeChain(v8::Local<v8::Value> v8Value, v8::Isolate* isolate) {
return V8PerIsolateData::From(isolate)->FindInstanceInPrototypeChain(&wrapperTypeInfo, v8Value);
}
WebGLVertexArrayObjectOES* V8WebGLVertexArrayObjectOES::ToImplWithTypeCheck(v8::Isolate* isolate, v8::Local<v8::Value> value) {
return hasInstance(value, isolate) ? ToImpl(v8::Local<v8::Object>::Cast(value)) : nullptr;
}
WebGLVertexArrayObjectOES* NativeValueTraits<WebGLVertexArrayObjectOES>::NativeValue(v8::Isolate* isolate, v8::Local<v8::Value> value, ExceptionState& exceptionState) {
WebGLVertexArrayObjectOES* nativeValue = V8WebGLVertexArrayObjectOES::ToImplWithTypeCheck(isolate, value);
if (!nativeValue) {
exceptionState.ThrowTypeError(ExceptionMessages::FailedToConvertJSValue(
"WebGLVertexArrayObjectOES"));
}
return nativeValue;
}
} // namespace blink
| [
"aoeiuv020@gmail.com"
] | aoeiuv020@gmail.com |
707f72a3b32e374573f30d2157e3d0a132dd486c | fb4b85546cc98fcf454fcba223104a2bd8847578 | /MCX_project0/src/executables/5_map_Polynomial/Test.h | d26a20c13502688fe2b6eea0bff65f388cc30f42 | [
"MIT"
] | permissive | mengchenxi98/CG | b4c30038aa1a463d1c3a3395a1e1f122f9d5fc7f | 9ab0b0bf1d06e26f49adf3d1ea693497740946c2 | refs/heads/master | 2020-12-31T22:15:17.472441 | 2020-02-14T16:13:22 | 2020-02-14T16:13:22 | 239,049,548 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,100 | h | #include "PolynomialList.h"
#include "PolynomialMap.h"
#include <iostream>
#include <ctime>
#include <cstdlib>
#include <string>
#include <vector>
using namespace std;
template<class Polynomial>
class Test {
public:
bool test_construct(const vector<int>& deg, const vector<double>& cof) {
clock_t t0 = clock();
cout << "Size: " << deg.size() << endl;
Polynomial p(deg, cof);
cout << "Construct_time: " << clock() - t0 << endl << endl;
return true;
}
bool test_operate(const vector<int>& deg_1, const vector<double>& cof_1,
const vector<int>& deg_2, const vector<double>& cof_2, bool showOutput = false)
{
Polynomial p_1(deg_1, cof_1);
Polynomial p_2(deg_2, cof_2);
clock_t t0 = clock();
if (showOutput) {
(p_1 * p_2).Print();
(p_1 + p_2).Print();
(p_1 - p_2).Print();
}
else {
p_1 * p_2;
p_1 + p_2;
p_1 - p_2;
}
cout << "Operate_time: " << clock() - t0 << endl << endl;
return true;
}
}; | [
"1435374134@qq.com"
] | 1435374134@qq.com |
e76505b8161f32003d6ee69c2c8fed316d5bc5c4 | 06c8aecae6cc0ea4000fbe07391cfc0b7a3ea24e | /src/SQLiteDbManager-Tool/SQLiteDbManager/stdafx.h | 05727d4aaf33f207b3f00c089ca8144862fba26f | [] | no_license | xingyun86/ppshuai_sqlite3manager | b587a34e005c79e1e033049b6d845baf4976aac9 | 39d04772884c37f4281684b587d4321e6c5d51fc | refs/heads/master | 2020-03-18T18:09:13.724340 | 2018-05-28T05:19:48 | 2018-05-28T05:19:48 | 135,074,333 | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 5,373 | h |
// stdafx.h : include file for standard system include files,
// or project specific include files that are used frequently,
// but are changed infrequently
#pragma once
#ifndef _SECURE_ATL
#define _SECURE_ATL 1
#endif
#ifndef VC_EXTRALEAN
#define VC_EXTRALEAN // Exclude rarely-used stuff from Windows headers
#endif
#include "targetver.h"
//#pragma comment(linker,"/ENTRY:WinMainCRTStartup")
#if !defined(_DEBUG) && !defined(DEBUG)
//如果是RELEASE选项
#if !defined(_UNICODE) && !defined(UNICODE)
//如果是RELEASE选项下的ANSI选项
#pragma comment(linker,"/ENTRY:WinMainCRTStartup")
#pragma comment(lib, "nafxcw.lib")
#else
//如果是RELEASE选项下的UNICODE选项
#pragma comment(linker,"/ENTRY:wWinMainCRTStartup")
#pragma comment(lib, "uafxcw.lib")
#endif
#pragma comment(lib, "libcmt.lib")
#else
//如果是DEBUG选项
#if !defined(_UNICODE) && !defined(UNICODE)
//如果是DEBUG选项下的ANSI选项
#pragma comment(linker,"/ENTRY:WinMainCRTStartup")
#pragma comment(lib, "nafxcwd.lib")
#else
//如果是DEBUG选项下的UNICODE选项
//#pragma comment(linker, "/nodefaultlib:libcmtd.lib")
#pragma comment(linker,"/ENTRY:wWinMainCRTStartup")
#pragma comment(lib, "uafxcwd.lib")
#endif
#pragma comment(lib, "libcmtd.lib")
#endif
//#pragma comment(linker,"/verbose:lib")
//#pragma comment(linker, "/nodefaultlib")
#define _ATL_CSTRING_EXPLICIT_CONSTRUCTORS // some CString constructors will be explicit
// turns off MFC's hiding of some common and often safely ignored warning messages
#define _AFX_ALL_WARNINGS
#include <afxwin.h> // MFC core and standard components
#include <afxext.h> // MFC extensions
#include <afxdisp.h> // MFC Automation classes
#ifndef _AFX_NO_OLE_SUPPORT
#include <afxdtctl.h> // MFC support for Internet Explorer 4 Common Controls
#endif
#ifndef _AFX_NO_AFXCMN_SUPPORT
#include <afxcmn.h> // MFC support for Windows Common Controls
#endif // _AFX_NO_AFXCMN_SUPPORT
#include <afxcontrolbars.h> // MFC support for ribbons and control bars
#define SQLITE3_WINDOW_TITLE TEXT("Sqlite3数据库管理工具")
//数据库路径
static _TCHAR G_DB_PATH[MAX_PATH] = { 0 };
#include <vector>
#include <map>
#if !defined(_UNICODE) && !defined(UNICODE)
#define tstring std::string
#else
#define tstring std::wstring
#endif
#define min_val(a,b) (((a) < (b)) ? (a) : (b))
#define max_val(a,b) (((a) > (b)) ? (a) : (b))
typedef std::vector<int> IntegerVector;
typedef std::vector<int>::iterator IntegerVectorIt;
typedef std::vector<tstring> StringVector;
typedef std::vector<tstring>::iterator StringVectorIt;
typedef std::vector<StringVector> StringVectorVector;
typedef std::vector<StringVector>::iterator StringVectorVectorIt;
//添加sqlite3库支持
#include <sqlitedb.h>
#include <tchar.h>
#include <fcntl.h>
#include <io.h>
#include <stdio.h>
#include <iostream>
__inline BOOL InitConsoleWindow()
{
BOOL bRet = FALSE;
if(AllocConsole())
{
//Retrieves a handle to the specified standard device (standard input, standard output, or standard error).
//Associates a C run-time file descriptor with an existing operating-system file handle.
int hIN = _open_osfhandle((intptr_t)::GetStdHandle (STD_INPUT_HANDLE), _O_TEXT | _O_BINARY);
int hOUT = _open_osfhandle((intptr_t)::GetStdHandle (STD_OUTPUT_HANDLE), _O_TEXT | _O_BINARY);
int hERR = _open_osfhandle((intptr_t)::GetStdHandle (STD_ERROR_HANDLE), _O_TEXT | _O_BINARY);
// When a program opens a file, the operating system returns a corresponding file descriptor that the program refers to
// in order to process the file. A file descriptor is a low positive integer. The first three file descriptors (0,1, and 2,)
// are associated with the standard input (stdin), the standard output (stdout), and the standard error (stderr), respectively.
// Thus, the function scanf() uses stdin and the function printf() uses stdout. You can override the default setting and
// re-direct the process's I/O to different files by using different file descriptors:
// #include <cstdio>
// fprintf(stdout, "writing to stdout"); //write to stdout instead of a physical file
*stdin = *_tfdopen(hIN, TEXT("rb"));
*stdout = *_tfdopen(hOUT, TEXT("wb"));
*stderr = *_tfdopen(hERR, TEXT("wb"));
std::ios_base::sync_with_stdio();
bRet = TRUE;
}
return bRet;
}
__inline void ExitConsoleWindow()
{
if (stdin)
{
fclose(stdin);
}
if (stdout)
{
fclose(stdout);
}
if (stderr)
{
fclose(stderr);
}
FreeConsole();
}
#ifdef _UNICODE
#if defined _M_IX86
#pragma comment(linker,"/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='x86' publicKeyToken='6595b64144ccf1df' language='*'\"")
#elif defined _M_X64
#pragma comment(linker,"/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='amd64' publicKeyToken='6595b64144ccf1df' language='*'\"")
#else
#pragma comment(linker,"/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='*' publicKeyToken='6595b64144ccf1df' language='*'\"")
#endif
#endif
| [
"xingyun_ppshuai@yeah.net"
] | xingyun_ppshuai@yeah.net |
23a9a6aadbcb967c4fabc99e15b857db6cb36a78 | 8511be11790c4e0f3890fef82845e337d7deefea | /source/main.cpp | e228b955ee109615a36d258603f7184193961745 | [] | no_license | kennykarnama/csv2png | 7af144a2eda67d6466f44f39fbb1da837dd07afd | 7628a3f08087aceed642feb3781d75cc62ef55b1 | refs/heads/master | 2020-03-15T18:22:49.921917 | 2018-05-05T20:42:16 | 2018-05-05T20:42:16 | 132,282,356 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 245 | cpp | #include "converter.h"
#include <iostream>
int main(int argc, char const *argv[])
{
/* code */
Converter c;
cv::Mat gambar = c.csv2png(argv[1]);
// cv::namedWindow("lol");
// cv::imshow("lol",gambar);
//cv::waitKey(0);
return 0;
} | [
"kennykarnama@gmail.com"
] | kennykarnama@gmail.com |
37bc90aeddbeebbf34d9933af1901655c0b81264 | d0fb46aecc3b69983e7f6244331a81dff42d9595 | /address-purification/include/alibabacloud/address-purification/model/GetAddressGeocodeResult.h | 2c0b7da51a923c3712c7faa348ad85438bbbbbed | [
"Apache-2.0"
] | permissive | aliyun/aliyun-openapi-cpp-sdk | 3d8d051d44ad00753a429817dd03957614c0c66a | e862bd03c844bcb7ccaa90571bceaa2802c7f135 | refs/heads/master | 2023-08-29T11:54:00.525102 | 2023-08-29T03:32:48 | 2023-08-29T03:32:48 | 115,379,460 | 104 | 82 | NOASSERTION | 2023-09-14T06:13:33 | 2017-12-26T02:53:27 | C++ | UTF-8 | C++ | false | false | 1,499 | h | /*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSGEOCODERESULT_H_
#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSGEOCODERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/address-purification/Address_purificationExport.h>
namespace AlibabaCloud
{
namespace Address_purification
{
namespace Model
{
class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT GetAddressGeocodeResult : public ServiceResult
{
public:
GetAddressGeocodeResult();
explicit GetAddressGeocodeResult(const std::string &payload);
~GetAddressGeocodeResult();
std::string getData()const;
protected:
void parse(const std::string &payload);
private:
std::string data_;
};
}
}
}
#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSGEOCODERESULT_H_ | [
"sdk-team@alibabacloud.com"
] | sdk-team@alibabacloud.com |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.